@fable-org/fable-library-ts 2.0.0-beta.4 → 2.0.0-beta.5

package/String.ts

@@ -1,7 +1,8 @@
-import { toString as dateToString } from "./Date.js";
-import { compare as numericCompare, isNumeric, isIntegral, multiply, Numeric, toExponential, toFixed, toHex, toPrecision } from "./Numeric.js";
-import { escape } from "./RegExp.js";
-import { toString } from "./Types.js";
+import { toString as dateToString } from "./Date.ts";
+import { compare as numericCompare, isNumeric, isIntegral, multiply, Numeric, toExponential, toFixed, toHex, toPrecision } from "./Numeric.ts";
+import { escape } from "./RegExp.ts";
+import { toString } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 const fsFormatRegExp = /(^|[^%])%([0+\- ]*)(\*|\d+)?(?:\.(\d+))?(\w)/g;
 const interpolateRegExp = /(?:(^|[^%])%([0+\- ]*)(\d+)?(?:\.(\d+))?(\w))?%P\(\)/g;
@@ -11,14 +12,16 @@ function isLessThan(x: Numeric, y: number) {
   return numericCompare(x, y) < 0;
 }
 
-const enum StringComparison {
-  CurrentCulture = 0,
-  CurrentCultureIgnoreCase = 1,
-  InvariantCulture = 2,
-  InvariantCultureIgnoreCase = 3,
-  Ordinal = 4,
-  OrdinalIgnoreCase = 5,
-}
+export const StringComparison = {
+  CurrentCulture: 0,
+  CurrentCultureIgnoreCase: 1,
+  InvariantCulture: 2,
+  InvariantCultureIgnoreCase: 3,
+  Ordinal: 4,
+  OrdinalIgnoreCase: 5,
+} as const;
+
+export type StringComparison = typeof StringComparison[keyof typeof StringComparison];
 
 function cmp(x: string, y: string, ic: boolean | StringComparison) {
   function isIgnoreCase(i: boolean | StringComparison) {
@@ -48,10 +51,10 @@ export function compare(...args: any[]): number {
     case 2: return cmp(args[0], args[1], false);
     case 3: return cmp(args[0], args[1], args[2]);
     case 4: return cmp(args[0], args[1], args[2] === true);
-    case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);
-    case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);
-    case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);
-    default: throw new Error("String.compare: Unsupported number of parameters");
+    case 5: return cmp(args[0].slice(args[1], args[1] + args[4]), args[2].slice(args[3], args[3] + args[4]), false);
+    case 6: return cmp(args[0].slice(args[1], args[1] + args[4]), args[2].slice(args[3], args[3] + args[4]), args[5]);
+    case 7: return cmp(args[0].slice(args[1], args[1] + args[4]), args[2].slice(args[3], args[3] + args[4]), args[5] === true);
+    default: throw new Exception("String.compare: Unsupported number of parameters");
   }
 }
 
@@ -68,7 +71,7 @@ export function startsWith(str: string, pattern: string, ic: boolean | StringCom
     return str.startsWith(pattern);
   }
   if (str.length >= pattern.length) {
-    return cmp(str.substr(0, pattern.length), pattern, ic) === 0;
+    return cmp(str.slice(0, pattern.length), pattern, ic) === 0;
   }
   return false;
 }
@@ -78,7 +81,7 @@ export function endsWith(str: string, pattern: string, ic: boolean | StringCompa
     return str.endsWith(pattern);
   }
   if (str.length >= pattern.length) {
-    return cmp(str.substr(str.length - pattern.length, pattern.length), pattern, ic) === 0;
+    return cmp(str.slice(-pattern.length), pattern, ic) === 0;
   }
   return false;
 }
@@ -89,14 +92,14 @@ export function indexOfAny(str: string, anyOf: string[], ...args: number[]) {
   }
   const startIndex = (args.length > 0) ? args[0] : 0;
   if (startIndex < 0) {
-    throw new Error("Start index cannot be negative");
+    throw new Exception("Start index cannot be negative");
   }
   const length = (args.length > 1) ? args[1] : str.length - startIndex;
   if (length < 0) {
-    throw new Error("Length cannot be negative");
+    throw new Exception("Length cannot be negative");
   }
   if (startIndex + length > str.length) {
-    throw new Error("Invalid startIndex and length");
+    throw new Exception("Invalid startIndex and length");
   }
   const endIndex = startIndex + length
   const anyOfAsStr = "".concat.apply("", anyOf);
@@ -166,7 +169,7 @@ export function toText(arg: IPrintfFormat | string) {
 
 export function toFail(arg: IPrintfFormat | string) {
   return continuePrint((x: string) => {
-    throw new Error(x);
+    throw new Exception(x);
   }, arg);
 }
 
@@ -246,7 +249,7 @@ function createPrinter(cont: (...args: any[]) => any, _strParts: string[], _matc
       }
       else if (padLength === "*") {
         if (arg < 0) {
-          throw new Error("Non-negative number required");
+          throw new Exception("Non-negative number required");
         }
         padArg = arg;
         continue;
@@ -320,7 +323,7 @@ export function format(str: string | object, ...args: any[]) {
 
   return str2.replace(formatRegExp, (_, idx: number, padLength, format, precision, pattern) => {
     if (idx < 0 || idx >= args.length) {
-      throw new Error("Index must be greater or equal to zero and less than the arguments' length.")
+      throw new Exception("Index must be greater or equal to zero and less than the arguments' length.")
     }
     let rep = args[idx];
     let parts;
@@ -329,7 +332,7 @@ export function format(str: string | object, ...args: any[]) {
       switch (format) {
         case "b": case "B":
           if (!isIntegral(rep)) {
-            throw new Error("Format specifier was invalid.");
+            throw new Exception("Format specifier was invalid.");
           }
           rep = (rep >>> 0).toString(2).replace(/^0+/, "").padStart(precision || 1, "0");
           break;
@@ -348,7 +351,7 @@ export function format(str: string | object, ...args: any[]) {
           break;
         case "d": case "D":
           if (!isIntegral(rep)) {
-            throw new Error("Format specifier was invalid.");
+            throw new Exception("Format specifier was invalid.");
           }
           rep = String(rep);
           if (precision != null) {
@@ -388,10 +391,10 @@ export function format(str: string | object, ...args: any[]) {
           rep = thousandSeparate(parts.integral) + "." + padRight(parts.decimal, precision, "0") + " %";
           break;
         case "r": case "R":
-          throw new Error("The round-trip format is not supported by Fable");
+          throw new Exception("The round-trip format is not supported by Fable");
         case "x": case "X":
           if (!isIntegral(rep)) {
-            throw new Error("Format specifier was invalid.");
+            throw new Exception("Format specifier was invalid.");
           }
           precision = precision != null ? precision : 2;
           rep = padLeft(toHex(rep), precision, "0");
@@ -403,7 +406,7 @@ export function format(str: string | object, ...args: any[]) {
           // If we have format and were not able to handle it throw
           // See: https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings#standard-format-specifiers
           if (format) {
-            throw new Error("Format specifier was invalid.");
+            throw new Exception("Format specifier was invalid.");
           }
 
           if (pattern) {
@@ -461,7 +464,7 @@ export function format(str: string | object, ...args: any[]) {
 
 export function initialize(n: number, f: (i: number) => string) {
   if (n < 0) {
-    throw new Error("String length must be non-negative");
+    throw new Exception("String length must be non-negative");
   }
   const xs = new Array(n);
   for (let i = 0; i < n; i++) {
@@ -472,7 +475,7 @@ export function initialize(n: number, f: (i: number) => string) {
 
 export function insert(str: string, startIndex: number, value: string) {
   if (startIndex < 0 || startIndex > str.length) {
-    throw new Error("startIndex is negative or greater than the length of this instance.");
+    throw new Exception("startIndex is negative or greater than the length of this instance.");
   }
   return str.substring(0, startIndex) + value + str.substring(startIndex);
 }
@@ -500,13 +503,13 @@ export function join<T>(delimiter: string, xs: Iterable<T>): string {
 export function joinWithIndices(delimiter: string, xs: string[], startIndex: number, count: number) {
   const endIndexPlusOne = startIndex + count;
   if (endIndexPlusOne > xs.length) {
-    throw new Error("Index and count must refer to a location within the buffer.");
+    throw new Exception("Index and count must refer to a location within the buffer.");
   }
   return xs.slice(startIndex, endIndexPlusOne).join(delimiter);
 }
 
 function notSupported(name: string): never {
-  throw new Error("The environment doesn't support '" + name + "', please use a polyfill.");
+  throw new Exception("The environment doesn't support '" + name + "', please use a polyfill.");
 }
 
 export function toBase64String(inArray: ArrayLike<number>) {
@@ -545,10 +548,10 @@ export function padRight(str: string, len: number, ch?: string) {
 
 export function remove(str: string, startIndex: number, count?: number) {
   if (startIndex >= str.length) {
-    throw new Error("startIndex must be less than length of string");
+    throw new Exception("startIndex must be less than length of string");
   }
   if (typeof count === "number" && (startIndex + count) > str.length) {
-    throw new Error("Index and count must refer to a location within the string.");
+    throw new Exception("Index and count must refer to a location within the string.");
   }
   return str.slice(0, startIndex) + (typeof count === "number" ? str.substr(startIndex + count) : "");
 }
@@ -563,7 +566,7 @@ export function replicate(n: number, x: string) {
 
 export function getCharAtIndex(input: string, index: number) {
   if (index < 0 || index >= input.length) {
-    throw new Error("Index was outside the bounds of the array.");
+    throw new Exception("Index was outside the bounds of the array.");
   }
   return input[index];
 }
@@ -572,7 +575,7 @@ export function split(str: string, splitters: string[], count?: number, options?
   count = typeof count === "number" ? count : undefined;
   options = typeof options === "number" ? options : 0;
   if (count && count < 0) {
-    throw new Error("Count cannot be less than zero");
+    throw new Exception("Count cannot be less than zero");
   }
   if (count === 0) {
     return [];
@@ -643,7 +646,7 @@ export function filter(pred: (char: string) => boolean, x: string) {
 
 export function substring(str: string, startIndex: number, length?: number) {
   if ((startIndex + (length || 0) > str.length)) {
-    throw new Error("Invalid startIndex and/or length");
+    throw new Exception("Invalid startIndex and/or length");
   }
   return length != null ? str.substr(startIndex, length) : str.substr(startIndex);
 }

package/System.Collections.Generic.ts

@@ -1,18 +1,38 @@
 
-import { IDisposable, disposeSafe, defaultOf, toIterator, IEnumerator, getEnumerator, structuralHash, equals as equals_1, IEqualityComparer, compare, IComparer, Nullable } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { toArray, empty, singleton, append, enumerateWhile, delay } from "./Seq.js";
-import { setItem, initialize, copyTo, fill, item as item_1 } from "./Array.js";
-import { max } from "./Double.js";
-import { FSharpRef } from "./Types.js";
+import { IDisposable, disposeSafe, defaultOf, MutableArray, toIterator, IEnumerator, getEnumerator, structuralHash, equals as equals_1, IEqualityComparer, compare, IComparer, Exception } from "./Util.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { SR_Arg_KeyNotFound } from "./Global.ts";
+import { int32 } from "./Int32.ts";
+import { toArray, empty, singleton, append, enumerateWhile, delay } from "./Seq.ts";
+import { setItem, initialize, copyTo, fill, item as item_1 } from "./Array.ts";
+import { max } from "./Double.ts";
+import { FSharpRef } from "./Types.ts";
+import { ArgumentOutOfRangeException_$ctor_Z721C83C5 } from "./System.ts";
+
+export class KeyNotFoundException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function KeyNotFoundException_$reflection(): TypeInfo {
+    return class_type("System.Collections.Generic.KeyNotFoundException", undefined, KeyNotFoundException, class_type("System.Exception"));
+}
+
+export function KeyNotFoundException_$ctor_Z721C83C5(message: string): KeyNotFoundException {
+    return new KeyNotFoundException(message);
+}
+
+export function KeyNotFoundException_$ctor(): KeyNotFoundException {
+    return KeyNotFoundException_$ctor_Z721C83C5(SR_Arg_KeyNotFound);
+}
 
 export class Comparer$1<T> implements IComparer<T> {
     readonly comparison: ((arg0: T, arg1: T) => int32);
     constructor(comparison: ((arg0: T, arg1: T) => int32)) {
         this.comparison = comparison;
     }
-    Compare(x: Nullable<T>, y: Nullable<T>): int32 {
+    Compare(x: T, y: T): int32 {
         const _: Comparer$1<T> = this;
         return ((x == null) ? ((y == null) ? 0 : -1) : ((y == null) ? 1 : _.comparison(x, y))) | 0;
     }
@@ -45,7 +65,7 @@ export class EqualityComparer$1<T> implements IEqualityComparer<T> {
         this.equals = equals;
         this.getHashCode = getHashCode;
     }
-    Equals(x: Nullable<T>, y: Nullable<T>): boolean {
+    Equals(x: T, y: T): boolean {
         const _: EqualityComparer$1<T> = this;
         return (x == null) ? (y == null) : ((y == null) ? false : _.equals(x, y));
     }
@@ -80,9 +100,9 @@ export function EqualityComparer$1__GetHashCode_2B595<T>(_: EqualityComparer$1<T
 }
 
 export class Stack$1<T> implements Iterable<T> {
-    contents: T[];
+    contents: MutableArray<T>;
     count: int32;
-    constructor(initialContents: T[], initialCount: int32) {
+    constructor(initialContents: MutableArray<T>, initialCount: int32) {
         this.contents = initialContents;
         this.count = (initialCount | 0);
     }
@@ -109,7 +129,7 @@ export function Stack$1_$reflection(gen0: TypeInfo): TypeInfo {
     return class_type("System.Collections.Generic.Stack`1", [gen0], Stack$1);
 }
 
-function Stack$1_$ctor_Z3B4C077E<T>(initialContents: T[], initialCount: int32): Stack$1<T> {
+function Stack$1_$ctor_Z3B4C077E<T>(initialContents: MutableArray<T>, initialCount: int32): Stack$1<T> {
     return new Stack$1(initialContents, initialCount);
 }
 
@@ -122,14 +142,14 @@ export function Stack$1_$ctor<T>(): Stack$1<T> {
 }
 
 export function Stack$1_$ctor_BB573A<T>(xs: Iterable<T>): Stack$1<T> {
-    const arr: T[] = Array.from(xs);
+    const arr: MutableArray<T> = Array.from(xs);
     return Stack$1_$ctor_Z3B4C077E<T>(arr, arr.length);
 }
 
 export function Stack$1__Ensure_Z524259A4<T>(_: Stack$1<T>, newSize: int32): void {
     const oldSize: int32 = _.contents.length | 0;
     if (newSize > oldSize) {
-        const old: T[] = _.contents;
+        const old: MutableArray<T> = _.contents;
         _.contents = fill(new Array(max(newSize, oldSize * 2)), 0, max(newSize, oldSize * 2), null);
         copyTo<T>(old, 0, _.contents, 0, _.count);
     }
@@ -199,16 +219,16 @@ export function Stack$1__TrimExcess<T>(this$: Stack$1<T>): void {
     }
 }
 
-export function Stack$1__ToArray<T>(_: Stack$1<T>): T[] {
+export function Stack$1__ToArray<T>(_: Stack$1<T>): MutableArray<T> {
     return initialize<T>(_.count, (i: int32): T => item_1((_.count - 1) - i, _.contents));
 }
 
 export class Queue$1<T> implements Iterable<T> {
-    contents: T[];
+    contents: MutableArray<T>;
     count: int32;
     head: int32;
     tail: int32;
-    constructor(initialContents: T[], initialCount: int32) {
+    constructor(initialContents: MutableArray<T>, initialCount: int32) {
         this.contents = initialContents;
         this.count = (initialCount | 0);
         this.head = 0;
@@ -231,13 +251,13 @@ export function Queue$1_$reflection(gen0: TypeInfo): TypeInfo {
     return class_type("System.Collections.Generic.Queue`1", [gen0], Queue$1);
 }
 
-function Queue$1_$ctor_Z3B4C077E<T>(initialContents: T[], initialCount: int32): Queue$1<T> {
+function Queue$1_$ctor_Z3B4C077E<T>(initialContents: MutableArray<T>, initialCount: int32): Queue$1<T> {
     return new Queue$1(initialContents, initialCount);
 }
 
 export function Queue$1_$ctor_Z524259A4<T>(initialCapacity: int32): Queue$1<T> {
     if (initialCapacity < 0) {
-        throw new Error("capacity is less than 0");
+        throw ArgumentOutOfRangeException_$ctor_Z721C83C5("capacity is less than 0");
     }
     return Queue$1_$ctor_Z3B4C077E<T>(fill(new Array(initialCapacity), 0, initialCapacity, null), 0);
 }
@@ -247,7 +267,7 @@ export function Queue$1_$ctor<T>(): Queue$1<T> {
 }
 
 export function Queue$1_$ctor_BB573A<T>(xs: Iterable<T>): Queue$1<T> {
-    const arr: T[] = Array.from(xs);
+    const arr: MutableArray<T> = Array.from(xs);
     return Queue$1_$ctor_Z3B4C077E<T>(arr, arr.length);
 }
 
@@ -266,7 +286,7 @@ export function Queue$1__Enqueue_2B595<T>(_: Queue$1<T>, value: T): void {
 
 export function Queue$1__Dequeue<T>(_: Queue$1<T>): T {
     if (_.count === 0) {
-        throw new Error("Queue is empty");
+        throw new Exception("Queue is empty");
     }
     const value: T = item_1(_.head, _.contents);
     _.head = (((_.head + 1) % Queue$1__size<T>(_)) | 0);
@@ -276,7 +296,7 @@ export function Queue$1__Dequeue<T>(_: Queue$1<T>): T {
 
 export function Queue$1__Peek<T>(_: Queue$1<T>): T {
     if (_.count === 0) {
-        throw new Error("Queue is empty");
+        throw new Exception("Queue is empty");
     }
     return item_1(_.head, _.contents);
 }
@@ -328,11 +348,11 @@ export function Queue$1__TrimExcess<T>(_: Queue$1<T>): void {
     }
 }
 
-export function Queue$1__ToArray<T>(_: Queue$1<T>): T[] {
+export function Queue$1__ToArray<T>(_: Queue$1<T>): MutableArray<T> {
     return toArray<T>(Queue$1__toSeq<T>(_));
 }
 
-export function Queue$1__CopyTo_Z3B4C077E<T>(_: Queue$1<T>, target: T[], start: int32): void {
+export function Queue$1__CopyTo_Z3B4C077E<T>(_: Queue$1<T>, target: MutableArray<T>, start: int32): void {
     let i: int32 = start;
     const enumerator: IEnumerator<T> = getEnumerator(Queue$1__toSeq<T>(_));
     try {
@@ -356,7 +376,7 @@ export function Queue$1__toIndex_Z524259A4<T>(this$: Queue$1<T>, i: int32): int3
 }
 
 export function Queue$1__ensure_Z524259A4<T>(this$: Queue$1<T>, requiredSize: int32): void {
-    const newBuffer: T[] = fill(new Array(requiredSize), 0, requiredSize, null);
+    const newBuffer: MutableArray<T> = fill(new Array(requiredSize), 0, requiredSize, null);
     if (this$.head < this$.tail) {
         copyTo<T>(this$.contents, this$.head, newBuffer, 0, this$.count);
     }

package/System.Text.ts

@@ -1,9 +1,9 @@
 
-import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.js";
-import { float64, int32 } from "./Int32.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { toString } from "./Types.js";
-import { clear, int32ToString, Nullable } from "./Util.js";
+import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.ts";
+import { float64, int32 } from "./Int32.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { toString } from "./Types.ts";
+import { Exception, clear, MutableArray, int32ToString } from "./Util.ts";
 
 export class StringBuilder {
     readonly buf: string[];
@@ -39,12 +39,12 @@ export function StringBuilder_$ctor(): StringBuilder {
     return StringBuilder_$ctor_Z18115A39("", 16);
 }
 
-export function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: Nullable<string>): StringBuilder {
+export function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder {
     void (x.buf.push(toString(s)));
     return x;
 }
 
-export function StringBuilder__Append_487EF8FB(x: StringBuilder, s: Nullable<string>, startIndex: int32, count: int32): StringBuilder {
+export function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder {
     void (x.buf.push(substring(toString(s), startIndex, count)));
     return x;
 }
@@ -80,7 +80,7 @@ export function StringBuilder__Append_4E60E31B(x: StringBuilder, o: any): String
     return x;
 }
 
-export function StringBuilder__Append_Z372E4D23(x: StringBuilder, cs: string[]): StringBuilder {
+export function StringBuilder__Append_Z372E4D23(x: StringBuilder, cs: MutableArray<string>): StringBuilder {
     void (x.buf.push(cs.join('')));
     return x;
 }
@@ -105,7 +105,7 @@ export function StringBuilder__AppendFormat_10D165E0(x: StringBuilder, fmt: stri
     return x;
 }
 
-export function StringBuilder__AppendFormat_Z17053F5(x: StringBuilder, fmt: string, arr: any[]): StringBuilder {
+export function StringBuilder__AppendFormat_Z17053F5(x: StringBuilder, fmt: string, arr: MutableArray<any>): StringBuilder {
     void (x.buf.push(format(fmt, ...arr)));
     return x;
 }
@@ -125,7 +125,7 @@ export function StringBuilder__AppendFormat_Z471ADCBB(x: StringBuilder, provider
     return x;
 }
 
-export function StringBuilder__AppendFormat_6C2E3E6E(x: StringBuilder, provider: any, fmt: string, arr: any[]): StringBuilder {
+export function StringBuilder__AppendFormat_6C2E3E6E(x: StringBuilder, provider: any, fmt: string, arr: MutableArray<any>): StringBuilder {
     void (x.buf.push(format(provider, fmt, ...arr)));
     return x;
 }
@@ -154,7 +154,7 @@ export function StringBuilder__get_Chars_Z524259A4(x: StringBuilder, index: int3
         len = ((len + x.buf[i].length) | 0);
     }
     if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
-        throw new Error("Index was outside the bounds of the array");
+        throw new Exception("Index was outside the bounds of the array");
     }
     else {
         const pos: int32 = ((len - index) - 1) | 0;
@@ -170,7 +170,7 @@ export function StringBuilder__set_Chars_413E0D0A(x: StringBuilder, index: int32
         len = ((len + x.buf[i].length) | 0);
     }
     if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
-        throw new Error("Index was outside the bounds of the array");
+        throw new Exception("Index was outside the bounds of the array");
     }
     else {
         const pos: int32 = ((len - index) - 1) | 0;