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

package/Random.ts

@@ -1,197 +1,199 @@
-import { uint8, int32, float64 } from "./Int32.js";
-import { class_type, TypeInfo } from "./Reflection.js";
-import { fromFloat64, op_Addition, toInt32_unchecked, toFloat64, compare, int64, fromInt32, toInt64_unchecked } from "./BigInt.js";
-import { Operators_IsNull } from "./FSharp.Core.js";
-import { item, fill, setItem } from "./Array.js";
-
-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");
+
+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(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: 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;
         }
-        return Math.floor(Math.random() * (max - min)) + min
-        ;
-}
-
-function Native_randomBytes(buffer: uint8[]): void {
-            if (buffer == null) {
-            throw new Error("Buffer cannot be null");
+    };
+}
+
+export interface IRandom {
+    Next0(): int32,
+    Next1(maxValue: int32): int32,
+    Next2(minValue: int32, maxValue: int32): int32,
+    NextBytes(buffer: MutableArray<uint8>): void,
+    NextDouble(): float64
+}
+
+export class NonSeeded implements IRandom {
+    constructor() {
+    }
+    Next0(): int32 {
+        return Native_randomNext(0, 2147483647) | 0;
+    }
+    Next1(maxValue: int32): int32 {
+        return Native_randomNext(0, maxValue) | 0;
+    }
+    Next2(minValue: int32, maxValue: int32): int32 {
+        return Native_randomNext(minValue, maxValue) | 0;
+    }
+    NextDouble(): float64 {
+        return Native_random();
+    }
+    NextBytes(buffer: MutableArray<uint8>): void {
+        Native_randomBytes(buffer);
+    }
+}
+
+export function NonSeeded_$reflection(): TypeInfo {
+    return class_type("Random.NonSeeded", undefined, NonSeeded);
+}
+
+export function NonSeeded_$ctor(): NonSeeded {
+    return new NonSeeded();
+}
+
+export class Seeded implements IRandom {
+    readonly MBIG: int32;
+    inext: int32;
+    inextp: int32;
+    seedArray: MutableArray<int32>;
+    constructor(seed: int32) {
+        this.MBIG = 2147483647;
+        this.inext = 0;
+        this.inextp = 0;
+        this.seedArray = (new Int32Array(56));
+        let ii = 0;
+        let mj = 0;
+        let mk = 0;
+        const subtraction: int32 = ((seed === -2147483648) ? 2147483647 : Math.abs(seed)) | 0;
+        mj = ((161803398 - subtraction) | 0);
+        this.seedArray[55] = (mj | 0);
+        mk = 1;
+        for (let i = 1; i <= 54; i++) {
+            ii = (((21 * i) % 55) | 0);
+            this.seedArray[ii] = (mk | 0);
+            mk = ((mj - mk) | 0);
+            if (mk < 0) {
+                mk = ((mk + this.MBIG) | 0);
+            }
+            mj = (item(ii, this.seedArray) | 0);
         }
-        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 k = 1; k <= 4; k++) {
+            for (let i_1 = 1; i_1 <= 55; i_1++) {
+                this.seedArray[i_1] = ((item(i_1, this.seedArray) - item(1 + ((i_1 + 30) % 55), this.seedArray)) | 0);
+                if (item(i_1, this.seedArray) < 0) {
+                    this.seedArray[i_1] = ((item(i_1, this.seedArray) + this.MBIG) | 0);
+                }
             }
-        };
-}
-
-export interface IRandom {
-    Next0(): int32,
-    Next1(maxValue: int32): int32,
-    Next2(minValue: int32, maxValue: int32): int32,
-    NextBytes(buffer: uint8[]): void,
-    NextDouble(): float64
-}
-
-export class NonSeeded implements IRandom {
-    constructor() {
-    }
-    Next0(): int32 {
-        return Native_randomNext(0, 2147483647) | 0;
-    }
-    Next1(maxValue: int32): int32 {
-        return Native_randomNext(0, maxValue) | 0;
-    }
-    Next2(minValue: int32, maxValue: int32): int32 {
-        return Native_randomNext(minValue, maxValue) | 0;
-    }
-    NextDouble(): float64 {
-        return Native_random();
-    }
-    NextBytes(buffer: uint8[]): void {
-        Native_randomBytes(buffer);
-    }
-}
-
-export function NonSeeded_$reflection(): TypeInfo {
-    return class_type("Random.NonSeeded", undefined, NonSeeded);
-}
-
-export function NonSeeded_$ctor(): NonSeeded {
-    return new NonSeeded();
-}
-
-export class Seeded implements IRandom {
-    readonly MBIG: int32;
-    inext: int32;
-    inextp: int32;
-    seedArray: int32[];
-    constructor(seed: int32) {
-        this.MBIG = 2147483647;
-        this.inext = 0;
-        this.inextp = 0;
-        this.seedArray = fill(new Array(56), 0, 56, 0);
-        let ii = 0;
-        let mj = 0;
-        let mk = 0;
-        const subtraction: int32 = ((seed === -2147483648) ? 2147483647 : Math.abs(seed)) | 0;
-        mj = ((161803398 - subtraction) | 0);
-        this.seedArray[55] = (mj | 0);
-        mk = 1;
-        for (let i = 1; i <= 54; i++) {
-            ii = (((21 * i) % 55) | 0);
-            this.seedArray[ii] = (mk | 0);
-            mk = ((mj - mk) | 0);
-            if (mk < 0) {
-                mk = ((mk + this.MBIG) | 0);
-            }
-            mj = (item(ii, this.seedArray) | 0);
-        }
-        for (let k = 1; k <= 4; k++) {
-            for (let i_1 = 1; i_1 <= 55; i_1++) {
-                this.seedArray[i_1] = ((item(i_1, this.seedArray) - item(1 + ((i_1 + 30) % 55), this.seedArray)) | 0);
-                if (item(i_1, this.seedArray) < 0) {
-                    this.seedArray[i_1] = ((item(i_1, this.seedArray) + this.MBIG) | 0);
-                }
-            }
-        }
-        this.inext = 0;
-        this.inextp = 21;
-    }
-    Next0(): int32 {
-        const this$: Seeded = this;
-        return Seeded__InternalSample(this$) | 0;
-    }
-    Next1(maxValue: int32): int32 {
-        const this$: Seeded = this;
-        if (maxValue < 0) {
-            throw new Error("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");
-        }
-        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;
-    }
-    NextDouble(): float64 {
-        const this$: Seeded = this;
-        return Seeded__Sample(this$);
-    }
-    NextBytes(buffer: uint8[]): void {
-        const this$: Seeded = this;
-        if (Operators_IsNull<uint8[]>(buffer)) {
-            throw new Error("buffer");
-        }
-        for (let i = 0; i <= (buffer.length - 1); i++) {
-            setItem(buffer, i, (Seeded__InternalSample(this$) % (~~255 + 1)) & 0xFF);
-        }
-    }
-}
-
-export function Seeded_$reflection(): TypeInfo {
-    return class_type("Random.Seeded", undefined, Seeded);
-}
-
-export function Seeded_$ctor_Z524259A4(seed: int32): Seeded {
-    return new Seeded(seed);
-}
-
-function Seeded__InternalSample(_: Seeded): int32 {
-    let retVal = 0;
-    let locINext: int32 = _.inext;
-    let locINextp: int32 = _.inextp;
-    locINext = ((locINext + 1) | 0);
-    if (locINext >= 56) {
-        locINext = 1;
-    }
-    locINextp = ((locINextp + 1) | 0);
-    if (locINextp >= 56) {
-        locINextp = 1;
-    }
-    retVal = ((item(locINext, _.seedArray) - item(locINextp, _.seedArray)) | 0);
-    if (retVal === _.MBIG) {
-        retVal = ((retVal - 1) | 0);
-    }
-    if (retVal < 0) {
-        retVal = ((retVal + _.MBIG) | 0);
-    }
-    _.seedArray[locINext] = (retVal | 0);
-    _.inext = (locINext | 0);
-    _.inextp = (locINextp | 0);
-    return retVal | 0;
-}
-
-export function Seeded__Sample(this$: Seeded): float64 {
-    return Seeded__InternalSample(this$) * (1 / this$.MBIG);
-}
-
-export function Seeded__GetSampleForLargeRange(this$: Seeded): float64 {
-    let result: float64 = Seeded__InternalSample(this$);
-    if ((Seeded__InternalSample(this$) % 2) === 0) {
-        result = -result;
-    }
-    let d: float64 = result;
-    d = (d + (2147483647 - 1));
-    d = (d / (2 * ((2147483647 - 1) >>> 0)));
-    return d;
-}
-
-export function nonSeeded(): NonSeeded {
-    return NonSeeded_$ctor();
-}
-
-export function seeded(seed: int32): Seeded {
-    return Seeded_$ctor_Z524259A4(seed);
-}
-
+        }
+        this.inext = 0;
+        this.inextp = 21;
+    }
+    Next0(): int32 {
+        const this$: Seeded = this;
+        return Seeded__InternalSample(this$) | 0;
+    }
+    Next1(maxValue: int32): int32 {
+        const this$: Seeded = this;
+        if (maxValue < 0) {
+            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 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;
+    }
+    NextDouble(): float64 {
+        const this$: Seeded = this;
+        return Seeded__Sample(this$);
+    }
+    NextBytes(buffer: MutableArray<uint8>): void {
+        const this$: Seeded = this;
+        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);
+        }
+    }
+}
+
+export function Seeded_$reflection(): TypeInfo {
+    return class_type("Random.Seeded", undefined, Seeded);
+}
+
+export function Seeded_$ctor_Z524259A4(seed: int32): Seeded {
+    return new Seeded(seed);
+}
+
+function Seeded__InternalSample(_: Seeded): int32 {
+    let retVal = 0;
+    let locINext: int32 = _.inext;
+    let locINextp: int32 = _.inextp;
+    locINext = ((locINext + 1) | 0);
+    if (locINext >= 56) {
+        locINext = 1;
+    }
+    locINextp = ((locINextp + 1) | 0);
+    if (locINextp >= 56) {
+        locINextp = 1;
+    }
+    retVal = ((item(locINext, _.seedArray) - item(locINextp, _.seedArray)) | 0);
+    if (retVal === _.MBIG) {
+        retVal = ((retVal - 1) | 0);
+    }
+    if (retVal < 0) {
+        retVal = ((retVal + _.MBIG) | 0);
+    }
+    _.seedArray[locINext] = (retVal | 0);
+    _.inext = (locINext | 0);
+    _.inextp = (locINextp | 0);
+    return retVal | 0;
+}
+
+export function Seeded__Sample(this$: Seeded): float64 {
+    return Seeded__InternalSample(this$) * (1 / this$.MBIG);
+}
+
+export function Seeded__GetSampleForLargeRange(this$: Seeded): float64 {
+    let result: float64 = Seeded__InternalSample(this$);
+    if ((Seeded__InternalSample(this$) % 2) === 0) {
+        result = -result;
+    }
+    let d: float64 = result;
+    d = (d + (2147483647 - 1));
+    d = (d / (2 * ((2147483647 - 1) >>> 0)));
+    return d;
+}
+
+export function nonSeeded(): NonSeeded {
+    return NonSeeded_$ctor();
+}
+
+export function seeded(seed: int32): Seeded {
+    return Seeded_$ctor_Z524259A4(seed);
+}
+

package/Range.ts

@@ -1,56 +1,57 @@
-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";
-
-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");
-    }
-    const stepGreaterThanZero: boolean = stepComparedWithZero > 0;
-    return (x: T): Option<[T, T]> => {
-        const comparedWithLast: int32 = compare(x, stop) | 0;
-        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? ([x, add(x, step)] as [T, T]) : undefined;
-    };
-}
-
-export function integralRangeStep<T>(start: T, step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): Iterable<T> {
-    const stepFn: ((arg0: T) => Option<[T, T]>) = makeRangeStepFunction<T>(step, stop, zero, add);
-    return delay<T>((): Iterable<T> => unfold<T, T>(stepFn, start));
-}
-
-export function rangeBigInt(start: bigint, step: bigint, stop: bigint): Iterable<bigint> {
-    return integralRangeStep<bigint>(start, step, stop, fromZero(), op_Addition);
-}
-
-export function rangeDecimal(start: decimal, step: decimal, stop: decimal): Iterable<decimal> {
-    return integralRangeStep<decimal>(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);
-}
-
-export function rangeDouble(start: float64, step: float64, stop: float64): Iterable<float64> {
-    return integralRangeStep<float64>(start, step, stop, 0, (x: float64, y: float64): float64 => (x + y));
-}
-
-export function rangeInt64(start: int64, step: int64, stop: int64): Iterable<int64> {
-    return integralRangeStep<int64>(start, step, stop, 0n, (x: int64, y: int64): int64 => toInt64_unchecked(op_Addition(x, y)));
-}
-
-export function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable<uint64> {
-    return integralRangeStep<uint64>(start, step, stop, 0n, (x: uint64, y: uint64): uint64 => toUInt64_unchecked(op_Addition(x, y)));
-}
-
-export function rangeChar(start: string, stop: string): Iterable<string> {
-    const intStop: int32 = ~~stop.charCodeAt(0) | 0;
-    return delay<string>((): Iterable<string> => unfold<int32, string>((i: int32): Option<[string, int32]> => {
-        if (i <= intStop) {
-            return [String.fromCharCode(i & 0xFFFF), i + 1] as [string, int32];
-        }
-        else {
-            return undefined;
-        }
-    }, ~~start.charCodeAt(0)));
-}
-
+
+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 Exception("The step of a range cannot be zero");
+    }
+    const stepGreaterThanZero: boolean = stepComparedWithZero > 0;
+    return (x: T): Option<[T, T]> => {
+        const comparedWithLast: int32 = compare(x, stop) | 0;
+        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? ([x, add(x, step)] as [T, T]) : undefined;
+    };
+}
+
+export function integralRangeStep<T>(start: T, step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): Iterable<T> {
+    const stepFn: ((arg0: T) => Option<[T, T]>) = makeRangeStepFunction<T>(step, stop, zero, add);
+    return delay<T>((): Iterable<T> => unfold<T, T>(stepFn, start));
+}
+
+export function rangeBigInt(start: bigint, step: bigint, stop: bigint): Iterable<bigint> {
+    return integralRangeStep<bigint>(start, step, stop, fromZero(), op_Addition);
+}
+
+export function rangeDecimal(start: decimal, step: decimal, stop: decimal): Iterable<decimal> {
+    return integralRangeStep<decimal>(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);
+}
+
+export function rangeDouble(start: float64, step: float64, stop: float64): Iterable<float64> {
+    return integralRangeStep<float64>(start, step, stop, 0, (x: float64, y: float64): float64 => (x + y));
+}
+
+export function rangeInt64(start: int64, step: int64, stop: int64): Iterable<int64> {
+    return integralRangeStep<int64>(start, step, stop, 0n, (x: int64, y: int64): int64 => toInt64_unchecked(op_Addition(x, y)));
+}
+
+export function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable<uint64> {
+    return integralRangeStep<uint64>(start, step, stop, 0n, (x: uint64, y: uint64): uint64 => toUInt64_unchecked(op_Addition(x, y)));
+}
+
+export function rangeChar(start: string, stop: string): Iterable<string> {
+    const intStop: int32 = ~~stop.charCodeAt(0) | 0;
+    return delay<string>((): Iterable<string> => unfold<int32, string>((i: int32): Option<[string, int32]> => {
+        if (i <= intStop) {
+            return [String.fromCharCode(i & 0xFFFF), i + 1] as [string, int32];
+        }
+        else {
+            return undefined;
+        }
+    }, ~~start.charCodeAt(0)));
+}
+