compostjs 0.0.11 → 0.0.12

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

@@ -0,0 +1,233 @@
+import { disposeSafe, defaultOf, toIterator, getEnumerator } from "./Util.js";
+import { iterate, map, iterateIndexed, concat } from "./Seq.js";
+import { 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";
+export class HashSet {
+    constructor(items, comparer) {
+        const this$ = new FSharpRef(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map([]));
+        this["init@9"] = 1;
+        const enumerator = getEnumerator(items);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                HashSet__Add_2B595(this$.contents, item);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "HashSet";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(concat(this$.hashMap.values()));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(item) {
+        const this$ = this;
+        HashSet__Add_2B595(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
+        const this$ = this;
+        iterateIndexed((i, e) => {
+            setItem(array, arrayIndex + i, e);
+        }, this$);
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const this$ = this;
+        return HashSet__get_Count(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, item);
+    }
+    get size() {
+        const this$ = this;
+        return HashSet__get_Count(this$) | 0;
+    }
+    add(k) {
+        const this$ = this;
+        HashSet__Add_2B595(this$, k);
+        return this$;
+    }
+    clear() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    delete(k) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, k);
+    }
+    has(k) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, k);
+    }
+    keys() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    values() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    entries() {
+        const this$ = this;
+        return map((v) => [v, v], this$);
+    }
+    forEach(f, thisArg) {
+        const this$ = this;
+        iterate((x) => {
+            f(x, x, this$);
+        }, this$);
+    }
+}
+export function HashSet_$reflection(gen0) {
+    return class_type("Fable.Collections.HashSet", [gen0], HashSet);
+}
+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))];
+    }
+    else {
+        return [false, h, -1];
+    }
+}
+function HashSet__TryFind_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);
+        default:
+            return undefined;
+    }
+}
+export function HashSet__get_Comparer(this$) {
+    return this$.comparer;
+}
+export function HashSet__Clear(this$) {
+    this$.hashMap.clear();
+}
+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;
+}
+export function HashSet__Add_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            return false;
+        }
+        else {
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            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;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+export function HashSet__Remove_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);
+            return true;
+        }
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { int32 } from "./Int32.js";
+export declare function Helpers_allocateArrayFromCons<T>(cons: any, len: int32): T[];

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

@@ -0,0 +1,8 @@
+export function Helpers_allocateArrayFromCons(cons, len) {
+    if ((typeof cons) === "function") {
+        return new cons(len);
+    }
+    else {
+        return new Array(len);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { IComparable } from "./Util.js";
+export declare const symbol: unique symbol;
+export interface CustomNumeric extends IComparable<Numeric> {
+    [symbol](): {
+        multiply(y: Numeric): Numeric;
+        toPrecision(sd?: number): string;
+        toExponential(dp?: number): string;
+        toFixed(dp?: number): string;
+        toHex(): string;
+    };
+}
+export type Numeric = number | bigint | CustomNumeric;
+export declare function isNumeric(x: any): any;
+export declare function compare(x: Numeric, y: number): number;
+export declare function multiply(x: Numeric, y: number): Numeric;
+export declare function toFixed(x: Numeric, dp?: number): string | bigint;
+export declare function toPrecision(x: Numeric, sd?: number): string | bigint;
+export declare function toExponential(x: Numeric, dp?: number): string | bigint;
+export declare function toHex(x: Numeric): string;

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

@@ -0,0 +1,71 @@
+export const symbol = Symbol("numeric");
+export function isNumeric(x) {
+    return typeof x === "number" || typeof x === "bigint" || x?.[symbol];
+}
+export function compare(x, y) {
+    if (typeof x === "number") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else if (typeof x === "bigint") {
+        return x < y ? -1 : (x > y ? 1 : 0);
+    }
+    else {
+        return x.CompareTo(y);
+    }
+}
+export function multiply(x, y) {
+    if (typeof x === "number") {
+        return x * y;
+    }
+    else if (typeof x === "bigint") {
+        return x * BigInt(y);
+    }
+    else {
+        return x[symbol]().multiply(y);
+    }
+}
+export function toFixed(x, dp) {
+    if (typeof x === "number") {
+        return x.toFixed(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toFixed(dp);
+    }
+}
+export function toPrecision(x, sd) {
+    if (typeof x === "number") {
+        return x.toPrecision(sd);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toPrecision(sd);
+    }
+}
+export function toExponential(x, dp) {
+    if (typeof x === "number") {
+        return x.toExponential(dp);
+    }
+    else if (typeof x === "bigint") {
+        return x;
+    }
+    else {
+        return x[symbol]().toExponential(dp);
+    }
+}
+export function toHex(x) {
+    if (typeof x === "number") {
+        return (Number(x) >>> 0).toString(16);
+    }
+    else if (typeof x === "bigint") {
+        // TODO: properly handle other bit sizes
+        return BigInt.asUintN(64, x).toString(16);
+    }
+    else {
+        return x[symbol]().toHex();
+    }
+}

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

@@ -0,0 +1,32 @@
+import { FSharpChoice$2_$union } from "./Choice.js";
+import { Option } from "./Option.js";
+import { IDisposable } from "./Util.js";
+export interface IObserver<T> {
+    OnNext: (x: T) => void;
+    OnError: (e: any) => void;
+    OnCompleted: () => void;
+}
+export declare class Observer<T> implements IObserver<T> {
+    OnNext: (x: T) => void;
+    OnError: (e: any) => void;
+    OnCompleted: () => void;
+    constructor(onNext: (x: T) => void, onError?: (e: any) => void, onCompleted?: () => void);
+}
+export interface IObservable<T> {
+    Subscribe: (o: IObserver<T>) => IDisposable;
+}
+declare class Observable<T> implements IObservable<T> {
+    Subscribe: (o: IObserver<T>) => IDisposable;
+    constructor(subscribe: (o: IObserver<T>) => IDisposable);
+}
+export declare function add<T>(callback: (x: T) => void, source: IObservable<T>): void;
+export declare function choose<T, U>(chooser: (x: T) => Option<U>, source: IObservable<T>): Observable<U>;
+export declare function filter<T>(predicate: (x: T) => boolean, source: IObservable<T>): IObservable<T>;
+export declare function map<T, U>(mapping: (x: T) => U, source: IObservable<T>): IObservable<U>;
+export declare function merge<T>(source1: IObservable<T>, source2: IObservable<T>): IObservable<T>;
+export declare function pairwise<T>(source: IObservable<T>): IObservable<[T, T]>;
+export declare function partition<T>(predicate: (x: T) => boolean, source: IObservable<T>): [Observable<T>, Observable<T>];
+export declare function scan<U, T>(collector: (u: U, t: T) => U, state: U, source: IObservable<T>): IObservable<U>;
+export declare function split<T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, source: IObservable<T>): [Observable<U1>, Observable<U2>];
+export declare function subscribe<T>(callback: (x: T) => void, source: IObservable<T>): IDisposable;
+export {};

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

@@ -0,0 +1,113 @@
+import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+import { value } from "./Option.js";
+export class Observer {
+    constructor(onNext, onError, onCompleted) {
+        this.OnNext = onNext;
+        this.OnError = onError || ((_e) => { return; });
+        this.OnCompleted = onCompleted || (() => { return; });
+    }
+}
+class Observable {
+    constructor(subscribe) {
+        this.Subscribe = subscribe;
+    }
+}
+function protect(f, succeed, fail) {
+    try {
+        return succeed(f());
+    }
+    catch (e) {
+        fail(e);
+    }
+}
+export function add(callback, source) {
+    source.Subscribe(new Observer(callback));
+}
+export function choose(chooser, source) {
+    return new Observable((observer) => source.Subscribe(new Observer((t) => protect(() => chooser(t), (u) => { if (u != null) {
+        observer.OnNext(value(u));
+    } }, observer.OnError), observer.OnError, observer.OnCompleted)));
+}
+export function filter(predicate, source) {
+    return choose((x) => predicate(x) ? x : void 0, source);
+}
+export function map(mapping, source) {
+    return new Observable((observer) => source.Subscribe(new Observer((t) => {
+        protect(() => mapping(t), observer.OnNext, observer.OnError);
+    }, observer.OnError, observer.OnCompleted)));
+}
+export function merge(source1, source2) {
+    return new Observable((observer) => {
+        let stopped = false;
+        let completed1 = false;
+        let completed2 = false;
+        const h1 = source1.Subscribe(new Observer((v) => { if (!stopped) {
+            observer.OnNext(v);
+        } }, (e) => {
+            if (!stopped) {
+                stopped = true;
+                observer.OnError(e);
+            }
+        }, () => {
+            if (!stopped) {
+                completed1 = true;
+                if (completed2) {
+                    stopped = true;
+                    observer.OnCompleted();
+                }
+            }
+        }));
+        const h2 = source2.Subscribe(new Observer((v) => { if (!stopped) {
+            observer.OnNext(v);
+        } }, (e) => {
+            if (!stopped) {
+                stopped = true;
+                observer.OnError(e);
+            }
+        }, () => {
+            if (!stopped) {
+                completed2 = true;
+                if (completed1) {
+                    stopped = true;
+                    observer.OnCompleted();
+                }
+            }
+        }));
+        return {
+            Dispose() {
+                h1.Dispose();
+                h2.Dispose();
+            },
+        };
+    });
+}
+export function pairwise(source) {
+    return new Observable((observer) => {
+        let last;
+        return source.Subscribe(new Observer((next) => {
+            if (last != null) {
+                observer.OnNext([last, next]);
+            }
+            last = next;
+        }, observer.OnError, observer.OnCompleted));
+    });
+}
+export function partition(predicate, source) {
+    return [filter(predicate, source), filter((x) => !predicate(x), source)];
+}
+export function scan(collector, state, source) {
+    return new Observable((observer) => {
+        return source.Subscribe(new Observer((t) => {
+            protect(() => collector(state, t), (u) => { state = u; observer.OnNext(u); }, observer.OnError);
+        }, observer.OnError, observer.OnCompleted));
+    });
+}
+export function split(splitter, source) {
+    return [
+        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), source),
+        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), source)
+    ];
+}
+export function subscribe(callback, source) {
+    return source.Subscribe(new Observer(callback));
+}

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

@@ -0,0 +1,28 @@
+export type Nullable<T> = T | null | undefined;
+export type Option<T> = T | Some<T> | undefined;
+export declare class Some<T> {
+    value: T;
+    constructor(value: T);
+    toJSON(): T;
+    toString(): string;
+    GetHashCode(): number;
+    Equals(other: Option<T>): boolean;
+    CompareTo(other: Option<T>): number;
+}
+export declare function value<T>(x: Option<T>): T;
+export declare function unwrap<T>(opt: Option<T>): T | undefined;
+export declare function some<T>(x: T): Option<T>;
+export declare function ofNullable<T>(x: Nullable<T>): Option<T>;
+export declare function toNullable<T>(x: Option<T>): Nullable<T>;
+export declare function flatten<T>(x: Option<Option<T>>): T | Some<T> | undefined;
+export declare function toArray<T>(opt: Option<T>): T[];
+export declare function defaultArg<T>(opt: Option<T>, defaultValue: T): T;
+export declare function defaultArgWith<T>(opt: Option<T>, defThunk: () => T): T;
+export declare function orElse<T>(opt: Option<T>, ifNone: Option<T>): Option<T>;
+export declare function orElseWith<T>(opt: Option<T>, ifNoneThunk: () => Option<T>): Option<T>;
+export declare function filter<T>(predicate: (arg: T) => boolean, opt: Option<T>): Option<T>;
+export declare function map<T, U>(mapping: (arg: T) => U, opt: Option<T>): Option<U>;
+export declare function map2<T1, T2, U>(mapping: (arg1: T1, arg2: T2) => Option<U>, opt1: Option<T1>, opt2: Option<T2>): Option<U>;
+export declare function map3<T1, T2, T3, U>(mapping: (arg1: T1, arg2: T2, arg3: T3) => Option<U>, opt1: Option<T1>, opt2: Option<T2>, opt3: Option<T3>): Option<U>;
+export declare function bind<T, U>(binder: (arg: T) => Option<U>, opt: Option<T>): Option<U>;
+export declare function tryOp<T, U>(op: (x: T) => U, arg: T): Option<U>;

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

@@ -0,0 +1,96 @@
+import { structuralHash, equals, compare } from "./Util.js";
+// Using a class here for better compatibility with TS files importing Some
+export class Some {
+    constructor(value) {
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+    // Don't add "Some" for consistency with erased options
+    toString() {
+        return String(this.value);
+    }
+    GetHashCode() {
+        return structuralHash(this.value);
+    }
+    Equals(other) {
+        if (other == null) {
+            return false;
+        }
+        else {
+            return equals(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+    CompareTo(other) {
+        if (other == null) {
+            return 1;
+        }
+        else {
+            return compare(this.value, other instanceof Some ? other.value : other);
+        }
+    }
+}
+export function value(x) {
+    if (x == null) {
+        throw new Error("Option has no value");
+    }
+    else {
+        return x instanceof Some ? x.value : x;
+    }
+}
+export function unwrap(opt) {
+    return opt instanceof Some ? opt.value : opt;
+}
+export function some(x) {
+    return x == null || x instanceof Some ? new Some(x) : x;
+}
+export function ofNullable(x) {
+    // This will fail with unit probably, an alternative would be:
+    // return x === null ? undefined : (x === undefined ? new Some(x) : x);
+    return x == null ? undefined : x;
+}
+export function toNullable(x) {
+    return x == null ? null : value(x);
+}
+export function flatten(x) {
+    return x == null ? undefined : value(x);
+}
+export function toArray(opt) {
+    return (opt == null) ? [] : [value(opt)];
+}
+export function defaultArg(opt, defaultValue) {
+    return (opt != null) ? value(opt) : defaultValue;
+}
+export function defaultArgWith(opt, defThunk) {
+    return (opt != null) ? value(opt) : defThunk();
+}
+export function orElse(opt, ifNone) {
+    return opt == null ? ifNone : opt;
+}
+export function orElseWith(opt, ifNoneThunk) {
+    return opt == null ? ifNoneThunk() : opt;
+}
+export function filter(predicate, opt) {
+    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;
+}
+export function map(mapping, opt) {
+    return (opt != null) ? some(mapping(value(opt))) : undefined;
+}
+export function map2(mapping, opt1, opt2) {
+    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;
+}
+export function map3(mapping, opt1, opt2, opt3) {
+    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;
+}
+export function bind(binder, opt) {
+    return opt != null ? binder(value(opt)) : undefined;
+}
+export function tryOp(op, arg) {
+    try {
+        return some(op(arg));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/fable_modules/fable-library-js.4.28.0/README.md

@@ -0,0 +1,3 @@
+# fable-library
+
+Core library used by F# projects compiled with [Fable](https://fable.io).

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

@@ -0,0 +1,37 @@
+import { uint8, int32, float64 } from "./Int32.js";
+import { TypeInfo } from "./Reflection.js";
+export interface IRandom {
+    Next0(): int32;
+    Next1(maxValue: int32): int32;
+    Next2(minValue: int32, maxValue: int32): int32;
+    NextBytes(buffer: uint8[]): void;
+    NextDouble(): float64;
+}
+export declare class NonSeeded implements IRandom {
+    constructor();
+    Next0(): int32;
+    Next1(maxValue: int32): int32;
+    Next2(minValue: int32, maxValue: int32): int32;
+    NextDouble(): float64;
+    NextBytes(buffer: uint8[]): void;
+}
+export declare function NonSeeded_$reflection(): TypeInfo;
+export declare function NonSeeded_$ctor(): NonSeeded;
+export declare class Seeded implements IRandom {
+    readonly MBIG: int32;
+    inext: int32;
+    inextp: int32;
+    seedArray: int32[];
+    constructor(seed: int32);
+    Next0(): int32;
+    Next1(maxValue: int32): int32;
+    Next2(minValue: int32, maxValue: int32): int32;
+    NextDouble(): float64;
+    NextBytes(buffer: uint8[]): void;
+}
+export declare function Seeded_$reflection(): TypeInfo;
+export declare function Seeded_$ctor_Z524259A4(seed: int32): Seeded;
+export declare function Seeded__Sample(this$: Seeded): float64;
+export declare function Seeded__GetSampleForLargeRange(this$: Seeded): float64;
+export declare function nonSeeded(): NonSeeded;
+export declare function seeded(seed: int32): Seeded;