@nodetool-ai/sandbox-runtime 0.0.0-stage → 0.8.9-bootstrap.0

package/vendor/quickjs/modules/string_decoder.js

@@ -0,0 +1,223 @@
+export default `
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import {Buffer} from 'node:buffer';
+
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
+
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+export function StringDecoder(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via \`new Buffer\`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}
+`;

package/vendor/quickjs/modules/timers.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nexport setTimeout\nexport clearTimeout\nexport setInterval\nexport clearInterval\nexport setImmediate\nexport clearImmediate\n\nexport default {setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate }\n";
+export default _default;

package/vendor/quickjs/modules/timers.js

@@ -0,0 +1,10 @@
+export default `
+export setTimeout
+export clearTimeout
+export setInterval
+export clearInterval
+export setImmediate
+export clearImmediate
+
+export default {setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate }
+`;

package/vendor/quickjs/modules/timers_promises.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\nexport const setTimeout = (delay, value, options) => new Promise((resolve, reject) => {\n  const id = globalThis.setTimeout(() => resolve(value), delay);\n  if (options && options.signal) {\n    const abortHandler = () => {\n      globalThis.clearTimeout(id);\n      reject(options.signal.reason ?? new Error('AbortError'));\n    };\n    if (options.signal.aborted) {\n      abortHandler();\n      return;\n    }\n    options.signal.addEventListener('abort', abortHandler, { once: true });\n  }\n});\n\nexport const setImmediate = (value, options) => new Promise((resolve, reject) => {\n  const id = globalThis.setTimeout(() => resolve(value), 0);\n  if (options && options.signal) {\n    const abortHandler = () => {\n      globalThis.clearTimeout(id);\n      reject(options.signal.reason ?? new Error('AbortError'));\n    };\n    if (options.signal.aborted) {\n      abortHandler();\n      return;\n    }\n    options.signal.addEventListener('abort', abortHandler, { once: true });\n  }\n});\n\nexport async function* setInterval(delay, value) {\n  while (true) {\n    await new Promise((resolve) => globalThis.setTimeout(resolve, delay));\n    yield value;\n  }\n}\n\nexport default { setTimeout, setImmediate, setInterval }\n";
+export default _default;

package/vendor/quickjs/modules/timers_promises.js

@@ -0,0 +1,40 @@
+export default `
+export const setTimeout = (delay, value, options) => new Promise((resolve, reject) => {
+  const id = globalThis.setTimeout(() => resolve(value), delay);
+  if (options && options.signal) {
+    const abortHandler = () => {
+      globalThis.clearTimeout(id);
+      reject(options.signal.reason ?? new Error('AbortError'));
+    };
+    if (options.signal.aborted) {
+      abortHandler();
+      return;
+    }
+    options.signal.addEventListener('abort', abortHandler, { once: true });
+  }
+});
+
+export const setImmediate = (value, options) => new Promise((resolve, reject) => {
+  const id = globalThis.setTimeout(() => resolve(value), 0);
+  if (options && options.signal) {
+    const abortHandler = () => {
+      globalThis.clearTimeout(id);
+      reject(options.signal.reason ?? new Error('AbortError'));
+    };
+    if (options.signal.aborted) {
+      abortHandler();
+      return;
+    }
+    options.signal.addEventListener('abort', abortHandler, { once: true });
+  }
+});
+
+export async function* setInterval(delay, value) {
+  while (true) {
+    await new Promise((resolve) => globalThis.setTimeout(resolve, delay));
+    yield value;
+  }
+}
+
+export default { setTimeout, setImmediate, setInterval }
+`;

package/vendor/quickjs/modules/url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n\nexport class URL {\n  constructor(url, base) {\n    const parser = __parseURL(url,base)\n    this.href = parser.href;\n    this.protocol = parser.protocol;\n    this.host = parser.host;\n    this.hostname = parser.hostname;\n    this.port = parser.port;\n    this.pathname = parser.pathname;\n    this.search = parser.search;\n    this.searchParams = new URLSearchParams(parser.search)\n    this.hash = parser.hash;\n    this.username = parser.username;\n    this.password = parser.password;\n    this.origin = parser.protocol+'//'+parser.host;\n  }\n\n  toString() {\n    return this.href;\n  }\n\n  toJSON() {\n    return this.href;\n  }\n}\n\n\n\n\nexport class URLSearchParams {\n  constructor(init = '') {\n    this.params = {};\n\n    if (typeof init === 'string') {\n      this._parseFromString(init);\n    } else if (init instanceof URLSearchParams) {\n      init.forEach((value, key) => this.append(key, value));\n    } else if (typeof init === 'object') {\n      Object.keys(init).forEach(key => this.append(key, init[key]));\n    }\n  }\n\n  _parseFromString(query) {\n    if (query.startsWith('?')) {\n      query = query.slice(1);\n    }\n    query.split('&').forEach(pair => {\n      const [key, value] = pair.split('=').map(decodeURIComponent);\n      this.append(key, value);\n    });\n  }\n\n  append(key, value) {\n    if (!this.params[key]) {\n      this.params[key] = [];\n    }\n    this.params[key].push(value);\n  }\n\n  delete(key) {\n    delete this.params[key];\n  }\n\n  get(key) {\n    return this.params[key] ? this.params[key][0] : null;\n  }\n\n  getAll(key) {\n    return this.params[key] || [];\n  }\n\n  has(key) {\n    return this.params.hasOwnProperty(key);\n  }\n\n  set(key, value) {\n    this.params[key] = [value];\n  }\n\n  toString() {\n    return Object.keys(this.params)\n      .map(key => this.params[key]\n        .map(value => encodeURIComponent(key)+'='+encodeURIComponent(value))\n        .join('&'))\n      .join('&');\n  }\n\n  forEach(callback, thisArg) {\n    Object.keys(this.params).forEach(key => {\n      this.params[key].forEach(value => {\n        callback.call(thisArg, value, key, this);\n      });\n    });\n  }\n}\n\nglobalThis.URLSearchParams = URLSearchParams;\nglobalThis.URL = URL;\n\n\nexport default { URLSearchParams, URL }\n";
+export default _default;

package/vendor/quickjs/modules/url.js

@@ -0,0 +1,104 @@
+export default `
+
+export class URL {
+  constructor(url, base) {
+    const parser = __parseURL(url,base)
+    this.href = parser.href;
+    this.protocol = parser.protocol;
+    this.host = parser.host;
+    this.hostname = parser.hostname;
+    this.port = parser.port;
+    this.pathname = parser.pathname;
+    this.search = parser.search;
+    this.searchParams = new URLSearchParams(parser.search)
+    this.hash = parser.hash;
+    this.username = parser.username;
+    this.password = parser.password;
+    this.origin = parser.protocol+'//'+parser.host;
+  }
+
+  toString() {
+    return this.href;
+  }
+
+  toJSON() {
+    return this.href;
+  }
+}
+
+
+
+
+export class URLSearchParams {
+  constructor(init = '') {
+    this.params = {};
+
+    if (typeof init === 'string') {
+      this._parseFromString(init);
+    } else if (init instanceof URLSearchParams) {
+      init.forEach((value, key) => this.append(key, value));
+    } else if (typeof init === 'object') {
+      Object.keys(init).forEach(key => this.append(key, init[key]));
+    }
+  }
+
+  _parseFromString(query) {
+    if (query.startsWith('?')) {
+      query = query.slice(1);
+    }
+    query.split('&').forEach(pair => {
+      const [key, value] = pair.split('=').map(decodeURIComponent);
+      this.append(key, value);
+    });
+  }
+
+  append(key, value) {
+    if (!this.params[key]) {
+      this.params[key] = [];
+    }
+    this.params[key].push(value);
+  }
+
+  delete(key) {
+    delete this.params[key];
+  }
+
+  get(key) {
+    return this.params[key] ? this.params[key][0] : null;
+  }
+
+  getAll(key) {
+    return this.params[key] || [];
+  }
+
+  has(key) {
+    return this.params.hasOwnProperty(key);
+  }
+
+  set(key, value) {
+    this.params[key] = [value];
+  }
+
+  toString() {
+    return Object.keys(this.params)
+      .map(key => this.params[key]
+        .map(value => encodeURIComponent(key)+'='+encodeURIComponent(value))
+        .join('&'))
+      .join('&');
+  }
+
+  forEach(callback, thisArg) {
+    Object.keys(this.params).forEach(key => {
+      this.params[key].forEach(value => {
+        callback.call(thisArg, value, key, this);
+      });
+    });
+  }
+}
+
+globalThis.URLSearchParams = URLSearchParams;
+globalThis.URL = URL;
+
+
+export default { URLSearchParams, URL }
+`;

package/vendor/quickjs/modules/util.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n\nclass TextEncoder {\n    encode(input = '') {\n        const utf8 = unescape(encodeURIComponent(input));\n        const result = new Uint8Array(utf8.length);\n        \n        for (let i = 0; i < utf8.length; i++) {\n            result[i] = utf8.charCodeAt(i);\n        }\n          \n        return result;\n    }\n}\n\nclass TextDecoder {\n    constructor(encoding = 'utf-8') {\n        if (encoding !== 'utf-8') {\n            throw new Error('Only utf-8 encoding is supported');\n        }\n    }\n\n    decode(input = new Uint8Array()) {\n        let str = '';\n        for (let i = 0; i < input.length; i++) {\n          str += String.fromCharCode(input[i]);\n        }\n        return decodeURIComponent(escape(str));\n    }\n}\n\n// Promisify: converts a callback-based function to a promise-based one\nfunction promisify(fn) {\n  return function (...args) {\n    return new Promise((resolve, reject) => {\n      fn(...args, (err, result) => {\n        if (err) {\n          reject(err);\n        } else {\n          resolve(result);\n        }\n      });\n    });\n  };\n}\n\n// Callbackify: converts a promise-based function to a callback-based one\nfunction callbackify(fn) {\n  return function (...args) {\n    const cb = args.pop();\n    fn(...args)\n      .then((result) => cb(null, result))\n      .catch((err) => cb(err));\n  };\n}\n\n// Inherits: implements inheritance\nfunction inherits(ctor, superCtor) {\n  if (typeof superCtor !== 'function' && superCtor !== null) {\n    throw new TypeError('Super constructor must either be a function or null');\n  }\n\n  ctor.super_ = superCtor;\n  if (Object.setPrototypeOf) {\n    Object.setPrototypeOf(ctor.prototype, superCtor.prototype);\n  } else {\n    ctor.prototype.__proto__ = superCtor.prototype;\n  }\n}\n\n// Deprecate: marks a method as deprecated\nfunction deprecate(fn, msg) {\n  let warned = false;\n  function deprecated(...args) {\n    if (!warned) {\n      console.warn(`DeprecationWarning: ${msg}`);\n      warned = true;\n    }\n    return fn.apply(this, args);\n  }\n  return deprecated;\n}\n\nconst types = {\n    isAnyArrayBuffer(value) {\n      return value instanceof ArrayBuffer || value instanceof SharedArrayBuffer;\n    },\n    isArrayBufferView(value) {\n      return ArrayBuffer.isView(value);\n    },\n    isArgumentsObject(value) {\n      return Object.prototype.toString.call(value) === '[object Arguments]';\n    },\n    isArrayBuffer(value) {\n      return value instanceof ArrayBuffer;\n    },\n    isAsyncFunction(value) {\n      return Object.prototype.toString.call(value) === '[object AsyncFunction]';\n    },\n    isBigInt64Array(value) {\n      return value instanceof BigInt64Array;\n    },\n    isBigUint64Array(value) {\n      return value instanceof BigUint64Array;\n    },\n    isBooleanObject(value) {\n      return typeof value === 'object' && typeof value.valueOf() === 'boolean';\n    },\n    isBoxedPrimitive(value) {\n      return ['[object Number]', '[object String]', '[object Boolean]', '[object Symbol]'].includes(Object.prototype.toString.call(value));\n    },\n    isCryptoKey(value) {\n      return typeof CryptoKey !== 'undefined' && value instanceof CryptoKey;\n    },\n    isDataView(value) {\n      return value instanceof DataView;\n    },\n    isDate(value) {\n      return value instanceof Date;\n    },\n    isExternal(value) {\n      return false; // Node.js specific\n    },\n    isFloat32Array(value) {\n      return value instanceof Float32Array;\n    },\n    isFloat64Array(value) {\n      return value instanceof Float64Array;\n    },\n    isGeneratorFunction(value) {\n      return Object.prototype.toString.call(value) === '[object GeneratorFunction]';\n    },\n    isGeneratorObject(value) {\n      return Object.prototype.toString.call(value) === '[object Generator]';\n    },\n    isInt8Array(value) {\n      return value instanceof Int8Array;\n    },\n    isInt16Array(value) {\n      return value instanceof Int16Array;\n    },\n    isInt32Array(value) {\n      return value instanceof Int32Array;\n    },\n    isKeyObject(value) {\n      return false; // Node.js specific\n    },\n    isMap(value) {\n      return value instanceof Map;\n    },\n    isMapIterator(value) {\n      return Object.prototype.toString.call(value) === '[object Map Iterator]';\n    },\n    isModuleNamespaceObject(value) {\n      return Object.prototype.toString.call(value) === '[object Module]';\n    },\n    isNativeError(value) {\n      return value instanceof Error;\n    },\n    isNumberObject(value) {\n      return typeof value === 'object' && typeof value.valueOf() === 'number';\n    },\n    isPromise(value) {\n      return value instanceof Promise;\n    },\n    isProxy(value) {\n      try {\n        Proxy.revocable(value, {});\n        return true;\n      } catch (e) {\n        return false;\n      }\n    },\n    isRegExp(value) {\n      return value instanceof RegExp;\n    },\n    isSet(value) {\n      return value instanceof Set;\n    },\n    isSetIterator(value) {\n      return Object.prototype.toString.call(value) === '[object Set Iterator]';\n    },\n    isSharedArrayBuffer(value) {\n      return value instanceof SharedArrayBuffer;\n    },\n    isStringObject(value) {\n      return typeof value === 'object' && typeof value.valueOf() === 'string';\n    },\n    isSymbolObject(value) {\n      return typeof value === 'object' && typeof value.valueOf() === 'symbol';\n    },\n    isTypedArray(value) {\n      return ArrayBuffer.isView(value) && !(value instanceof DataView);\n    },\n    isUint8Array(value) {\n      return value instanceof Uint8Array;\n    },\n    isUint8ClampedArray(value) {\n      return value instanceof Uint8ClampedArray;\n    },\n    isUint16Array(value) {\n      return value instanceof Uint16Array;\n    },\n    isUint32Array(value) {\n      return value instanceof Uint32Array;\n    },\n    isWeakMap(value) {\n      return value instanceof WeakMap;\n    },\n    isWeakSet(value) {\n      return value instanceof WeakSet;\n    },\n  }\n\n\nconst util = {\n  promisify,\n  callbackify,\n  inherits,\n  deprecate,\n  types,\n  TextEncoder,\n  TextDecoder\n};\n\nglobalThis.TextEncoder = TextEncoder;\nglobalThis.TextDecoder = TextDecoder;\n\nexport default util;\n\nexport { promisify, callbackify, inherits, deprecate, types, TextEncoder,TextDecoder };\n\n";
+export default _default;

package/vendor/quickjs/modules/util.js

@@ -0,0 +1,233 @@
+export default `
+
+class TextEncoder {
+    encode(input = '') {
+        const utf8 = unescape(encodeURIComponent(input));
+        const result = new Uint8Array(utf8.length);
+        
+        for (let i = 0; i < utf8.length; i++) {
+            result[i] = utf8.charCodeAt(i);
+        }
+          
+        return result;
+    }
+}
+
+class TextDecoder {
+    constructor(encoding = 'utf-8') {
+        if (encoding !== 'utf-8') {
+            throw new Error('Only utf-8 encoding is supported');
+        }
+    }
+
+    decode(input = new Uint8Array()) {
+        let str = '';
+        for (let i = 0; i < input.length; i++) {
+          str += String.fromCharCode(input[i]);
+        }
+        return decodeURIComponent(escape(str));
+    }
+}
+
+// Promisify: converts a callback-based function to a promise-based one
+function promisify(fn) {
+  return function (...args) {
+    return new Promise((resolve, reject) => {
+      fn(...args, (err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  };
+}
+
+// Callbackify: converts a promise-based function to a callback-based one
+function callbackify(fn) {
+  return function (...args) {
+    const cb = args.pop();
+    fn(...args)
+      .then((result) => cb(null, result))
+      .catch((err) => cb(err));
+  };
+}
+
+// Inherits: implements inheritance
+function inherits(ctor, superCtor) {
+  if (typeof superCtor !== 'function' && superCtor !== null) {
+    throw new TypeError('Super constructor must either be a function or null');
+  }
+
+  ctor.super_ = superCtor;
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+  } else {
+    ctor.prototype.__proto__ = superCtor.prototype;
+  }
+}
+
+// Deprecate: marks a method as deprecated
+function deprecate(fn, msg) {
+  let warned = false;
+  function deprecated(...args) {
+    if (!warned) {
+      console.warn(\`DeprecationWarning: \${msg}\`);
+      warned = true;
+    }
+    return fn.apply(this, args);
+  }
+  return deprecated;
+}
+
+const types = {
+    isAnyArrayBuffer(value) {
+      return value instanceof ArrayBuffer || value instanceof SharedArrayBuffer;
+    },
+    isArrayBufferView(value) {
+      return ArrayBuffer.isView(value);
+    },
+    isArgumentsObject(value) {
+      return Object.prototype.toString.call(value) === '[object Arguments]';
+    },
+    isArrayBuffer(value) {
+      return value instanceof ArrayBuffer;
+    },
+    isAsyncFunction(value) {
+      return Object.prototype.toString.call(value) === '[object AsyncFunction]';
+    },
+    isBigInt64Array(value) {
+      return value instanceof BigInt64Array;
+    },
+    isBigUint64Array(value) {
+      return value instanceof BigUint64Array;
+    },
+    isBooleanObject(value) {
+      return typeof value === 'object' && typeof value.valueOf() === 'boolean';
+    },
+    isBoxedPrimitive(value) {
+      return ['[object Number]', '[object String]', '[object Boolean]', '[object Symbol]'].includes(Object.prototype.toString.call(value));
+    },
+    isCryptoKey(value) {
+      return typeof CryptoKey !== 'undefined' && value instanceof CryptoKey;
+    },
+    isDataView(value) {
+      return value instanceof DataView;
+    },
+    isDate(value) {
+      return value instanceof Date;
+    },
+    isExternal(value) {
+      return false; // Node.js specific
+    },
+    isFloat32Array(value) {
+      return value instanceof Float32Array;
+    },
+    isFloat64Array(value) {
+      return value instanceof Float64Array;
+    },
+    isGeneratorFunction(value) {
+      return Object.prototype.toString.call(value) === '[object GeneratorFunction]';
+    },
+    isGeneratorObject(value) {
+      return Object.prototype.toString.call(value) === '[object Generator]';
+    },
+    isInt8Array(value) {
+      return value instanceof Int8Array;
+    },
+    isInt16Array(value) {
+      return value instanceof Int16Array;
+    },
+    isInt32Array(value) {
+      return value instanceof Int32Array;
+    },
+    isKeyObject(value) {
+      return false; // Node.js specific
+    },
+    isMap(value) {
+      return value instanceof Map;
+    },
+    isMapIterator(value) {
+      return Object.prototype.toString.call(value) === '[object Map Iterator]';
+    },
+    isModuleNamespaceObject(value) {
+      return Object.prototype.toString.call(value) === '[object Module]';
+    },
+    isNativeError(value) {
+      return value instanceof Error;
+    },
+    isNumberObject(value) {
+      return typeof value === 'object' && typeof value.valueOf() === 'number';
+    },
+    isPromise(value) {
+      return value instanceof Promise;
+    },
+    isProxy(value) {
+      try {
+        Proxy.revocable(value, {});
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    isRegExp(value) {
+      return value instanceof RegExp;
+    },
+    isSet(value) {
+      return value instanceof Set;
+    },
+    isSetIterator(value) {
+      return Object.prototype.toString.call(value) === '[object Set Iterator]';
+    },
+    isSharedArrayBuffer(value) {
+      return value instanceof SharedArrayBuffer;
+    },
+    isStringObject(value) {
+      return typeof value === 'object' && typeof value.valueOf() === 'string';
+    },
+    isSymbolObject(value) {
+      return typeof value === 'object' && typeof value.valueOf() === 'symbol';
+    },
+    isTypedArray(value) {
+      return ArrayBuffer.isView(value) && !(value instanceof DataView);
+    },
+    isUint8Array(value) {
+      return value instanceof Uint8Array;
+    },
+    isUint8ClampedArray(value) {
+      return value instanceof Uint8ClampedArray;
+    },
+    isUint16Array(value) {
+      return value instanceof Uint16Array;
+    },
+    isUint32Array(value) {
+      return value instanceof Uint32Array;
+    },
+    isWeakMap(value) {
+      return value instanceof WeakMap;
+    },
+    isWeakSet(value) {
+      return value instanceof WeakSet;
+    },
+  }
+
+
+const util = {
+  promisify,
+  callbackify,
+  inherits,
+  deprecate,
+  types,
+  TextEncoder,
+  TextDecoder
+};
+
+globalThis.TextEncoder = TextEncoder;
+globalThis.TextDecoder = TextDecoder;
+
+export default util;
+
+export { promisify, callbackify, inherits, deprecate, types, TextEncoder,TextDecoder };
+
+`;

package/vendor/quickjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/vendor/quickjs/sandbox/asyncVersion/createAsyncEvalCodeFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Scope } from 'quickjs-emscripten-core';
+import type { CodeFunctionAsyncInput } from '../../types/CodeFunctionInput.js';
+import type { SandboxEvalCode } from '../../types/SandboxEvalCode.js';
+export declare const createAsyncEvalCodeFunction: (input: CodeFunctionAsyncInput, scope: Scope) => SandboxEvalCode;