@nfdi4plants/arctrl 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -0,0 +1,574 @@
+import { padWithZeros } from './Util.js';
+
+/**
+ * DateTimeOffset functions.
+ *
+ * Note: Date 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.
+ *
+ * Basically; invariant: date.getTime() always return UTC time.
+ */
+const shortDays = [
+    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+];
+const longDays = [
+    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+];
+const shortMonths = [
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+];
+const longMonths = [
+    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
+];
+function parseRepeatToken(format, pos, patternChar) {
+    let tokenLength = 0;
+    let internalPos = pos;
+    while (internalPos < format.length && format[internalPos] === patternChar) {
+        internalPos++;
+        tokenLength++;
+    }
+    return tokenLength;
+}
+function parseNextChar(format, pos) {
+    if (pos >= format.length - 1) {
+        return -1;
+    }
+    return format.charCodeAt(pos + 1);
+}
+function parseQuotedString(format, pos) {
+    let beginPos = pos;
+    // Get the character used to quote the string
+    const quoteChar = format[pos];
+    let result = "";
+    let foundQuote = false;
+    while (pos < format.length) {
+        pos++;
+        const currentChar = format[pos];
+        if (currentChar === quoteChar) {
+            foundQuote = true;
+            break;
+        }
+        else if (currentChar === "\\") {
+            if (pos < format.length) {
+                pos++;
+                result += format[pos];
+            }
+            else {
+                // This means that '\' is the last character in the string.
+                throw new Error("Invalid string format");
+            }
+        }
+        else {
+            result += currentChar;
+        }
+    }
+    if (!foundQuote) {
+        // We could not find the matching quote
+        throw new Error(`Invalid string format could not find matching quote for ${quoteChar}`);
+    }
+    return [result, pos - beginPos + 1];
+}
+function dateToStringWithCustomFormat(date, format, utc) {
+    let cursorPos = 0;
+    let tokenLength = 0;
+    let result = "";
+    const localizedDate = utc ? DateTime(date.getTime(), 1 /* DateKind.UTC */) : date;
+    while (cursorPos < format.length) {
+        const token = format[cursorPos];
+        switch (token) {
+            case "d":
+                tokenLength = parseRepeatToken(format, cursorPos, "d");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += day(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(day(localizedDate), 2);
+                        break;
+                    case 3:
+                        result += shortDays[dayOfWeek(localizedDate)];
+                        break;
+                    case 4:
+                        result += longDays[dayOfWeek(localizedDate)];
+                        break;
+                }
+                break;
+            case "f":
+                tokenLength = parseRepeatToken(format, cursorPos, "f");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    result += padWithZeros(Math.floor(millisecond(localizedDate) / precision), tokenLength);
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we fill the rest of the precision with 0 as if the date didn't have
+                    // milliseconds provided to it.
+                    // This is to have the same behavior as .NET when doing:
+                    // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
+                    result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+                }
+                break;
+            case "F":
+                tokenLength = parseRepeatToken(format, cursorPos, "F");
+                cursorPos += tokenLength;
+                if (tokenLength <= 3) {
+                    const precision = 10 ** (3 - tokenLength);
+                    const value = Math.floor(millisecond(localizedDate) / precision);
+                    if (value != 0) {
+                        result += padWithZeros(value, tokenLength);
+                    }
+                }
+                else if (tokenLength <= 7) {
+                    // JavaScript Date only support precision to the millisecond
+                    // so we can't go beyond that.
+                    // We also need to pad start with 0 if the value is not 0
+                    const value = millisecond(localizedDate);
+                    if (value != 0) {
+                        result += padWithZeros(value, 3);
+                    }
+                }
+                break;
+            case "g":
+                tokenLength = parseRepeatToken(format, cursorPos, "g");
+                cursorPos += tokenLength;
+                if (tokenLength <= 2) {
+                    result += "A.D.";
+                }
+                break;
+            case "h":
+                tokenLength = parseRepeatToken(format, cursorPos, "h");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate) % 12;
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate) % 12, 2);
+                        break;
+                }
+                break;
+            case "H":
+                tokenLength = parseRepeatToken(format, cursorPos, "H");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += hour(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(hour(localizedDate), 2);
+                        break;
+                }
+                break;
+            case "K":
+                tokenLength = parseRepeatToken(format, cursorPos, "K");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        switch (kind(localizedDate)) {
+                            case 1 /* DateKind.UTC */:
+                                result += "Z";
+                                break;
+                            case 2 /* DateKind.Local */:
+                                result += dateOffsetToString(localizedDate.getTimezoneOffset() * -6e4);
+                                break;
+                        }
+                        break;
+                }
+                break;
+            case "m":
+                tokenLength = parseRepeatToken(format, cursorPos, "m");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += minute(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(minute(localizedDate), 2);
+                        break;
+                }
+                break;
+            case "M":
+                tokenLength = parseRepeatToken(format, cursorPos, "M");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += month(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(month(localizedDate), 2);
+                        break;
+                    case 3:
+                        result += shortMonths[month(localizedDate) - 1];
+                        break;
+                    case 4:
+                        result += longMonths[month(localizedDate) - 1];
+                        break;
+                }
+                break;
+            case "s":
+                tokenLength = parseRepeatToken(format, cursorPos, "s");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += second(localizedDate);
+                        break;
+                    case 2:
+                        result += padWithZeros(second(localizedDate), 2);
+                        break;
+                }
+                break;
+            case "t":
+                tokenLength = parseRepeatToken(format, cursorPos, "t");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getHours() < 12 ? "A" : "P";
+                        break;
+                    case 2:
+                        result += localizedDate.getHours() < 12 ? "AM" : "PM";
+                        break;
+                }
+                break;
+            case "y":
+                tokenLength = parseRepeatToken(format, cursorPos, "y");
+                cursorPos += tokenLength;
+                switch (tokenLength) {
+                    case 1:
+                        result += localizedDate.getFullYear() % 100;
+                        break;
+                    case 2:
+                        result += padWithZeros(localizedDate.getFullYear() % 100, 2);
+                        break;
+                    case 3:
+                        result += padWithZeros(localizedDate.getFullYear(), 3);
+                        break;
+                    case 4:
+                        result += padWithZeros(localizedDate.getFullYear(), 4);
+                        break;
+                    case 5:
+                        result += padWithZeros(localizedDate.getFullYear(), 5);
+                        break;
+                }
+                break;
+            case "z":
+                tokenLength = parseRepeatToken(format, cursorPos, "z");
+                cursorPos += tokenLength;
+                let utcOffsetText = "";
+                switch (kind(localizedDate)) {
+                    case 1 /* DateKind.UTC */:
+                        utcOffsetText = "+00:00";
+                        break;
+                    case 2 /* DateKind.Local */:
+                        utcOffsetText = dateOffsetToString(localizedDate.getTimezoneOffset() * -6e4);
+                        break;
+                    case 0 /* DateKind.Unspecified */:
+                        utcOffsetText = dateOffsetToString(toLocalTime(localizedDate).getTimezoneOffset() * -6e4);
+                        break;
+                }
+                const sign = utcOffsetText[0] === "-" ? "-" : "+";
+                const hours = parseInt(utcOffsetText.substring(1, 3), 10);
+                const minutes = parseInt(utcOffsetText.substring(4, 6), 10);
+                switch (tokenLength) {
+                    case 1:
+                        result += `${sign}${hours}`;
+                        break;
+                    case 2:
+                        result += `${sign}${padWithZeros(hours, 2)}`;
+                        break;
+                    default:
+                        result += `${sign}${padWithZeros(hours, 2)}:${padWithZeros(minutes, 2)}`;
+                        break;
+                }
+                break;
+            case ":":
+                result += ":";
+                cursorPos++;
+                break;
+            case "/":
+                result += "/";
+                cursorPos++;
+                break;
+            case "'":
+            case '"':
+                const [quotedString, quotedStringLenght] = parseQuotedString(format, cursorPos);
+                result += quotedString;
+                cursorPos += quotedStringLenght;
+                break;
+            case "%":
+                const nextChar = parseNextChar(format, cursorPos);
+                if (nextChar >= 0 && nextChar !== "%".charCodeAt(0)) {
+                    cursorPos += 2;
+                    result += dateToStringWithCustomFormat(localizedDate, String.fromCharCode(nextChar), utc);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            case "\\":
+                const nextChar2 = parseNextChar(format, cursorPos);
+                if (nextChar2 >= 0) {
+                    cursorPos += 2;
+                    result += String.fromCharCode(nextChar2);
+                }
+                else {
+                    throw new Error("Invalid format string");
+                }
+                break;
+            default:
+                cursorPos++;
+                result += token;
+                break;
+        }
+    }
+    return result;
+}
+function kind(value) {
+    return value.kind || 0;
+}
+function dateOffsetToString(offset) {
+    const isMinus = offset < 0;
+    offset = Math.abs(offset);
+    const hours = ~~(offset / 3600000);
+    const minutes = (offset % 3600000) / 60000;
+    return (isMinus ? "-" : "+") +
+        padWithZeros(hours, 2) + ":" +
+        padWithZeros(minutes, 2);
+}
+function dateToHalfUTCString(date, half) {
+    const str = date.toISOString();
+    return half === "first"
+        ? str.substring(0, str.indexOf("T"))
+        : str.substring(str.indexOf("T") + 1, str.length - 1);
+}
+function dateToISOString(d, utc) {
+    if (utc) {
+        return d.toISOString();
+    }
+    else {
+        // JS Date is always local
+        const printOffset = d.kind == null ? true : d.kind === 2 /* DateKind.Local */;
+        return padWithZeros(d.getFullYear(), 4) + "-" +
+            padWithZeros(d.getMonth() + 1, 2) + "-" +
+            padWithZeros(d.getDate(), 2) + "T" +
+            padWithZeros(d.getHours(), 2) + ":" +
+            padWithZeros(d.getMinutes(), 2) + ":" +
+            padWithZeros(d.getSeconds(), 2) + "." +
+            padWithZeros(d.getMilliseconds(), 3) +
+            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -6e4) : "");
+    }
+}
+function dateToISOStringWithOffset(dateWithOffset, offset) {
+    const str = dateWithOffset.toISOString();
+    return str.substring(0, str.length - 1) + dateOffsetToString(offset);
+}
+function dateToStringWithOffset(date, format) {
+    const d = new Date(date.getTime() + (date.offset ?? 0));
+    if (typeof format !== "string") {
+        return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString((date.offset ?? 0));
+    }
+    else if (format.length === 1) {
+        switch (format) {
+            case "D":
+            case "d": return dateToHalfUTCString(d, "first");
+            case "T":
+            case "t": return dateToHalfUTCString(d, "second");
+            case "O":
+            case "o": return dateToISOStringWithOffset(d, (date.offset ?? 0));
+            default: throw new Error("Unrecognized Date print format");
+        }
+    }
+    else {
+        return dateToStringWithCustomFormat(d, format, true);
+    }
+}
+function dateToStringWithKind(date, format) {
+    const utc = date.kind === 1 /* DateKind.UTC */;
+    if (typeof format !== "string") {
+        return utc ? date.toUTCString() : date.toLocaleString();
+    }
+    else if (format.length === 1) {
+        switch (format) {
+            case "D":
+            case "d":
+                return utc ? dateToHalfUTCString(date, "first") : date.toLocaleDateString();
+            case "T":
+            case "t":
+                return utc ? dateToHalfUTCString(date, "second") : date.toLocaleTimeString();
+            case "O":
+            case "o":
+                return dateToISOString(date, utc);
+            default:
+                throw new Error("Unrecognized Date print format");
+        }
+    }
+    else {
+        return dateToStringWithCustomFormat(date, format, utc);
+    }
+}
+function toString(date, format, _provider) {
+    return date.offset != null
+        ? dateToStringWithOffset(date, format)
+        : dateToStringWithKind(date, format);
+}
+function DateTime(value, kind) {
+    const d = new Date(value);
+    d.kind = (kind == null ? 0 /* DateKind.Unspecified */ : kind) | 0;
+    return d;
+}
+function minValue() {
+    // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
+    return DateTime(-621355968e5, 1 /* DateKind.UTC */);
+}
+function parseRaw(input) {
+    function fail() {
+        throw new Error(`The string is not a valid Date: ${input}`);
+    }
+    if (input == null || input.trim() === "") {
+        fail();
+    }
+    // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.
+    if (input.length === 10 && input[4] === "-" && input[7] === "-") {
+        input += "T00:00:00";
+    }
+    let date = new Date(input);
+    let offset = null;
+    if (isNaN(date.getTime())) {
+        // Try to check strings JS Date cannot parse (see #1045, #1422)
+        const m = /^\s*(\d+[^\w\s:]\d+[^\w\s:]\d+)?\s*(\d+:\d+(?::\d+(?:\.\d+)?)?)?\s*([AaPp][Mm])?\s*(Z|[+-]([01]?\d):?([0-5]?\d)?)?\s*$/.exec(input);
+        if (m != null) {
+            let baseDate;
+            let timeInSeconds = 0;
+            if (m[2] != null) {
+                const timeParts = m[2].split(":");
+                const hourPart = parseInt(timeParts[0], 10);
+                timeInSeconds =
+                    hourPart * 3600 +
+                        parseInt(timeParts[1] || "0", 10) * 60 +
+                        parseFloat(timeParts[2] || "0");
+                if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
+                    timeInSeconds += 720;
+                }
+            }
+            if (m[4] != null) { // There's an offset, parse as UTC
+                if (m[1] != null) {
+                    baseDate = new Date(m[1] + " UTC");
+                }
+                else {
+                    const d = new Date();
+                    baseDate = new Date(d.getUTCFullYear() + "/" + (d.getUTCMonth() + 1) + "/" + d.getUTCDate());
+                }
+                if (m[4] === "Z") {
+                    offset = "Z";
+                }
+                else {
+                    let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || "0", 10);
+                    if (m[4][0] === "-") {
+                        offsetInMinutes *= -1;
+                    }
+                    offset = offsetInMinutes;
+                    timeInSeconds -= offsetInMinutes * 60;
+                }
+            }
+            else {
+                if (m[1] != null) {
+                    baseDate = new Date(m[1]);
+                }
+                else {
+                    const d = new Date();
+                    baseDate = new Date(d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate());
+                }
+            }
+            date = new Date(baseDate.getTime() + timeInSeconds * 1000);
+            // correct for daylight savings time
+            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);
+        }
+        else {
+            fail();
+        }
+        // Check again the date is valid after transformations, see #2229
+        if (isNaN(date.getTime())) {
+            fail();
+        }
+    }
+    return [date, offset];
+}
+function parse(str, detectUTC = false) {
+    const [date, offset] = parseRaw(str);
+    // .NET always parses DateTime as Local if there's offset info (even "Z")
+    // Newtonsoft.Json uses UTC if the offset is "Z"
+    const kind = offset != null
+        ? (detectUTC && offset === "Z" ? 1 /* DateKind.UTC */ : 2 /* DateKind.Local */)
+        : 0 /* DateKind.Unspecified */;
+    return DateTime(date.getTime(), kind);
+}
+function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {
+    const date = kind === 1 /* DateKind.UTC */
+        ? new Date(Date.UTC(year, month - 1, day, h, m, s, ms))
+        : new Date(year, month - 1, day, h, m, s, ms);
+    if (year <= 99) {
+        if (kind === 1 /* DateKind.UTC */) {
+            date.setUTCFullYear(year, month - 1, day);
+        }
+        else {
+            date.setFullYear(year, month - 1, day);
+        }
+    }
+    const dateValue = date.getTime();
+    if (isNaN(dateValue)) {
+        throw new Error("The parameters describe an unrepresentable Date.");
+    }
+    return DateTime(dateValue, kind);
+}
+function now() {
+    return DateTime(Date.now(), 2 /* DateKind.Local */);
+}
+function today() {
+    return date(now());
+}
+function toUniversalTime(date) {
+    return date.kind === 1 /* DateKind.UTC */ ? date : DateTime(date.getTime(), 1 /* DateKind.UTC */);
+}
+function toLocalTime(date) {
+    return date.kind === 2 /* DateKind.Local */ ? date : DateTime(date.getTime(), 2 /* DateKind.Local */);
+}
+function date(d) {
+    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);
+}
+function day(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCDate() : d.getDate();
+}
+function hour(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCHours() : d.getHours();
+}
+function millisecond(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCMilliseconds() : d.getMilliseconds();
+}
+function minute(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCMinutes() : d.getMinutes();
+}
+function month(d) {
+    return (d.kind === 1 /* DateKind.UTC */ ? d.getUTCMonth() : d.getMonth()) + 1;
+}
+function second(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCSeconds() : d.getSeconds();
+}
+function year(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCFullYear() : d.getFullYear();
+}
+function dayOfWeek(d) {
+    return d.kind === 1 /* DateKind.UTC */ ? d.getUTCDay() : d.getDay();
+}
+
+export { DateTime, create, date, dateOffsetToString, dateToHalfUTCString, day, dayOfWeek, DateTime as default, hour, kind, millisecond, minValue, minute, month, now, parse, parseRaw, second, toLocalTime, toString, toUniversalTime, today, tryParse, year };

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

@@ -0,0 +1,59 @@
+/**
+ * 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() * -6e4;
+    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 */:
+            offset2 = 0;
+            break;
+        case 2 /* DateKind.Local */:
+            offset2 = date.getTimezoneOffset() * -6e4;
+            break;
+        case 0 /* DateKind.Unspecified */:
+        default:
+            {
+                offset2 = date.getTimezoneOffset() * -6e4;
+            }
+            break;
+    }
+    return DateTimeOffset(date.getTime(), offset2);
+}
+function add(d, ts) {
+    return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
+}
+function op_Addition(x, y) {
+    return add(x, y);
+}
+
+export { add, DateTimeOffset as default, fromDate, offset, op_Addition };

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

@@ -0,0 +1,65 @@
+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);
+new Big(1);
+new Big(-1);
+new Big("79228162514264337593543950335");
+new Big("-79228162514264337593543950335");
+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.`);
+    }
+}
+// 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 { Big as default, get_Zero, parse, tryParse };