quickjs 0.11.2 → 0.13.0.pre

data/polyfills/src/encoding.js

@@ -0,0 +1,231 @@
+// WHATWG TextEncoder/TextDecoder polyfill for QuickJS
+// Spec: https://encoding.spec.whatwg.org/
+
+class TextEncoder {
+  get encoding() {
+    return "utf-8";
+  }
+
+  encode(input = "") {
+    const str = String(input);
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+      let code = str.charCodeAt(i);
+
+      if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+        const next = str.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+          i++;
+        }
+      }
+
+      if (code <= 0x7f) {
+        bytes.push(code);
+      } else if (code <= 0x7ff) {
+        bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+      } else if (code <= 0xffff) {
+        bytes.push(
+          0xe0 | (code >> 12),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f)
+        );
+      } else {
+        bytes.push(
+          0xf0 | (code >> 18),
+          0x80 | ((code >> 12) & 0x3f),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f)
+        );
+      }
+    }
+    return new Uint8Array(bytes);
+  }
+
+  encodeInto(source, destination) {
+    const str = String(source);
+    let read = 0;
+    let written = 0;
+
+    for (let i = 0; i < str.length; i++) {
+      let code = str.charCodeAt(i);
+
+      if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+        const next = str.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          if (written + 4 > destination.length) break;
+          code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+          destination[written++] = 0xf0 | (code >> 18);
+          destination[written++] = 0x80 | ((code >> 12) & 0x3f);
+          destination[written++] = 0x80 | ((code >> 6) & 0x3f);
+          destination[written++] = 0x80 | (code & 0x3f);
+          read += 2;
+          i++;
+          continue;
+        }
+      }
+
+      let byteCount;
+      if (code <= 0x7f) byteCount = 1;
+      else if (code <= 0x7ff) byteCount = 2;
+      else byteCount = 3;
+
+      if (written + byteCount > destination.length) break;
+
+      if (byteCount === 1) {
+        destination[written++] = code;
+      } else if (byteCount === 2) {
+        destination[written++] = 0xc0 | (code >> 6);
+        destination[written++] = 0x80 | (code & 0x3f);
+      } else {
+        destination[written++] = 0xe0 | (code >> 12);
+        destination[written++] = 0x80 | ((code >> 6) & 0x3f);
+        destination[written++] = 0x80 | (code & 0x3f);
+      }
+      read++;
+    }
+
+    return { read, written };
+  }
+}
+
+const UTF8_LABELS = [
+  "unicode-1-1-utf-8", "unicode11utf8", "unicode20utf8",
+  "utf-8", "utf8", "x-unicode20utf8",
+];
+
+function normalizeEncodingLabel(label) {
+  const normalized = label.trim().toLowerCase();
+  if (UTF8_LABELS.includes(normalized)) return "utf-8";
+  return null;
+}
+
+class TextDecoder {
+  #encoding;
+  #fatal;
+  #ignoreBOM;
+
+  constructor(label = "utf-8", options = {}) {
+    const normalized = normalizeEncodingLabel(String(label));
+    if (!normalized) {
+      throw new RangeError(`The "${label}" encoding is not supported.`);
+    }
+    this.#encoding = normalized;
+    this.#fatal = Boolean(options.fatal);
+    this.#ignoreBOM = Boolean(options.ignoreBOM);
+  }
+
+  get encoding() {
+    return this.#encoding;
+  }
+
+  get fatal() {
+    return this.#fatal;
+  }
+
+  get ignoreBOM() {
+    return this.#ignoreBOM;
+  }
+
+  decode(input, options = {}) {
+    if (input === undefined || input === null) return "";
+
+    let bytes;
+    if (input instanceof ArrayBuffer) {
+      bytes = new Uint8Array(input);
+    } else if (ArrayBuffer.isView(input)) {
+      bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    } else {
+      throw new TypeError(
+        "The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"
+      );
+    }
+
+    let start = 0;
+    if (
+      !this.#ignoreBOM &&
+      bytes.length >= 3 &&
+      bytes[0] === 0xef &&
+      bytes[1] === 0xbb &&
+      bytes[2] === 0xbf
+    ) {
+      start = 3;
+    }
+
+    return decodeUTF8(bytes, start, this.#fatal);
+  }
+}
+
+function decodeUTF8(bytes, start, fatal) {
+  let str = "";
+  let i = start;
+  while (i < bytes.length) {
+    const b = bytes[i];
+    let code, byteLen;
+
+    if (b <= 0x7f) {
+      code = b;
+      byteLen = 1;
+    } else if ((b & 0xe0) === 0xc0) {
+      if (i + 1 >= bytes.length || (bytes[i + 1] & 0xc0) !== 0x80) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code = ((b & 0x1f) << 6) | (bytes[i + 1] & 0x3f);
+      byteLen = 2;
+    } else if ((b & 0xf0) === 0xe0) {
+      if (
+        i + 2 >= bytes.length ||
+        (bytes[i + 1] & 0xc0) !== 0x80 ||
+        (bytes[i + 2] & 0xc0) !== 0x80
+      ) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code =
+        ((b & 0x0f) << 12) |
+        ((bytes[i + 1] & 0x3f) << 6) |
+        (bytes[i + 2] & 0x3f);
+      byteLen = 3;
+    } else if ((b & 0xf8) === 0xf0) {
+      if (
+        i + 3 >= bytes.length ||
+        (bytes[i + 1] & 0xc0) !== 0x80 ||
+        (bytes[i + 2] & 0xc0) !== 0x80 ||
+        (bytes[i + 3] & 0xc0) !== 0x80
+      ) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code =
+        ((b & 0x07) << 18) |
+        ((bytes[i + 1] & 0x3f) << 12) |
+        ((bytes[i + 2] & 0x3f) << 6) |
+        (bytes[i + 3] & 0x3f);
+      byteLen = 4;
+    } else {
+      if (fatal) throw new TypeError("The encoded data was not valid.");
+      str += "\ufffd";
+      i++;
+      continue;
+    }
+
+    if (code <= 0xffff) {
+      str += String.fromCharCode(code);
+    } else {
+      code -= 0x10000;
+      str += String.fromCharCode(0xd800 + (code >> 10), 0xdc00 + (code & 0x3ff));
+    }
+    i += byteLen;
+  }
+  return str;
+}
+
+globalThis.TextEncoder = TextEncoder;
+globalThis.TextDecoder = TextDecoder;

data/polyfills/src/file.js

@@ -0,0 +1,218 @@
+// W3C Blob and File polyfill for QuickJS
+// Spec: https://www.w3.org/TR/FileAPI/
+
+class Blob {
+  #bytes;
+  #type;
+
+  constructor(blobParts, options) {
+    this.#type = normalizeType(options?.type ?? "");
+
+    if (!blobParts) {
+      this.#bytes = new Uint8Array(0);
+      return;
+    }
+
+    if (!Array.isArray(blobParts)) {
+      throw new TypeError(
+        "Failed to construct 'Blob': The provided value cannot be converted to a sequence."
+      );
+    }
+
+    const parts = [];
+    let totalLength = 0;
+
+    for (const part of blobParts) {
+      let bytes;
+      if (typeof part === "string") {
+        bytes = encodeUTF8(part);
+      } else if (part instanceof ArrayBuffer) {
+        bytes = new Uint8Array(part);
+      } else if (ArrayBuffer.isView(part)) {
+        bytes = new Uint8Array(part.buffer, part.byteOffset, part.byteLength);
+      } else if (part instanceof Blob) {
+        bytes = part.#bytes;
+      } else {
+        bytes = encodeUTF8(String(part));
+      }
+      parts.push(bytes);
+      totalLength += bytes.byteLength;
+    }
+
+    const merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const part of parts) {
+      merged.set(part, offset);
+      offset += part.byteLength;
+    }
+    this.#bytes = merged;
+  }
+
+  get size() {
+    return this.#bytes.byteLength;
+  }
+
+  get type() {
+    return this.#type;
+  }
+
+  slice(start, end, contentType) {
+    const size = this.size;
+    let relStart = start === undefined ? 0 : clampIndex(start, size);
+    let relEnd = end === undefined ? size : clampIndex(end, size);
+    const span = Math.max(relEnd - relStart, 0);
+
+    const sliced = new Blob();
+    sliced.#bytes = this.#bytes.slice(relStart, relStart + span);
+    sliced.#type = normalizeType(contentType ?? "");
+    return sliced;
+  }
+
+  text() {
+    return Promise.resolve(decodeUTF8(this.#bytes));
+  }
+
+  arrayBuffer() {
+    return Promise.resolve(this.#bytes.buffer.slice(this.#bytes.byteOffset, this.#bytes.byteOffset + this.#bytes.byteLength));
+  }
+
+  toString() {
+    return "[object Blob]";
+  }
+
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+}
+
+function normalizeType(type) {
+  // Spec: type must be lowercase ASCII without 0x20-7E exclusions
+  if (/[^\x20-\x7E]/.test(type)) {
+    return "";
+  }
+  return type.toLowerCase();
+}
+
+function clampIndex(index, size) {
+  if (index < 0) {
+    return Math.max(size + index, 0);
+  }
+  return Math.min(index, size);
+}
+
+function encodeUTF8(str) {
+  // Manual UTF-8 encoding for QuickJS (no TextEncoder)
+  const utf8 = [];
+  for (let i = 0; i < str.length; i++) {
+    let code = str.charCodeAt(i);
+
+    // Handle surrogate pairs
+    if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+      const next = str.charCodeAt(i + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+        i++;
+      }
+    }
+
+    if (code <= 0x7f) {
+      utf8.push(code);
+    } else if (code <= 0x7ff) {
+      utf8.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    } else if (code <= 0xffff) {
+      utf8.push(
+        0xe0 | (code >> 12),
+        0x80 | ((code >> 6) & 0x3f),
+        0x80 | (code & 0x3f)
+      );
+    } else {
+      utf8.push(
+        0xf0 | (code >> 18),
+        0x80 | ((code >> 12) & 0x3f),
+        0x80 | ((code >> 6) & 0x3f),
+        0x80 | (code & 0x3f)
+      );
+    }
+  }
+  return new Uint8Array(utf8);
+}
+
+function decodeUTF8(bytes) {
+  // Manual UTF-8 decoding for QuickJS (no TextDecoder)
+  let str = "";
+  let i = 0;
+  while (i < bytes.length) {
+    let code;
+    const b = bytes[i];
+    if (b <= 0x7f) {
+      code = b;
+      i++;
+    } else if ((b & 0xe0) === 0xc0) {
+      code = ((b & 0x1f) << 6) | (bytes[i + 1] & 0x3f);
+      i += 2;
+    } else if ((b & 0xf0) === 0xe0) {
+      code =
+        ((b & 0x0f) << 12) |
+        ((bytes[i + 1] & 0x3f) << 6) |
+        (bytes[i + 2] & 0x3f);
+      i += 3;
+    } else {
+      code =
+        ((b & 0x07) << 18) |
+        ((bytes[i + 1] & 0x3f) << 12) |
+        ((bytes[i + 2] & 0x3f) << 6) |
+        (bytes[i + 3] & 0x3f);
+      i += 4;
+    }
+
+    if (code <= 0xffff) {
+      str += String.fromCharCode(code);
+    } else {
+      // Encode as surrogate pair
+      code -= 0x10000;
+      str += String.fromCharCode(0xd800 + (code >> 10), 0xdc00 + (code & 0x3ff));
+    }
+  }
+  return str;
+}
+
+class File extends Blob {
+  #name;
+  #lastModified;
+
+  constructor(fileBits, fileName, options) {
+    if (arguments.length < 2) {
+      throw new TypeError(
+        "Failed to construct 'File': 2 arguments required, but only " +
+          arguments.length +
+          " present."
+      );
+    }
+
+    super(fileBits, options);
+    this.#name = String(fileName);
+    this.#lastModified =
+      options?.lastModified !== undefined
+        ? Number(options.lastModified)
+        : Date.now();
+  }
+
+  get name() {
+    return this.#name;
+  }
+
+  get lastModified() {
+    return this.#lastModified;
+  }
+
+  toString() {
+    return "[object File]";
+  }
+
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+}
+
+globalThis.Blob = Blob;
+globalThis.File = File;

data/polyfills/src/intl-en.js

@@ -0,0 +1,15 @@
+// FormatJS Intl polyfills for QuickJS (no native Intl support)
+// Order matters: getCanonicalLocales and Locale are deps of the others
+
+import "@formatjs/intl-getcanonicallocales/polyfill-force.js";
+import "@formatjs/intl-locale/polyfill-force.js";
+
+import "@formatjs/intl-pluralrules/polyfill-force.js";
+import "@formatjs/intl-pluralrules/locale-data/en";
+
+import "@formatjs/intl-numberformat/polyfill-force.js";
+import "@formatjs/intl-numberformat/locale-data/en";
+
+import "@formatjs/intl-datetimeformat/polyfill-force.js";
+import "@formatjs/intl-datetimeformat/locale-data/en";
+import "@formatjs/intl-datetimeformat/add-all-tz.js";

data/sig/quickjs.rbs

@@ -1,4 +1,72 @@
 module Quickjs
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  MODULE_STD: Symbol
+  MODULE_OS: Symbol
+  FEATURE_TIMEOUT: Symbol
+  POLYFILL_INTL: Symbol
+  POLYFILL_FILE: Symbol
+  POLYFILL_HTML_BASE64: Symbol
+
+  def self.eval_code: (String code, ?Hash[Symbol, untyped] overwrite_opts) -> untyped
+
+  class Value
+    UNDEFINED: Symbol
+    NAN: Symbol
+  end
+
+  class VM
+    def initialize: (?features: Array[Symbol], ?memory_limit: Integer, ?max_stack_size: Integer, ?timeout_msec: Integer) -> void
+
+    def eval_code: (String code) -> untyped
+
+    def define_function: (String | Symbol name, *Symbol flags) { (*untyped) -> untyped } -> Symbol
+
+    def import: (String | Array[String] | Hash[Symbol, String] imported, from: String, ?code_to_expose: String?) -> true
+
+    def logs: () -> Array[Log]
+
+    class Log
+      attr_reader severity: Symbol
+
+      def raw: () -> Array[untyped]
+
+      def to_s: () -> String
+
+      def inspect: () -> String
+    end
+  end
+
+  class RuntimeError < ::RuntimeError
+    def initialize: (String message, String? js_name) -> void
+
+    attr_reader js_name: String?
+  end
+
+  class SyntaxError < RuntimeError
+  end
+
+  class TypeError < RuntimeError
+  end
+
+  class ReferenceError < RuntimeError
+  end
+
+  class RangeError < RuntimeError
+  end
+
+  class EvalError < RuntimeError
+  end
+
+  class URIError < RuntimeError
+  end
+
+  class AggregateError < RuntimeError
+  end
+
+  class InterruptedError < RuntimeError
+  end
+
+  class NoAwaitError < RuntimeError
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.13.0.pre
 platform: ruby
 authors:
 - hmsk
@@ -46,6 +46,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE
 - README.md
 - Rakefile
@@ -77,9 +78,19 @@ files:
 - ext/quickjsrb/quickjs/unicode_gen_def.h
 - ext/quickjsrb/quickjsrb.c
 - ext/quickjsrb/quickjsrb.h
+- ext/quickjsrb/quickjsrb_file.c
+- ext/quickjsrb/quickjsrb_file.h
+- ext/quickjsrb/vendor/polyfill-encoding.min.js
+- ext/quickjsrb/vendor/polyfill-file.min.js
 - ext/quickjsrb/vendor/polyfill-intl-en.min.js
 - lib/quickjs.rb
 - lib/quickjs/version.rb
+- polyfills/package-lock.json
+- polyfills/package.json
+- polyfills/rolldown.config.mjs
+- polyfills/src/encoding.js
+- polyfills/src/file.js
+- polyfills/src/intl-en.js
 - sig/quickjs.rbs
 homepage: https://github.com/hmsk/quickjs.rb
 licenses: