@ccheever/exact-ibex-runtime 0.1.0

package/src/polyfills/set.ts

@@ -0,0 +1,245 @@
+// @ts-nocheck
+/**
+ * ES2025 Set methods polyfills for Hermes engine
+ *
+ * - Set.prototype.union()
+ * - Set.prototype.intersection()
+ * - Set.prototype.difference()
+ * - Set.prototype.symmetricDifference()
+ * - Set.prototype.isSubsetOf()
+ * - Set.prototype.isSupersetOf()
+ * - Set.prototype.isDisjointFrom()
+ */
+
+/**
+ * Helper: get the size of a Set-like object.
+ */
+function getSetLikeSize(other: any): number {
+  if (typeof other.size === 'number') return other.size;
+  if (typeof other.size === 'function') return other.size();
+  throw new TypeError('Set-like object must have a size property');
+}
+
+/**
+ * Helper: ensure a Set-like has the minimum required interface.
+ */
+function requireSetLike(other: any): void {
+  if (other == null || typeof other !== 'object') {
+    throw new TypeError('The argument must be a Set-like object');
+  }
+  if (typeof other.has !== 'function') {
+    throw new TypeError('Set-like object must have a has method');
+  }
+}
+
+export function installSetPolyfills(): void {
+  // --------------------------------------------------------------------------
+  // Set.prototype.union
+  // Returns a new Set containing all elements from both this and other.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.union !== 'function') {
+    Object.defineProperty(Set.prototype, 'union', {
+      value: function union<T>(this: Set<T>, other: Set<T>): Set<T> {
+        requireSetLike(other);
+        const result = new Set<T>(this);
+        if (typeof other[Symbol.iterator] === 'function') {
+          for (const value of other) {
+            result.add(value);
+          }
+        } else if (typeof other.forEach === 'function') {
+          other.forEach((value: T) => result.add(value));
+        } else {
+          throw new TypeError('Set-like object must be iterable or have forEach');
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.intersection
+  // Returns a new Set containing elements present in both this and other.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.intersection !== 'function') {
+    Object.defineProperty(Set.prototype, 'intersection', {
+      value: function intersection<T>(this: Set<T>, other: Set<T>): Set<T> {
+        requireSetLike(other);
+        const result = new Set<T>();
+        const otherSize = getSetLikeSize(other);
+
+        // Iterate the smaller set for performance
+        if (this.size <= otherSize) {
+          for (const value of this) {
+            if (other.has(value)) {
+              result.add(value);
+            }
+          }
+        } else {
+          if (typeof other[Symbol.iterator] === 'function') {
+            for (const value of other) {
+              if (this.has(value)) {
+                result.add(value);
+              }
+            }
+          } else if (typeof other.forEach === 'function') {
+            other.forEach((value: T) => {
+              if (this.has(value)) {
+                result.add(value);
+              }
+            });
+          }
+        }
+
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.difference
+  // Returns a new Set containing elements in this but not in other.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.difference !== 'function') {
+    Object.defineProperty(Set.prototype, 'difference', {
+      value: function difference<T>(this: Set<T>, other: Set<T>): Set<T> {
+        requireSetLike(other);
+        const result = new Set<T>();
+        for (const value of this) {
+          if (!other.has(value)) {
+            result.add(value);
+          }
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.symmetricDifference
+  // Returns a new Set containing elements in either this or other, but not both.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.symmetricDifference !== 'function') {
+    Object.defineProperty(Set.prototype, 'symmetricDifference', {
+      value: function symmetricDifference<T>(this: Set<T>, other: Set<T>): Set<T> {
+        requireSetLike(other);
+        const result = new Set<T>(this);
+        if (typeof other[Symbol.iterator] === 'function') {
+          for (const value of other) {
+            if (result.has(value)) {
+              result.delete(value);
+            } else {
+              result.add(value);
+            }
+          }
+        } else if (typeof other.forEach === 'function') {
+          other.forEach((value: T) => {
+            if (result.has(value)) {
+              result.delete(value);
+            } else {
+              result.add(value);
+            }
+          });
+        }
+        return result;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.isSubsetOf
+  // Returns true if every element of this is in other.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.isSubsetOf !== 'function') {
+    Object.defineProperty(Set.prototype, 'isSubsetOf', {
+      value: function isSubsetOf<T>(this: Set<T>, other: Set<T>): boolean {
+        requireSetLike(other);
+        const otherSize = getSetLikeSize(other);
+        if (this.size > otherSize) return false;
+        for (const value of this) {
+          if (!other.has(value)) return false;
+        }
+        return true;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.isSupersetOf
+  // Returns true if every element of other is in this.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.isSupersetOf !== 'function') {
+    Object.defineProperty(Set.prototype, 'isSupersetOf', {
+      value: function isSupersetOf<T>(this: Set<T>, other: Set<T>): boolean {
+        requireSetLike(other);
+        const otherSize = getSetLikeSize(other);
+        if (this.size < otherSize) return false;
+        if (typeof other[Symbol.iterator] === 'function') {
+          for (const value of other) {
+            if (!this.has(value)) return false;
+          }
+        } else if (typeof other.forEach === 'function') {
+          let allPresent = true;
+          other.forEach((value: T) => {
+            if (!this.has(value)) allPresent = false;
+          });
+          return allPresent;
+        }
+        return true;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // Set.prototype.isDisjointFrom
+  // Returns true if this and other have no elements in common.
+  // --------------------------------------------------------------------------
+  if (typeof Set.prototype.isDisjointFrom !== 'function') {
+    Object.defineProperty(Set.prototype, 'isDisjointFrom', {
+      value: function isDisjointFrom<T>(this: Set<T>, other: Set<T>): boolean {
+        requireSetLike(other);
+        const otherSize = getSetLikeSize(other);
+
+        // Iterate the smaller set
+        if (this.size <= otherSize) {
+          for (const value of this) {
+            if (other.has(value)) return false;
+          }
+        } else {
+          if (typeof other[Symbol.iterator] === 'function') {
+            for (const value of other) {
+              if (this.has(value)) return false;
+            }
+          } else if (typeof other.forEach === 'function') {
+            let disjoint = true;
+            other.forEach((value: T) => {
+              if (this.has(value)) disjoint = false;
+            });
+            return disjoint;
+          }
+        }
+        return true;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}

package/src/polyfills/string.ts

@@ -0,0 +1,85 @@
+// @ts-nocheck
+/**
+ * ES2024 String well-formed polyfills for Hermes engine
+ *
+ * - String.prototype.isWellFormed()
+ * - String.prototype.toWellFormed()
+ */
+
+export function installStringPolyfills(): void {
+  // --------------------------------------------------------------------------
+  // String.prototype.isWellFormed (ES2024)
+  // Returns true if the string contains no lone surrogates.
+  // A lone surrogate is a code unit in the range 0xD800-0xDBFF (high surrogate)
+  // not followed by 0xDC00-0xDFFF (low surrogate), or a low surrogate not
+  // preceded by a high surrogate.
+  // --------------------------------------------------------------------------
+  if (typeof String.prototype.isWellFormed !== 'function') {
+    Object.defineProperty(String.prototype, 'isWellFormed', {
+      value: function isWellFormed(this: string): boolean {
+        if (this == null) {
+          throw new TypeError('String.prototype.isWellFormed called on null or undefined');
+        }
+        const str = String(this);
+        for (let i = 0; i < str.length; i++) {
+          const code = str.charCodeAt(i);
+          // High surrogate
+          if (code >= 0xD800 && code <= 0xDBFF) {
+            const next = str.charCodeAt(i + 1);
+            // Must be followed by a low surrogate
+            if (next < 0xDC00 || next > 0xDFFF || i + 1 >= str.length) {
+              return false;
+            }
+            i++; // Skip the low surrogate
+          } else if (code >= 0xDC00 && code <= 0xDFFF) {
+            // Lone low surrogate
+            return false;
+          }
+        }
+        return true;
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+
+  // --------------------------------------------------------------------------
+  // String.prototype.toWellFormed (ES2024)
+  // Returns a new string with lone surrogates replaced by U+FFFD.
+  // --------------------------------------------------------------------------
+  if (typeof String.prototype.toWellFormed !== 'function') {
+    Object.defineProperty(String.prototype, 'toWellFormed', {
+      value: function toWellFormed(this: string): string {
+        if (this == null) {
+          throw new TypeError('String.prototype.toWellFormed called on null or undefined');
+        }
+        const str = String(this);
+        const result: string[] = [];
+        for (let i = 0; i < str.length; i++) {
+          const code = str.charCodeAt(i);
+          if (code >= 0xD800 && code <= 0xDBFF) {
+            const next = str.charCodeAt(i + 1);
+            if (next >= 0xDC00 && next <= 0xDFFF && i + 1 < str.length) {
+              // Valid surrogate pair
+              result.push(str[i], str[i + 1]);
+              i++;
+            } else {
+              // Lone high surrogate
+              result.push('\uFFFD');
+            }
+          } else if (code >= 0xDC00 && code <= 0xDFFF) {
+            // Lone low surrogate
+            result.push('\uFFFD');
+          } else {
+            result.push(str[i]);
+          }
+        }
+        return result.join('');
+      },
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}

package/src/polyfills/typedarray.ts

@@ -0,0 +1,110 @@
+function normalizeTypedArrayIndex(index: number | undefined, length: number): number {
+  if (index === undefined) {
+    return 0;
+  }
+
+  let value = Number(index);
+  if (!Number.isFinite(value) || value === 0) {
+    return 0;
+  }
+
+  value = value < 0 ? Math.ceil(value) : Math.floor(value);
+  if (value < 0) {
+    return Math.max(length + value, 0);
+  }
+  return Math.min(value, length);
+}
+
+export function installTypedArrayPolyfills(): void {
+  const typedArrayNames = [
+    'Int8Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Int16Array',
+    'Uint16Array',
+    'Int32Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+  ];
+  if (typeof (globalThis as any).BigInt64Array === 'function') {
+    typedArrayNames.push('BigInt64Array');
+  }
+  if (typeof (globalThis as any).BigUint64Array === 'function') {
+    typedArrayNames.push('BigUint64Array');
+  }
+
+  for (const ctorName of typedArrayNames) {
+    const TypedArrayCtor = (globalThis as any)[ctorName] as
+      | {
+          prototype: { subarray?: (begin?: number, end?: number) => ArrayBufferView };
+          BYTES_PER_ELEMENT?: number;
+        }
+      | undefined;
+    if (!TypedArrayCtor || typeof TypedArrayCtor.prototype?.subarray !== 'function') {
+      continue;
+    }
+
+    const originalSubarray = TypedArrayCtor.prototype.subarray as typeof Uint8Array.prototype.subarray & {
+      __exactZeroLengthWrapped?: boolean;
+    };
+    if (originalSubarray.__exactZeroLengthWrapped) {
+      continue;
+    }
+
+    const bytesPerElement =
+      TypedArrayCtor.BYTES_PER_ELEMENT ??
+      (TypedArrayCtor.prototype as { BYTES_PER_ELEMENT?: number }).BYTES_PER_ELEMENT ??
+      1;
+
+    const patchedSubarray = function (
+      this: { buffer: ArrayBufferLike; byteOffset: number; byteLength: number; length?: number },
+      begin?: number,
+      end?: number
+    ): ArrayBufferView {
+      const result = originalSubarray.call(this as any, begin, end);
+      if (
+        result.byteLength !== 0 ||
+        result.buffer !== this.buffer ||
+        !(this.buffer instanceof ArrayBuffer)
+      ) {
+        return result;
+      }
+
+      const length = typeof this.length === 'number'
+        ? this.length
+        : Math.floor(this.byteLength / bytesPerElement);
+      const start = normalizeTypedArrayIndex(begin, length);
+      const finish = end === undefined ? length : normalizeTypedArrayIndex(end, length);
+      if (finish !== start) {
+        return result;
+      }
+
+      const correctedByteOffset = this.byteOffset + start * bytesPerElement;
+      try {
+        Object.defineProperty(result, 'byteOffset', {
+          value: correctedByteOffset,
+          configurable: true,
+        });
+        return result;
+      } catch (_error) {
+        return new (TypedArrayCtor as any)(
+          this.buffer,
+          correctedByteOffset,
+          0
+        );
+      }
+    };
+
+    Object.defineProperty(patchedSubarray, '__exactZeroLengthWrapped', {
+      value: true,
+      configurable: true,
+    });
+    Object.defineProperty(TypedArrayCtor.prototype, 'subarray', {
+      value: patchedSubarray,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+}