@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/fable-library-js.4.24.0/Decimal.js

@@ -1,212 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Double.d.ts

@@ -1,11 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Double.js

@@ -1,46 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Encoding.d.ts

@@ -1,12 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Encoding.js

@@ -1,173 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Event.d.ts

@@ -1,31 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Event.js

@@ -1,93 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/FSharp.Collections.d.ts

@@ -1,7 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/FSharp.Collections.js

@@ -1,27 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/FSharp.Core.CompilerServices.d.ts

@@ -1,12 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/FSharp.Core.CompilerServices.js

@@ -1,27 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/FSharp.Core.d.ts

@@ -1,17 +0,0 @@
-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;