godothub/godot-minigame / skills
godot-wechat-minigame-adapter
UnverifiedApply the bundled self-contained Godot WeChat Mini Game adapter kit to an official Godot checkout. Use when the user wants to port official Godot to WeChat Mini Game, refresh a nearby 4.6-based port, or inspect the shipped patch/source bundle for WXMEMFS, `wx.request`, audio cleanup, display/input, WXGLX dual-path rendering, `.wasm.br`, and `wx.exitMiniProgram`. This skill is version-locked to the bundled upstream base and must not be described as a generic “Godot 4.x” patch dump.
sources/godot-4.6.2-rc-a16e481cf4/platform/web/js/libs/library_blob.js
View on GitHub/* Blob.js
* A Blob, File, FileReader & URL implementation.
* 2020-02-01
*
* By Eli Grey, https://eligrey.com
* By Jimmy Wärting, https://github.com/jimmywarting
* License: MIT
* See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
*/
function array2base64(input) {
var byteToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var output = [];
for (var i = 0; i < input.length; i += 3) {
var byte1 = input[i];
var haveByte2 = i + 1 < input.length;
var byte2 = haveByte2 ? input[i + 1] : 0;
var haveByte3 = i + 2 < input.length;
var byte3 = haveByte3 ? input[i + 2] : 0;
var outByte1 = byte1 >> 2;
var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
var outByte3 = ((byte2 & 0x0F) << 2) | (byte3 >> 6);
var outByte4 = byte3 & 0x3F;
if (!haveByte3) {
outByte4 = 64;
if (!haveByte2) {
outByte3 = 64;
}
}
output.push(
byteToCharMap[outByte1], byteToCharMap[outByte2],
byteToCharMap[outByte3], byteToCharMap[outByte4]
);
}
return output.join("");
}
(function (global) {
(function (factory) {
if (typeof define === "function" && define.amd) {
// AMD. Register as an anonymous module.
define(["exports"], factory);
} else if (typeof exports === "object" && typeof exports.nodeName !== "string") {
// CommonJS
factory(exports);
} else {
// Browser globals
factory(global);
}
})(function (exports) {
"use strict";
var BlobBuilder = global.BlobBuilder
|| global.WebKitBlobBuilder
|| global.MSBlobBuilder
|| global.MozBlobBuilder;
var URL = global.URL || global.webkitURL || function (href, a) {
a = document.createElement("a");
a.href = href;
return a;
};
var origBlob = global.Blob;
var createObjectURL = URL.createObjectURL;
var revokeObjectURL = URL.revokeObjectURL;
var strTag = global.Symbol && global.Symbol.toStringTag;
var blobSupported = false;
var blobSupportsArrayBufferView = false;
var blobBuilderSupported = BlobBuilder
&& BlobBuilder.prototype.append
&& BlobBuilder.prototype.getBlob;
try {
// Check if Blob constructor is supported
blobSupported = new Blob(["ä"]).size === 2;
// Check if Blob constructor supports ArrayBufferViews
// Fails in Safari 6, so we need to map to ArrayBuffers there.
blobSupportsArrayBufferView = new Blob([new Uint8Array([1, 2])]).size === 2;
} catch (e) {/* eslint-disable-line no-unused-vars */ }
// Helper function that maps ArrayBufferViews to ArrayBuffers
// Used by BlobBuilder constructor and old browsers that didn't
// support it in the Blob constructor.
function mapArrayBufferViews(ary) {
return ary.map(function (chunk) {
if (chunk.buffer instanceof ArrayBuffer) {
var buf = chunk.buffer;
// if this is a subarray, make a copy so we only
// include the subarray region from the underlying buffer
if (chunk.byteLength !== buf.byteLength) {
var copy = new Uint8Array(chunk.byteLength);
copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));
buf = copy.buffer;
}
return buf;
}
return chunk;
});
}
function BlobBuilderConstructor(ary, options) {
options = options || {};
var bb = new BlobBuilder();
mapArrayBufferViews(ary).forEach(function (part) {
bb.append(part);
});
return options.type ? bb.getBlob(options.type) : bb.getBlob();
}
function BlobConstructor(ary, options) {
return new origBlob(mapArrayBufferViews(ary), options || {});
}
if (global.Blob) {
BlobBuilderConstructor.prototype = global.Blob.prototype;
BlobConstructor.prototype = global.Blob.prototype;
}
/********************************************************/
/* String Encoder fallback */
/********************************************************/
function stringEncode(string) {
var pos = 0;
var len = string.length;
var Arr = global.Uint8Array || Array; // Use byte array when possible
var at = 0; // output position
var tlen = Math.max(32, len + (len >> 1) + 7); // 1.5x size
var target = new Arr((tlen >> 3) << 3); // ... but at 8 byte offset
while (pos < len) {
var value = string.charCodeAt(pos++);
if (value >= 0xd800 && value <= 0xdbff) {
// high surrogate
if (pos < len) {
var extra = string.charCodeAt(pos);
if ((extra & 0xfc00) === 0xdc00) {
++pos;
value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
}
}
if (value >= 0xd800 && value <= 0xdbff) {
continue; // drop lone surrogate
}
}
// expand the buffer if we couldn't write 4 bytes
if (at + 4 > target.length) {
tlen += 8; // minimum extra
tlen *= (1.0 + (pos / string.length) * 2); // take 2x the remaining
tlen = (tlen >> 3) << 3; // 8 byte offset
var update = new Uint8Array(tlen);
update.set(target);
target = update;
}
if ((value & 0xffffff80) === 0) { // 1-byte
target[at++] = value; // ASCII
continue;
} else if ((value & 0xfffff800) === 0) { // 2-byte
target[at++] = ((value >> 6) & 0x1f) | 0xc0;
} else if ((value & 0xffff0000) === 0) { // 3-byte
target[at++] = ((value >> 12) & 0x0f) | 0xe0;
target[at++] = ((value >> 6) & 0x3f) | 0x80;
} else if ((value & 0xffe00000) === 0) { // 4-byte
target[at++] = ((value >> 18) & 0x07) | 0xf0;
target[at++] = ((value >> 12) & 0x3f) | 0x80;
target[at++] = ((value >> 6) & 0x3f) | 0x80;
} else {
// FIXME: do we care
continue;
}
target[at++] = (value & 0x3f) | 0x80;
}
return target.slice(0, at);
}
/********************************************************/
/* String Decoder fallback */
/********************************************************/
function stringDecode(buf) {
var end = buf.length;
var res = [];
var i = 0;
while (i < end) {
var firstByte = buf[i];
var codePoint = null;
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1;
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint;
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte;
}
break;
case 2:
secondByte = buf[i + 1];
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint;
}
}
break;
case 3:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint;
}
}
break;
case 4:
secondByte = buf[i + 1];
thirdByte = buf[i + 2];
fourthByte = buf[i + 3];
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint;
}
}
}
}
if (codePoint === null) {
// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD;
bytesPerSequence = 1;
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000;
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
codePoint = 0xDC00 | codePoint & 0x3FF;
}
res.push(codePoint);
i += bytesPerSequence;
}
var len = res.length;
var str = "";
var j = 0;
while (j < len) {
str += String.fromCharCode.apply(String, res.slice(j, j += 0x1000));
}
return str;
}
// string -> buffer
var textEncode = typeof TextEncoder === "function"
? TextEncoder.prototype.encode.bind(new TextEncoder())
: stringEncode;
// buffer -> string
var textDecode = typeof TextDecoder === "function"
? TextDecoder.prototype.decode.bind(new TextDecoder())
: stringDecode;
function FakeBlobBuilder() {
function bufferClone(buf) {
var view = new Array(buf.byteLength);
var array = new Uint8Array(buf);
var i = view.length;
while (i--) {
view[i] = array[i];
}
return view;
}
var create = Object.create || function (a) {
function c() { }
c.prototype = a;
return new c();
};
function getObjectTypeName(o) {
return Object.prototype.toString.call(o).slice(8, -1);
}
function isPrototypeOf(c, o) {
return typeof c === "object" && Object.prototype.isPrototypeOf.call(c.prototype, o);
}
function isDataView(o) {
return getObjectTypeName(o) === "DataView" || isPrototypeOf(global.DataView, o);
}
var arrayBufferClassNames = [
"Int8Array",
"Uint8Array",
"Uint8ClampedArray",
"Int16Array",
"Uint16Array",
"Int32Array",
"Uint32Array",
"Float32Array",
"Float64Array",
"ArrayBuffer"
];
function includes(a, v) {
return a.indexOf(v) !== -1;
}
function isArrayBuffer(o) {
return includes(arrayBufferClassNames, getObjectTypeName(o)) || isPrototypeOf(global.ArrayBuffer, o);
}
function concatTypedarrays(chunks) {
var size = 0;
var j = chunks.length;
while (j--) { size += chunks[j].length; }
var b = new Uint8Array(size);
var offset = 0;
for (var i = 0; i < chunks.length; i++) {
var chunk = chunks[i];
b.set(chunk, offset);
offset += chunk.byteLength || chunk.length;
}
return b;
}
/********************************************************/
/* Blob constructor */
/********************************************************/
function Blob(chunks, opts) {
chunks = chunks ? chunks.slice() : [];
opts = opts == null ? {} : opts;
for (var i = 0, len = chunks.length; i < len; i++) {
var chunk = chunks[i];
if (chunk instanceof Blob) {
chunks[i] = chunk._buffer;
} else if (typeof chunk === "string") {
chunks[i] = textEncode(chunk);
} else if (isDataView(chunk)) {
chunks[i] = bufferClone(chunk.buffer);
} else if (isArrayBuffer(chunk)) {
chunks[i] = bufferClone(chunk);
} else {
chunks[i] = textEncode(String(chunk));
}
}
this._buffer = global.Uint8Array
? concatTypedarrays(chunks)
: [].concat.apply([], chunks);
this.size = this._buffer.length;
this.type = opts.type || "";
if (/[^\u0020-\u007E]/.test(this.type)) {
this.type = "";
} else {
this.type = this.type.toLowerCase();
}
}
Blob.isPolyfill = true;
Blob.prototype.arrayBuffer = function () {
return Promise.resolve(this._buffer.buffer || this._buffer);
};
Blob.prototype.text = function () {
return Promise.resolve(textDecode(this._buffer));
};
Blob.prototype.slice = function (start, end, type) {
var slice = this._buffer.slice(start || 0, end || this._buffer.length);
return new Blob([slice], { type: type });
};
Blob.prototype.toString = function () {
return "[object Blob]";
};
/********************************************************/
/* File constructor */
/********************************************************/
function File(chunks, name, opts) {
opts = opts || {};
var a = Blob.call(this, chunks, opts) || this;
a.name = name.replace(/\//g, ":");
a.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date();
a.lastModified = +a.lastModifiedDate;
return a;
}
File.isPolyfill = true;
File.prototype = create(Blob.prototype);
File.prototype.constructor = File;
if (Object.setPrototypeOf) {
Object.setPrototypeOf(File, Blob);
} else {
try {
File.__proto__ = Blob;
} catch (e) {/* eslint-disable-line no-unused-vars */ }
}
File.prototype.toString = function () {
return "[object File]";
};
/********************************************************/
/* URL */
/********************************************************/
URL.createObjectURL = function (blob) {
return blob instanceof Blob
? "data:" + blob.type + ";base64," + array2base64(blob._buffer)
: createObjectURL.call(URL, blob);
};
URL.createObjectURL.isPolyfill = true;
URL.revokeObjectURL = function (url) {
revokeObjectURL && revokeObjectURL.call(URL, url);
};
URL.revokeObjectURL.isPolyfill = true;
/********************************************************/
/* XHR */
/********************************************************/
var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send;
if (_send) {
XMLHttpRequest.prototype.send = function (data) {
if (data instanceof Blob) {
this.setRequestHeader("Content-Type", data.type);
_send.call(this, textDecode(data._buffer));
} else {
_send.call(this, data);
}
};
}
exports.Blob = Blob;
exports.File = File;
}
function fixFileAndXHR() {
var isIE = !!global.ActiveXObject || (typeof document !== "undefined" &&
"-ms-scroll-limit" in document.documentElement.style &&
"-ms-ime-align" in document.documentElement.style
);
// Monkey patched
// IE doesn't set Content-Type header on XHR whose body is a typed Blob
// https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6047383
var _send = global.XMLHttpRequest && global.XMLHttpRequest.prototype.send;
if (isIE && _send) {
XMLHttpRequest.prototype.send = function (data) {
if (data instanceof Blob) {
this.setRequestHeader("Content-Type", data.type);
_send.call(this, data);
} else {
_send.call(this, data);
}
};
}
try {
new File([], "");
exports.File = global.File;
} catch (e) { // eslint-disable-line no-unused-vars
try {
exports.File = new Function("class File extends Blob {" +
"constructor(chunks, name, opts) {" +
"opts = opts || {};" +
"super(chunks, opts || {});" +
"this.name = name.replace(/\\//g, \":\");" +
"this.lastModifiedDate = opts.lastModified ? new Date(opts.lastModified) : new Date();" +
"this.lastModified = +this.lastModifiedDate;" +
"}};" +
"return new File([], \"\"), File"
)();
} catch (e) { // eslint-disable-line no-unused-vars
exports.File = function File(b, d, c) {
var blob = new Blob(b, c);
var t = c && void 0 !== c.lastModified ? new Date(c.lastModified) : new Date();
blob.name = d.replace(/\//g, ":");
blob.lastModifiedDate = t;
blob.lastModified = +t;
blob.toString = function () {
return "[object File]";
};
if (strTag) {
blob[strTag] = "File";
}
return blob;
};
}
exports.File.isPolyfill = true;
}
}
if (blobSupported) {
fixFileAndXHR();
exports.Blob = blobSupportsArrayBufferView ? global.Blob : BlobConstructor;
} else if (blobBuilderSupported) {
fixFileAndXHR();
exports.Blob = BlobBuilderConstructor;
} else {
FakeBlobBuilder();
}
/********************************************************/
/* FileReader constructor */
/********************************************************/
function FileReader() {
if (!(this instanceof FileReader)) {
throw new TypeError("Failed to construct 'FileReader': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
}
var delegate = document.createDocumentFragment();
this.addEventListener = delegate.addEventListener;
this.dispatchEvent = function (evt) {
var local = this["on" + evt.type];
if (typeof local === "function") local(evt);
delegate.dispatchEvent(evt);
};
this.removeEventListener = delegate.removeEventListener;
}
function _read(fr, blob, kind) {
if (!(blob instanceof exports.Blob)) {
throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
}
fr.result = "";
setTimeout(function () {
this.readyState = FileReader.LOADING;
fr.dispatchEvent(new Event("load"));
fr.dispatchEvent(new Event("loadend"));
});
}
FileReader.EMPTY = 0;
FileReader.LOADING = 1;
FileReader.DONE = 2;
FileReader.prototype.error = null;
FileReader.prototype.onabort = null;
FileReader.prototype.onerror = null;
FileReader.prototype.onload = null;
FileReader.prototype.onloadend = null;
FileReader.prototype.onloadstart = null;
FileReader.prototype.onprogress = null;
FileReader.prototype.readAsDataURL = function (blob) {
_read(this, blob, "readAsDataURL");
this.result = "data:" + blob.type + ";base64," + array2base64(blob._buffer);
};
FileReader.prototype.readAsText = function (blob) {
_read(this, blob, "readAsText");
this.result = textDecode(blob._buffer);
};
FileReader.prototype.readAsArrayBuffer = function (blob) {
_read(this, blob, "readAsText");
// return ArrayBuffer when possible
this.result = (blob._buffer.buffer || blob._buffer).slice();
};
FileReader.prototype.abort = function () { };
exports.FileReader = global.FileReader || FileReader;
exports.URL = global.URL || URL;
if (strTag) {
if (!exports.File.prototype[strTag]) exports.File.prototype[strTag] = "File";
if (!exports.Blob.prototype[strTag]) exports.Blob.prototype[strTag] = "Blob";
if (!exports.FileReader.prototype[strTag]) exports.FileReader.prototype[strTag] = "FileReader";
}
var blob = exports.Blob.prototype;
var stream;
try {
new ReadableStream({ type: "bytes" });
stream = function stream() {
var position = 0;
var blob = this;
return new ReadableStream({
type: "bytes",
autoAllocateChunkSize: 524288,
pull: function (controller) {
var v = controller.byobRequest.view;
var chunk = blob.slice(position, position + v.byteLength);
return chunk.arrayBuffer()
.then(function (buffer) {
var uint8array = new Uint8Array(buffer);
var bytesRead = uint8array.byteLength;
position += bytesRead;
v.set(uint8array);
controller.byobRequest.respond(bytesRead);
if (position >= blob.size)
controller.close();
});
}
});
};
} catch (e) { // eslint-disable-line no-unused-vars
try {
new ReadableStream({});
stream = function stream(blob) {
var position = 0;
return new ReadableStream({
pull: function (controller) {
var chunk = blob.slice(position, position + 524288);
return chunk.arrayBuffer().then(function (buffer) {
position += buffer.byteLength;
var uint8array = new Uint8Array(buffer);
controller.enqueue(uint8array);
if (position == blob.size)
controller.close();
});
}
});
};
} catch (e) { // eslint-disable-line no-unused-vars
try {
new Response("").body.getReader().read();
stream = function stream() {
return (new Response(this)).body;
};
} catch (e) { // eslint-disable-line no-unused-vars
stream = function stream() {
throw new Error("Include https://github.com/MattiasBuelens/web-streams-polyfill");
};
}
}
}
function promisify(obj) {
return new Promise(function (resolve, reject) {
obj.onload = obj.onerror = function (evt) {
obj.onload = obj.onerror = null;
evt.type === "load" ?
resolve(obj.result || obj) :
reject(new Error("Failed to read the blob/file"));
};
});
}
if (!blob.arrayBuffer) {
blob.arrayBuffer = function arrayBuffer() {
var fr = new exports.FileReader();
fr.readAsArrayBuffer(this);
return promisify(fr);
};
}
if (!blob.text) {
blob.text = function text() {
var fr = new exports.FileReader();
fr.readAsText(this);
return promisify(fr);
};
}
if (!blob.stream) {
blob.stream = stream;
}
});
})(
typeof self !== "undefined" && self ||
typeof window !== "undefined" && window ||
typeof global !== "undefined" && global ||
this
);
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |