@fable-org/fable-library-js 2.10.0 → 2.12.0

package/MutableSet.js

@@ -4,13 +4,14 @@ import { item as item_1, setItem } from "./Array.js";
 import { some } from "./Option.js";
 import { FSharpRef } from "./Types.js";
 import { class_type } from "./Reflection.js";
-import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+import { getItemFromDict } from "./MapUtil.js";
 export class HashSet {
     constructor(items, comparer) {
         const this$ = new FSharpRef(defaultOf());
         this.comparer = comparer;
         this$.contents = this;
         this.hashMap = (new Map([]));
+        this.count = 0;
         this["init@9"] = 1;
         const enumerator = getEnumerator(items);
         try {
@@ -116,39 +117,39 @@ export function HashSet_$reflection(gen0) {
 export function HashSet_$ctor_Z6150332D(items, comparer) {
     return new HashSet(items, comparer);
 }
-function HashSet__TryFindIndex_2B595(this$, k) {
-    const h = this$.comparer.GetHashCode(k) | 0;
-    let matchValue;
-    let outArg = defaultOf();
-    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {
-            outArg = v;
-        })), outArg];
-    if (matchValue[0]) {
-        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];
+function HashSet__TryFindBucket_Z524259A4(this$, h) {
+    if (this$.hashMap.has(h)) {
+        return getItemFromDict(this$.hashMap, h);
     }
     else {
-        return [false, h, -1];
+        return undefined;
     }
 }
-function HashSet__TryFind_2B595(this$, k) {
-    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
-    let matchResult = undefined;
-    if (matchValue[0]) {
-        if (matchValue[2] > -1) {
-            matchResult = 0;
-        }
-        else {
-            matchResult = 1;
+function HashSet__FindIndex_Z142BBCA7(this$, k, bucket) {
+    let i = 0;
+    let found = -1;
+    while ((found < 0) && (i < bucket.length)) {
+        if (this$.comparer.Equals(k, item_1(i, bucket))) {
+            found = (i | 0);
         }
+        i = ((i + 1) | 0);
     }
-    else {
-        matchResult = 1;
+    return found | 0;
+}
+function HashSet__TryFind_2B595(this$, k) {
+    const matchValue = HashSet__TryFindBucket_Z524259A4(this$, this$.comparer.GetHashCode(k));
+    if (matchValue == null) {
+        return undefined;
     }
-    switch (matchResult) {
-        case 0:
-            return some(item_1(matchValue[2], getItemFromDict(this$.hashMap, matchValue[1])));
-        default:
+    else {
+        const bucket = matchValue;
+        const i = HashSet__FindIndex_Z142BBCA7(this$, k, bucket) | 0;
+        if (i > -1) {
+            return some(item_1(i, bucket));
+        }
+        else {
             return undefined;
+        }
     }
 }
 export function HashSet__get_Comparer(this$) {
@@ -156,82 +157,59 @@ export function HashSet__get_Comparer(this$) {
 }
 export function HashSet__Clear(this$) {
     this$.hashMap.clear();
+    this$.count = 0;
 }
 export function HashSet__get_Count(this$) {
-    let count = 0;
-    let enumerator = getEnumerator(this$.hashMap.values());
-    try {
-        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
-            const items = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
-            count = ((count + items.length) | 0);
-        }
-    }
-    finally {
-        disposeSafe(enumerator);
-    }
-    return count | 0;
+    return this$.count | 0;
 }
 export function HashSet__Add_2B595(this$, k) {
-    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
-    if (matchValue[0]) {
-        if (matchValue[2] > -1) {
+    const h = this$.comparer.GetHashCode(k) | 0;
+    const matchValue = HashSet__TryFindBucket_Z524259A4(this$, h);
+    if (matchValue == null) {
+        this$.hashMap.set(h, [k]);
+        this$.count = ((this$.count + 1) | 0);
+        return true;
+    }
+    else {
+        const bucket = matchValue;
+        if (HashSet__FindIndex_Z142BBCA7(this$, k, bucket) > -1) {
             return false;
         }
         else {
-            void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            void (bucket.push(k));
+            this$.count = ((this$.count + 1) | 0);
             return true;
         }
     }
-    else {
-        this$.hashMap.set(matchValue[1], [k]);
-        return true;
-    }
 }
 export function HashSet__Contains_2B595(this$, k) {
-    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
-    let matchResult = undefined;
-    if (matchValue[0]) {
-        if (matchValue[2] > -1) {
-            matchResult = 0;
-        }
-        else {
-            matchResult = 1;
-        }
+    const matchValue = HashSet__TryFindBucket_Z524259A4(this$, this$.comparer.GetHashCode(k));
+    if (matchValue == null) {
+        return false;
     }
     else {
-        matchResult = 1;
-    }
-    switch (matchResult) {
-        case 0:
-            return true;
-        default:
-            return false;
+        return HashSet__FindIndex_Z142BBCA7(this$, k, matchValue) > -1;
     }
 }
 export function HashSet__Remove_2B595(this$, k) {
-    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
-    let matchResult = undefined;
-    if (matchValue[0]) {
-        if (matchValue[2] > -1) {
-            matchResult = 0;
-        }
-        else {
-            matchResult = 1;
-        }
+    const h = this$.comparer.GetHashCode(k) | 0;
+    const matchValue = HashSet__TryFindBucket_Z524259A4(this$, h);
+    if (matchValue == null) {
+        return false;
     }
     else {
-        matchResult = 1;
-    }
-    switch (matchResult) {
-        case 0: {
-            const h_1 = matchValue[1] | 0;
-            getItemFromDict(this$.hashMap, h_1).splice(matchValue[2], 1);
-            if (getItemFromDict(this$.hashMap, h_1).length === 0) {
-                this$.hashMap.delete(h_1);
+        const bucket = matchValue;
+        const i = HashSet__FindIndex_Z142BBCA7(this$, k, bucket) | 0;
+        if (i > -1) {
+            bucket.splice(i, 1);
+            this$.count = ((this$.count - 1) | 0);
+            if (bucket.length === 0) {
+                this$.hashMap.delete(h);
             }
             return true;
         }
-        default:
+        else {
             return false;
+        }
     }
 }

package/NumberStyles.js

@@ -0,0 +1,56 @@
+import { Exception } from "./Util.js";
+export const NumberStyles = {
+    None: 0,
+    AllowLeadingWhite: 1,
+    AllowTrailingWhite: 2,
+    AllowLeadingSign: 4,
+    AllowTrailingSign: 8,
+    AllowParentheses: 16,
+    AllowDecimalPoint: 32,
+    AllowThousands: 64,
+    AllowExponent: 128,
+    AllowHexSpecifier: 512,
+    Integer: 7,
+    Number: 111,
+    Float: 167,
+};
+// The digits of a number string once white space, sign and parentheses are stripped.
+// .NET allows group separators anywhere after the first digit of the integral part, even repeated.
+function digitsPattern(style) {
+    const integral = style & NumberStyles.AllowThousands ? "\\d+(?:,\\d*)*" : "\\d+";
+    const point = style & NumberStyles.AllowDecimalPoint ? "(?:\\.\\d*)?" : "";
+    const leadingPoint = style & NumberStyles.AllowDecimalPoint ? "|\\.\\d+" : "";
+    const exponent = style & NumberStyles.AllowExponent ? "(?:[eE][+-]?\\d+)?" : "";
+    return new RegExp(`^(?:${integral}${point}${leadingPoint})${exponent}$`);
+}
+// Returns undefined when the string does not have the format allowed by the style
+export function splitNumber(str, style) {
+    if (style & NumberStyles.AllowHexSpecifier) {
+        throw new Exception("The number style AllowHexSpecifier is not supported on floating point data types.");
+    }
+    // .NET ignores trailing NULs and its white space is only [\t\n\v\f\r ]
+    let s = str.replace(/\0+$/, "");
+    if (style & NumberStyles.AllowLeadingWhite) {
+        s = s.replace(/^[\t-\r ]+/, "");
+    }
+    if (style & NumberStyles.AllowTrailingWhite) {
+        s = s.replace(/[\t-\r ]+$/, "");
+    }
+    let negative = false;
+    if (style & NumberStyles.AllowParentheses && s.startsWith("(") && s.endsWith(")")) {
+        s = s.slice(1, -1);
+        negative = true;
+    }
+    if (style & NumberStyles.AllowLeadingSign && /^[+-]/.test(s)) {
+        negative = s[0] === "-" ? !negative : negative;
+        s = s.slice(1);
+    }
+    else if (style & NumberStyles.AllowTrailingSign && /[+-]$/.test(s)) {
+        negative = s[s.length - 1] === "-" ? !negative : negative;
+        s = s.slice(0, -1);
+    }
+    if (!digitsPattern(style).test(s)) {
+        return undefined;
+    }
+    return { digits: s.replace(/,/g, ""), negative };
+}

package/Numeric.js

@@ -98,15 +98,21 @@ export function toExponential(x, dp) {
         return x[symbol]().toExponential(dp);
     }
 }
-export function toHex(x) {
+export function toRadix(x, radix) {
     if (typeof x === "number") {
-        return (Number(x) >>> 0).toString(16);
+        return (Number(x) >>> 0).toString(radix);
     }
     else if (typeof x === "bigint") {
         // TODO: properly handle other bit sizes
-        return BigInt.asUintN(64, x).toString(16);
+        return BigInt.asUintN(64, x).toString(radix);
     }
-    else {
+    else if (radix === 16) {
         return x[symbol]().toHex();
     }
+    else {
+        return String(x);
+    }
+}
+export function toHex(x) {
+    return toRadix(x, 16);
 }

package/Random.js

@@ -1,5 +1,4 @@
 import { ArgumentNullException_$ctor_Z721C83C5, ArgumentOutOfRangeException_$ctor_Z721C83C5 } from "./System.js";
-import { Operators_IsNull } from "./FSharp.Core.js";
 import { class_type } from "./Reflection.js";
 import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, fromInt32, toInt64_unchecked } from "./BigInt.js";
 import { item, setItem } from "./Array.js";
@@ -13,7 +12,7 @@ function Native_randomNext(minValue, maxValue) {
     return Math.floor(Math.random() * (maxValue - minValue)) + minValue;
 }
 function Native_randomBytes(buffer) {
-    if (Operators_IsNull(buffer)) {
+    if (buffer == null) {
         throw ArgumentNullException_$ctor_Z721C83C5("buffer");
     }
     for (let i = 0; i < buffer.length; i += 6) {
@@ -113,11 +112,11 @@ export class Seeded {
     }
     NextBytes(buffer) {
         const this$ = this;
-        if (Operators_IsNull(buffer)) {
+        if (buffer == null) {
             throw ArgumentNullException_$ctor_Z721C83C5("buffer");
         }
         for (let i = 0; i <= (buffer.length - 1); i++) {
-            setItem(buffer, i, (Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
+            setItem(buffer, i, ~~(Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
         }
     }
 }

package/Range.js

@@ -1,11 +1,12 @@
-import { Exception, compare } from "./Util.js";
+import { compare } from "./Util.js";
+import { Operators_InvalidArg } from "./FSharp.Core.js";
 import { unfold, delay } from "./Seq.js";
 import { toUInt64_unchecked, toInt64_unchecked, op_Addition, fromZero } from "./BigInt.js";
 import { op_Addition as op_Addition_1, fromParts } from "./Decimal.js";
 export function makeRangeStepFunction(step, stop, zero, add) {
     const stepComparedWithZero = compare(step, zero) | 0;
     if (stepComparedWithZero === 0) {
-        throw new Exception("The step of a range cannot be zero");
+        throw Operators_InvalidArg("step", "The step of a range cannot be zero.");
     }
     const stepGreaterThanZero = stepComparedWithZero > 0;
     return (x) => {
@@ -36,7 +37,7 @@ export function rangeChar(start, stop) {
     const intStop = ~~stop.charCodeAt(0) | 0;
     return delay(() => unfold((i) => {
         if (i <= intStop) {
-            return [String.fromCharCode(i & 0xFFFF), i + 1];
+            return [String.fromCharCode(~~i & 0xFFFF), i + 1];
         }
         else {
             return undefined;

package/RegExp.js

@@ -6,8 +6,9 @@ export function create(pattern, options = 0) {
     // * Compiled:    0x0008 (ignored)
     // * Singleline:  0x0010
     // * ECMAScript:  0x0100 (ignored)
-    if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
-        throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+    // * NonBacktracking: 0x0400 (ignored)
+    if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256 ^ 1024)) !== 0) {
+        throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline, ECMAScript and NonBacktracking");
     }
     // Set always global and unicode flags for compatibility with dotnet, see #2925
     let flags = "gu";