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

package/MutableSet.ts

@@ -1,12 +1,12 @@
 
-import { IMap, IEqualityComparer, IDisposable, disposeSafe, defaultOf, ISet, toIterator, IEnumerator, getEnumerator } from "./Util.js";
-import { iterate, map, iterateIndexed, concat } from "./Seq.js";
-import { setItem } from "./Array.js";
-import { int32 } from "./Int32.js";
-import { some, Option } from "./Option.js";
-import { FSharpRef } from "./Types.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+import { IMap, IEqualityComparer, IDisposable, disposeSafe, defaultOf, ISet, MutableArray, toIterator, IEnumerator, getEnumerator } from "./Util.ts";
+import { iterate, map, iterateIndexed, concat } from "./Seq.ts";
+import { setItem } from "./Array.ts";
+import { int32 } from "./Int32.ts";
+import { some, Option } from "./Option.ts";
+import { FSharpRef } from "./Types.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { getItemFromDict, tryGetValue } from "./MapUtil.ts";
 
 export class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
     readonly comparer: IEqualityComparer<T>;
@@ -59,7 +59,7 @@ export class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
         const this$: HashSet<T> = this;
         return HashSet__Contains_2B595<T>(this$, item);
     }
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void {
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: MutableArray<T>, arrayIndex: int32): void {
         const this$: HashSet<T> = this;
         iterateIndexed<T>((i: int32, e: T): void => {
             setItem(array, arrayIndex + i, e);
@@ -142,7 +142,7 @@ function HashSet__TryFindIndex_2B595<T>(this$: HashSet<T>, k: T): [boolean, int3
 
 function HashSet__TryFind_2B595<T>(this$: HashSet<T>, k: T): Option<T> {
     const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;
@@ -204,7 +204,7 @@ export function HashSet__Add_2B595<T>(this$: HashSet<T>, k: T): boolean {
 
 export function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean {
     const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;
@@ -226,7 +226,7 @@ export function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean {
 
 export function HashSet__Remove_2B595<T>(this$: HashSet<T>, k: T): boolean {
     const matchValue: [boolean, int32, int32] = HashSet__TryFindIndex_2B595<T>(this$, k);
-    let matchResult: int32;
+    let matchResult: int32 = undefined as any;
     if (matchValue[0]) {
         if (matchValue[2] > -1) {
             matchResult = 0;

package/Native.ts

@@ -1,8 +1,8 @@
 
-import { Nullable } from "./Util.js";
-import { int32 } from "./Int32.js";
+import { int32 } from "./Int32.ts";
+import { MutableArray } from "./Util.ts";
 
-export function Helpers_allocateArrayFromCons<T>(cons: Nullable<any>, len: int32): T[] {
+export function Helpers_allocateArrayFromCons<T>(cons: any, len: int32): MutableArray<T> {
     if (cons == null) {
         return new Array(len);
     }

package/Numeric.ts

@@ -1,4 +1,4 @@
-import { IComparable } from "./Util.js";
+import { IComparable } from "./Util.ts";
 
 export const symbol = Symbol("numeric");
 

package/Observable.ts

@@ -1,7 +1,7 @@
 
-import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
-import { Option, value } from "./Option.js";
-import { IDisposable } from "./Util.js";
+import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.ts";
+import { Option, value } from "./Option.ts";
+import { IDisposable } from "./Util.ts";
 
 export interface IObserver<T> {
   OnNext: (x: T) => void;

package/Option.ts

@@ -1,4 +1,4 @@
-import { Nullable, structuralHash, equals, compare } from "./Util.js";
+import { Exception, Nullable, structuralHash, equals, compare } from "./Util.ts";
 
 // Options are erased in runtime by Fable, but we have
 // the `Some` type below to wrap values that would evaluate
@@ -54,7 +54,7 @@ export class Some<T> {
 
 export function nonNullValue<T>(x: Nullable<T>): T {
   if (x == null) {
-    throw new Error("Nullable has no value");
+    throw new Exception("Nullable has no value");
   } else {
     return x;
   }
@@ -62,7 +62,7 @@ export function nonNullValue<T>(x: Nullable<T>): T {
 
 export function value<T>(x: Option<T>) {
   if (x == null) {
-    throw new Error("Option has no value");
+    throw new Exception("Option has no value");
   } else {
     return x instanceof Some ? x.value : x;
   }

package/Random.ts

@@ -1,44 +1,44 @@
 
-import { uint8, int32, float64 } from "./Int32.js";
-import { Operators_IsNull, Operators_NonNull } from "./FSharp.Core.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, int64, fromInt32, toInt64_unchecked } from "./BigInt.js";
-import { Nullable } from "./Util.js";
-import { item, fill, setItem } from "./Array.js";
+import { uint8, int32, float64 } from "./Int32.ts";
+import { ArgumentNullException_$ctor_Z721C83C5, ArgumentOutOfRangeException_$ctor_Z721C83C5 } from "./System.ts";
+import { Operators_IsNull, Operators_NonNull } from "./FSharp.Core.ts";
+import { MutableArray } from "./Util.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, int64, fromInt32, toInt64_unchecked } from "./BigInt.ts";
+import { item, setItem } from "./Array.ts";
 
 function Native_random(): float64 {
     return Math.random();
 }
 
-function Native_randomNext(min: int32, max: int32): int32 {
-            if (max < min) {
-            throw new Error("minValue must be less than maxValue");
-        }
-        return Math.floor(Math.random() * (max - min)) + min
-        ;
+function Native_randomNext(minValue: int32, maxValue: int32): int32 {
+    if (maxValue < minValue) {
+        throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
+    }
+    return Math.floor(Math.random() * (maxValue - minValue)) + minValue;
 }
 
-function Native_randomBytes(buffer: uint8[]): void {
-            if (buffer == null) {
-            throw new Error("Buffer cannot be null");
+function Native_randomBytes(buffer: MutableArray<uint8>): void {
+    if (Operators_IsNull<any>(buffer)) {
+        throw ArgumentNullException_$ctor_Z721C83C5("buffer");
+    }
+    for (let i = 0; i < buffer.length; i += 6) {
+        // Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.
+        let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.
+        const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.
+        for (let j = 0; j < 6 && i + j < buffer.length; j++) {
+            if (j === 3) { r = rhi; }
+            buffer[i + j] = r & 255;
+            r >>>= 8;
         }
-        for (let i = 0; i < buffer.length; i += 6) {
-            // Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.
-            let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.
-            const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.
-            for (let j = 0; j < 6 && i + j < buffer.length; j++) {
-                if (j === 3) { r = rhi; }
-                buffer[i + j] = r & 255;
-                r >>>= 8;
-            }
-        };
+    };
 }
 
 export interface IRandom {
     Next0(): int32,
     Next1(maxValue: int32): int32,
     Next2(minValue: int32, maxValue: int32): int32,
-    NextBytes(buffer: uint8[]): void,
+    NextBytes(buffer: MutableArray<uint8>): void,
     NextDouble(): float64
 }
 
@@ -57,7 +57,7 @@ export class NonSeeded implements IRandom {
     NextDouble(): float64 {
         return Native_random();
     }
-    NextBytes(buffer: uint8[]): void {
+    NextBytes(buffer: MutableArray<uint8>): void {
         Native_randomBytes(buffer);
     }
 }
@@ -74,12 +74,12 @@ export class Seeded implements IRandom {
     readonly MBIG: int32;
     inext: int32;
     inextp: int32;
-    seedArray: int32[];
+    seedArray: MutableArray<int32>;
     constructor(seed: int32) {
         this.MBIG = 2147483647;
         this.inext = 0;
         this.inextp = 0;
-        this.seedArray = fill(new Array(56), 0, 56, 0);
+        this.seedArray = (new Int32Array(56));
         let ii = 0;
         let mj = 0;
         let mk = 0;
@@ -114,14 +114,14 @@ export class Seeded implements IRandom {
     Next1(maxValue: int32): int32 {
         const this$: Seeded = this;
         if (maxValue < 0) {
-            throw new Error("maxValue must be positive");
+            throw ArgumentOutOfRangeException_$ctor_Z721C83C5("maxValue must be positive");
         }
         return ~~(Seeded__Sample(this$) * maxValue) | 0;
     }
     Next2(minValue: int32, maxValue: int32): int32 {
         const this$: Seeded = this;
         if (minValue > maxValue) {
-            throw new Error("minValue must be less than maxValue");
+            throw ArgumentOutOfRangeException_$ctor_Z721C83C5("minValue must be less than maxValue");
         }
         const range: int64 = toInt64_unchecked(fromInt32(maxValue - minValue));
         return ((compare(range, toInt64_unchecked(fromInt32(2147483647))) <= 0) ? (~~(Seeded__Sample(this$) * toFloat64(range)) + minValue) : ~~toInt32_unchecked(toInt64_unchecked(op_Addition(toInt64_unchecked(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64_unchecked(fromInt32(minValue)))))) | 0;
@@ -130,10 +130,10 @@ export class Seeded implements IRandom {
         const this$: Seeded = this;
         return Seeded__Sample(this$);
     }
-    NextBytes(buffer: uint8[]): void {
+    NextBytes(buffer: MutableArray<uint8>): void {
         const this$: Seeded = this;
-        if (Operators_IsNull<Nullable<any>>(buffer)) {
-            throw new Error("buffer");
+        if (Operators_IsNull<any>(buffer)) {
+            throw ArgumentNullException_$ctor_Z721C83C5("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {
             setItem(buffer, i, (Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);

package/Range.ts

@@ -1,15 +1,15 @@
 
-import { compare } from "./Util.js";
-import { float64, int32 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { unfold, delay } from "./Seq.js";
-import { uint64, toUInt64_unchecked, int64, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.js";
-import { decimal, op_Addition as op_Addition_1, fromParts } from "./Decimal.js";
+import { Exception, compare } from "./Util.ts";
+import { float64, int32 } from "./Int32.ts";
+import { Option } from "./Option.ts";
+import { unfold, delay } from "./Seq.ts";
+import { uint64, toUInt64_unchecked, int64, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.ts";
+import { decimal, op_Addition as op_Addition_1, fromParts } from "./Decimal.ts";
 
 export function makeRangeStepFunction<T>(step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): ((arg0: T) => Option<[T, T]>) {
     const stepComparedWithZero: int32 = compare(step, zero) | 0;
     if (stepComparedWithZero === 0) {
-        throw new Error("The step of a range cannot be zero");
+        throw new Exception("The step of a range cannot be zero");
     }
     const stepGreaterThanZero: boolean = stepComparedWithZero > 0;
     return (x: T): Option<[T, T]> => {

package/Reflection.ts

@@ -1,6 +1,6 @@
-import { FSharpRef, Record, Union } from "./Types.js";
-import { combineHashCodes, equalArraysWith, IEquatable, stringHash } from "./Util.js";
-import Decimal from "./Decimal.js";
+import { FSharpRef, Record, Union } from "./Types.ts";
+import { Exception, MutableArray, combineHashCodes, equalArraysWith, IEquatable, stringHash } from "./Util.ts";
+import Decimal from "./Decimal.ts";
 
 export type FieldInfo = [string, TypeInfo];
 export type PropertyInfo = FieldInfo;
@@ -9,34 +9,67 @@ export type ParameterInfo = FieldInfo;
 export type Constructor = new (...args: any[]) => any;
 
 export class CaseInfo {
+  public declaringType: TypeInfo;
+  public tag: number;
+  public name: string;
+  public fields?: FieldInfo[];
+
   constructor(
-    public declaringType: TypeInfo,
-    public tag: number,
-    public name: string,
-    public fields?: FieldInfo[]) {
+    declaringType: TypeInfo,
+    tag: number,
+    name: string,
+    fields?: FieldInfo[]
+  ) {
+    this.declaringType = declaringType;
+    this.tag = tag;
+    this.name = name;
+    this.fields = fields;
   }
 }
 
 export type EnumCase = [string, number];
 
 export class MethodInfo {
+  public name: string;
+  public parameters: ParameterInfo[];
+  public returnType: TypeInfo;
+
   constructor(
-    public name: string,
-    public parameters: ParameterInfo[],
-    public returnType: TypeInfo,
+    name: string,
+    parameters: ParameterInfo[],
+    returnType: TypeInfo,
   ) {
+    this.name = name;
+    this.parameters = parameters;
+    this.returnType = returnType;
   }
 }
 
 export class TypeInfo implements IEquatable<TypeInfo> {
+  public fullname: string;
+  public generics?: TypeInfo[];
+  public construct?: Constructor;
+  public parent?: TypeInfo;
+  public fields?: () => FieldInfo[];
+  public cases?: () => CaseInfo[];
+  public enumCases?: EnumCase[];
+
   constructor(
-    public fullname: string,
-    public generics?: TypeInfo[],
-    public construct?: Constructor,
-    public parent?: TypeInfo,
-    public fields?: () => FieldInfo[],
-    public cases?: () => CaseInfo[],
-    public enumCases?: EnumCase[]) {
+    fullname: string,
+    generics?: TypeInfo[],
+    construct?: Constructor,
+    parent?: TypeInfo,
+    fields?: () => FieldInfo[],
+    cases?: () => CaseInfo[],
+    enumCases?: EnumCase[]
+  ) {
+    this.fullname = fullname;
+    this.generics = generics;
+    this.construct = construct;
+    this.parent = parent;
+    this.fields = fields;
+    this.cases = cases;
+    this.enumCases = enumCases;
   }
   public toString() {
     return fullName(this);
@@ -50,9 +83,9 @@ export class TypeInfo implements IEquatable<TypeInfo> {
 }
 
 export class GenericParameter extends TypeInfo {
-    constructor(name: string) {
-      super(name);
-    }
+  constructor(name: string) {
+    super(name);
+  }
 }
 
 export function getGenerics(t: TypeInfo): TypeInfo[] {
@@ -177,7 +210,7 @@ export function name(info: FieldInfo | TypeInfo | CaseInfo | MethodInfo): string
       return name(elemType) + "[]";
     } else {
       const i = info.fullname.lastIndexOf(".");
-      return i === -1 ? info.fullname : info.fullname.substr(i + 1);
+      return i === -1 ? info.fullname : info.fullname.slice(i + 1);
     }
   } else {
     return info.name;
@@ -201,7 +234,7 @@ export function namespace(t: TypeInfo): string {
     return namespace(elemType);
   } else {
     const i = t.fullname.lastIndexOf(".");
-    return i === -1 ? "" : t.fullname.substr(0, i);
+    return i === -1 ? "" : t.fullname.slice(0, i);
   }
 }
 
@@ -290,7 +323,7 @@ export function getEnumValues(t: TypeInfo): number[] {
   if (isEnum(t) && t.enumCases != null) {
     return t.enumCases.map((kv) => kv[1]);
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -298,7 +331,7 @@ export function getEnumNames(t: TypeInfo): string[] {
   if (isEnum(t) && t.enumCases != null) {
     return t.enumCases.map((kv) => kv[0]);
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -310,7 +343,7 @@ function getEnumCase(t: TypeInfo, v: number | string): EnumCase {
           return kv;
         }
       }
-      throw new Error(`'${v}' was not found in ${t.fullname}`);
+      throw new Exception(`'${v}' was not found in ${t.fullname}`);
     } else {
       for (const kv of t.enumCases) {
         if (kv[1] === v) {
@@ -321,7 +354,7 @@ function getEnumCase(t: TypeInfo, v: number | string): EnumCase {
       return ["", v];
     }
   } else {
-    throw new Error(`${t.fullname} is not an enum type`);
+    throw new Exception(`${t.fullname} is not an enum type`);
   }
 }
 
@@ -360,7 +393,7 @@ export function getUnionCases(t: TypeInfo): CaseInfo[] {
   if (t.cases != null) {
     return t.cases();
   } else {
-    throw new Error(`${t.fullname} is not an F# union type`);
+    throw new Exception(`${t.fullname} is not an F# union type`);
   }
 }
 
@@ -368,7 +401,7 @@ export function getRecordElements(t: TypeInfo): FieldInfo[] {
   if (t.fields != null) {
     return t.fields();
   } else {
-    throw new Error(`${t.fullname} is not an F# record type`);
+    throw new Exception(`${t.fullname} is not an F# record type`);
   }
 }
 
@@ -376,7 +409,7 @@ export function getTupleElements(t: TypeInfo): TypeInfo[] {
   if (isTuple(t) && t.generics != null) {
     return t.generics;
   } else {
-    throw new Error(`${t.fullname} is not a tuple type`);
+    throw new Exception(`${t.fullname} is not a tuple type`);
   }
 }
 
@@ -385,7 +418,7 @@ export function getFunctionElements(t: TypeInfo): [TypeInfo, TypeInfo] {
     const gen = t.generics;
     return [gen[0], gen[1]];
   } else {
-    throw new Error(`${t.fullname} is not an F# function type`);
+    throw new Exception(`${t.fullname} is not an F# function type`);
   }
 }
 
@@ -412,7 +445,7 @@ export function getUnionFields(v: any, t: TypeInfo): [CaseInfo, any[]] {
   const cases = getUnionCases(t);
   const case_ = cases[v.tag];
   if (case_ == null) {
-    throw new Error(`Cannot find case ${v.name} in union type`);
+    throw new Exception(`Cannot find case ${v.name} in union type`);
   }
   return [case_, v.fields];
 }
@@ -424,7 +457,7 @@ export function getUnionCaseFields(uci: CaseInfo): FieldInfo[] {
 // This is used as replacement of `FSharpValue.GetRecordFields`
 // For `FSharpTypes.GetRecordFields` see `getRecordElements`
 // Object.keys returns keys in the order they were added to the object
-export function getRecordFields(v: any): any[] {
+export function getRecordFields(v: any): MutableArray<any> {
   return Object.keys(v).map((k) => v[k]);
 }
 
@@ -432,7 +465,7 @@ export function getRecordField(v: any, field: FieldInfo): any {
   return v[field[0]];
 }
 
-export function getTupleFields(v: any): any[] {
+export function getTupleFields(v: any): MutableArray<any> {
   return v;
 }
 
@@ -440,10 +473,10 @@ export function getTupleField(v: any, i: number): any {
   return v[i];
 }
 
-export function makeUnion(uci: CaseInfo, values: any[]): any {
+export function makeUnion(uci: CaseInfo, values: MutableArray<any>): any {
   const expectedLength = (uci.fields || []).length;
   if (values.length !== expectedLength) {
-    throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);
+    throw new Exception(`Expected an array of length ${expectedLength} but got ${values.length}`);
   }
   const construct = uci.declaringType.construct;
   if (construct == null) {
@@ -458,10 +491,10 @@ export function makeUnion(uci: CaseInfo, values: any[]): any {
   }
 }
 
-export function makeRecord(t: TypeInfo, values: any[]): any {
+export function makeRecord(t: TypeInfo, values: MutableArray<any>): any {
   const fields = getRecordElements(t);
   if (fields.length !== values.length) {
-    throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);
+    throw new Exception(`Expected an array of length ${fields.length} but got ${values.length}`);
   }
   return t.construct != null
     ? new t.construct(...values)
@@ -471,7 +504,7 @@ export function makeRecord(t: TypeInfo, values: any[]): any {
     }, {} as any);
 }
 
-export function makeTuple(values: any[], _t: TypeInfo): any {
+export function makeTuple(values: MutableArray<any>, _t: TypeInfo): any {
   return values;
 }
 
@@ -506,7 +539,7 @@ export function createInstance(t: TypeInfo, consArgs?: any[]): any {
         // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null
         return null;
       default:
-        throw new Error(`Cannot access constructor of ${t.fullname}`);
+        throw new Exception(`Cannot access constructor of ${t.fullname}`);
     }
   }
 }
@@ -519,7 +552,7 @@ export function getValue(propertyInfo: PropertyInfo, v: any): any {
 
 function assertUnion(x: any) {
   if (!(x instanceof Union)) {
-    throw new Error(`Value is not an F# union type`);
+    throw new Exception(`Value is not an F# union type`);
   }
 }
 

package/RegExp.ts

@@ -1,3 +1,5 @@
+import { Exception } from "./Util.ts";
+
 export type MatchEvaluator = (match: any) => string;
 
 export function create(pattern: string, options = 0) {
@@ -8,7 +10,7 @@ export function create(pattern: string, options = 0) {
   // * Singleline:  0x0010
   // * ECMAScript:  0x0100 (ignored)
   if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
-    throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+    throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
   }
   // Set always global and unicode flags for compatibility with dotnet, see #2925
   let flags = "gu";
@@ -39,10 +41,10 @@ export function match(reg: RegExp, input: string, startAt = 0) {
 
 export function matches(reg: RegExp, input: string, startAt = 0) {
   if (input == null) {
-    throw new Error("Input cannot ve null");
+    throw new Exception("Input cannot ve null");
   }
   if (!reg.global) {
-    throw new Error("Non-global RegExp"); // Prevent infinite loop
+    throw new Exception("Non-global RegExp"); // Prevent infinite loop
   }
   reg.lastIndex = startAt;
   const matches: RegExpExecArray[] = [];