@ccheever/exact-ibex-runtime 0.1.0

package/src/encoding/TextDecoderStream.ts

@@ -0,0 +1,58 @@
+// @ts-nocheck
+/**
+ * TextDecoderStream - Web Standard TextDecoderStream Implementation
+ *
+ * @see https://encoding.spec.whatwg.org/#interface-textdecoderstream
+ *
+ * Wraps a TransformStream that decodes Uint8Array chunks into string chunks
+ * using TextDecoder in streaming mode.
+ */
+
+import { TransformStream } from '../streams/TransformStream';
+import { TextDecoder } from './TextDecoder';
+import type { TextDecoderOptions } from './TextDecoder';
+
+export class TextDecoderStream {
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+  readonly readable: ReadableStream<string>;
+  readonly writable: WritableStream<Uint8Array>;
+
+  /** @internal */
+  private _transform: TransformStream<Uint8Array, string>;
+
+  constructor(label?: string, options?: TextDecoderOptions) {
+    // Create the underlying TextDecoder (validates the label/options)
+    const decoder = new TextDecoder(label, options);
+
+    this.encoding = decoder.encoding;
+    this.fatal = decoder.fatal;
+    this.ignoreBOM = decoder.ignoreBOM;
+
+    this._transform = new TransformStream<Uint8Array, string>({
+      transform(chunk: Uint8Array, controller) {
+        // Decode in streaming mode so incomplete multi-byte sequences
+        // are buffered until the next chunk arrives
+        const decoded = decoder.decode(chunk, { stream: true });
+        if (decoded.length > 0) {
+          controller.enqueue(decoded);
+        }
+      },
+      flush(controller) {
+        // Final call without stream: true to flush any pending bytes
+        const final = decoder.decode(undefined, { stream: false });
+        if (final.length > 0) {
+          controller.enqueue(final);
+        }
+      },
+    });
+
+    this.readable = this._transform.readable as unknown as ReadableStream<string>;
+    this.writable = this._transform.writable as unknown as WritableStream<Uint8Array>;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'TextDecoderStream';
+  }
+}

package/src/encoding/TextEncoder.ts

@@ -0,0 +1,180 @@
+/**
+ * TextEncoder - Web Standard TextEncoder Implementation
+ *
+ * @see https://encoding.spec.whatwg.org/#textencoder
+ */
+
+import { getNativeModule } from '../native/NativeModules';
+
+export interface TextEncoderEncodeIntoResult {
+  read: number;
+  written: number;
+}
+
+export class TextEncoder {
+  readonly encoding: "utf-8" = "utf-8";
+
+  /**
+   * Encode a string to UTF-8 bytes
+   *
+   * @param input String to encode
+   * @returns Uint8Array of UTF-8 bytes
+   */
+  encode(input?: string): Uint8Array {
+    if (input === undefined) {
+      return new Uint8Array(0);
+    }
+
+    const str = String(input);
+    
+    // Try native encoding for better performance
+    const nativeEncoding = getNativeModule('encoding');
+    if (nativeEncoding) {
+      return nativeEncoding.encodeUTF8(str);
+    }
+
+    // Fallback to JS implementation
+    const bytes: number[] = [];
+
+    for (let i = 0; i < str.length; i++) {
+      let codePoint = str.charCodeAt(i);
+
+      // Handle surrogate pairs
+      if (codePoint >= 0xd800 && codePoint <= 0xdbff) {
+        const high = codePoint;
+        const low = str.charCodeAt(++i);
+
+        if (low >= 0xdc00 && low <= 0xdfff) {
+          codePoint = (high - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+        } else {
+          // Unpaired high surrogate - use replacement character
+          codePoint = 0xfffd;
+          i--;
+        }
+      } else if (codePoint >= 0xdc00 && codePoint <= 0xdfff) {
+        // Unpaired low surrogate - use replacement character
+        codePoint = 0xfffd;
+      }
+
+      // Encode code point to UTF-8
+      if (codePoint <= 0x7f) {
+        bytes.push(codePoint);
+      } else if (codePoint <= 0x7ff) {
+        bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+      } else if (codePoint <= 0xffff) {
+        bytes.push(
+          0xe0 | (codePoint >> 12),
+          0x80 | ((codePoint >> 6) & 0x3f),
+          0x80 | (codePoint & 0x3f)
+        );
+      } else {
+        bytes.push(
+          0xf0 | (codePoint >> 18),
+          0x80 | ((codePoint >> 12) & 0x3f),
+          0x80 | ((codePoint >> 6) & 0x3f),
+          0x80 | (codePoint & 0x3f)
+        );
+      }
+    }
+
+    return new Uint8Array(bytes);
+  }
+
+  /**
+   * Encode a string into an existing Uint8Array
+   *
+   * @param source String to encode
+   * @param destination Uint8Array to write into
+   * @returns Object with read (chars) and written (bytes) counts
+   */
+  encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult {
+    if (!(destination instanceof Uint8Array)) {
+      throw new TypeError("encodeInto requires a Uint8Array destination");
+    }
+
+    // Handle detached ArrayBuffer
+    if (destination.buffer.byteLength === 0 && destination.byteLength === 0 && destination.length === 0) {
+      return { read: 0, written: 0 };
+    }
+
+    if (!source) {
+      return { read: 0, written: 0 };
+    }
+
+    let read = 0;
+    let written = 0;
+
+    for (let i = 0; i < source.length; i++) {
+      let codePoint = source.charCodeAt(i);
+      let bytesNeeded: number;
+      let isSurrogatePair = false;
+
+      // Handle surrogate pairs
+      if (codePoint >= 0xd800 && codePoint <= 0xdbff) {
+        const high = codePoint;
+        const low = source.charCodeAt(i + 1);
+
+        if (low >= 0xdc00 && low <= 0xdfff) {
+          codePoint = (high - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+          isSurrogatePair = true;
+        } else {
+          codePoint = 0xfffd;
+        }
+      } else if (codePoint >= 0xdc00 && codePoint <= 0xdfff) {
+        codePoint = 0xfffd;
+      }
+
+      // Calculate bytes needed
+      if (codePoint <= 0x7f) {
+        bytesNeeded = 1;
+      } else if (codePoint <= 0x7ff) {
+        bytesNeeded = 2;
+      } else if (codePoint <= 0xffff) {
+        bytesNeeded = 3;
+      } else {
+        bytesNeeded = 4;
+      }
+
+      // Check if we have room
+      if (written + bytesNeeded > destination.length) {
+        // If a surrogate pair doesn't fit as 4 bytes, fall back to treating
+        // the high surrogate as unpaired (U+FFFD = 3 bytes)
+        if (isSurrogatePair && written + 3 <= destination.length) {
+          codePoint = 0xfffd;
+          bytesNeeded = 3;
+          isSurrogatePair = false;
+        } else {
+          break;
+        }
+      }
+
+      // Write bytes
+      if (codePoint <= 0x7f) {
+        destination[written++] = codePoint;
+      } else if (codePoint <= 0x7ff) {
+        destination[written++] = 0xc0 | (codePoint >> 6);
+        destination[written++] = 0x80 | (codePoint & 0x3f);
+      } else if (codePoint <= 0xffff) {
+        destination[written++] = 0xe0 | (codePoint >> 12);
+        destination[written++] = 0x80 | ((codePoint >> 6) & 0x3f);
+        destination[written++] = 0x80 | (codePoint & 0x3f);
+      } else {
+        destination[written++] = 0xf0 | (codePoint >> 18);
+        destination[written++] = 0x80 | ((codePoint >> 12) & 0x3f);
+        destination[written++] = 0x80 | ((codePoint >> 6) & 0x3f);
+        destination[written++] = 0x80 | (codePoint & 0x3f);
+      }
+
+      // Count characters read
+      if (isSurrogatePair) {
+        // Surrogate pair = 2 UTF-16 code units
+        read += 2;
+        i++; // Skip the low surrogate
+      } else {
+        read += 1;
+      }
+    }
+
+    return { read, written };
+  }
+}

package/src/encoding/TextEncoderStream.ts

@@ -0,0 +1,39 @@
+/**
+ * TextEncoderStream - Web Standard TextEncoderStream Implementation
+ *
+ * @see https://encoding.spec.whatwg.org/#interface-textencoderstream
+ *
+ * Wraps a TransformStream that encodes string chunks into UTF-8 Uint8Array chunks.
+ */
+
+import { TransformStream } from '../streams/TransformStream';
+import { TextEncoder } from './TextEncoder';
+
+export class TextEncoderStream {
+  readonly encoding: "utf-8" = "utf-8";
+  readonly readable: ReadableStream<Uint8Array>;
+  readonly writable: WritableStream<string>;
+
+  /** @internal */
+  private _transform: TransformStream<string, Uint8Array>;
+
+  constructor() {
+    const encoder = new TextEncoder();
+
+    this._transform = new TransformStream<string, Uint8Array>({
+      transform(chunk: string, controller) {
+        const encoded = encoder.encode(String(chunk));
+        if (encoded.length > 0) {
+          controller.enqueue(encoded);
+        }
+      },
+    });
+
+    this.readable = this._transform.readable as unknown as ReadableStream<Uint8Array>;
+    this.writable = this._transform.writable as unknown as WritableStream<string>;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'TextEncoderStream';
+  }
+}

package/src/encoding/index.ts

@@ -0,0 +1,8 @@
+export { TextEncoder } from "./TextEncoder";
+export type { TextEncoderEncodeIntoResult } from "./TextEncoder";
+
+export { TextDecoder } from "./TextDecoder";
+export type { TextDecoderOptions, TextDecodeOptions } from "./TextDecoder";
+
+export { TextEncoderStream } from "./TextEncoderStream";
+export { TextDecoderStream } from "./TextDecoderStream";

package/src/events/CloseEvent.ts

@@ -0,0 +1,91 @@
+/**
+ * CloseEvent - Event for WebSocket close events
+ * 
+ * @see https://html.spec.whatwg.org/multipage/web-sockets.html#closeevent
+ */
+
+import { Event, EventInit } from './Event';
+
+export interface CloseEventInit extends EventInit {
+  wasClean?: boolean;
+  code?: number;
+  reason?: string;
+}
+
+function assertCloseEventBrand(value: unknown): CloseEvent {
+  if (!(value instanceof CloseEvent)) {
+    throw new TypeError('Illegal invocation');
+  }
+  return value;
+}
+
+export class CloseEvent extends Event {
+  _wasClean: boolean;
+  _code: number;
+  _reason: string;
+
+  constructor(type: string, eventInitDict?: CloseEventInit) {
+    super(type, eventInitDict);
+    this._wasClean = eventInitDict?.wasClean ?? false;
+    this._code = eventInitDict?.code ?? 0;
+    this._reason = eventInitDict?.reason ?? '';
+  }
+
+  get wasClean(): boolean {
+    return assertCloseEventBrand(this)._wasClean;
+  }
+
+  get code(): number {
+    return assertCloseEventBrand(this)._code;
+  }
+
+  get reason(): string {
+    return assertCloseEventBrand(this)._reason;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'CloseEvent';
+  }
+}
+
+Object.defineProperty(CloseEvent, 'length', {
+  value: 1,
+  configurable: true,
+});
+
+function nameAccessor(
+  descriptor: PropertyDescriptor | undefined,
+  propertyName: string
+): PropertyDescriptor | undefined {
+  if (!descriptor) {
+    return descriptor;
+  }
+  if (typeof descriptor.get === 'function') {
+    Object.defineProperty(descriptor.get, 'name', {
+      value: `get ${propertyName}`,
+      configurable: true,
+    });
+  }
+  if (typeof descriptor.set === 'function') {
+    Object.defineProperty(descriptor.set, 'name', {
+      value: `set ${propertyName}`,
+      configurable: true,
+    });
+  }
+  return descriptor;
+}
+
+const wasCleanDescriptor = nameAccessor(Object.getOwnPropertyDescriptor(CloseEvent.prototype, 'wasClean'), 'wasClean')!;
+const codeDescriptor = nameAccessor(Object.getOwnPropertyDescriptor(CloseEvent.prototype, 'code'), 'code')!;
+const reasonDescriptor = nameAccessor(Object.getOwnPropertyDescriptor(CloseEvent.prototype, 'reason'), 'reason')!;
+
+Object.defineProperties(CloseEvent.prototype, {
+  wasClean: { get: wasCleanDescriptor.get, enumerable: true, configurable: true },
+  code: { get: codeDescriptor.get, enumerable: true, configurable: true },
+  reason: { get: reasonDescriptor.get, enumerable: true, configurable: true },
+});
+
+Object.setPrototypeOf(CloseEvent.prototype, Event.prototype);
+Object.setPrototypeOf(CloseEvent, Event);
+
+export default CloseEvent;