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

package/FSharp.Core.ts

@@ -1,185 +1,186 @@
-import { IDisposable, disposeSafe, defaultOf, IEqualityComparer, IComparer, structuralHash, equals } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
-import { value as value_1, Nullable, Option } from "./Option.js";
-import { FSharpChoice$2_$union, FSharpChoice$2_Choice2Of2, FSharpChoice$2_Choice1Of2 } from "./Choice.js";
-import { concat } from "./String.js";
-import { StringBuilder, StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
-
-export const LanguagePrimitives_GenericEqualityComparer: any = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x: any, y: any): boolean {
-        return equals(x, y);
-    },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
-        return structuralHash(x_1) | 0;
-    },
-};
-
-export const LanguagePrimitives_GenericEqualityERComparer: any = {
-    "System.Collections.IEqualityComparer.Equals541DA560"(x: any, y: any): boolean {
-        return equals(x, y);
-    },
-    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
-        return structuralHash(x_1) | 0;
-    },
-};
-
-export function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T> {
-    return ComparisonIdentity_Structural<T>();
-}
-
-export function LanguagePrimitives_FastGenericComparerFromTable<T>(): IComparer<T> {
-    return ComparisonIdentity_Structural<T>();
-}
-
-export function LanguagePrimitives_FastGenericEqualityComparer<T>(): IEqualityComparer<T> {
-    return HashIdentity_Structural<T>();
-}
-
-export function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IEqualityComparer<T> {
-    return HashIdentity_Structural<T>();
-}
-
-export function Operators_Failure(message: string): Error {
-    return new Error(message);
-}
-
-export function Operators_FailurePattern(exn: Error): Option<string> {
-    return exn.message;
-}
-
-export function Operators_NullArg<$a>(x: string): $a {
-    throw new Error(x);
-}
-
-export function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R {
-    try {
-        return action(resource);
-    }
-    finally {
-        if (equals(resource, defaultOf())) {
-        }
-        else {
-            let copyOfStruct: T = resource;
-            disposeSafe(copyOfStruct);
-        }
-    }
-}
-
-export function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b {
-    return action();
-}
-
-export function Operators_IsNull<T>(value: T): boolean {
-    if (equals(value, defaultOf())) {
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-
-export function Operators_IsNotNull<T>(value: T): boolean {
-    if (equals(value, defaultOf())) {
-        return false;
-    }
-    else {
-        return true;
-    }
-}
-
-export function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean {
-    return !(value != null);
-}
-
-export function Operators_NonNull<T>(value: T): T {
-    if (equals(value, defaultOf())) {
-        throw new Error();
-    }
-    else {
-        return value;
-    }
-}
-
-export function Operators_NonNullV<T extends any>(value: Nullable<T>): T {
-    if (value != null) {
-        return value_1(value);
-    }
-    else {
-        throw new Error();
-    }
-}
-
-export function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T> {
-    if (equals(value, defaultOf())) {
-        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
-    }
-    else {
-        return FSharpChoice$2_Choice2Of2<void, T>(value);
-    }
-}
-
-export function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T> {
-    if (value != null) {
-        return FSharpChoice$2_Choice2Of2<void, T>(value_1(value));
-    }
-    else {
-        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
-    }
-}
-
-export function Operators_NonNullQuickPattern<T>(value: T): T {
-    if (equals(value, defaultOf())) {
-        throw new Error();
-    }
-    else {
-        return value;
-    }
-}
-
-export function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T {
-    if (value != null) {
-        return value_1(value);
-    }
-    else {
-        throw new Error();
-    }
-}
-
-export function Operators_WithNull<T>(value: T): T {
-    return value;
-}
-
-export function Operators_WithNullV<T extends any>(value: T): T {
-    return value;
-}
-
-export function Operators_NullV<T extends any>(): Nullable<T> {
-    return defaultOf();
-}
-
-export function Operators_NullArgCheck<T>(argumentName: string, value: T): T {
-    if (equals(value, defaultOf())) {
-        throw new Error(concat("Value cannot be null. (Parameter \'", argumentName, ..."\')"));
-    }
-    else {
-        return value;
-    }
-}
-
-export function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a {
-    return input.Value;
-}
-
-export function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b {
-    return format.cont((s: string): $a => {
-        StringBuilder__Append_Z721C83C5(builder, s);
-        return continuation();
-    });
-}
-
-export function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a {
-    return PrintfModule_PrintFormatToStringBuilderThen<void, $a>((): void => {
-    }, builder, format);
-}
-
+
+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 = {
+    Equals(x: any, y: any): boolean {
+        return equals(x, y);
+    },
+    GetHashCode(x_1: any): int32 {
+        return structuralHash(x_1) | 0;
+    },
+};
+
+export const LanguagePrimitives_GenericEqualityERComparer: any = {
+    Equals(x: any, y: any): boolean {
+        return equals(x, y);
+    },
+    GetHashCode(x_1: any): int32 {
+        return structuralHash(x_1) | 0;
+    },
+};
+
+export function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T> {
+    return ComparisonIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericComparerFromTable<T>(): IComparer<T> {
+    return ComparisonIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericEqualityComparer<T>(): IEqualityComparer<T> {
+    return HashIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IEqualityComparer<T> {
+    return HashIdentity_Structural<T>();
+}
+
+export function Operators_Failure(message: string): any {
+    return new Exception(message);
+}
+
+export function Operators_FailurePattern(exn: Exception): Option<string> {
+    return exn.message;
+}
+
+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 {
+    try {
+        return action(resource);
+    }
+    finally {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct: T = resource;
+            disposeSafe(copyOfStruct);
+        }
+    }
+}
+
+export function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b {
+    return action();
+}
+
+export function Operators_IsNull<T>(value: T): boolean {
+    if (equals(value, defaultOf())) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+
+export function Operators_IsNotNull<T>(value: T): boolean {
+    if (equals(value, defaultOf())) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+
+export function Operators_IsNullV<T extends any>(value: Nullable<T>): boolean {
+    return !(value != null);
+}
+
+export function Operators_NonNull<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
+    }
+    else {
+        return value;
+    }
+}
+
+export function Operators_NonNullV<T extends any>(value: Nullable<T>): T {
+    if (value != null) {
+        return nonNullValue(value);
+    }
+    else {
+        throw NullReferenceException_$ctor();
+    }
+}
+
+export function Operators_NullMatchPattern<T>(value: T): FSharpChoice$2_$union<void, T> {
+    if (equals(value, defaultOf())) {
+        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
+    }
+    else {
+        return FSharpChoice$2_Choice2Of2<void, T>(value);
+    }
+}
+
+export function Operators_NullValueMatchPattern<T extends any>(value: Nullable<T>): FSharpChoice$2_$union<void, T> {
+    if (value != null) {
+        return FSharpChoice$2_Choice2Of2<void, T>(nonNullValue(value));
+    }
+    else {
+        return FSharpChoice$2_Choice1Of2<void, T>(undefined);
+    }
+}
+
+export function Operators_NonNullQuickPattern<T>(value: T): T {
+    if (equals(value, defaultOf())) {
+        throw NullReferenceException_$ctor();
+    }
+    else {
+        return value;
+    }
+}
+
+export function Operators_NonNullQuickValuePattern<T extends any>(value: Nullable<T>): T {
+    if (value != null) {
+        return nonNullValue(value);
+    }
+    else {
+        throw NullReferenceException_$ctor();
+    }
+}
+
+export function Operators_WithNull<T>(value: T): T {
+    return value;
+}
+
+export function Operators_WithNullV<T extends any>(value: T): T {
+    return value;
+}
+
+export function Operators_NullV<T extends any>(): Nullable<T> {
+    return null;
+}
+
+export function Operators_NullArgCheck<T>(argumentName: string, value: T): T {
+    if (equals(value, defaultOf())) {
+        throw ArgumentNullException_$ctor_Z721C83C5(argumentName);
+    }
+    else {
+        return value;
+    }
+}
+
+export function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a {
+    return input.Value;
+}
+
+export function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: any, format: any): $b {
+    return format.cont((s: string): $a => {
+        StringBuilder__Append_Z721C83C5(builder, s);
+        return continuation();
+    });
+}
+
+export function PrintfModule_PrintFormatToStringBuilder<$a>(builder: any, format: any): $a {
+    return PrintfModule_PrintFormatToStringBuilderThen<void, $a>((): void => {
+    }, builder, format);
+}
+

package/Global.ts

@@ -1,37 +1,80 @@
-import { int32 } from "./Int32.js";
-
-export interface Fable_Core_IGenericAdder$1<T> {
-    Add(arg0: T, arg1: T): T,
-    GetZero(): T
-}
-
-export interface Fable_Core_IGenericAverager$1<T> {
-    Add(arg0: T, arg1: T): T,
-    DivideByInt(arg0: T, arg1: int32): T,
-    GetZero(): T
-}
-
-export interface Fable_Core_Symbol_wellknown {
-    [Symbol.toStringTag]: string
-}
-
-export interface Fable_Core_IJsonSerializable {
-    toJSON(): any
-}
-
-export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
-
-export const SR_inputWasEmpty = "Collection was empty.";
-
-export const SR_inputMustBeNonNegative = "The input must be non-negative.";
-
-export const SR_inputSequenceEmpty = "The input sequence was empty.";
-
-export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
-
-export const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
-
-export const SR_differentLengths = "The collections had different lengths.";
-
-export const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
-
+
+import { int32 } from "./Int32.ts";
+
+export interface Fable_Core_IGenericAdder$1<T> {
+    Add(arg0: T, arg1: T): T,
+    GetZero(): T
+}
+
+export interface Fable_Core_IGenericAverager$1<T> {
+    Add(arg0: T, arg1: T): T,
+    DivideByInt(arg0: T, arg1: int32): T,
+    GetZero(): T
+}
+
+export interface Fable_Core_Symbol_wellknown {
+    get [Symbol.toStringTag](): string
+}
+
+export interface Fable_Core_IJsonSerializable {
+    toJSON(): any
+}
+
+export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
+
+export const SR_inputWasEmpty = "Collection was empty.";
+
+export const SR_inputMustBeNonNegative = "The input must be non-negative.";
+
+export const SR_inputSequenceEmpty = "The input sequence was empty.";
+
+export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+
+export const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+
+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 {