compostjs 0.0.8 → 0.0.12

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

@@ -0,0 +1,212 @@
+import Decimal from "./lib/big.js";
+import { symbol } from "./Numeric.js";
+import { FSharpRef } from "./Types.js";
+import { combineHashCodes } from "./Util.js";
+Decimal.prototype.GetHashCode = function () {
+    return combineHashCodes([this.s, this.e].concat(this.c));
+};
+Decimal.prototype.Equals = function (x) {
+    return !this.cmp(x);
+};
+Decimal.prototype.CompareTo = function (x) {
+    return this.cmp(x);
+};
+Decimal.prototype[symbol] = function () {
+    const _this = this;
+    return {
+        multiply: (y) => _this.mul(y),
+        toPrecision: (sd) => _this.toPrecision(sd),
+        toExponential: (dp) => _this.toExponential(dp),
+        toFixed: (dp) => _this.toFixed(dp),
+        toHex: () => (Number(_this) >>> 0).toString(16),
+    };
+};
+export default Decimal;
+export const get_Zero = new Decimal(0);
+export const get_One = new Decimal(1);
+export const get_MinusOne = new Decimal(-1);
+export const get_MaxValue = new Decimal("79228162514264337593543950335");
+export const get_MinValue = new Decimal("-79228162514264337593543950335");
+export function compare(x, y) {
+    return x.cmp(y);
+}
+export function equals(x, y) {
+    return !x.cmp(y);
+}
+export function abs(x) { return x.abs(); }
+export function sign(x) { return x.lt(get_Zero) ? -1 : x.gt(get_Zero) ? 1 : 0; }
+export function max(x, y) { return x.gt(y) ? x : y; }
+export function min(x, y) { return x.lt(y) ? x : y; }
+export function maxMagnitude(x, y) { return abs(x).gt(abs(y)) ? x : y; }
+export function minMagnitude(x, y) { return abs(x).lt(abs(y)) ? x : y; }
+export function clamp(x, min, max) {
+    return x.lt(min) ? min : x.gt(max) ? max : x;
+}
+export function round(x, digits = 0) {
+    return x.round(digits, 2 /* ROUND_HALF_EVEN */);
+}
+export function truncate(x) {
+    return x.round(0, 0 /* ROUND_DOWN */);
+}
+export function ceiling(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);
+}
+export function floor(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);
+}
+export function pow(x, n) {
+    return x.pow(n);
+}
+export function sqrt(x) {
+    return x.sqrt();
+}
+export function op_Addition(x, y) {
+    return x.add(y);
+}
+export function op_Subtraction(x, y) {
+    return x.sub(y);
+}
+export function op_Multiply(x, y) {
+    return x.mul(y);
+}
+export function op_Division(x, y) {
+    return x.div(y);
+}
+export function op_Modulus(x, y) {
+    return x.mod(y);
+}
+export function op_UnaryNegation(x) {
+    const x2 = new Decimal(x);
+    x2.s = -x2.s || 0;
+    return x2;
+}
+export function op_UnaryPlus(x) {
+    return x;
+}
+export const add = op_Addition;
+export const subtract = op_Subtraction;
+export const multiply = op_Multiply;
+export const divide = op_Division;
+export const remainder = op_Modulus;
+export const negate = op_UnaryNegation;
+export function toString(x) {
+    return x.toString();
+}
+export function tryParse(str, defValue) {
+    try {
+        defValue.contents = new Decimal(str.trim());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function parse(str) {
+    const defValue = new FSharpRef(get_Zero);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`The input string ${str} was not in a correct format.`);
+    }
+}
+export function toNumber(x) {
+    return +x;
+}
+function decimalToHex(dec, bitSize) {
+    const hex = new Uint8Array(bitSize / 4 | 0);
+    let hexCount = 1;
+    for (let d = 0; d < dec.length; d++) {
+        let value = dec[d];
+        for (let i = 0; i < hexCount; i++) {
+            const digit = hex[i] * 10 + value | 0;
+            hex[i] = digit & 0xF;
+            value = digit >> 4;
+        }
+        if (value !== 0) {
+            hex[hexCount++] = value;
+        }
+    }
+    return hex.slice(0, hexCount); // digits in reverse order
+}
+function hexToDecimal(hex, bitSize) {
+    const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);
+    let decCount = 1;
+    for (let d = hex.length - 1; d >= 0; d--) {
+        let carry = hex[d];
+        for (let i = 0; i < decCount; i++) {
+            const val = dec[i] * 16 + carry | 0;
+            dec[i] = (val % 10) | 0;
+            carry = (val / 10) | 0;
+        }
+        while (carry > 0) {
+            dec[decCount++] = (carry % 10) | 0;
+            carry = (carry / 10) | 0;
+        }
+    }
+    return dec.slice(0, decCount); // digits in reverse order
+}
+function setInt32Bits(hexDigits, bits, offset) {
+    for (let i = 0; i < 8; i++) {
+        hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;
+    }
+}
+function getInt32Bits(hexDigits, offset) {
+    let bits = 0;
+    for (let i = 0; i < 8; i++) {
+        bits = bits | (hexDigits[offset + i] << (i * 4));
+    }
+    return bits;
+}
+export function fromIntArray(bits) {
+    return fromInts(bits[0], bits[1], bits[2], bits[3]);
+}
+export function fromInts(low, mid, high, signExp) {
+    const isNegative = signExp < 0;
+    const scale = (signExp >> 16) & 0x7F;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+export function fromParts(low, mid, high, isNegative, scale) {
+    const bitSize = 96;
+    const hexDigits = new Uint8Array(bitSize / 4);
+    setInt32Bits(hexDigits, low, 0);
+    setInt32Bits(hexDigits, mid, 8);
+    setInt32Bits(hexDigits, high, 16);
+    const decDigits = hexToDecimal(hexDigits, bitSize);
+    scale = scale & 0x7F;
+    const big = new Decimal(0);
+    big.c = Array.from(decDigits.reverse());
+    big.e = decDigits.length - scale - 1;
+    big.s = isNegative ? -1 : 1;
+    const d = new Decimal(big);
+    return d;
+}
+export function getBits(d) {
+    const bitSize = 96;
+    const decDigits = Uint8Array.from(d.c);
+    const hexDigits = decimalToHex(decDigits, bitSize);
+    const low = getInt32Bits(hexDigits, 0);
+    const mid = getInt32Bits(hexDigits, 8);
+    const high = getInt32Bits(hexDigits, 16);
+    const decStr = d.toString();
+    const dotPos = decStr.indexOf(".");
+    const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;
+    const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);
+    return [low, mid, high, signExp];
+}
+// export function makeRangeStepFunction(step: Decimal, last: Decimal) {
+//   const stepComparedWithZero = step.cmp(get_Zero);
+//   if (stepComparedWithZero === 0) {
+//     throw new Error("The step of a range cannot be zero");
+//   }
+//   const stepGreaterThanZero = stepComparedWithZero > 0;
+//   return (x: Decimal) => {
+//     const comparedWithLast = x.cmp(last);
+//     if ((stepGreaterThanZero && comparedWithLast <= 0)
+//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {
+//       return [x, op_Addition(x, step)];
+//     } else {
+//       return undefined;
+//     }
+//   };
+// }

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

@@ -0,0 +1,11 @@
+import { FSharpRef } from "./Types.js";
+export declare function tryParse(str: string, defValue: FSharpRef<number>): boolean;
+export declare function parse(str: string): number;
+export declare function isPositiveInfinity(x: number): boolean;
+export declare function isNegativeInfinity(x: number): boolean;
+export declare function isInfinity(x: number): boolean;
+export declare function max(x: number, y: number): number;
+export declare function min(x: number, y: number): number;
+export declare function maxMagnitude(x: number, y: number): number;
+export declare function minMagnitude(x: number, y: number): number;
+export declare function clamp(x: number, min: number, max: number): number;

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

@@ -0,0 +1,46 @@
+import { FSharpRef } from "./Types.js";
+export function tryParse(str, defValue) {
+    // TODO: test if value is valid and in range
+    if (str != null && /\S/.test(str)) {
+        const v = +str.replace("_", "");
+        if (!Number.isNaN(v)) {
+            defValue.contents = v;
+            return true;
+        }
+    }
+    return false;
+}
+export function parse(str) {
+    const defValue = new FSharpRef(0);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`The input string ${str} was not in a correct format.`);
+    }
+}
+// JS Number.isFinite function evals false for NaN
+export function isPositiveInfinity(x) {
+    return x === Number.POSITIVE_INFINITY;
+}
+export function isNegativeInfinity(x) {
+    return x === Number.NEGATIVE_INFINITY;
+}
+export function isInfinity(x) {
+    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
+}
+export function max(x, y) {
+    return x > y ? x : y;
+}
+export function min(x, y) {
+    return x < y ? x : y;
+}
+export function maxMagnitude(x, y) {
+    return Math.abs(x) > Math.abs(y) ? x : y;
+}
+export function minMagnitude(x, y) {
+    return Math.abs(x) < Math.abs(y) ? x : y;
+}
+export function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}

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

@@ -0,0 +1,12 @@
+import { uint8 } from "./Int32.js";
+declare class UTF16LE {
+    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
+    getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
+}
+declare class UTF8 {
+    getBytes(str: string | string[], index?: number, count?: number): Uint8Array;
+    getString(bytes: ArrayLike<uint8>, index?: number, count?: number): string;
+}
+export declare function get_Unicode(): UTF16LE;
+export declare function get_UTF8(): UTF8;
+export {};

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

@@ -0,0 +1,173 @@
+const littleEndian = true;
+function utf16le_encode(str) {
+    const bytes = new Uint8Array(str.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        view.setUint16(i * 2, code, littleEndian);
+    }
+    return bytes;
+}
+function utf16le_decode(bytes) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    const chars = new Array(view.byteLength / 2);
+    for (let i = 0; i < chars.length; i++) {
+        const code = view.getUint16(i * 2, littleEndian);
+        chars[i] = String.fromCharCode(code);
+    }
+    return chars.join("");
+}
+function utf8_encode(str) {
+    let pos = 0;
+    let buf = new Uint8Array(str.length * 3);
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code >= 0xD800 && code <= 0xDBFF) {
+            const nextCode = (i < str.length) ? str.charCodeAt(i + 1) : 0;
+            if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
+                i += 1;
+                code = (code - 0xD800) * 0x400 + nextCode - 0xDC00 + 0x10000;
+                if (code > 0xFFFF) {
+                    buf[pos++] = (0x1E << 3) | (code >>> 18);
+                    buf[pos++] = (0x2 << 6) | ((code >>> 12) & 0x3F);
+                    buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+                    buf[pos++] = (0x2 << 6) | (code & 0x3F);
+                }
+            }
+            else {
+                buf[pos++] = 0xEF;
+                buf[pos++] = 0xBF;
+                buf[pos++] = 0xBD;
+            }
+        }
+        else if (code <= 0x007F) {
+            buf[pos++] = (0x0 << 7) | code;
+        }
+        else if (code <= 0x07FF) {
+            buf[pos++] = (0x6 << 5) | (code >>> 6);
+            buf[pos++] = (0x2 << 6) | (code & 0x3F);
+        }
+        else {
+            buf[pos++] = (0xE << 4) | (code >>> 12);
+            buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+            buf[pos++] = (0x2 << 6) | (code & 0x3F);
+        }
+    }
+    buf = new Uint8Array(buf.buffer.slice(0, pos));
+    return buf;
+}
+function utf8_decode(bytes) {
+    let pos = 0;
+    const decodeUtf8 = () => {
+        const i1 = bytes[pos++];
+        if ((i1 & 0x80) === 0) {
+            return i1;
+        }
+        else if ((i1 & 0xE0) === 0xC0) {
+            const i2 = bytes[pos++];
+            return ((i1 & 0x1F) << 6) | (i2 & 0x3F);
+        }
+        else if ((i1 & 0xF0) === 0xE0) {
+            const i2 = bytes[pos++];
+            const i3 = bytes[pos++];
+            return ((i1 & 0x0F) << 12) | ((i2 & 0x3F) << 6) | (i3 & 0x3F);
+        }
+        else if ((i1 & 0xF8) === 0xF0) {
+            const i2 = bytes[pos++];
+            const i3 = bytes[pos++];
+            const i4 = bytes[pos++];
+            return ((i1 & 0x07) << 18) | ((i2 & 0x3F) << 12) | ((i3 & 0x3F) << 6) | (i4 & 0x3F);
+        }
+        else {
+            throw new RangeError("Invalid UTF8 byte: " + i1);
+        }
+    };
+    const chars = new Array();
+    while (pos < bytes.length) {
+        const code = decodeUtf8();
+        chars.push(String.fromCodePoint(code));
+    }
+    return chars.join("");
+}
+class UTF16LE {
+    getBytes(str, index, count) {
+        str = Array.isArray(str) ? str.join("") : str;
+        if (index != null && count != null) {
+            str = str.substring(index, index + count);
+        }
+        else if (index != null) {
+            str = str.substring(index);
+        }
+        if (typeof Buffer !== "undefined") {
+            const bytes = Buffer.from(str, "utf16le");
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        else {
+            return utf16le_encode(str); // polyfill
+        }
+    }
+    getString(bytes, index, count) {
+        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        if (index != null && count != null) {
+            buffer = buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            buffer = buffer.subarray(index);
+        }
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder("utf-16le").decode(buffer);
+        }
+        else if (typeof Buffer !== "undefined") {
+            return Buffer.from(buffer).toString("utf16le");
+        }
+        else {
+            return utf16le_decode(buffer); // polyfill
+        }
+    }
+}
+class UTF8 {
+    getBytes(str, index, count) {
+        str = Array.isArray(str) ? str.join("") : str;
+        if (index != null && count != null) {
+            str = str.substring(index, index + count);
+        }
+        else if (index != null) {
+            str = str.substring(index);
+        }
+        if (typeof TextEncoder !== "undefined") {
+            return new TextEncoder().encode(str);
+        }
+        else if (typeof Buffer !== "undefined") {
+            const bytes = Buffer.from(str, "utf8");
+            return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        }
+        else {
+            return utf8_encode(str); // polyfill
+        }
+    }
+    getString(bytes, index, count) {
+        const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+        let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        if (index != null && count != null) {
+            buffer = buffer.subarray(index, index + count);
+        }
+        else if (index != null) {
+            buffer = buffer.subarray(index);
+        }
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder().decode(buffer);
+        }
+        else if (typeof Buffer !== "undefined") {
+            return Buffer.from(buffer).toString("utf8");
+        }
+        else {
+            return utf8_decode(buffer); // polyfill
+        }
+    }
+}
+const _UTF16 = new UTF16LE();
+const _UTF8 = new UTF8();
+export function get_Unicode() { return _UTF16; }
+export function get_UTF8() { return _UTF8; }

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

@@ -0,0 +1,31 @@
+import { IObservable } from "./Observable.js";
+import { Option } from "./Option.js";
+import { FSharpChoice$2_$union } from "./Choice.js";
+export type Handler<T> = (sender: any, x: T) => void;
+export interface IDelegateEvent<Delegate extends Function> {
+    AddHandler(d: Delegate): void;
+    RemoveHandler(d: Delegate): void;
+}
+export interface IEvent$2<Delegate extends Function, Args> extends IDelegateEvent<Delegate>, IObservable<Args> {
+}
+export type IEvent<T> = IEvent$2<Handler<T>, T>;
+export declare class Event$2<Delegate extends Function, Args> {
+    private delegates;
+    private _add;
+    private _remove;
+    get Publish(): IEvent$2<Delegate, Args>;
+    Trigger(value: Args): void;
+    Trigger(sender: any, value: Args): void;
+}
+export declare class Event<T> extends Event$2<Handler<T>, T> {
+}
+export declare function add<Del extends Function, T>(callback: (x: T) => void, sourceEvent: IEvent$2<Del, T>): void;
+export declare function choose<Del extends Function, T, U>(chooser: (x: T) => Option<U>, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
+export declare function filter<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): IEvent<T>;
+export declare function map<Del extends Function, T, U>(mapping: (x: T) => U, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
+export declare function merge<Del1 extends Function, Del2 extends Function, T>(event1: IEvent$2<Del1, T>, event2: IEvent$2<Del2, T>): IEvent<T>;
+export declare function pairwise<Del extends Function, T>(sourceEvent: IEvent$2<Del, T>): IEvent<[T, T]>;
+export declare function partition<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): [IEvent<T>, IEvent<T>];
+export declare function scan<Del extends Function, U, T>(collector: (u: U, t: T) => U, state: U, sourceEvent: IEvent$2<Del, T>): IEvent<U>;
+export declare function split<Del extends Function, T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, sourceEvent: IEvent$2<Del, T>): [IEvent<U1>, IEvent<U2>];
+export declare function createEvent<Del extends Function, T>(addHandler: (h: Del) => void, removeHandler: (h: Del) => void): IEvent$2<Del, T>;

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

@@ -0,0 +1,93 @@
+import { subscribe } from "./Observable.js";
+import { some, value } from "./Option.js";
+import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+export class Event$2 {
+    constructor() {
+        this.delegates = [];
+    }
+    _add(d) {
+        this.delegates.push(d);
+    }
+    _remove(d) {
+        const index = this.delegates.indexOf(d);
+        if (index > -1) {
+            this.delegates.splice(index, 1);
+        }
+    }
+    get Publish() {
+        return createEvent(h => { this._add(h); }, h => { this._remove(h); });
+    }
+    Trigger(senderOrValue, valueOrUndefined) {
+        let sender = null;
+        const value = valueOrUndefined === undefined ? senderOrValue : (sender = senderOrValue, valueOrUndefined);
+        this.delegates.forEach(f => { f(sender, value); });
+    }
+}
+export class Event extends Event$2 {
+}
+export function add(callback, sourceEvent) {
+    subscribe(callback, sourceEvent);
+}
+export function choose(chooser, sourceEvent) {
+    const ev = new Event();
+    add((t) => {
+        const u = chooser(t);
+        if (u != null) {
+            ev.Trigger(value(u));
+        }
+    }, sourceEvent);
+    return ev.Publish;
+}
+export function filter(predicate, sourceEvent) {
+    return choose((x) => predicate(x) ? some(x) : undefined, sourceEvent);
+}
+export function map(mapping, sourceEvent) {
+    const ev = new Event();
+    add((t) => ev.Trigger(mapping(t)), sourceEvent);
+    return ev.Publish;
+}
+export function merge(event1, event2) {
+    const ev = new Event();
+    const fn = (x) => ev.Trigger(x);
+    add(fn, event1);
+    add(fn, event2);
+    return ev.Publish;
+}
+export function pairwise(sourceEvent) {
+    const ev = new Event();
+    let last;
+    let haveLast = false;
+    add((next) => {
+        if (haveLast) {
+            ev.Trigger([last, next]);
+        }
+        last = next;
+        haveLast = true;
+    }, sourceEvent);
+    return ev.Publish;
+}
+export function partition(predicate, sourceEvent) {
+    return [filter(predicate, sourceEvent), filter((x) => !predicate(x), sourceEvent)];
+}
+export function scan(collector, state, sourceEvent) {
+    return map((t) => state = collector(state, t), sourceEvent);
+}
+export function split(splitter, sourceEvent) {
+    return [
+        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), sourceEvent),
+        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), sourceEvent),
+    ];
+}
+export function createEvent(addHandler, removeHandler) {
+    return {
+        AddHandler(h) { addHandler(h); },
+        RemoveHandler(h) { removeHandler(h); },
+        Subscribe(r) {
+            const h = ((_, args) => r.OnNext(args));
+            addHandler(h);
+            return {
+                Dispose() { removeHandler(h); }
+            };
+        }
+    };
+}

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

@@ -0,0 +1,7 @@
+import { int32 } from "./Int32.js";
+import { IComparer, IEqualityComparer } from "./Util.js";
+export declare function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T>;
+export declare function HashIdentity_Structural<T>(): IEqualityComparer<T>;
+export declare function HashIdentity_Reference<T>(): IEqualityComparer<T>;
+export declare function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T>;
+export declare function ComparisonIdentity_Structural<T>(): IComparer<T>;

package/dist/fable_modules/fable-library-js.4.28.0/FSharp.Collections.js

@@ -0,0 +1,27 @@
+import { compare, physicalHash, equals, structuralHash } from "./Util.js";
+export function HashIdentity_FromFunctions(hash, eq) {
+    return {
+        Equals(x, y) {
+            return eq(x, y);
+        },
+        GetHashCode(x_1) {
+            return hash(x_1);
+        },
+    };
+}
+export function HashIdentity_Structural() {
+    return HashIdentity_FromFunctions(structuralHash, equals);
+}
+export function HashIdentity_Reference() {
+    return HashIdentity_FromFunctions(physicalHash, (e, e_1) => (e === e_1));
+}
+export function ComparisonIdentity_FromFunction(comparer) {
+    return {
+        Compare(x, y) {
+            return comparer(x, y);
+        },
+    };
+}
+export function ComparisonIdentity_Structural() {
+    return ComparisonIdentity_FromFunction(compare);
+}

package/dist/fable_modules/fable-library-js.4.28.0/FSharp.Core.CompilerServices.d.ts

@@ -0,0 +1,12 @@
+import { TypeInfo } from "./Reflection.js";
+import { FSharpList } from "./List.js";
+export declare class ListCollector$1<T> {
+    readonly collector: T[];
+    constructor();
+}
+export declare function ListCollector$1_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function ListCollector$1_$ctor<T>(): ListCollector$1<T>;
+export declare function ListCollector$1__Add_2B595<T>(this$: ListCollector$1<T>, value: T): void;
+export declare function ListCollector$1__AddMany_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): void;
+export declare function ListCollector$1__AddManyAndClose_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): FSharpList<T>;
+export declare function ListCollector$1__Close<T>(this$: ListCollector$1<T>): FSharpList<T>;

package/dist/fable_modules/fable-library-js.4.28.0/FSharp.Core.CompilerServices.js

@@ -0,0 +1,27 @@
+import { class_type } from "./Reflection.js";
+import { addRangeInPlace } from "./Array.js";
+import { toList } from "./Seq.js";
+export class ListCollector$1 {
+    constructor() {
+        this.collector = [];
+    }
+}
+export function ListCollector$1_$reflection(gen0) {
+    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
+}
+export function ListCollector$1_$ctor() {
+    return new ListCollector$1();
+}
+export function ListCollector$1__Add_2B595(this$, value) {
+    void (this$.collector.push(value));
+}
+export function ListCollector$1__AddMany_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+}
+export function ListCollector$1__AddManyAndClose_BB573A(this$, values) {
+    addRangeInPlace(values, this$.collector);
+    return toList(this$.collector);
+}
+export function ListCollector$1__Close(this$) {
+    return toList(this$.collector);
+}

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

@@ -0,0 +1,17 @@
+import { IDisposable, IEqualityComparer, IComparer } from "./Util.js";
+import { Option } from "./Option.js";
+import { StringBuilder } from "./System.Text.js";
+export declare const LanguagePrimitives_GenericEqualityComparer: any;
+export declare const LanguagePrimitives_GenericEqualityERComparer: any;
+export declare function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T>;
+export declare function LanguagePrimitives_FastGenericComparerFromTable<T>(): IComparer<T>;
+export declare function LanguagePrimitives_FastGenericEqualityComparer<T>(): IEqualityComparer<T>;
+export declare function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IEqualityComparer<T>;
+export declare function Operators_Failure(message: string): Error;
+export declare function Operators_FailurePattern(exn: Error): Option<string>;
+export declare function Operators_NullArg<$a>(x: string): $a;
+export declare function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R;
+export declare function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b;
+export declare function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a;
+export declare function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b;
+export declare function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a;