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

package/Decimal.ts

@@ -1,10 +1,10 @@
 import Decimal, { BigSource } from "./lib/big.js";
-import { Numeric, symbol } from "./Numeric.js";
-import { FSharpRef } from "./Types.js";
-import { combineHashCodes } from "./Util.js";
-import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
-import { fromDecimal, int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.js";
-import * as bigInt from "./BigInt.js";
+import { Numeric, symbol } from "./Numeric.ts";
+import { FSharpRef } from "./Types.ts";
+import { Exception, combineHashCodes } from "./Util.ts";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.ts";
+import { fromDecimal, int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.ts";
+import * as bigInt from "./BigInt.ts";
 
 Decimal.prototype.GetHashCode = function () {
   return combineHashCodes([this.s, this.e].concat(this.c))
@@ -138,7 +138,7 @@ export function parse(str: string): Decimal {
   if (tryParse(str, defValue)) {
     return defValue.contents;
   } else {
-    throw new Error(`The input string ${str} was not in a correct format.`);
+    throw new Exception(`The input string ${str} was not in a correct format.`);
   }
 }
 
@@ -149,7 +149,7 @@ export function toNumber(x: Decimal): number {
 export function toChar(x: Decimal): string {
   const n = toNumber(x);
   if (n < 0 || n > 65535 || isNaN(n)) {
-    throw new Error("Value was either too large or too small for a character.");
+    throw new Exception("Value was either too large or too small for a character.");
   }
   return String.fromCharCode(n);
 }
@@ -263,7 +263,7 @@ export function getBits(d: Decimal) {
 // export function makeRangeStepFunction(step: Decimal, last: Decimal) {
 //   const stepComparedWithZero = step.cmp(get_Zero);
 //   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 = stepComparedWithZero > 0;
 //   return (x: Decimal) => {

package/Double.ts

@@ -1,4 +1,5 @@
-import { FSharpRef } from "./Types.js";
+import { FSharpRef } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 export function tryParse(str: string, defValue: FSharpRef<number>): boolean {
   // TODO: test if value is valid and in range
@@ -17,7 +18,7 @@ export function parse(str: string): number {
   if (tryParse(str, defValue)) {
     return defValue.contents;
   } else {
-    throw new Error(`The input string ${str} was not in a correct format.`);
+    throw new Exception(`The input string ${str} was not in a correct format.`);
   }
 }
 

package/Encoding.ts

@@ -1,4 +1,4 @@
-import { uint8 } from "./Int32.js";
+import { uint8 } from "./Int32.ts";
 
 const littleEndian = true;
 

package/Event.ts

@@ -1,6 +1,6 @@
-import { IObservable, subscribe } from "./Observable.js";
-import { Option, some, value } from "./Option.js";
-import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+import { IObservable, subscribe } from "./Observable.ts";
+import { Option, some, value } from "./Option.ts";
+import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.ts";
 
 export type Handler<T> = (sender: any, x: T) => void;
 

package/FSharp.Collections.ts

@@ -1,35 +1,53 @@
 
-import { compare, IComparer, physicalHash, nullableEquals, structuralHash, IEqualityComparer, Nullable } from "./Util.js";
-import { int32 } from "./Int32.js";
+import { int32 } from "./Int32.ts";
+import { compare, IComparer, physicalHash, equals as equals_1, structuralHash, IEqualityComparer } from "./Util.ts";
 
-export function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: Nullable<T>, arg1: Nullable<T>) => boolean)): IEqualityComparer<T> {
+export function HashIdentity_FromFunctions<T>(hasher: ((arg0: T) => int32), equals: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T> {
     return {
-        Equals(x: Nullable<T>, y: Nullable<T>): boolean {
-            return eq(x, y);
+        GetHashCode(x: T): int32 {
+            return hasher(x) | 0;
         },
-        GetHashCode(x_1: T): int32 {
-            return hash(x_1) | 0;
+        Equals(x_1: T, y: T): boolean {
+            return (x_1 == null) ? (y == null) : ((y == null) ? false : equals(x_1, y));
         },
     };
 }
 
 export function HashIdentity_Structural<T>(): IEqualityComparer<T> {
-    return HashIdentity_FromFunctions<T>((obj: T): int32 => (structuralHash(obj) | 0), nullableEquals);
+    return {
+        GetHashCode(x: T): int32 {
+            return structuralHash(x) | 0;
+        },
+        Equals(x_1: T, y: T): boolean {
+            return equals_1(x_1, y);
+        },
+    };
 }
 
 export function HashIdentity_Reference<T>(): IEqualityComparer<T> {
-    return HashIdentity_FromFunctions<T>((obj: T): int32 => (physicalHash(obj) | 0), nullableEquals);
+    return {
+        GetHashCode(x: T): int32 {
+            return physicalHash(x) | 0;
+        },
+        Equals(x_1: T, y: T): boolean {
+            return equals_1(x_1, y);
+        },
+    };
 }
 
-export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: Nullable<T>, arg1: Nullable<T>) => int32)): IComparer<T> {
+export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T> {
     return {
-        Compare(x: Nullable<T>, y: Nullable<T>): int32 {
-            return comparer(x, y) | 0;
+        Compare(x: T, y: T): int32 {
+            return ((x == null) ? ((y == null) ? 0 : -1) : ((y == null) ? 1 : comparer(x, y))) | 0;
         },
     };
 }
 
 export function ComparisonIdentity_Structural<T>(): IComparer<T> {
-    return ComparisonIdentity_FromFunction<T>((e: Nullable<T>, e_1: Nullable<T>): int32 => (compare(e, e_1) | 0));
+    return {
+        Compare(x: T, y: T): int32 {
+            return compare(x, y) | 0;
+        },
+    };
 }
 

package/FSharp.Core.CompilerServices.ts

@@ -1,8 +1,8 @@
 
-import { class_type, TypeInfo } from "./Reflection.js";
-import { addRangeInPlace } from "./Array.js";
-import { toList } from "./Seq.js";
-import { FSharpList } from "./List.js";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { addRangeInPlace } from "./Array.ts";
+import { toList } from "./Seq.ts";
+import { FSharpList } from "./List.ts";
 
 export class ListCollector$1<T> {
     readonly collector: T[];

package/FSharp.Core.ts

@@ -1,26 +1,26 @@
 
-import { IDisposable, disposeSafe, IEqualityComparer, IComparer, structuralHash, Nullable, nullableEquals } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
-import { nonNullValue, Option } from "./Option.js";
-import { FSharpChoice$2_$union, FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
-import { concat } from "./String.js";
-import { StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
+import { Nullable, IDisposable, disposeSafe, defaultOf, Exception, IEqualityComparer, IComparer, structuralHash, equals } from "./Util.ts";
+import { int32 } from "./Int32.ts";
+import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.ts";
+import { nonNullValue, Option } from "./Option.ts";
+import { NullReferenceException_$ctor, ArgumentNullException_$ctor_Z721C83C5 } from "./System.ts";
+import { FSharpChoice$2_$union, FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.ts";
+import { StringBuilder__Append_Z721C83C5 } from "./System.Text.ts";
 
 export const LanguagePrimitives_GenericEqualityComparer: any = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x: Nullable<any>, y: Nullable<any>): boolean {
-        return nullableEquals(x, y);
+    Equals(x: any, y: any): boolean {
+        return equals(x, y);
     },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
+    GetHashCode(x_1: any): int32 {
         return structuralHash(x_1) | 0;
     },
 };
 
 export const LanguagePrimitives_GenericEqualityERComparer: any = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x: Nullable<any>, y: Nullable<any>): boolean {
-        return nullableEquals(x, y);
+    Equals(x: any, y: any): boolean {
+        return equals(x, y);
     },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
+    GetHashCode(x_1: any): int32 {
         return structuralHash(x_1) | 0;
     },
 };
@@ -41,16 +41,16 @@ export function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IE
     return HashIdentity_Structural<T>();
 }
 
-export function Operators_Failure(message: string): Error {
-    return new Error(message);
+export function Operators_Failure(message: string): any {
+    return new Exception(message);
 }
 
-export function Operators_FailurePattern(exn: Error): Option<string> {
+export function Operators_FailurePattern(exn: Exception): Option<string> {
     return exn.message;
 }
 
-export function Operators_NullArg<$a>(x: string): $a {
-    throw new Error(x);
+export function Operators_NullArg<$a>(argumentName: string): $a {
+    throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
 }
 
 export function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R {
@@ -58,7 +58,7 @@ export function Operators_Using<T extends IDisposable, R>(resource: T, action: (
         return action(resource);
     }
     finally {
-        if (resource == null) {
+        if (equals(resource, defaultOf())) {
         }
         else {
             let copyOfStruct: T = resource;
@@ -72,7 +72,7 @@ export function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b {
 }
 
 export function Operators_IsNull<T>(value: T): boolean {
-    if (value == null) {
+    if (equals(value, defaultOf())) {
         return true;
     }
     else {
@@ -81,7 +81,7 @@ export function Operators_IsNull<T>(value: T): boolean {
 }
 
 export function Operators_IsNotNull<T>(value: T): boolean {
-    if (value == null) {
+    if (equals(value, defaultOf())) {
         return false;
     }
     else {
@@ -93,9 +93,9 @@ export function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean {
     return !(value != null);
 }
 
-export function Operators_NonNull<T>(value: Nullable<T>): T {
-    if (value == null) {
-        throw new Error();
+export function Operators_NonNull<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
     }
     else {
         return value;
@@ -107,12 +107,12 @@ export function Operators_NonNullV<T extends any>(value: Nullable<T>): T {
         return nonNullValue(value);
     }
     else {
-        throw new Error();
+        throw NullReferenceException_$ctor();
     }
 }
 
-export function Operators_NullMatchPattern<T>(value: Nullable<T>): FSharpChoice$2_$union<void, T> {
-    if (value == null) {
+export function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T> {
+    if (equals(value, defaultOf())) {
         return FSharpChoice$2_Choice1Of2<void, T>(undefined);
     }
     else {
@@ -129,9 +129,9 @@ export function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T
     }
 }
 
-export function Operators_NonNullQuickPattern<T>(value: Nullable<T>): T {
-    if (value == null) {
-        throw new Error();
+export function Operators_NonNullQuickPattern<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
     }
     else {
         return value;
@@ -143,7 +143,7 @@ export function Operators_NonNullQuickValuePattern<T extends any>(value: Nullabl
         return nonNullValue(value);
     }
     else {
-        throw new Error();
+        throw NullReferenceException_$ctor();
     }
 }
 
@@ -159,9 +159,9 @@ export function Operators_NullV<T extends any>(): Nullable<T> {
     return null;
 }
 
-export function Operators_NullArgCheck<T>(argumentName: string, value: Nullable<T>): T {
-    if (value == null) {
-        throw new Error(concat("Value cannot be null. (Parameter \'", argumentName, ..."\')"));
+export function Operators_NullArgCheck<T>(argumentName: string, value: T): T {
+    if (equals(value, defaultOf())) {
+        throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
     }
     else {
         return value;

package/Global.ts

@@ -1,5 +1,5 @@
 
-import { int32 } from "./Int32.js";
+import { int32 } from "./Int32.ts";
 
 export interface Fable_Core_IGenericAdder$1<T> {
     Add(arg0: T, arg1: T): T,
@@ -13,7 +13,7 @@ export interface Fable_Core_IGenericAverager$1<T> {
 }
 
 export interface Fable_Core_Symbol_wellknown {
-    [Symbol.toStringTag]: string
+    get [Symbol.toStringTag](): string
 }
 
 export interface Fable_Core_IJsonSerializable {
@@ -36,3 +36,45 @@ export const SR_differentLengths = "The collections had different lengths.";
 
 export const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
 
+export const SR_Arg_ApplicationException = "Error in the application.";
+
+export const SR_Arg_ArgumentException = "Value does not fall within the expected range.";
+
+export const SR_Arg_ArgumentOutOfRangeException = "Specified argument was out of the range of valid values.";
+
+export const SR_ArgumentNull_Generic = "Value cannot be null.";
+
+export const SR_Arg_ParamName_Name = " (Parameter \'";
+
+export const SR_Arg_ArithmeticException = "Overflow or underflow in the arithmetic operation.";
+
+export const SR_Arg_DivideByZero = "Attempted to divide by zero.";
+
+export const SR_Arg_FormatException = "One of the identified items was in an invalid format.";
+
+export const SR_Arg_IndexOutOfRangeException = "Index was outside the bounds of the array.";
+
+export const SR_Arg_InvalidOperationException = "Operation is not valid due to the current state of the object.";
+
+export const SR_Arg_KeyNotFound = "The given key was not present in the dictionary.";
+
+export const SR_Arg_NotFiniteNumberException = "Number encountered was not a finite quantity.";
+
+export const SR_Arg_NotImplementedException = "The method or operation is not implemented.";
+
+export const SR_Arg_NotSupportedException = "Specified method is not supported.";
+
+export const SR_Arg_NullReferenceException = "Object reference not set to an instance of an object.";
+
+export const SR_Arg_OutOfMemoryException = "Insufficient memory to continue the execution of the program.";
+
+export const SR_Arg_OverflowException = "Arithmetic operation resulted in an overflow.";
+
+export const SR_Arg_RankException = "Attempted to operate on an array with the incorrect number of dimensions.";
+
+export const SR_Arg_StackOverflowException = "Operation caused a stack overflow.";
+
+export const SR_Arg_SystemException = "System error.";
+
+export const SR_Arg_TimeoutException = "The operation has timed out.";
+

package/Guid.ts

@@ -1,5 +1,6 @@
-import { trim } from "./String.js";
-import { FSharpRef } from "./Types.js";
+import { trim } from "./String.ts";
+import { FSharpRef } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 // RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220
 // const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -23,7 +24,7 @@ export function toString(str: string, format?: string, _provider?: any) {
       case "X":
         return str.replace(guidHexCaptures, "{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}");
       default:
-        throw new Error("Unrecognized Guid print format");
+        throw new Exception("Unrecognized Guid print format");
     }
   }
   else {
@@ -49,7 +50,7 @@ export function parse(str: string): string {
     return hyphenateGuid(wsTrimAndLowered.replace(/[\{\},]|0x/g, ''));
   }
   else {
-    throw new Error("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+    throw new Exception("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
   }
 }
 
@@ -82,7 +83,7 @@ function initConvertMaps() {
   _byteToHex = new Array(256);
   _hexToByte = {};
   for (let i = 0; i < 256; i++) {
-    _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+    _byteToHex[i] = i.toString(16).padStart(2, '0');
     _hexToByte[_byteToHex[i]] = i;
   }
   _convertMapsInitialized = true;
@@ -125,7 +126,7 @@ export function guidToArray(s: string): number[] {
 /** Convert UUID byte array into a string */
 export function arrayToGuid(buf: ArrayLike<number>) {
   if (buf.length !== 16) {
-    throw new Error("Byte array for GUID must be exactly 16 bytes long");
+    throw new Exception("Byte array for GUID must be exactly 16 bytes long");
   }
   if (!_convertMapsInitialized) {
     initConvertMaps();

package/Int32.ts

@@ -1,4 +1,5 @@
-import { FSharpRef } from "./Types.js";
+import { FSharpRef } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 export type int8 = number;
 export type uint8 = number;
@@ -11,18 +12,18 @@ export type float16 = number;
 export type float32 = number;
 export type float64 = number;
 
-export enum NumberStyles {
-  // None = 0x00000000,
-  // AllowLeadingWhite = 0x00000001,
-  // AllowTrailingWhite = 0x00000002,
-  // AllowLeadingSign = 0x00000004,
-  // AllowTrailingSign = 0x00000008,
-  // AllowParentheses = 0x00000010,
-  // AllowDecimalPoint = 0x00000020,
-  // AllowThousands = 0x00000040,
-  // AllowExponent = 0x00000080,
-  // AllowCurrencySymbol = 0x00000100,
-  AllowHexSpecifier = 0x00000200,
+export const NumberStyles = {
+  // None: 0x00000000,
+  // AllowLeadingWhite: 0x00000001,
+  // AllowTrailingWhite: 0x00000002,
+  // AllowLeadingSign: 0x00000004,
+  // AllowTrailingSign: 0x00000008,
+  // AllowParentheses: 0x00000010,
+  // AllowDecimalPoint: 0x00000020,
+  // AllowThousands: 0x00000040,
+  // AllowExponent: 0x00000080,
+  // AllowCurrencySymbol: 0x00000100,
+  AllowHexSpecifier: 0x00000200,
 
   // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,
   // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,
@@ -34,7 +35,9 @@ export enum NumberStyles {
   //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,
   // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |
   //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,
-}
+} as const;
+
+export type NumberStyles = typeof NumberStyles[keyof typeof NumberStyles];
 
 function validResponse(regexMatch: RegExpExecArray, radix: number) {
   const [/*all*/, sign, prefix, digits] = regexMatch;
@@ -51,7 +54,7 @@ function getRange(unsigned: boolean, bitsize: number): [number, number] {
     case 8: return unsigned ? [0, 255] : [-128, 127];
     case 16: return unsigned ? [0, 65535] : [-32768, 32767];
     case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];
-    default: throw new Error("Invalid bit size.");
+    default: throw new Exception("Invalid bit size.");
   }
 }
 
@@ -62,7 +65,7 @@ function getInvalidDigits(radix: number): RegExp {
     case 10: return /[^0-9]/;
     case 16: return /[^0-9a-fA-F]/;
     default:
-      throw new Error("Invalid Base.");
+      throw new Exception("Invalid Base.");
   }
 }
 
@@ -118,7 +121,7 @@ export function parse(str: string, style: number, unsigned: boolean, bitsize: nu
       }
     }
   }
-  throw new Error(`The input string ${str} was not in a correct format.`);
+  throw new Exception(`The input string ${str} was not in a correct format.`);
 }
 
 export function tryParse(str: string, style: number, unsigned: boolean, bitsize: number, defValue: FSharpRef<number>): boolean {