@nfdi4plants/arctrl 3.0.0-alpha.4 → 3.0.0-beta.10

package/dist/ts/node_modules/@fable-org/fable-library-js/DateOffset.js

@@ -0,0 +1,271 @@
+import { toFloat64, fromFloat64 } from './BigInt.js';
+import { ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks, parseRaw, dateOffsetToString, DateTime, create as create$1, daysInMonth } from './Date.js';
+import { padWithZeros, compareDates } from './Util.js';
+
+/**
+ * DateTimeOffset functions.
+ *
+ * Note: DateOffset instances are always DateObjects in local
+ * timezone (because JS dates are all kinds of messed up).
+ * A local date returns UTC epoch when `.getTime()` is called.
+ *
+ * However, this means that in order to construct an UTC date
+ * from a DateOffset with offset of +5 hours, you first need
+ * to subtract those 5 hours, than add the "local" offset.
+ * As said, all kinds of messed up.
+ *
+ * Basically; invariant: date.getTime() always return UTC time.
+ */
+function DateTimeOffset(value, offset) {
+    checkOffsetInRange(offset);
+    const d = new Date(value);
+    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;
+    return d;
+}
+function offset(value) {
+    return value.offset || 0;
+}
+function checkOffsetInRange(offset) {
+    if (offset != null && offset !== 0) {
+        if (offset % 60000 !== 0) {
+            throw new Error("Offset must be specified in whole minutes.");
+        }
+        if (Math.abs(offset / 3600000) > 14) {
+            throw new Error("Offset must be within plus or minus 14 hours.");
+        }
+    }
+}
+function fromDate(date, offset) {
+    let offset2 = 0;
+    switch (date.kind) {
+        case 1 /* DateKind.UTC */:
+            if (offset != null && offset !== 0) {
+                throw new Error("The UTC Offset for Utc DateTime instances must be 0.");
+            }
+            offset2 = 0;
+            break;
+        case 2 /* DateKind.Local */:
+            offset2 = date.getTimezoneOffset() * -60000;
+            if (offset != null && offset !== offset2) {
+                throw new Error("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+            }
+            break;
+        case 0 /* DateKind.Unspecified */:
+        default:
+            if (offset == null) {
+                offset2 = date.getTimezoneOffset() * -60000;
+            }
+            else {
+                offset2 = offset;
+            }
+            break;
+    }
+    return DateTimeOffset(date.getTime(), offset2);
+}
+function fromTicks(ticks, offset) {
+    const ms = ticksToUnixEpochMilliseconds(ticks) - offset;
+    return DateTimeOffset(ms, offset);
+}
+function fromUnixTimeMilliseconds(ms) {
+    return DateTimeOffset(toFloat64(ms), 0);
+}
+function fromUnixTimeSeconds(seconds) {
+    return DateTimeOffset(toFloat64(seconds * 1000n), 0);
+}
+function getUtcTicks(date) {
+    return unixEpochMillisecondsToTicks(date.getTime(), 0);
+}
+function minValue() {
+    // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
+    return DateTimeOffset(-62135596800000, 0);
+}
+function maxValue() {
+    // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
+    return DateTimeOffset(253402300799999, 0);
+}
+function parse(str) {
+    const [date, offsetMatch] = parseRaw(str);
+    const offset = offsetMatch == null
+        ? date.getTimezoneOffset() * -60000
+        : (offsetMatch === "Z" ? 0 : offsetMatch * 60000);
+    return DateTimeOffset(date.getTime(), offset);
+}
+function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+function create(year, month, day, h, m, s, ms, offset) {
+    if (offset == null) {
+        offset = ms;
+        ms = 0;
+    }
+    checkOffsetInRange(offset);
+    let date;
+    if (offset === 0) {
+        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));
+        if (year <= 99) {
+            date.setUTCFullYear(year, month - 1, day);
+        }
+    }
+    else {
+        const str = padWithZeros(year, 4) + "-" +
+            padWithZeros(month, 2) + "-" +
+            padWithZeros(day, 2) + "T" +
+            padWithZeros(h, 2) + ":" +
+            padWithZeros(m, 2) + ":" +
+            padWithZeros(s, 2) + "." +
+            padWithZeros(ms, 3) +
+            dateOffsetToString(offset);
+        date = new Date(str);
+    }
+    const dateValue = date.getTime();
+    if (isNaN(dateValue)) {
+        throw new Error("The parameters describe an unrepresentable Date");
+    }
+    return DateTimeOffset(dateValue, offset);
+}
+function now() {
+    const date = new Date();
+    const offset = date.getTimezoneOffset() * -60000;
+    return DateTimeOffset(date.getTime(), offset);
+}
+function utcNow() {
+    const date = now();
+    return DateTimeOffset(date.getTime(), 0);
+}
+function toUniversalTime(date) {
+    return DateTime(date.getTime(), 1 /* DateKind.UTC */);
+}
+function toLocalTime(date) {
+    return DateTime(date.getTime(), 2 /* DateKind.Local */);
+}
+function timeOfDay(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return d2.getUTCHours() * 3600000
+        + d2.getUTCMinutes() * 60000
+        + d2.getUTCSeconds() * 1000
+        + d2.getUTCMilliseconds();
+}
+function date(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return create$1(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+function day(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDate();
+}
+function hour(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCHours();
+}
+function millisecond(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMilliseconds();
+}
+function minute(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMinutes();
+}
+function month(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMonth() + 1;
+}
+function second(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCSeconds();
+}
+function year(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCFullYear();
+}
+function dayOfWeek(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDay();
+}
+function dayOfYear(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    const _year = d2.getUTCFullYear();
+    const _month = d2.getUTCMonth() + 1;
+    let _day = d2.getUTCDate();
+    for (let i = 1; i < _month; i++) {
+        _day += daysInMonth(_year, i);
+    }
+    return _day;
+}
+function add(d, ts) {
+    return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
+}
+function addDays(d, v) {
+    return add(d, v * 86400000);
+}
+function addHours(d, v) {
+    return add(d, v * 3600000);
+}
+function addMinutes(d, v) {
+    return add(d, v * 60000);
+}
+function addSeconds(d, v) {
+    return add(d, v * 1000);
+}
+function addMilliseconds(d, v) {
+    return add(d, v);
+}
+function addTicks(d, v) {
+    return add(d, toFloat64(v / 10000n));
+}
+function addYears(d, v) {
+    const newMonth = d.getUTCMonth() + 1;
+    const newYear = d.getUTCFullYear() + v;
+    const _daysInMonth = daysInMonth(newYear, newMonth);
+    const newDay = Math.min(_daysInMonth, d.getUTCDate());
+    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), (d.offset ?? 0));
+}
+function addMonths(d, v) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    let newMonth = d2.getUTCMonth() + 1 + v;
+    let newMonth_ = 0;
+    let yearOffset = 0;
+    if (newMonth > 12) {
+        newMonth_ = newMonth % 12;
+        yearOffset = Math.floor(newMonth / 12);
+        newMonth = newMonth_;
+    }
+    else if (newMonth < 1) {
+        newMonth_ = 12 + newMonth % 12;
+        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
+        newMonth = newMonth_;
+    }
+    const newYear = d2.getUTCFullYear() + yearOffset;
+    const _daysInMonth = daysInMonth(newYear, newMonth);
+    const newDay = Math.min(_daysInMonth, d2.getUTCDate());
+    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), (d.offset ?? 0));
+}
+function subtract(d, that) {
+    return typeof that === "number"
+        ? DateTimeOffset(d.getTime() - that, (d.offset ?? 0))
+        : d.getTime() - that.getTime();
+}
+function equals(d1, d2) {
+    return d1.getTime() === d2.getTime();
+}
+function equalsExact(d1, d2) {
+    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;
+}
+function compare(d1, d2) {
+    return compareDates(d1, d2);
+}
+const compareTo = compare;
+function op_Addition(x, y) {
+    return add(x, y);
+}
+function op_Subtraction(x, y) {
+    return subtract(x, y);
+}
+function toOffset(d, offset) {
+    return DateTimeOffset(d.getTime(), offset);
+}
+function toUnixTimeMilliseconds(d) {
+    return fromFloat64(d.getTime());
+}
+function toUnixTimeSeconds(d) {
+    return fromFloat64(d.getTime() / 1000.0);
+}
+
+export { add, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addTicks, addYears, compare, compareTo, create, date, day, dayOfWeek, dayOfYear, DateTimeOffset as default, equals, equalsExact, fromDate, fromTicks, fromUnixTimeMilliseconds, fromUnixTimeSeconds, getUtcTicks, hour, maxValue, millisecond, minValue, minute, month, now, offset, op_Addition, op_Subtraction, parse, second, subtract, timeOfDay, toLocalTime, toOffset, toUniversalTime, toUnixTimeMilliseconds, toUnixTimeSeconds, tryParse, utcNow, year };

package/dist/ts/node_modules/@fable-org/fable-library-js/Decimal.js

@@ -0,0 +1,214 @@
+import { Big } from './lib/big.js';
+import { symbol } from './Numeric.js';
+import { FSharpRef } from './Types.js';
+import { combineHashCodes } from './Util.js';
+
+Big.prototype.GetHashCode = function () {
+    return combineHashCodes([this.s, this.e].concat(this.c));
+};
+Big.prototype.Equals = function (x) {
+    return !this.cmp(x);
+};
+Big.prototype.CompareTo = function (x) {
+    return this.cmp(x);
+};
+Big.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),
+    };
+};
+const get_Zero = new Big(0);
+const get_One = new Big(1);
+const get_MinusOne = new Big(-1);
+const get_MaxValue = new Big("79228162514264337593543950335");
+const get_MinValue = new Big("-79228162514264337593543950335");
+function compare(x, y) {
+    return x.cmp(y);
+}
+function equals(x, y) {
+    return !x.cmp(y);
+}
+function abs(x) { return x.abs(); }
+function sign(x) { return x.lt(get_Zero) ? -1 : x.gt(get_Zero) ? 1 : 0; }
+function max(x, y) { return x.gt(y) ? x : y; }
+function min(x, y) { return x.lt(y) ? x : y; }
+function maxMagnitude(x, y) { return abs(x).gt(abs(y)) ? x : y; }
+function minMagnitude(x, y) { return abs(x).lt(abs(y)) ? x : y; }
+function clamp(x, min, max) {
+    return x.lt(min) ? min : x.gt(max) ? max : x;
+}
+function round(x, digits = 0) {
+    return x.round(digits, 2 /* ROUND_HALF_EVEN */);
+}
+function truncate(x) {
+    return x.round(0, 0 /* ROUND_DOWN */);
+}
+function ceiling(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);
+}
+function floor(x) {
+    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);
+}
+function pow(x, n) {
+    return x.pow(n);
+}
+function sqrt(x) {
+    return x.sqrt();
+}
+function op_Addition(x, y) {
+    return x.add(y);
+}
+function op_Subtraction(x, y) {
+    return x.sub(y);
+}
+function op_Multiply(x, y) {
+    return x.mul(y);
+}
+function op_Division(x, y) {
+    return x.div(y);
+}
+function op_Modulus(x, y) {
+    return x.mod(y);
+}
+function op_UnaryNegation(x) {
+    const x2 = new Big(x);
+    x2.s = -x2.s || 0;
+    return x2;
+}
+function op_UnaryPlus(x) {
+    return x;
+}
+const add = op_Addition;
+const subtract = op_Subtraction;
+const multiply = op_Multiply;
+const divide = op_Division;
+const remainder = op_Modulus;
+const negate = op_UnaryNegation;
+function toString(x) {
+    return x.toString();
+}
+function tryParse(str, defValue) {
+    try {
+        defValue.contents = new Big(str.trim());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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.`);
+    }
+}
+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;
+}
+function fromIntArray(bits) {
+    return fromInts(bits[0], bits[1], bits[2], bits[3]);
+}
+function fromInts(low, mid, high, signExp) {
+    const isNegative = signExp < 0;
+    const scale = (signExp >> 16) & 0x7F;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+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 Big(0);
+    big.c = Array.from(decDigits.reverse());
+    big.e = decDigits.length - scale - 1;
+    big.s = isNegative ? -1 : 1;
+    const d = new Big(big);
+    return d;
+}
+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;
+//     }
+//   };
+// }
+
+export { abs, add, ceiling, clamp, compare, Big as default, divide, equals, floor, fromIntArray, fromInts, fromParts, getBits, get_MaxValue, get_MinValue, get_MinusOne, get_One, get_Zero, max, maxMagnitude, min, minMagnitude, multiply, negate, op_Addition, op_Division, op_Modulus, op_Multiply, op_Subtraction, op_UnaryNegation, op_UnaryPlus, parse, pow, remainder, round, sign, sqrt, subtract, toNumber, toString, truncate, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/Double.js

@@ -0,0 +1,49 @@
+import { FSharpRef } from './Types.js';
+
+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;
+}
+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
+function isPositiveInfinity(x) {
+    return x === Number.POSITIVE_INFINITY;
+}
+function isNegativeInfinity(x) {
+    return x === Number.NEGATIVE_INFINITY;
+}
+function isInfinity(x) {
+    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
+}
+function max(x, y) {
+    return x > y ? x : y;
+}
+function min(x, y) {
+    return x < y ? x : y;
+}
+function maxMagnitude(x, y) {
+    return Math.abs(x) > Math.abs(y) ? x : y;
+}
+function minMagnitude(x, y) {
+    return Math.abs(x) < Math.abs(y) ? x : y;
+}
+function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
+
+export { clamp, isInfinity, isNegativeInfinity, isPositiveInfinity, max, maxMagnitude, min, minMagnitude, parse, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/FSharp.Collections.js

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

package/dist/ts/node_modules/@fable-org/fable-library-js/FSharp.Core.js

@@ -0,0 +1,72 @@
+import { structuralHash, equals, defaultOf, disposeSafe } from './Util.js';
+import { ComparisonIdentity_Structural, HashIdentity_Structural } from './FSharp.Collections.js';
+import { StringBuilder__Append_Z721C83C5 } from './System.Text.js';
+
+const LanguagePrimitives_GenericEqualityComparer = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
+        return structuralHash(x_1);
+    },
+};
+const LanguagePrimitives_GenericEqualityERComparer = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x, y) {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1) {
+        return structuralHash(x_1);
+    },
+};
+function LanguagePrimitives_FastGenericComparer() {
+    return ComparisonIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericComparerFromTable() {
+    return ComparisonIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericEqualityComparer() {
+    return HashIdentity_Structural();
+}
+function LanguagePrimitives_FastGenericEqualityComparerFromTable() {
+    return HashIdentity_Structural();
+}
+function Operators_Failure(message) {
+    return new Error(message);
+}
+function Operators_FailurePattern(exn) {
+    return exn.message;
+}
+function Operators_NullArg(x) {
+    throw new Error(x);
+}
+function Operators_Using(resource, action) {
+    try {
+        return action(resource);
+    }
+    finally {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct = resource;
+            disposeSafe(copyOfStruct);
+        }
+    }
+}
+function Operators_Lock(_lockObj, action) {
+    return action();
+}
+function ExtraTopLevelOperators_LazyPattern(input) {
+    return input.Value;
+}
+function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {
+    return format.cont((s) => {
+        StringBuilder__Append_Z721C83C5(builder, s);
+        return continuation();
+    });
+}
+function PrintfModule_PrintFormatToStringBuilder(builder, format) {
+    return PrintfModule_PrintFormatToStringBuilderThen(() => {
+    }, builder, format);
+}
+
+export { ExtraTopLevelOperators_LazyPattern, LanguagePrimitives_FastGenericComparer, LanguagePrimitives_FastGenericComparerFromTable, LanguagePrimitives_FastGenericEqualityComparer, LanguagePrimitives_FastGenericEqualityComparerFromTable, LanguagePrimitives_GenericEqualityComparer, LanguagePrimitives_GenericEqualityERComparer, Operators_Failure, Operators_FailurePattern, Operators_Lock, Operators_NullArg, Operators_Using, PrintfModule_PrintFormatToStringBuilder, PrintfModule_PrintFormatToStringBuilderThen };

package/dist/ts/node_modules/@fable-org/fable-library-js/Global.js

@@ -0,0 +1,10 @@
+const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
+const SR_inputWasEmpty = "Collection was empty.";
+const SR_inputMustBeNonNegative = "The input must be non-negative.";
+const SR_inputSequenceEmpty = "The input sequence was empty.";
+const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+const SR_differentLengths = "The collections had different lengths.";
+const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+
+export { SR_differentLengths, SR_indexOutOfBounds, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_inputSequenceTooLong, SR_inputWasEmpty, SR_keyNotFoundAlt, SR_notEnoughElements };