@ccheever/exact-ibex-runtime 0.1.0

package/src/polyfills/array.ts

@@ -0,0 +1,236 @@
+// @ts-nocheck
+/**
+ * ES2023+ Array polyfills for Hermes engine
+ *
+ * - Array.prototype.toSorted()
+ * - Array.prototype.toReversed()
+ * - Array.prototype.with()
+ * - Array.prototype.toSpliced()
+ * - Array.fromAsync()
+ */
+
+export function installArrayPolyfills(): void {
+  // --------------------------------------------------------------------------
+  // Array.prototype.toSorted (ES2023)
+  // Returns a new sorted array without mutating the original.
+  // --------------------------------------------------------------------------
+  if (typeof Array.prototype.toSorted !== 'function') {
+    Object.defineProperty(Array.prototype, 'toSorted', {
+      value: function toSorted(
+        this: any[],
+        compareFn?: (a: any, b: any) => number,
+      ): any[] {
+        if (this == null) {
+          throw new TypeError('Array.prototype.toSorted called on null or undefined');
+        }
+        const o = Object(this);
+        const len = o.length >>> 0;
+        const copy = new Array(len);
+        for (let i = 0; i < len; i++) {
+          copy[i] = o[i];
+        }
+        copy.sort(compareFn);
+        return copy;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Array.prototype.toReversed (ES2023)
+  // Returns a new reversed array without mutating the original.
+  // --------------------------------------------------------------------------
+  if (typeof Array.prototype.toReversed !== 'function') {
+    Object.defineProperty(Array.prototype, 'toReversed', {
+      value: function toReversed(this: any[]): any[] {
+        if (this == null) {
+          throw new TypeError('Array.prototype.toReversed called on null or undefined');
+        }
+        const o = Object(this);
+        const len = o.length >>> 0;
+        const result = new Array(len);
+        for (let i = 0; i < len; i++) {
+          result[i] = o[len - 1 - i];
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Array.prototype.with (ES2023)
+  // Returns a new array with the element at the given index replaced.
+  // --------------------------------------------------------------------------
+  if (typeof (Array.prototype as any).with !== 'function') {
+    Object.defineProperty(Array.prototype, 'with', {
+      value: function withMethod(this: any[], index: number, value: any): any[] {
+        if (this == null) {
+          throw new TypeError('Array.prototype.with called on null or undefined');
+        }
+        const o = Object(this);
+        const len = o.length >>> 0;
+        const relativeIndex = Number(index);
+        const actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
+        if (actualIndex < 0 || actualIndex >= len) {
+          throw new RangeError(`Invalid index : ${index}`);
+        }
+        const result = new Array(len);
+        for (let i = 0; i < len; i++) {
+          result[i] = i === actualIndex ? value : o[i];
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Array.prototype.toSpliced (ES2023)
+  // Returns a new array with elements added/removed at the given index.
+  // --------------------------------------------------------------------------
+  if (typeof Array.prototype.toSpliced !== 'function') {
+    Object.defineProperty(Array.prototype, 'toSpliced', {
+      value: function toSpliced(
+        this: any[],
+        start: number,
+        deleteCount?: number,
+        ...items: any[]
+      ): any[] {
+        if (this == null) {
+          throw new TypeError('Array.prototype.toSpliced called on null or undefined');
+        }
+        const o = Object(this);
+        const len = o.length >>> 0;
+
+        // Normalize start
+        const relativeStart = Number(start) || 0;
+        let actualStart: number;
+        if (relativeStart < 0) {
+          actualStart = Math.max(len + relativeStart, 0);
+        } else {
+          actualStart = Math.min(relativeStart, len);
+        }
+
+        // Normalize deleteCount
+        let actualDeleteCount: number;
+        if (deleteCount === undefined && items.length === 0) {
+          // If called with only start, delete everything from start
+          actualDeleteCount = len - actualStart;
+        } else {
+          actualDeleteCount = Math.min(
+            Math.max(Number(deleteCount) || 0, 0),
+            len - actualStart,
+          );
+        }
+
+        const newLen = len - actualDeleteCount + items.length;
+        const result = new Array(newLen);
+        let r = 0;
+
+        // Copy elements before start
+        for (let i = 0; i < actualStart; i++) {
+          result[r++] = o[i];
+        }
+
+        // Insert new items
+        for (let i = 0; i < items.length; i++) {
+          result[r++] = items[i];
+        }
+
+        // Copy remaining elements after deleted section
+        for (let i = actualStart + actualDeleteCount; i < len; i++) {
+          result[r++] = o[i];
+        }
+
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Array.fromAsync (ES2024)
+  // Creates a new Array from an async iterable or iterable/array-like.
+  // --------------------------------------------------------------------------
+  if (typeof Array.fromAsync !== 'function') {
+    Object.defineProperty(Array, 'fromAsync', {
+      value: async function fromAsync(
+        arrayLike: any,
+        mapFn?: (value: any, index: number) => any,
+        thisArg?: any,
+      ): Promise<any[]> {
+        if (mapFn !== undefined && typeof mapFn !== 'function') {
+          throw new TypeError('mapFn must be a function');
+        }
+
+        const result: any[] = [];
+        let index = 0;
+
+        // Try async iterator first
+        if (arrayLike != null && typeof arrayLike[Symbol.asyncIterator] === 'function') {
+          const iterator = arrayLike[Symbol.asyncIterator]();
+          let shouldCloseIterator = false;
+
+          try {
+            while (true) {
+              const step = await iterator.next();
+              if (step.done) {
+                return result;
+              }
+
+              // Keep the iterator closable while mapping or pushing the current
+              // item so abrupt failures mirror for-await cleanup closely enough
+              // for our runtime.
+              shouldCloseIterator = true;
+              const value = mapFn ? await mapFn.call(thisArg, step.value, index) : step.value;
+              result.push(value);
+              index++;
+              shouldCloseIterator = false;
+            }
+          } catch (error) {
+            if (shouldCloseIterator && typeof iterator.return === 'function') {
+              try {
+                await iterator.return();
+              } catch {
+                // Preserve the original failure from the mapper or consumer.
+              }
+            }
+            throw error;
+          }
+        }
+
+        // Try sync iterator
+        if (arrayLike != null && typeof arrayLike[Symbol.iterator] === 'function') {
+          for (const item of arrayLike) {
+            const awaited = await item;
+            const value = mapFn ? await mapFn.call(thisArg, awaited, index) : awaited;
+            result.push(value);
+            index++;
+          }
+          return result;
+        }
+
+        // Array-like object
+        const len = (arrayLike && arrayLike.length) >>> 0;
+        for (let i = 0; i < len; i++) {
+          const awaited = await arrayLike[i];
+          const value = mapFn ? await mapFn.call(thisArg, awaited, i) : awaited;
+          result.push(value);
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}

package/src/polyfills/arraybuffer.ts

@@ -0,0 +1,172 @@
+// @ts-nocheck
+/**
+ * ES2024 ArrayBuffer transfer polyfills for Hermes engine
+ *
+ * - ArrayBuffer.prototype.transfer()
+ * - ArrayBuffer.prototype.transferToFixedLength()
+ */
+
+import { markDetachedArrayBuffer } from "../arraybuffer-detach";
+
+export function installArrayBufferPolyfills(): void {
+  const NativeArrayBuffer = ArrayBuffer;
+  const resizableBuffers = new WeakSet<ArrayBuffer>();
+  const maxByteLengthByBuffer = new WeakMap<ArrayBuffer, number>();
+
+  if (!(NativeArrayBuffer as any).__exactResizableWrapped) {
+    const WrappedArrayBuffer = function ArrayBuffer(
+      this: ArrayBuffer,
+      length: number,
+      options?: { maxByteLength?: number },
+    ): ArrayBuffer {
+      const buffer = new NativeArrayBuffer(length);
+      if (options && typeof options === 'object' && options.maxByteLength !== undefined) {
+        const maxByteLength = Number(options.maxByteLength);
+        if (!Number.isFinite(maxByteLength) || maxByteLength < buffer.byteLength) {
+          throw new RangeError('Invalid array buffer max length');
+        }
+        resizableBuffers.add(buffer);
+        maxByteLengthByBuffer.set(buffer, maxByteLength);
+      }
+      return buffer;
+    } as unknown as typeof ArrayBuffer;
+
+    WrappedArrayBuffer.prototype = NativeArrayBuffer.prototype;
+    Object.setPrototypeOf(WrappedArrayBuffer, NativeArrayBuffer);
+    Object.defineProperty(WrappedArrayBuffer, '__exactResizableWrapped', {
+      value: true,
+      configurable: true,
+    });
+    (globalThis as any).ArrayBuffer = WrappedArrayBuffer;
+  }
+
+  if (!Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'resizable')) {
+    Object.defineProperty(ArrayBuffer.prototype, 'resizable', {
+      get: function resizable(this: ArrayBuffer): boolean {
+        if (!(this instanceof ArrayBuffer)) {
+          throw new TypeError('resizable called on non-ArrayBuffer');
+        }
+        return resizableBuffers.has(this);
+      },
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  if (!Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'maxByteLength')) {
+    Object.defineProperty(ArrayBuffer.prototype, 'maxByteLength', {
+      get: function maxByteLength(this: ArrayBuffer): number {
+        if (!(this instanceof ArrayBuffer)) {
+          throw new TypeError('maxByteLength called on non-ArrayBuffer');
+        }
+        return maxByteLengthByBuffer.get(this) ?? this.byteLength;
+      },
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  if (typeof (ArrayBuffer.prototype as any).resize !== 'function') {
+    Object.defineProperty(ArrayBuffer.prototype, 'resize', {
+      value: function resize(this: ArrayBuffer, newLength: number): void {
+        if (!(this instanceof ArrayBuffer)) {
+          throw new TypeError('resize called on non-ArrayBuffer');
+        }
+        if (!resizableBuffers.has(this)) {
+          throw new TypeError('Cannot resize a fixed-length ArrayBuffer');
+        }
+        const targetLength = Number(newLength);
+        if (!Number.isFinite(targetLength) || targetLength < 0) {
+          throw new RangeError('Invalid array buffer length');
+        }
+        if (targetLength > (maxByteLengthByBuffer.get(this) ?? this.byteLength)) {
+          throw new RangeError('Invalid array buffer length');
+        }
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // ArrayBuffer.prototype.transfer (ES2024)
+  // Creates a new ArrayBuffer with the same byte content, optionally resized,
+  // and detaches (neuters) the original. Since we cannot truly detach in pure
+  // JS, we zero the original buffer's bytes to simulate detachment.
+  // --------------------------------------------------------------------------
+  if (typeof ArrayBuffer.prototype.transfer !== 'function') {
+    Object.defineProperty(ArrayBuffer.prototype, 'transfer', {
+      value: function transfer(this: ArrayBuffer, newLength?: number): ArrayBuffer {
+        if (!(this instanceof ArrayBuffer)) {
+          throw new TypeError('transfer called on non-ArrayBuffer');
+        }
+
+        const oldLength = this.byteLength;
+        const targetLength = newLength !== undefined ? Number(newLength) : oldLength;
+
+        if (targetLength < 0 || !Number.isFinite(targetLength)) {
+          throw new RangeError('Invalid array buffer length');
+        }
+
+        const newBuffer = new ArrayBuffer(targetLength);
+        const copyLength = Math.min(oldLength, targetLength);
+
+        if (copyLength > 0) {
+          const source = new Uint8Array(this, 0, copyLength);
+          const target = new Uint8Array(newBuffer, 0, copyLength);
+          target.set(source);
+        }
+
+        markDetachedArrayBuffer(this);
+
+        return newBuffer;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // ArrayBuffer.prototype.transferToFixedLength (ES2024)
+  // Same as transfer, but the result is always a non-resizable ArrayBuffer.
+  // In our polyfill, all ArrayBuffers are fixed-length, so this is identical
+  // to transfer.
+  // --------------------------------------------------------------------------
+  if (typeof ArrayBuffer.prototype.transferToFixedLength !== 'function') {
+    Object.defineProperty(ArrayBuffer.prototype, 'transferToFixedLength', {
+      value: function transferToFixedLength(
+        this: ArrayBuffer,
+        newLength?: number,
+      ): ArrayBuffer {
+        if (!(this instanceof ArrayBuffer)) {
+          throw new TypeError('transferToFixedLength called on non-ArrayBuffer');
+        }
+
+        const oldLength = this.byteLength;
+        const targetLength = newLength !== undefined ? Number(newLength) : oldLength;
+
+        if (targetLength < 0 || !Number.isFinite(targetLength)) {
+          throw new RangeError('Invalid array buffer length');
+        }
+
+        const newBuffer = new ArrayBuffer(targetLength);
+        const copyLength = Math.min(oldLength, targetLength);
+
+        if (copyLength > 0) {
+          const source = new Uint8Array(this, 0, copyLength);
+          const target = new Uint8Array(newBuffer, 0, copyLength);
+          target.set(source);
+        }
+
+        markDetachedArrayBuffer(this);
+
+        return newBuffer;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}

package/src/polyfills/groupby.ts

@@ -0,0 +1,85 @@
+// @ts-nocheck
+/**
+ * ES2024 Object.groupBy and Map.groupBy polyfills for Hermes engine
+ *
+ * - Object.groupBy()
+ * - Map.groupBy()
+ */
+
+export function installGroupByPolyfills(): void {
+  // --------------------------------------------------------------------------
+  // Object.groupBy (ES2024)
+  // Groups elements of an iterable by a callback's return value into a
+  // null-prototype object.
+  // --------------------------------------------------------------------------
+  if (typeof Object.groupBy !== 'function') {
+    Object.defineProperty(Object, 'groupBy', {
+      value: function groupBy<T>(
+        items: Iterable<T>,
+        callbackFn: (element: T, index: number) => PropertyKey,
+      ): Record<PropertyKey, T[]> {
+        if (typeof callbackFn !== 'function') {
+          throw new TypeError('callbackFn must be a function');
+        }
+        if (items == null) {
+          throw new TypeError('items is null or undefined');
+        }
+
+        const result = Object.create(null) as Record<PropertyKey, T[]>;
+        let index = 0;
+
+        for (const item of items) {
+          const key = callbackFn(item, index++);
+          if (key in result) {
+            result[key].push(item);
+          } else {
+            result[key] = [item];
+          }
+        }
+
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Map.groupBy (ES2024)
+  // Groups elements of an iterable by a callback's return value into a Map.
+  // --------------------------------------------------------------------------
+  if (typeof Map.groupBy !== 'function') {
+    Object.defineProperty(Map, 'groupBy', {
+      value: function groupBy<T, K>(
+        items: Iterable<T>,
+        callbackFn: (element: T, index: number) => K,
+      ): Map<K, T[]> {
+        if (typeof callbackFn !== 'function') {
+          throw new TypeError('callbackFn must be a function');
+        }
+        if (items == null) {
+          throw new TypeError('items is null or undefined');
+        }
+
+        const result = new Map<K, T[]>();
+        let index = 0;
+
+        for (const item of items) {
+          const key = callbackFn(item, index++);
+          const group = result.get(key);
+          if (group !== undefined) {
+            group.push(item);
+          } else {
+            result.set(key, [item]);
+          }
+        }
+
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}

package/src/polyfills/index.ts

@@ -0,0 +1,85 @@
+/**
+ * ES2023+ Polyfills for Hermes Engine
+ *
+ * Installs all modern JavaScript polyfills that Hermes doesn't natively support.
+ * Each polyfill checks for existing implementations before installing.
+ *
+ * Covers:
+ * - Array: toSorted, toReversed, with, toSpliced, fromAsync
+ * - Object/Map: groupBy
+ * - Set: union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf, isDisjointFrom
+ * - Promise: withResolvers
+ * - String: isWellFormed, toWellFormed
+ * - ArrayBuffer: transfer, transferToFixedLength
+ * - Iterator: map, filter, take, drop, flatMap, reduce, toArray, forEach, some, every, find, from
+ * - Intl: PluralRules, ListFormat, RelativeTimeFormat, Segmenter, DisplayNames,
+ *         DateTimeFormat.formatRange/formatToParts, NumberFormat.formatRange/formatToParts
+ */
+
+import { installArrayPolyfills } from './array';
+import { installGroupByPolyfills } from './groupby';
+import { installSetPolyfills } from './set';
+import { installPromisePolyfills } from './promise';
+import { installStringPolyfills } from './string';
+import { installArrayBufferPolyfills } from './arraybuffer';
+import { installTypedArrayPolyfills } from './typedarray';
+import { installIteratorPolyfills } from './iterator';
+import { installIntlPolyfills } from './intl';
+
+/**
+ * Install all ES2023+ polyfills.
+ * Safe to call multiple times; each polyfill checks before installing.
+ */
+export function installPolyfills(): void {
+  installArrayPolyfills();
+  installGroupByPolyfills();
+  installSetPolyfills();
+  installPromisePolyfills();
+  installStringPolyfills();
+  installArrayBufferPolyfills();
+  installTypedArrayPolyfills();
+  installIteratorPolyfills();
+
+  // Intl polyfills are deferred until first access to reduce startup cost.
+  // Hermes provides an empty Intl object; we proxy it so that accessing
+  // any Intl method (e.g., Intl.DateTimeFormat) triggers the full install.
+  const g = globalThis as any;
+  if (typeof g.Intl === 'object' && g.Intl !== null) {
+    const realIntl = g.Intl;
+    let installed = false;
+    function ensureIntl() {
+      if (installed) return;
+      installed = true;
+      // Restore the real Intl before installing so the polyfills
+      // can detect what's already there.
+      g.Intl = realIntl;
+      installIntlPolyfills();
+    }
+    g.Intl = new Proxy(realIntl, {
+      get(target: any, prop: string | symbol, receiver: any) {
+        ensureIntl();
+        return Reflect.get(g.Intl, prop, receiver);
+      },
+      has(target: any, prop: string | symbol) {
+        ensureIntl();
+        return Reflect.has(g.Intl, prop);
+      },
+    });
+  } else {
+    // No Intl object at all — install eagerly
+    installIntlPolyfills();
+  }
+}
+
+// Re-export individual installers for selective use
+export {
+  installArrayPolyfills,
+  installGroupByPolyfills,
+  installSetPolyfills,
+  installPromisePolyfills,
+  installStringPolyfills,
+  installArrayBufferPolyfills,
+  installTypedArrayPolyfills,
+  installIteratorPolyfills,
+  installIntlPolyfills,
+};