@tsonic/js 10.0.39 → 10.0.40

package/bindings.json

@@ -20,6 +20,11 @@
       "assembly": "Tsonic.JSRuntime",
       "type": "Tsonic.JSRuntime.Math"
     },
+    "Number": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Number"
+    },
     "RegExp": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
@@ -37,10 +42,16 @@
       "type": "Tsonic.JSRuntime.Set`1",
       "csharpName": "Set"
     },
+    "String": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.String"
+    },
     "Array": {
       "kind": "global",
       "assembly": "Tsonic.JSRuntime",
       "type": "Tsonic.JSRuntime.JSArray`1",
+      "staticType": "Tsonic.JSRuntime.JSArrayStatics",
       "csharpName": "JSArray"
     },
     "ReadonlyArray": {
@@ -72,6 +83,16 @@
       "assembly": "Tsonic.JSRuntime",
       "type": "Tsonic.JSRuntime.Globals",
       "csharpName": "Globals.isNaN"
+    },
+    "RangeError": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.RangeError"
+    },
+    "Error": {
+      "kind": "global",
+      "assembly": "Tsonic.JSRuntime",
+      "type": "Tsonic.JSRuntime.Error"
     }
   }
 }

package/core-globals.d.ts

@@ -0,0 +1,205 @@
+declare global {
+  class Error {
+    name: string;
+    message: string;
+    stack?: string;
+    constructor(message?: string);
+  }
+
+  interface Function {
+    prototype: any;
+  }
+
+  interface CallableFunction extends Function {
+  }
+
+  interface NewableFunction extends Function {
+  }
+
+  interface IArguments {
+  }
+
+  interface RegExp {
+  }
+
+  interface ImportMeta {
+  }
+
+  interface String {
+  }
+
+  interface Number {
+  }
+
+  interface Boolean {
+  }
+
+  interface Object {
+    constructor: Function;
+  }
+
+  interface SymbolConstructor {
+    readonly iterator: symbol;
+    readonly asyncIterator: symbol;
+    readonly hasInstance: symbol;
+    readonly isConcatSpreadable: symbol;
+    readonly species: symbol;
+    readonly toPrimitive: symbol;
+    readonly toStringTag: symbol;
+  }
+
+  interface Array<T> {
+    [n: number]: T;
+    readonly length: number;
+    [Symbol.iterator](): IterableIterator<T>;
+  }
+
+  interface ReadonlyArray<T> {
+    readonly [n: number]: T;
+    readonly length: number;
+    [Symbol.iterator](): IterableIterator<T>;
+  }
+
+  interface ArrayConstructor {
+    new<T>(size?: number): T[];
+  }
+
+  interface Promise<T> {
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: | ((value: T) => TResult1 | PromiseLike<TResult1>)
+        | undefined
+        | null, onrejected?: | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+        | undefined
+        | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: | ((reason: any) => TResult | PromiseLike<TResult>)
+        | undefined
+        | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+  }
+
+  interface PromiseLike<T> {
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: | ((value: T) => TResult1 | PromiseLike<TResult1>)
+        | undefined
+        | null, onrejected?: | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+        | undefined
+        | null): PromiseLike<TResult1 | TResult2>;
+  }
+
+  interface PromiseConstructor {
+    new<T>(executor: (
+        resolve: (value: T | PromiseLike<T>) => void,
+        reject: (reason?: any) => void
+      ) => void): Promise<T>;
+    resolve(): Promise<void>;
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+    reject<T = never>(reason?: any): Promise<T>;
+    all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]>;
+    race<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T>;
+  }
+
+  interface Iterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return(value?: TReturn): IteratorResult<T, TReturn>;
+    throw(e?: any): IteratorResult<T, TReturn>;
+  }
+
+  interface IteratorResult<T, TReturn = any> {
+    done: boolean;
+    value: T | TReturn;
+  }
+
+  interface IteratorYieldResult<T> {
+    done: false;
+    value: T;
+  }
+
+  interface IteratorReturnResult<TReturn> {
+    done: true;
+    value: TReturn;
+  }
+
+  interface Iterable<T, TReturn = any, TNext = undefined> {
+    [Symbol.iterator](): Iterator<T, TReturn, TNext>;
+  }
+
+  interface IterableIterator<T, TReturn = any, TNext = undefined> extends Iterator<T, TReturn, TNext> {
+    [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+  }
+
+  interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e?: any): Promise<IteratorResult<T, TReturn>>;
+  }
+
+  interface AsyncIterable<T, TReturn = any, TNext = undefined> {
+    [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
+  }
+
+  interface AsyncIterableIterator<T, TReturn = any, TNext = undefined> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+  }
+
+  interface Generator<T = unknown, TReturn = any, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return(value: TReturn): IteratorResult<T, TReturn>;
+    throw(e: any): IteratorResult<T, TReturn>;
+    [Symbol.iterator](): Generator<T, TReturn, TNext>;
+  }
+
+  interface AsyncGenerator<T = unknown, TReturn = any, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e: any): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+  }
+
+  interface TemplateStringsArray extends ReadonlyArray<string> {
+    readonly raw: readonly string[];
+  }
+
+  type PropertyKey = string | number | symbol;
+
+  type Partial<T> = { [P in keyof T]?: T[P] };
+
+  type Required<T> = { [P in keyof T]-?: T[P] };
+
+  type Readonly<T> = { readonly [P in keyof T]: T[P] };
+
+  type Pick<T, K extends keyof T> = { [P in K]: T[P] };
+
+  type Record<K extends keyof any, T> = { [P in K]: T };
+
+  type Exclude<T, U> = T extends U ? never : T;
+
+  type Extract<T, U> = T extends U ? T : never;
+
+  type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
+  type NonNullable<T> = T extends null | undefined ? never : T;
+
+  type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
+
+  type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;
+
+  type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
+
+  type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;
+
+  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
+
+  type Uppercase<S extends string> = intrinsic;
+
+  type Lowercase<S extends string> = intrinsic;
+
+  type Capitalize<S extends string> = intrinsic;
+
+  type Uncapitalize<S extends string> = intrinsic;
+
+  const Symbol: SymbolConstructor;
+
+  const Array: ArrayConstructor;
+
+  const Promise: PromiseConstructor;
+}
+
+export {};

package/globals.d.ts

@@ -1,96 +1,219 @@
 import type { int, long, double } from "@tsonic/core/types.js";
 
 declare global {
+  class RangeError extends Error {
+    constructor(message?: string);
+  }
+
+  interface ArrayLike<T> {
+    readonly length: int;
+    readonly [n: number]: T;
+  }
+
   interface String {
     readonly length: int;
-    trim(): string;
-    toUpperCase(): string;
-    toLowerCase(): string;
+    at(index: int): string;
+    charAt(index: int): string;
+    charCodeAt(index: int): int;
+    codePointAt(index: int): int;
+    concat(...strings: string[]): string;
+    endsWith(searchString: string): boolean;
+    includes(searchString: string): boolean;
     indexOf(searchString: string, position?: int): int;
-    split(separator: string, limit?: int): string[];
-    includes(searchString: string, position?: int): boolean;
-    startsWith(searchString: string, position?: int): boolean;
-    endsWith(searchString: string, endPosition?: int): boolean;
+    isWellFormed(): boolean;
+    lastIndexOf(searchString: string, position?: int): int;
+    localeCompare(compareString: string): int;
+    match(pattern: string): string[] | undefined;
+    matchAll(pattern: string): string[][];
+    normalize(form?: string): string;
+    padEnd(targetLength: int, padString?: string): string;
+    padStart(targetLength: int, padString?: string): string;
+    repeat(count: int): string;
+    replace(searchValue: string, replaceValue: string): string;
+    replaceAll(searchValue: string, replaceValue: string): string;
+    search(pattern: string): int;
     slice(start?: int, end?: int): string;
+    split(separator: string, limit?: int): string[];
+    startsWith(searchString: string): boolean;
+    substr(start: int, length?: int): string;
     substring(start: int, end?: int): string;
-    replace(searchValue: string, replaceValue: string): string;
-    charAt(index: int): string;
-    charCodeAt(index: int): int;
+    toLocaleLowerCase(): string;
+    toLocaleUpperCase(): string;
+    toLowerCase(): string;
+    toString(): string;
+    trim(): string;
+    trimLeft(): string;
+    trimRight(): string;
+    trimStart(): string;
+    trimEnd(): string;
+    toUpperCase(): string;
+    toWellFormed(): string;
+    valueOf(): string;
+  }
+
+  interface StringConstructor {
+    fromCharCode(...codes: int[]): string;
+    fromCodePoint(...codePoints: int[]): string;
+  }
+
+  interface Number {
+    toString(): string;
+    valueOf(): double;
   }
+
+  interface NumberConstructor {
+    readonly EPSILON: double;
+    readonly MAX_SAFE_INTEGER: double;
+    readonly MAX_VALUE: double;
+    readonly MIN_SAFE_INTEGER: double;
+    readonly MIN_VALUE: double;
+    readonly NEGATIVE_INFINITY: double;
+    readonly POSITIVE_INFINITY: double;
+    readonly NaN: double;
+    isFinite(value: double): boolean;
+    isInteger(value: double): boolean;
+    isNaN(value: double): boolean;
+    isSafeInteger(value: double): boolean;
+    parseFloat(str: string): double;
+    parseInt(str: string, radix?: int): long | undefined;
+  }
+
   interface Array<T> {
     readonly length: int;
     at(index: int): T;
-    concat(...items: T[]): T[];
+    concat(...items: unknown[]): T[];
+    copyWithin(target: int, start?: int, end?: int): T[];
+    entries(): Iterable<[int, T]>;
     every(callback: (value: T) => boolean): boolean;
+    every(callback: (value: T, index: int, array: T[]) => boolean): boolean;
+    fill(value: T, start?: int, end?: int): T[];
     filter(callback: (value: T) => boolean): T[];
     filter(callback: (value: T, index: int) => boolean): T[];
+    filter(callback: (value: T, index: int, array: T[]) => boolean): T[];
     find(callback: (value: T) => boolean): T | undefined;
     find(callback: (value: T, index: int) => boolean): T | undefined;
+    find(callback: (value: T, index: int, array: T[]) => boolean): T | undefined;
     findIndex(callback: (value: T) => boolean): int;
     findIndex(callback: (value: T, index: int) => boolean): int;
+    findIndex(callback: (value: T, index: int, array: T[]) => boolean): int;
     findLast(callback: (value: T) => boolean): T | undefined;
     findLast(callback: (value: T, index: int) => boolean): T | undefined;
+    findLast(callback: (value: T, index: int, array: T[]) => boolean): T | undefined;
     findLastIndex(callback: (value: T) => boolean): int;
     findLastIndex(callback: (value: T, index: int) => boolean): int;
+    findLastIndex(callback: (value: T, index: int, array: T[]) => boolean): int;
     flat(depth?: int): unknown[];
+    flatMap<TResult>(callback: (value: T, index: int, array: T[]) => unknown): TResult[];
     forEach(callback: (value: T) => void): void;
     forEach(callback: (value: T, index: int) => void): void;
+    forEach(callback: (value: T, index: int, array: T[]) => void): void;
     includes(searchElement: T): boolean;
-    includes(searchElement: T, fromIndex?: int): boolean;
     indexOf(searchElement: T, fromIndex?: int): int;
     join(separator?: string): string;
+    keys(): Iterable<int>;
     lastIndexOf(searchElement: T, fromIndex?: int): int;
     map<TResult>(callback: (value: T) => TResult): TResult[];
     map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
+    map<TResult>(callback: (value: T, index: int, array: T[]) => TResult): TResult[];
+    pop(): T;
+    push(...items: T[]): int;
     reduce(callback: (previousValue: T, currentValue: T) => T): T;
-    reduce<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    reduceRight<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
+    reduce<TResult>(callback: (previousValue: TResult, currentValue: T) => TResult, initialValue: TResult): TResult;
+    reduce<TResult>(callback: (previousValue: TResult, currentValue: T, index: int) => TResult, initialValue: TResult): TResult;
+    reduce<TResult>(callback: (
+        previousValue: TResult,
+        currentValue: T,
+        index: int,
+        array: T[]
+      ) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (previousValue: TResult, currentValue: T) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (previousValue: TResult, currentValue: T, index: int) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (
+        previousValue: TResult,
+        currentValue: T,
+        index: int,
+        array: T[]
+      ) => TResult, initialValue: TResult): TResult;
+    reverse(): T[];
+    shift(): T;
     slice(start?: int, end?: int): T[];
     some(callback: (value: T) => boolean): boolean;
+    some(callback: (value: T, index: int, array: T[]) => boolean): boolean;
+    sort(compareFunc?: (left: T, right: T) => double): T[];
+    splice(start: int, deleteCount?: int, ...items: T[]): T[];
+    toLocaleString(): string;
+    toReversed(): T[];
+    toSorted(compareFunc?: (left: T, right: T) => double): T[];
+    toSpliced(start: int, deleteCount?: int, ...items: T[]): T[];
+    toString(): string;
+    unshift(...items: T[]): int;
+    values(): Iterable<T>;
+    with(index: int, value: T): T[];
   }
+
   interface ReadonlyArray<T> {
     readonly length: int;
     at(index: int): T;
-    concat(...items: T[]): T[];
+    concat(...items: unknown[]): T[];
+    entries(): Iterable<[int, T]>;
     every(callback: (value: T) => boolean): boolean;
+    every(callback: (value: T, index: int, array: readonly T[]) => boolean): boolean;
     filter(callback: (value: T) => boolean): T[];
     filter(callback: (value: T, index: int) => boolean): T[];
+    filter(callback: (value: T, index: int, array: readonly T[]) => boolean): T[];
     find(callback: (value: T) => boolean): T | undefined;
     find(callback: (value: T, index: int) => boolean): T | undefined;
+    find(callback: (value: T, index: int, array: readonly T[]) => boolean): T | undefined;
     findIndex(callback: (value: T) => boolean): int;
     findIndex(callback: (value: T, index: int) => boolean): int;
+    findIndex(callback: (value: T, index: int, array: readonly T[]) => boolean): int;
     findLast(callback: (value: T) => boolean): T | undefined;
     findLast(callback: (value: T, index: int) => boolean): T | undefined;
+    findLast(callback: (value: T, index: int, array: readonly T[]) => boolean): T | undefined;
     findLastIndex(callback: (value: T) => boolean): int;
     findLastIndex(callback: (value: T, index: int) => boolean): int;
+    findLastIndex(callback: (value: T, index: int, array: readonly T[]) => boolean): int;
     flat(depth?: int): unknown[];
+    flatMap<TResult>(callback: (value: T, index: int, array: readonly T[]) => unknown): TResult[];
     forEach(callback: (value: T) => void): void;
     forEach(callback: (value: T, index: int) => void): void;
+    forEach(callback: (value: T, index: int, array: readonly T[]) => void): void;
     includes(searchElement: T): boolean;
-    includes(searchElement: T, fromIndex?: int): boolean;
     indexOf(searchElement: T, fromIndex?: int): int;
     join(separator?: string): string;
+    keys(): Iterable<int>;
     lastIndexOf(searchElement: T, fromIndex?: int): int;
     map<TResult>(callback: (value: T) => TResult): TResult[];
     map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
+    map<TResult>(callback: (value: T, index: int, array: readonly T[]) => TResult): TResult[];
     reduce(callback: (previousValue: T, currentValue: T) => T): T;
-    reduce<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    reduceRight<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
+    reduce<TResult>(callback: (previousValue: TResult, currentValue: T) => TResult, initialValue: TResult): TResult;
+    reduce<TResult>(callback: (previousValue: TResult, currentValue: T, index: int) => TResult, initialValue: TResult): TResult;
+    reduce<TResult>(callback: (
+        previousValue: TResult,
+        currentValue: T,
+        index: int,
+        array: readonly T[]
+      ) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (previousValue: TResult, currentValue: T) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (previousValue: TResult, currentValue: T, index: int) => TResult, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: (
+        previousValue: TResult,
+        currentValue: T,
+        index: int,
+        array: readonly T[]
+      ) => TResult, initialValue: TResult): TResult;
     slice(start?: int, end?: int): T[];
     some(callback: (value: T) => boolean): boolean;
+    some(callback: (value: T, index: int, array: readonly T[]) => boolean): boolean;
+    toLocaleString(): string;
+    toReversed(): T[];
+    toSorted(compareFunc?: (left: T, right: T) => double): T[];
+    toString(): string;
+    values(): Iterable<T>;
+    with(index: int, value: T): T[];
   }
+
   interface Console {
     log(...data: unknown[]): void;
     error(...data: unknown[]): void;
@@ -98,47 +221,55 @@ declare global {
     info(...data: unknown[]): void;
     debug(...data: unknown[]): void;
   }
-  const console: Console;
+
+  interface ArrayConstructor {
+    isArray(value: unknown): boolean;
+    from(source: string): string[];
+    from<TResult>(source: string, mapfn: (value: string, index: int) => TResult): TResult[];
+    from<T>(source: Iterable<T> | ArrayLike<T>): T[];
+    from<T, TResult>(source: Iterable<T> | ArrayLike<T>, mapfn: (value: T, index: int) => TResult): TResult[];
+    of<T>(...items: T[]): T[];
+  }
+
   interface Date {
     toISOString(): string;
     getTime(): long;
   }
+
   interface DateConstructor {
-    new (): Date;
-    new (value: string | number | long): Date;
+    new(): Date;
+    new(value: string | number | long): Date;
     now(): long;
     parse(s: string): long;
   }
-  const Date: DateConstructor;
+
   interface JSON {
     parse<T = unknown>(text: string): T;
-    stringify(
-      value: unknown,
-      replacer?: unknown,
-      space?: string | number | int
-    ): string;
+    stringify(value: unknown, replacer?: unknown, space?: string | number | int): string;
   }
-  const JSON: JSON;
+
   interface Math {
     round(x: double): double;
     max(...values: double[]): double;
     min(...values: double[]): double;
     random(): double;
   }
-  const Math: Math;
+
   interface RegExpMatchArray extends Array<string> {
     index?: int;
     input?: string;
   }
+
   interface RegExp {
     exec(string: string): RegExpMatchArray | null;
     test(string: string): boolean;
   }
+
   interface RegExpConstructor {
-    new (pattern: string | RegExp, flags?: string): RegExp;
+    new(pattern: string | RegExp, flags?: string): RegExp;
     (pattern: string | RegExp, flags?: string): RegExp;
   }
-  const RegExp: RegExpConstructor;
+
   interface Map<K, V> {
     readonly size: int;
     clear(): void;
@@ -147,10 +278,11 @@ declare global {
     has(key: K): boolean;
     set(key: K, value: V): this;
   }
+
   interface MapConstructor {
-    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+    new<K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
   }
-  const Map: MapConstructor;
+
   interface Set<T> {
     readonly size: int;
     add(value: T): this;
@@ -158,25 +290,43 @@ declare global {
     delete(value: T): boolean;
     has(value: T): boolean;
   }
+
   interface SetConstructor {
-    new <T = unknown>(values?: readonly T[] | null): Set<T>;
+    new<T = unknown>(values?: readonly T[] | null): Set<T>;
   }
+
+  const String: StringConstructor;
+
+  const Number: NumberConstructor;
+
+  const console: Console;
+
+  const Date: DateConstructor;
+
+  const JSON: JSON;
+
+  const Math: Math;
+
+  const RegExp: RegExpConstructor;
+
+  const Map: MapConstructor;
+
   const Set: SetConstructor;
+
   function parseInt(str: string, radix?: int): long | undefined;
+
   function parseFloat(str: string): double;
+
   function isFinite(value: double): boolean;
+
   function isNaN(value: double): boolean;
-  function setTimeout(
-    handler: (...args: unknown[]) => void,
-    timeout?: int,
-    ...args: unknown[]
-  ): int;
+
+  function setTimeout(handler: (...args: unknown[]) => void, timeout?: int, ...args: unknown[]): int;
+
   function clearTimeout(id: int): void;
-  function setInterval(
-    handler: (...args: unknown[]) => void,
-    timeout?: int,
-    ...args: unknown[]
-  ): int;
+
+  function setInterval(handler: (...args: unknown[]) => void, timeout?: int, ...args: unknown[]): int;
+
   function clearInterval(id: int): void;
 }
 

package/index.d.ts

@@ -1,3 +1,6 @@
+/// <reference path="./core-globals.d.ts" />
+/// <reference path="./globals.d.ts" />
+
 // Generated by tsbindgen - Architecture
 // Namespace: Tsonic.JSRuntime
 // Facade - Public API Surface
@@ -11,12 +14,14 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 // Cross-namespace type imports for constraints
 import type { IEnumerable as IEnumerable__System_Collections_Generic, IEnumerator, KeyValuePair, List } from '@tsonic/dotnet/System.Collections.Generic.js';
 import type { IEnumerable } from '@tsonic/dotnet/System.Collections.js';
-import type { Action, Boolean as ClrBoolean, Byte, Comparison, Double, Func, Int16, Int32, Int64, Nullable, Object as ClrObject, SByte, Single, String as ClrString, UInt16, UInt32, ValueTuple, Void } from '@tsonic/dotnet/System.js';
+import type { Action, Boolean as ClrBoolean, Byte, Comparison, Double, Exception, Func, Int16, Int32, Int64, Nullable, Object as ClrObject, SByte, Single, String as ClrString, UInt16, UInt32, ValueTuple, Void } from '@tsonic/dotnet/System.js';
+import type { ISerializable } from '@tsonic/dotnet/System.Runtime.Serialization.js';
 
 // Public API exports (curated - no internal $instance/$views leakage)
 export { ArrayBuffer as ArrayBuffer } from './index/internal/index.js';
 export { console$instance as console } from './index/internal/index.js';
 export { Date as Date } from './index/internal/index.js';
+export { Error as Error } from './index/internal/index.js';
 export { Float32Array as Float32Array } from './index/internal/index.js';
 export { Float64Array as Float64Array } from './index/internal/index.js';
 export { Globals$instance as Globals } from './index/internal/index.js';
@@ -24,10 +29,12 @@ export { Int16Array as Int16Array } from './index/internal/index.js';
 export { Int32Array as Int32Array } from './index/internal/index.js';
 export { Int8Array as Int8Array } from './index/internal/index.js';
 export { JSArray_1 as JSArray } from './index/internal/index.js';
+export { JSArrayStatics$instance as JSArrayStatics } from './index/internal/index.js';
 export { JSON$instance as JSON } from './index/internal/index.js';
 export { Map_2 as Map } from './index/internal/index.js';
 export { Math$instance as Math } from './index/internal/index.js';
 export { Number$instance as Number } from './index/internal/index.js';
+export { RangeError as RangeError } from './index/internal/index.js';
 export { RegExp as RegExp } from './index/internal/index.js';
 export { RegExpMatchResult as RegExpMatchResult } from './index/internal/index.js';
 export { Set_1 as Set } from './index/internal/index.js';