quickjs 0.11.1 → 0.12.0

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";

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - hmsk
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -47,6 +46,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE
 - README.md
 - Rakefile
@@ -78,9 +78,15 @@ files:
 - ext/quickjsrb/quickjs/unicode_gen_def.h
 - ext/quickjsrb/quickjsrb.c
 - ext/quickjsrb/quickjsrb.h
+- 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/file.js
+- polyfills/src/intl-en.js
 - sig/quickjs.rbs
 homepage: https://github.com/hmsk/quickjs.rb
 licenses:
@@ -89,7 +95,6 @@ metadata:
   homepage_uri: https://github.com/hmsk/quickjs.rb
   source_code_uri: https://github.com/hmsk/quickjs.rb
   changelog_uri: https://github.com/hmsk/quickjs.rb/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,8 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Run binding of QuickJS
 test_files: []