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

package/System.js

@@ -0,0 +1,283 @@
+import { Exception } from "./Util.js";
+import { class_type } from "./Reflection.js";
+import { SR_Arg_ArgumentOutOfRangeException, SR_ArgumentNull_Generic, SR_Arg_ArgumentException, SR_Arg_ParamName_Name, SR_Arg_TimeoutException, SR_Arg_StackOverflowException, SR_Arg_RankException, SR_Arg_OverflowException, SR_Arg_OutOfMemoryException, SR_Arg_NullReferenceException, SR_Arg_NotSupportedException, SR_Arg_NotImplementedException, SR_Arg_NotFiniteNumberException, SR_Arg_InvalidOperationException, SR_Arg_IndexOutOfRangeException, SR_Arg_FormatException, SR_Arg_DivideByZero, SR_Arg_ArithmeticException, SR_Arg_ApplicationException, SR_Arg_SystemException } from "./Global.js";
+import { isNullOrEmpty } from "./String.js";
+export class SystemException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function SystemException_$reflection() {
+    return class_type("System.SystemException", undefined, SystemException, class_type("System.Exception"));
+}
+export function SystemException_$ctor_Z721C83C5(message) {
+    return new SystemException(message);
+}
+export function SystemException_$ctor() {
+    return SystemException_$ctor_Z721C83C5(SR_Arg_SystemException);
+}
+export class ApplicationException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function ApplicationException_$reflection() {
+    return class_type("System.ApplicationException", undefined, ApplicationException, class_type("System.Exception"));
+}
+export function ApplicationException_$ctor_Z721C83C5(message) {
+    return new ApplicationException(message);
+}
+export function ApplicationException_$ctor() {
+    return ApplicationException_$ctor_Z721C83C5(SR_Arg_ApplicationException);
+}
+export class ArithmeticException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function ArithmeticException_$reflection() {
+    return class_type("System.ArithmeticException", undefined, ArithmeticException, class_type("System.Exception"));
+}
+export function ArithmeticException_$ctor_Z721C83C5(message) {
+    return new ArithmeticException(message);
+}
+export function ArithmeticException_$ctor() {
+    return ArithmeticException_$ctor_Z721C83C5(SR_Arg_ArithmeticException);
+}
+export class DivideByZeroException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function DivideByZeroException_$reflection() {
+    return class_type("System.DivideByZeroException", undefined, DivideByZeroException, class_type("System.Exception"));
+}
+export function DivideByZeroException_$ctor_Z721C83C5(message) {
+    return new DivideByZeroException(message);
+}
+export function DivideByZeroException_$ctor() {
+    return DivideByZeroException_$ctor_Z721C83C5(SR_Arg_DivideByZero);
+}
+export class FormatException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function FormatException_$reflection() {
+    return class_type("System.FormatException", undefined, FormatException, class_type("System.Exception"));
+}
+export function FormatException_$ctor_Z721C83C5(message) {
+    return new FormatException(message);
+}
+export function FormatException_$ctor() {
+    return FormatException_$ctor_Z721C83C5(SR_Arg_FormatException);
+}
+export class IndexOutOfRangeException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function IndexOutOfRangeException_$reflection() {
+    return class_type("System.IndexOutOfRangeException", undefined, IndexOutOfRangeException, class_type("System.Exception"));
+}
+export function IndexOutOfRangeException_$ctor_Z721C83C5(message) {
+    return new IndexOutOfRangeException(message);
+}
+export function IndexOutOfRangeException_$ctor() {
+    return IndexOutOfRangeException_$ctor_Z721C83C5(SR_Arg_IndexOutOfRangeException);
+}
+export class InvalidOperationException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function InvalidOperationException_$reflection() {
+    return class_type("System.InvalidOperationException", undefined, InvalidOperationException, class_type("System.Exception"));
+}
+export function InvalidOperationException_$ctor_Z721C83C5(message) {
+    return new InvalidOperationException(message);
+}
+export function InvalidOperationException_$ctor() {
+    return InvalidOperationException_$ctor_Z721C83C5(SR_Arg_InvalidOperationException);
+}
+export class NotFiniteNumberException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotFiniteNumberException_$reflection() {
+    return class_type("System.NotFiniteNumberException", undefined, NotFiniteNumberException, class_type("System.Exception"));
+}
+export function NotFiniteNumberException_$ctor_Z721C83C5(message) {
+    return new NotFiniteNumberException(message);
+}
+export function NotFiniteNumberException_$ctor() {
+    return NotFiniteNumberException_$ctor_Z721C83C5(SR_Arg_NotFiniteNumberException);
+}
+export class NotImplementedException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotImplementedException_$reflection() {
+    return class_type("System.NotImplementedException", undefined, NotImplementedException, class_type("System.Exception"));
+}
+export function NotImplementedException_$ctor_Z721C83C5(message) {
+    return new NotImplementedException(message);
+}
+export function NotImplementedException_$ctor() {
+    return NotImplementedException_$ctor_Z721C83C5(SR_Arg_NotImplementedException);
+}
+export class NotSupportedException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotSupportedException_$reflection() {
+    return class_type("System.NotSupportedException", undefined, NotSupportedException, class_type("System.Exception"));
+}
+export function NotSupportedException_$ctor_Z721C83C5(message) {
+    return new NotSupportedException(message);
+}
+export function NotSupportedException_$ctor() {
+    return NotSupportedException_$ctor_Z721C83C5(SR_Arg_NotSupportedException);
+}
+export class NullReferenceException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NullReferenceException_$reflection() {
+    return class_type("System.NullReferenceException", undefined, NullReferenceException, class_type("System.Exception"));
+}
+export function NullReferenceException_$ctor_Z721C83C5(message) {
+    return new NullReferenceException(message);
+}
+export function NullReferenceException_$ctor() {
+    return NullReferenceException_$ctor_Z721C83C5(SR_Arg_NullReferenceException);
+}
+export class OutOfMemoryException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function OutOfMemoryException_$reflection() {
+    return class_type("System.OutOfMemoryException", undefined, OutOfMemoryException, class_type("System.Exception"));
+}
+export function OutOfMemoryException_$ctor_Z721C83C5(message) {
+    return new OutOfMemoryException(message);
+}
+export function OutOfMemoryException_$ctor() {
+    return OutOfMemoryException_$ctor_Z721C83C5(SR_Arg_OutOfMemoryException);
+}
+export class OverflowException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function OverflowException_$reflection() {
+    return class_type("System.OverflowException", undefined, OverflowException, class_type("System.Exception"));
+}
+export function OverflowException_$ctor_Z721C83C5(message) {
+    return new OverflowException(message);
+}
+export function OverflowException_$ctor() {
+    return OverflowException_$ctor_Z721C83C5(SR_Arg_OverflowException);
+}
+export class RankException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function RankException_$reflection() {
+    return class_type("System.RankException", undefined, RankException, class_type("System.Exception"));
+}
+export function RankException_$ctor_Z721C83C5(message) {
+    return new RankException(message);
+}
+export function RankException_$ctor() {
+    return RankException_$ctor_Z721C83C5(SR_Arg_RankException);
+}
+export class StackOverflowException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function StackOverflowException_$reflection() {
+    return class_type("System.StackOverflowException", undefined, StackOverflowException, class_type("System.Exception"));
+}
+export function StackOverflowException_$ctor_Z721C83C5(message) {
+    return new StackOverflowException(message);
+}
+export function StackOverflowException_$ctor() {
+    return StackOverflowException_$ctor_Z721C83C5(SR_Arg_StackOverflowException);
+}
+export class TimeoutException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function TimeoutException_$reflection() {
+    return class_type("System.TimeoutException", undefined, TimeoutException, class_type("System.Exception"));
+}
+export function TimeoutException_$ctor_Z721C83C5(message) {
+    return new TimeoutException(message);
+}
+export function TimeoutException_$ctor() {
+    return TimeoutException_$ctor_Z721C83C5(SR_Arg_TimeoutException);
+}
+export class ArgumentException extends Exception {
+    constructor(message, paramName) {
+        super(isNullOrEmpty(paramName) ? message : (((message + SR_Arg_ParamName_Name) + paramName) + "\')"));
+        this.paramName = paramName;
+    }
+}
+export function ArgumentException_$reflection() {
+    return class_type("System.ArgumentException", undefined, ArgumentException, class_type("System.Exception"));
+}
+export function ArgumentException_$ctor_Z384F8060(message, paramName) {
+    return new ArgumentException(message, paramName);
+}
+export function ArgumentException_$ctor() {
+    return ArgumentException_$ctor_Z384F8060(SR_Arg_ArgumentException, "");
+}
+export function ArgumentException_$ctor_Z721C83C5(message) {
+    return ArgumentException_$ctor_Z384F8060(message, "");
+}
+export function ArgumentException__get_ParamName(_) {
+    return _.paramName;
+}
+export class ArgumentNullException extends ArgumentException {
+    constructor(paramName, message) {
+        super(message, paramName);
+    }
+}
+export function ArgumentNullException_$reflection() {
+    return class_type("System.ArgumentNullException", undefined, ArgumentNullException, ArgumentException_$reflection());
+}
+export function ArgumentNullException_$ctor_Z384F8060(paramName, message) {
+    return new ArgumentNullException(paramName, message);
+}
+export function ArgumentNullException_$ctor_Z721C83C5(paramName) {
+    return ArgumentNullException_$ctor_Z384F8060(paramName, SR_ArgumentNull_Generic);
+}
+export function ArgumentNullException_$ctor() {
+    return ArgumentNullException_$ctor_Z721C83C5("");
+}
+export class ArgumentOutOfRangeException extends ArgumentException {
+    constructor(paramName, message) {
+        super(message, paramName);
+    }
+}
+export function ArgumentOutOfRangeException_$reflection() {
+    return class_type("System.ArgumentOutOfRangeException", undefined, ArgumentOutOfRangeException, ArgumentException_$reflection());
+}
+export function ArgumentOutOfRangeException_$ctor_Z384F8060(paramName, message) {
+    return new ArgumentOutOfRangeException(paramName, message);
+}
+export function ArgumentOutOfRangeException_$ctor_Z721C83C5(paramName) {
+    return ArgumentOutOfRangeException_$ctor_Z384F8060(paramName, SR_Arg_ArgumentOutOfRangeException);
+}
+export function ArgumentOutOfRangeException_$ctor() {
+    return ArgumentOutOfRangeException_$ctor_Z721C83C5("");
+}

package/TimeOnly.js

@@ -1,9 +1,9 @@
 import { hours, minutes, seconds, milliseconds } from "./TimeSpan.js";
-import { padWithZeros } from "./Util.js";
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
 const millisecondsPerDay = 86400000;
 export function create(h = 0, m = 0, s = 0, ms = 0) {
     if (h < 0 || m < 0 || s < 0 || ms < 0)
-        throw new Error("The parameters describe an unrepresentable TimeOnly.");
+        throw new Exception("The parameters describe an unrepresentable TimeOnly.");
     return h * 3600000 + m * 60000 + s * 1000 + ms;
 }
 export function fromTicks(ticks) {
@@ -11,11 +11,11 @@ export function fromTicks(ticks) {
 }
 export function fromTimeSpan(timeSpan) {
     if (timeSpan < 0 || timeSpan >= millisecondsPerDay)
-        throw new Error("The TimeSpan describes an unrepresentable TimeOnly.");
+        throw new Exception("The TimeSpan describes an unrepresentable TimeOnly.");
     return timeSpan;
 }
 export function fromDateTime(d) {
-    return d.kind === 1 /* DateKind.UTC */
+    return d.kind === DateTimeKind.Utc
         ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())
         : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
 }
@@ -55,7 +55,7 @@ export function isBetween(t, start, end) {
 }
 export function toString(t, format = "t", _provider) {
     if (["r", "R", "o", "O", "t", "T"].indexOf(format) === -1) {
-        throw new Error("Custom formats are not supported");
+        throw new Exception("Custom formats are not supported");
     }
     const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;
     if (format === "t")
@@ -106,7 +106,7 @@ export function parse(str) {
         }
         return create(h, m, s, Math.trunc(ms));
     }
-    throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);
+    throw new Exception(`String '${str}' was not recognized as a valid TimeOnly.`);
 }
 export function tryParse(v, defValue) {
     try {

package/TimeSpan.js

@@ -1,4 +1,4 @@
-import { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
+import { Exception, comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
 import { toInt64, fromFloat64 } from "./BigInt.js";
 /**
  * Calls:
@@ -98,7 +98,7 @@ export function duration(x) {
 }
 export function toString(ts, format = "c", _provider) {
     if (["c", "g", "G"].indexOf(format) === -1) {
-        throw new Error("Custom formats are not supported");
+        throw new Exception("Custom formats are not supported");
     }
     const d = Math.abs(days(ts));
     const h = Math.abs(hours(ts));
@@ -114,7 +114,7 @@ export function parse(str) {
     if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4
         const d = parseInt(str, 0);
         if (isNaN(d)) {
-            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+            throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
         }
         else {
             return create(d, 0, 0, 0, 0);
@@ -161,13 +161,13 @@ export function parse(str) {
                         ms = +r[8] / 10000;
                         break;
                     default:
-                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+                        throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
                 }
             }
             return sign * create(d, h, m, s, ms);
         }
     }
-    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+    throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
 }
 export function tryParse(v, defValue) {
     try {

package/Types.js

@@ -1,4 +1,4 @@
-import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.js";
+import { Exception, combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.js";
 export function seqToString(self) {
     let count = 0;
     let str = "[";
@@ -172,22 +172,6 @@ export class FSharpRef {
     }
 }
 // EXCEPTIONS
-// Exception is intentionally not derived from Error, for performance reasons (see #2160)
-export class Exception {
-    constructor(message) {
-        this.message = message;
-    }
-}
-export function isException(x) {
-    return x instanceof Exception || x instanceof Error;
-}
-export function isPromise(x) {
-    return x instanceof Promise;
-}
-export function ensureErrorOrException(e) {
-    // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
-    return (isException(e) || isPromise(e)) ? e : new Error(String(e));
-}
 export class FSharpException extends Exception {
     toJSON() { return recordToJSON(this); }
     toString() { return recordToString(this); }

package/Uri.js

@@ -1,3 +1,9 @@
+import { Exception } from "./Util.js";
+export const UriKind = {
+    RelativeOrAbsolute: 0,
+    Absolute: 1,
+    Relative: 2,
+};
 const ok = (value) => ({
     tag: "ok",
     value,
@@ -18,41 +24,41 @@ export class Uri {
     }
     static tryCreateWithKind(uri, kind) {
         switch (kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return Uri.isAbsoluteUri(uri)
                     ? ok(new Uri({ original: uri, value: new URL(uri), kind }))
                     : error("Invalid URI: The format of the URI could not be determined.");
-            case 2 /* UriKind.Relative */:
+            case UriKind.Relative:
                 return Uri.isAbsoluteUri(uri)
                     ? error("URI is not a relative path.")
                     : ok(new Uri({ original: uri, value: uri, kind }));
-            case 0 /* UriKind.RelativeOrAbsolute */:
+            case UriKind.RelativeOrAbsolute:
                 return Uri.isAbsoluteUri(uri)
-                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* UriKind.Absolute */ }))
-                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* UriKind.Relative */ }));
+                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: UriKind.Absolute }))
+                    : ok(new Uri({ original: uri, value: uri, kind: UriKind.Relative }));
             default:
                 const never = kind;
                 return never;
         }
     }
     static tryCreateWithBase(baseUri, relativeUri) {
-        return baseUri.uri.kind !== 1 /* UriKind.Absolute */
+        return baseUri.uri.kind !== UriKind.Absolute
             ? error("Base URI should have Absolute kind")
             : typeof relativeUri === "string"
                 ? ok(new Uri({
                     original: new URL(relativeUri, baseUri.uri.value).toString(),
                     value: new URL(relativeUri, baseUri.uri.value),
-                    kind: 1 /* UriKind.Absolute */,
+                    kind: UriKind.Absolute,
                 }))
-                : relativeUri.uri.kind === 2 /* UriKind.Relative */
+                : relativeUri.uri.kind === UriKind.Relative
                     ? ok(new Uri({
                         original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),
                         value: new URL(relativeUri.uri.value, baseUri.uri.value),
-                        kind: 1 /* UriKind.Absolute */,
+                        kind: UriKind.Absolute,
                     }))
                     : ok(baseUri);
     }
-    static tryCreateImpl(value, kindOrUri = 1 /* UriKind.Absolute */) {
+    static tryCreateImpl(value, kindOrUri = UriKind.Absolute) {
         return typeof value === "string"
             ? typeof kindOrUri !== "number"
                 ? error("Kind must be specified when the baseUri is a string.")
@@ -61,19 +67,19 @@ export class Uri {
                 ? error("Kind should not be specified when the baseUri is an absolute Uri.")
                 : Uri.tryCreateWithBase(value, kindOrUri);
     }
-    static create(value, kindOrUri = 1 /* UriKind.Absolute */) {
+    static create(value, kindOrUri = UriKind.Absolute) {
         const result = Uri.tryCreateImpl(value, kindOrUri);
         switch (result.tag) {
             case "ok":
                 return result.value;
             case "error":
-                throw new Error(result.error);
+                throw new Exception(result.error);
             default:
                 const never = result;
                 return never;
         }
     }
-    static tryCreate(value, kindOrUri = 1 /* UriKind.Absolute */, out) {
+    static tryCreate(value, kindOrUri = UriKind.Absolute, out) {
         const result = Uri.tryCreateImpl(value, kindOrUri);
         switch (result.tag) {
             case "ok":
@@ -88,9 +94,9 @@ export class Uri {
     }
     toString() {
         switch (this.uri.kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return decodeURIComponent(this.asUrl().toString());
-            case 2 /* UriKind.Relative */:
+            case UriKind.Relative:
                 return this.uri.value;
             default:
                 const never = this.uri;
@@ -99,17 +105,17 @@ export class Uri {
     }
     asUrl() {
         switch (this.uri.kind) {
-            case 1 /* UriKind.Absolute */:
+            case UriKind.Absolute:
                 return this.uri.value;
-            case 2 /* UriKind.Relative */:
-                throw new Error("This operation is not supported for a relative URI.");
+            case UriKind.Relative:
+                throw new Exception("This operation is not supported for a relative URI.");
             default:
                 const never = this.uri;
                 return never;
         }
     }
     get isAbsoluteUri() {
-        return this.uri.kind === 1 /* UriKind.Absolute */;
+        return this.uri.kind === UriKind.Absolute;
     }
     get absoluteUri() {
         return this.asUrl().href;

package/Util.js

@@ -1,6 +1,31 @@
+// Don't change, this corresponds to DateTimeKind.Kind enum values in .NET
+export const DateTimeKind = {
+    Unspecified: 0,
+    Utc: 1,
+    Local: 2,
+};
+// Exception is intentionally not derived from Error, for performance reasons (see #2160)
+export class Exception {
+    constructor(msg) {
+        this.message = msg ?? "";
+    }
+}
+export function isException(x) {
+    return x instanceof Exception || x instanceof Error;
+}
+export function isPromise(x) {
+    return x instanceof Promise;
+}
+export function ensureErrorOrException(e) {
+    // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
+    return (isException(e) || isPromise(e)) ? e : new Exception(String(e));
+}
 export function isArrayLike(x) {
     return Array.isArray(x) || ArrayBuffer.isView(x);
 }
+export function isMutableArray(x) {
+    return Array.isArray(x) || ArrayBuffer.isView(x);
+}
 export function isIterable(x) {
     return x != null && typeof x === "object" && Symbol.iterator in x;
 }
@@ -34,9 +59,7 @@ export function sameConstructor(x, y) {
     return Object.getPrototypeOf(x)?.constructor === Object.getPrototypeOf(y)?.constructor;
 }
 export class Enumerable {
-    constructor(en) {
-        this.en = en;
-    }
+    constructor(en) { this.en = en; }
     GetEnumerator() { return this.en; }
     "System.Collections.IEnumerable.GetEnumerator"() { return this.en; }
     [Symbol.iterator]() {
@@ -50,8 +73,8 @@ export class Enumerable {
 }
 export class Enumerator {
     constructor(iter) {
-        this.iter = iter;
         this.current = defaultOf();
+        this.iter = iter;
     }
     ["System.Collections.Generic.IEnumerator`1.get_Current"]() {
         return this.current;
@@ -65,7 +88,7 @@ export class Enumerator {
         return !cur.done;
     }
     ["System.Collections.IEnumerator.Reset"]() {
-        throw new Error("JS iterators cannot be reset");
+        throw new Exception("JS iterators cannot be reset");
     }
     Dispose() {
         return;
@@ -124,7 +147,7 @@ export function comparerFromEqualityComparer(comparer) {
 }
 export function assertEqual(actual, expected, msg) {
     if (!equals(actual, expected)) {
-        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+        throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
             actual,
             expected,
         });
@@ -132,7 +155,7 @@ export function assertEqual(actual, expected, msg) {
 }
 export function assertNotEqual(actual, expected, msg) {
     if (equals(actual, expected)) {
-        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
+        throw Object.assign(new Exception(msg || `Expected: ${expected} - Actual: ${actual}`), {
             actual,
             expected,
         });
@@ -167,7 +190,7 @@ export function dateOffset(date) {
     const date1 = date;
     return typeof date1.offset === "number"
         ? date1.offset
-        : (date.kind === 1 /* DateKind.UTC */
+        : (date.kind === DateTimeKind.Utc
             ? 0 : date.getTimezoneOffset() * -60000);
 }
 export function int16ToString(i, radix) {
@@ -333,7 +356,7 @@ function equalObjects(x, y) {
     }
     return true;
 }
-export function physicalEquality(x, y) {
+export function physicalEquals(x, y) {
     return x === y;
 }
 export function equals(x, y) {

package/package.json

@@ -1,24 +1,24 @@
 {
-  "sideEffects": false,
-  "private": false,
-  "type": "module",
-  "name": "@fable-org/fable-library-js",
-  "version": "2.0.0-beta.3",
-  "description": "Core library used by F# projects compiled with fable.io",
-  "author": "Fable Contributors",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/fable-compiler/Fable.git"
-  },
-  "bugs": {
-    "url": "https://github.com/fable-compiler/Fable/issues"
-  },
-  "homepage": "https://fable.io",
-  "keywords": [
-    "fable",
-    "fable-compiler",
-    "fsharp",
-    "F#"
-  ]
-}
+    "sideEffects": false,
+    "private": false,
+    "type": "module",
+    "name": "@fable-org/fable-library-js",
+    "version": "2.0.0-beta.5",
+    "description": "Core library used by F# projects compiled with fable.io",
+    "author": "Fable Contributors",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fable-compiler/Fable.git"
+    },
+    "bugs": {
+        "url": "https://github.com/fable-compiler/Fable/issues"
+    },
+    "homepage": "https://fable.io",
+    "keywords": [
+        "fable",
+        "fable-compiler",
+        "fsharp",
+        "F#"
+    ]
+}