compostjs 0.0.8 → 0.0.12

package/dist/fable_modules/fable-library-js.4.28.0/Random.js

@@ -0,0 +1,170 @@
+import { class_type } from "./Reflection.js";
+import { fromFloat64, op_Addition, toInt32, toFloat64, compare, fromInt32, toInt64 } from "./BigInt.js";
+import { item, fill, setItem } from "./Array.js";
+function Native_random() {
+    return Math.random();
+}
+function Native_randomNext(min, max) {
+    if (max < min) {
+        throw new Error("minValue must be less than maxValue");
+    }
+    return Math.floor(Math.random() * (max - min)) + min;
+}
+function Native_randomBytes(buffer) {
+    if (buffer == null) {
+        throw new Error("Buffer cannot be null");
+    }
+    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;
+        }
+    }
+    ;
+}
+export class NonSeeded {
+    constructor() {
+    }
+    Next0() {
+        return Native_randomNext(0, 2147483647);
+    }
+    Next1(maxValue) {
+        return Native_randomNext(0, maxValue);
+    }
+    Next2(minValue, maxValue) {
+        return Native_randomNext(minValue, maxValue);
+    }
+    NextDouble() {
+        return Native_random();
+    }
+    NextBytes(buffer) {
+        Native_randomBytes(buffer);
+    }
+}
+export function NonSeeded_$reflection() {
+    return class_type("Random.NonSeeded", undefined, NonSeeded);
+}
+export function NonSeeded_$ctor() {
+    return new NonSeeded();
+}
+export class Seeded {
+    constructor(seed) {
+        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 = ((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() {
+        const this$ = this;
+        return Seeded__InternalSample(this$) | 0;
+    }
+    Next1(maxValue) {
+        const this$ = this;
+        if (maxValue < 0) {
+            throw new Error("maxValue must be positive");
+        }
+        return ~~(Seeded__Sample(this$) * maxValue) | 0;
+    }
+    Next2(minValue, maxValue) {
+        const this$ = this;
+        if (minValue > maxValue) {
+            throw new Error("minValue must be less than maxValue");
+        }
+        const range = toInt64(fromInt32(maxValue - minValue));
+        return ((compare(range, toInt64(fromInt32(2147483647))) <= 0) ? (~~(Seeded__Sample(this$) * toFloat64(range)) + minValue) : ~~toInt32(toInt64(op_Addition(toInt64(fromFloat64(Seeded__GetSampleForLargeRange(this$) * toFloat64(range))), toInt64(fromInt32(minValue)))))) | 0;
+    }
+    NextDouble() {
+        const this$ = this;
+        return Seeded__Sample(this$);
+    }
+    NextBytes(buffer) {
+        const this$ = this;
+        if (buffer == null) {
+            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() {
+    return class_type("Random.Seeded", undefined, Seeded);
+}
+export function Seeded_$ctor_Z524259A4(seed) {
+    return new Seeded(seed);
+}
+function Seeded__InternalSample(_) {
+    let retVal = 0;
+    let locINext = _.inext;
+    let locINextp = _.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$) {
+    return Seeded__InternalSample(this$) * (1 / this$.MBIG);
+}
+export function Seeded__GetSampleForLargeRange(this$) {
+    let result = Seeded__InternalSample(this$);
+    if ((Seeded__InternalSample(this$) % 2) === 0) {
+        result = -result;
+    }
+    let d = result;
+    d = (d + (2147483647 - 1));
+    d = (d / (2 * ((2147483647 - 1) >>> 0)));
+    return d;
+}
+export function nonSeeded() {
+    return NonSeeded_$ctor();
+}
+export function seeded(seed) {
+    return Seeded_$ctor_Z524259A4(seed);
+}

package/dist/fable_modules/fable-library-js.4.28.0/Range.d.ts

@@ -0,0 +1,12 @@
+import { float64 } from "./Int32.js";
+import { Option } from "./Option.js";
+import { uint64, int64 } from "./BigInt.js";
+import { decimal } from "./Decimal.js";
+export declare function makeRangeStepFunction<T>(step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): ((arg0: T) => Option<[T, T]>);
+export declare function integralRangeStep<T>(start: T, step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): Iterable<T>;
+export declare function rangeBigInt(start: bigint, step: bigint, stop: bigint): Iterable<bigint>;
+export declare function rangeDecimal(start: decimal, step: decimal, stop: decimal): Iterable<decimal>;
+export declare function rangeDouble(start: float64, step: float64, stop: float64): Iterable<float64>;
+export declare function rangeInt64(start: int64, step: int64, stop: int64): Iterable<int64>;
+export declare function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable<uint64>;
+export declare function rangeChar(start: string, stop: string): Iterable<string>;

package/dist/fable_modules/fable-library-js.4.28.0/Range.js

@@ -0,0 +1,45 @@
+import { compare } from "./Util.js";
+import { unfold, delay } from "./Seq.js";
+import { toUInt64, toInt64, 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 Error("The step of a range cannot be zero");
+    }
+    const stepGreaterThanZero = stepComparedWithZero > 0;
+    return (x) => {
+        const comparedWithLast = compare(x, stop) | 0;
+        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : (!stepGreaterThanZero && (comparedWithLast >= 0))) ? [x, add(x, step)] : undefined;
+    };
+}
+export function integralRangeStep(start, step, stop, zero, add) {
+    const stepFn = makeRangeStepFunction(step, stop, zero, add);
+    return delay(() => unfold(stepFn, start));
+}
+export function rangeBigInt(start, step, stop) {
+    return integralRangeStep(start, step, stop, fromZero(), op_Addition);
+}
+export function rangeDecimal(start, step, stop) {
+    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);
+}
+export function rangeDouble(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));
+}
+export function rangeInt64(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toInt64(op_Addition(x, y)));
+}
+export function rangeUInt64(start, step, stop) {
+    return integralRangeStep(start, step, stop, 0n, (x, y) => toUInt64(op_Addition(x, y)));
+}
+export function rangeChar(start, stop) {
+    const intStop = ~~stop.charCodeAt(0) | 0;
+    return delay(() => unfold((c) => {
+        if (c <= intStop) {
+            return [String.fromCharCode(c), c + 1];
+        }
+        else {
+            return undefined;
+        }
+    }, ~~start.charCodeAt(0)));
+}

package/dist/fable_modules/fable-library-js.4.28.0/Reflection.d.ts

@@ -0,0 +1,119 @@
+import { FSharpRef } from "./Types.js";
+import { IEquatable } from "./Util.js";
+export type FieldInfo = [string, TypeInfo];
+export type PropertyInfo = FieldInfo;
+export type ParameterInfo = FieldInfo;
+export type Constructor = new (...args: any[]) => any;
+export declare class CaseInfo {
+    declaringType: TypeInfo;
+    tag: number;
+    name: string;
+    fields?: FieldInfo[] | undefined;
+    constructor(declaringType: TypeInfo, tag: number, name: string, fields?: FieldInfo[] | undefined);
+}
+export type EnumCase = [string, number];
+export declare class MethodInfo {
+    name: string;
+    parameters: ParameterInfo[];
+    returnType: TypeInfo;
+    constructor(name: string, parameters: ParameterInfo[], returnType: TypeInfo);
+}
+export declare class TypeInfo implements IEquatable<TypeInfo> {
+    fullname: string;
+    generics?: TypeInfo[] | undefined;
+    construct?: Constructor | undefined;
+    parent?: TypeInfo | undefined;
+    fields?: (() => FieldInfo[]) | undefined;
+    cases?: (() => CaseInfo[]) | undefined;
+    enumCases?: EnumCase[] | undefined;
+    constructor(fullname: string, generics?: TypeInfo[] | undefined, construct?: Constructor | undefined, parent?: TypeInfo | undefined, fields?: (() => FieldInfo[]) | undefined, cases?: (() => CaseInfo[]) | undefined, enumCases?: EnumCase[] | undefined);
+    toString(): string;
+    GetHashCode(): number;
+    Equals(other: TypeInfo): boolean;
+}
+export declare class GenericParameter extends TypeInfo {
+    constructor(name: string);
+}
+export declare function getGenerics(t: TypeInfo): TypeInfo[];
+export declare function getHashCode(t: TypeInfo): number;
+export declare function equals(t1: TypeInfo, t2: TypeInfo): boolean;
+export declare function class_type(fullname: string, generics?: TypeInfo[], construct?: Constructor, parent?: TypeInfo): TypeInfo;
+export declare function record_type(fullname: string, generics: TypeInfo[], construct: Constructor, fields: () => FieldInfo[]): TypeInfo;
+export declare function anonRecord_type(...fields: FieldInfo[]): TypeInfo;
+export declare function union_type(fullname: string, generics: TypeInfo[], construct: Constructor, cases: () => FieldInfo[][]): TypeInfo;
+export declare function tuple_type(...generics: TypeInfo[]): TypeInfo;
+export declare function delegate_type(...generics: TypeInfo[]): TypeInfo;
+export declare function lambda_type(argType: TypeInfo, returnType: TypeInfo): TypeInfo;
+export declare function option_type(generic: TypeInfo): TypeInfo;
+export declare function list_type(generic: TypeInfo): TypeInfo;
+export declare function array_type(generic: TypeInfo): TypeInfo;
+export declare function enum_type(fullname: string, underlyingType: TypeInfo, enumCases: EnumCase[]): TypeInfo;
+export declare function measure_type(fullname: string): TypeInfo;
+export declare function generic_type(name: string): TypeInfo;
+export declare const obj_type: TypeInfo;
+export declare const unit_type: TypeInfo;
+export declare const char_type: TypeInfo;
+export declare const string_type: TypeInfo;
+export declare const bool_type: TypeInfo;
+export declare const int8_type: TypeInfo;
+export declare const uint8_type: TypeInfo;
+export declare const int16_type: TypeInfo;
+export declare const uint16_type: TypeInfo;
+export declare const int32_type: TypeInfo;
+export declare const uint32_type: TypeInfo;
+export declare const int64_type: TypeInfo;
+export declare const uint64_type: TypeInfo;
+export declare const int128_type: TypeInfo;
+export declare const uint128_type: TypeInfo;
+export declare const nativeint_type: TypeInfo;
+export declare const unativeint_type: TypeInfo;
+export declare const float16_type: TypeInfo;
+export declare const float32_type: TypeInfo;
+export declare const float64_type: TypeInfo;
+export declare const decimal_type: TypeInfo;
+export declare const bigint_type: TypeInfo;
+export declare function name(info: FieldInfo | TypeInfo | CaseInfo | MethodInfo): string;
+export declare function fullName(t: TypeInfo): string;
+export declare function namespace(t: TypeInfo): string;
+export declare function isArray(t: TypeInfo): boolean;
+export declare function getElementType(t: TypeInfo): TypeInfo | undefined;
+export declare function isGenericType(t: TypeInfo): boolean;
+export declare function isGenericParameter(t: TypeInfo): t is GenericParameter;
+export declare function isEnum(t: TypeInfo): boolean;
+export declare function isSubclassOf(t1: TypeInfo, t2: TypeInfo): boolean;
+export declare function isInstanceOfType(t: TypeInfo, o: any): boolean;
+/**
+ * This doesn't replace types for fields (records) or cases (unions)
+ * but it should be enough for type comparison purposes
+ */
+export declare function getGenericTypeDefinition(t: TypeInfo): TypeInfo;
+export declare function getEnumUnderlyingType(t: TypeInfo): TypeInfo | undefined;
+export declare function getEnumValues(t: TypeInfo): number[];
+export declare function getEnumNames(t: TypeInfo): string[];
+export declare function parseEnum(t: TypeInfo, str: string): number;
+export declare function tryParseEnum(t: TypeInfo, str: string, defValue: FSharpRef<number>): boolean;
+export declare function getEnumName(t: TypeInfo, v: number): string;
+export declare function isEnumDefined(t: TypeInfo, v: string | number): boolean;
+export declare function getUnionCases(t: TypeInfo): CaseInfo[];
+export declare function getRecordElements(t: TypeInfo): FieldInfo[];
+export declare function getTupleElements(t: TypeInfo): TypeInfo[];
+export declare function getFunctionElements(t: TypeInfo): [TypeInfo, TypeInfo];
+export declare function isUnion(t: any): boolean;
+export declare function isRecord(t: any): boolean;
+export declare function isTuple(t: TypeInfo): boolean;
+export declare function isFunction(t: TypeInfo): boolean;
+export declare function getUnionFields(v: any, t: TypeInfo): [CaseInfo, any[]];
+export declare function getUnionCaseFields(uci: CaseInfo): FieldInfo[];
+export declare function getRecordFields(v: any): any[];
+export declare function getRecordField(v: any, field: FieldInfo): any;
+export declare function getTupleFields(v: any): any[];
+export declare function getTupleField(v: any, i: number): any;
+export declare function makeUnion(uci: CaseInfo, values: any[]): any;
+export declare function makeRecord(t: TypeInfo, values: any[]): any;
+export declare function makeTuple(values: any[], _t: TypeInfo): any;
+export declare function makeGenericType(t: TypeInfo, generics: TypeInfo[]): TypeInfo;
+export declare function createInstance(t: TypeInfo, consArgs?: any[]): any;
+export declare function getValue(propertyInfo: PropertyInfo, v: any): any;
+export declare function getCaseTag(x: any): number;
+export declare function getCaseName(x: any): string;
+export declare function getCaseFields(x: any): any[];