@magnusopera/fscript 0.75.0

package/dist/fable_modules/fable-library-js.5.2.0/DateOffset.js

@@ -0,0 +1,261 @@
+/**
+ * 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.
+ */
+import { fromFloat64, toFloat64 } from "./BigInt.js";
+import DateTime, { create as createDate, daysInMonth, parseRaw, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from "./Date.js";
+import { Exception, compareDates, DateTimeKind } from "./Util.js";
+export default function DateTimeOffset(value, offset) {
+    checkOffsetInRange(offset);
+    const d = new Date(value);
+    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;
+    return d;
+}
+export function offset(value) {
+    return value.offset || 0;
+}
+function checkOffsetInRange(offset) {
+    if (offset != null && offset !== 0) {
+        if (offset % 60000 !== 0) {
+            throw new Exception("Offset must be specified in whole minutes.");
+        }
+        if (Math.abs(offset / 3600000) > 14) {
+            throw new Exception("Offset must be within plus or minus 14 hours.");
+        }
+    }
+}
+export function fromDate(date, offset) {
+    let offset2 = 0;
+    switch (date.kind) {
+        case DateTimeKind.Utc:
+            if (offset != null && offset !== 0) {
+                throw new Exception("The UTC Offset for Utc DateTime instances must be 0.");
+            }
+            offset2 = 0;
+            break;
+        case DateTimeKind.Local:
+            offset2 = date.getTimezoneOffset() * -60000;
+            if (offset != null && offset !== offset2) {
+                throw new Exception("The UTC Offset of the local dateTime parameter does not match the offset argument.");
+            }
+            break;
+        case DateTimeKind.Unspecified:
+        default:
+            if (offset == null) {
+                offset2 = date.getTimezoneOffset() * -60000;
+            }
+            else {
+                offset2 = offset;
+            }
+            break;
+    }
+    return DateTimeOffset(date.getTime(), offset2);
+}
+export function fromDateTime(dateOnly, timeOnly, offset) {
+    return DateTimeOffset(dateOnly.getTime() - offset + timeOnly, offset);
+}
+export function fromTicks(ticks, offset) {
+    const ms = ticksToUnixEpochMilliseconds(ticks) - offset;
+    return DateTimeOffset(ms, offset);
+}
+export function fromUnixTimeMilliseconds(ms) {
+    return DateTimeOffset(toFloat64(ms), 0);
+}
+export function fromUnixTimeSeconds(seconds) {
+    return DateTimeOffset(toFloat64(seconds * 1000n), 0);
+}
+export function getUtcTicks(date) {
+    return unixEpochMillisecondsToTicks(date.getTime(), 0);
+}
+export function minValue() {
+    // This is "0001-01-01T00:00:00.000Z", actual JS min value is -8640000000000000
+    return DateTimeOffset(-62135596800000, 0);
+}
+export function maxValue() {
+    // This is "9999-12-31T23:59:59.999Z", actual JS max value is 8640000000000000
+    return DateTimeOffset(253402300799999, 0);
+}
+export 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);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+export function create(year, month, day, h, m, s, ms, offset) {
+    if (offset == null) {
+        offset = ms;
+        ms = 0;
+    }
+    checkOffsetInRange(offset);
+    let date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms) - offset);
+    if (year <= 99) {
+        date.setUTCFullYear(year, month - 1, day);
+    }
+    const dateValue = date.getTime();
+    if (isNaN(dateValue)) {
+        throw new Exception("The parameters describe an unrepresentable Date");
+    }
+    return DateTimeOffset(dateValue, offset);
+}
+export function now() {
+    const date = new Date();
+    const offset = date.getTimezoneOffset() * -60000;
+    return DateTimeOffset(date.getTime(), offset);
+}
+export function utcNow() {
+    const date = new Date();
+    // const offset = date.getTimezoneOffset() * -60_000;
+    return DateTimeOffset(date.getTime(), 0);
+}
+export function toUniversalTime(date) {
+    return DateTime(date.getTime(), DateTimeKind.Utc);
+}
+export function toLocalTime(date) {
+    return DateTime(date.getTime(), DateTimeKind.Local);
+}
+export function localDateTime(date) {
+    return DateTime(date.getTime(), DateTimeKind.Local);
+}
+export function timeOfDay(d) {
+    const d2 = new Date(d.getTime() + offset(d));
+    return d2.getUTCHours() * 3600000
+        + d2.getUTCMinutes() * 60000
+        + d2.getUTCSeconds() * 1000
+        + d2.getUTCMilliseconds();
+}
+export function date(d) {
+    const d2 = new Date(d.getTime() + offset(d));
+    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+export function day(d) {
+    return new Date(d.getTime() + offset(d)).getUTCDate();
+}
+export function hour(d) {
+    return new Date(d.getTime() + offset(d)).getUTCHours();
+}
+export function millisecond(d) {
+    return new Date(d.getTime() + offset(d)).getUTCMilliseconds();
+}
+export function minute(d) {
+    return new Date(d.getTime() + offset(d)).getUTCMinutes();
+}
+export function month(d) {
+    return new Date(d.getTime() + offset(d)).getUTCMonth() + 1;
+}
+export function second(d) {
+    return new Date(d.getTime() + offset(d)).getUTCSeconds();
+}
+export function year(d) {
+    return new Date(d.getTime() + offset(d)).getUTCFullYear();
+}
+export function dayOfWeek(d) {
+    return new Date(d.getTime() + offset(d)).getUTCDay();
+}
+export function dayOfYear(d) {
+    const d2 = new Date(d.getTime() + offset(d));
+    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;
+}
+export function add(d, ts) {
+    return DateTimeOffset(d.getTime() + ts, offset(d));
+}
+export function addDays(d, v) {
+    return add(d, v * 86400000);
+}
+export function addHours(d, v) {
+    return add(d, v * 3600000);
+}
+export function addMinutes(d, v) {
+    return add(d, v * 60000);
+}
+export function addSeconds(d, v) {
+    return add(d, v * 1000);
+}
+export function addMilliseconds(d, v) {
+    return add(d, v);
+}
+export function addTicks(d, v) {
+    return add(d, toFloat64(v / 10000n));
+}
+export 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(), offset(d));
+}
+export function addMonths(d, v) {
+    const d2 = new Date(d.getTime() + offset(d));
+    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(), offset(d));
+}
+export function subtract(d, that) {
+    return typeof that === "number"
+        ? DateTimeOffset(d.getTime() - that, offset(d))
+        : d.getTime() - that.getTime();
+}
+export function equals(d1, d2) {
+    return d1.getTime() === d2.getTime();
+}
+export function equalsExact(d1, d2) {
+    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;
+}
+export function compare(d1, d2) {
+    return compareDates(d1, d2);
+}
+export const compareTo = compare;
+export function op_Addition(x, y) {
+    return add(x, y);
+}
+export function op_Subtraction(x, y) {
+    return subtract(x, y);
+}
+export function toOffset(d, offset) {
+    return DateTimeOffset(d.getTime(), offset);
+}
+export function toUnixTimeMilliseconds(d) {
+    return fromFloat64(d.getTime());
+}
+export function toUnixTimeSeconds(d) {
+    return fromFloat64(d.getTime() / 1000.0);
+}

package/dist/fable_modules/fable-library-js.5.2.0/DateOnly.js

@@ -0,0 +1,124 @@
+import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth, ticksToUnixEpochMilliseconds } from "./Date.js";
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
+export function fromUnixMilliseconds(value) {
+    return DateTime(value, DateTimeKind.Utc);
+}
+export function create(year, month, day) {
+    const d = fromUnixMilliseconds(Date.UTC(year, month - 1, day));
+    if (year <= 99) {
+        d.setUTCFullYear(year);
+    }
+    return d;
+}
+export function maxValue() {
+    // This is "9999-12-31T00:00:00.000Z"
+    return fromUnixMilliseconds(253402214400000);
+}
+export function minValue() {
+    // This is "0001-01-01T00:00:00.000Z"
+    return fromUnixMilliseconds(-62135596800000);
+}
+export function dayNumber(d) {
+    return Number((getTicks(d) / 864000000000n));
+}
+export function fromDayNumber(dayNumber) {
+    const ticks = 864000000000n * BigInt(dayNumber);
+    return fromUnixMilliseconds(ticksToUnixEpochMilliseconds(ticks));
+}
+export function fromDateTime(d) {
+    return create(Date_year(d), Date_month(d), Date_day(d));
+}
+export function day(d) {
+    return d.getUTCDate();
+}
+export function month(d) {
+    return d.getUTCMonth() + 1;
+}
+export function year(d) {
+    return d.getUTCFullYear();
+}
+export function dayOfWeek(d) {
+    return d.getUTCDay();
+}
+export function dayOfYear(d) {
+    return Date_dayOfYear(d);
+}
+export function toDateTime(d, time, kind = DateTimeKind.Unspecified) {
+    return DateTime(d.getTime() + time + (kind !== DateTimeKind.Utc ? d.getTimezoneOffset() : 0) * 60000, kind);
+}
+export function toString(d, format = "d", _provider) {
+    if (["d", "o", "O"].indexOf(format) === -1) {
+        throw new Exception("Custom formats are not supported");
+    }
+    const y = padWithZeros(year(d), 4);
+    const m = padWithZeros(month(d), 2);
+    const dd = padWithZeros(day(d), 2);
+    return format === "d" ? `${m}/${dd}/${y}` : `${y}-${m}-${dd}`;
+}
+export function parse(str) {
+    function fail() {
+        throw new Exception(`String '${str}' was not recognized as a valid DateOnly.`);
+    }
+    // Allowed separators: . , / -
+    // TODO whitespace alone as the separator
+    //
+    // Whitespace around separators
+    //
+    // Allowed format types:
+    // yyyy/mm/dd
+    // mm/dd/yyyy
+    // mm/dd
+    // mm/yyyy
+    // yyyy/mm
+    const r = /^\s*(\d{1,4})(?:\s*[.,-\/]\s*(\d{1,2}))?\s*[.,-\/]\s*(\d{1,4})\s*$/.exec(str);
+    if (r != null) {
+        let y = 0;
+        let m = 0;
+        let d = 1;
+        if (r[2] == null) {
+            if (r[1].length < 3) {
+                if (r[3].length < 3) {
+                    // 12/30 = December 30, {CurrentYear}
+                    y = new Date().getFullYear();
+                    m = +r[1];
+                    d = +r[3];
+                }
+                else {
+                    // 12/2000 = December 1, 2000
+                    m = +r[1];
+                    y = +r[3];
+                }
+            }
+            else {
+                if (r[3].length > 2)
+                    fail();
+                // 2000/12 = December 1, 2000
+                y = +r[1];
+                m = +r[3];
+            }
+        }
+        else {
+            // 2000/1/30 or 1/30/2000
+            const yearFirst = r[1].length > 2;
+            const yTmp = r[yearFirst ? 1 : 3];
+            y = +yTmp;
+            // year 0-29 is 2000-2029, 30-99 is 1930-1999
+            if (yTmp.length < 3)
+                y += y >= 30 ? 1900 : 2000;
+            m = +r[yearFirst ? 2 : 1];
+            d = +r[yearFirst ? 3 : 2];
+        }
+        if (y > 0 && m > 0 && m < 13 && d > 0 && d <= Date_daysInMonth(y, m))
+            return create(y, m, d);
+    }
+    return fail();
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,238 @@
+import Decimal from "./lib/big.js";
+import { symbol } from "./Numeric.js";
+import { FSharpRef } from "./Types.js";
+import { Exception, combineHashCodes } from "./Util.js";
+import { fromDecimal } from "./BigInt.js";
+import * as bigInt from "./BigInt.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 Exception(`The input string ${str} was not in a correct format.`);
+    }
+}
+export function toNumber(x) {
+    return +x;
+}
+export function toChar(x) {
+    const n = toNumber(x);
+    if (n < 0 || n > 65535 || isNaN(n)) {
+        throw new Exception("Value was either too large or too small for a character.");
+    }
+    return String.fromCharCode(n);
+}
+export function toInt8(x) { return bigInt.toInt8(fromDecimal(x)); }
+export function toUInt8(x) { return bigInt.toUInt8(fromDecimal(x)); }
+export function toInt16(x) { return bigInt.toInt16(fromDecimal(x)); }
+export function toUInt16(x) { return bigInt.toUInt16(fromDecimal(x)); }
+export function toInt32(x) { return bigInt.toInt32(fromDecimal(x)); }
+export function toUInt32(x) { return bigInt.toUInt32(fromDecimal(x)); }
+export function toInt64(x) { return bigInt.toInt64(fromDecimal(x)); }
+export function toUInt64(x) { return bigInt.toUInt64(fromDecimal(x)); }
+export function toInt128(x) { return bigInt.toInt128(fromDecimal(x)); }
+export function toUInt128(x) { return bigInt.toUInt128(fromDecimal(x)); }
+export function toNativeInt(x) { return bigInt.toNativeInt(fromDecimal(x)); }
+export function toUNativeInt(x) { return bigInt.toUNativeInt(fromDecimal(x)); }
+export function toFloat16(x) { return toNumber(x); }
+export function toFloat32(x) { return toNumber(x); }
+export function toFloat64(x) { return toNumber(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 decStr = d.toString();
+    const absStr = decStr[0] === "-" ? decStr.slice(1) : decStr;
+    const dotPos = absStr.indexOf(".");
+    const scale = dotPos < 0 ? 0 : absStr.length - dotPos - 1;
+    const mantissaStr = absStr.replace(".", "");
+    const decDigits = Uint8Array.from(mantissaStr, ch => ch.charCodeAt(0) - 48);
+    const hexDigits = decimalToHex(decDigits, bitSize);
+    const low = getInt32Bits(hexDigits, 0);
+    const mid = getInt32Bits(hexDigits, 8);
+    const high = getInt32Bits(hexDigits, 16);
+    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 Exception("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.5.2.0/Double.js

@@ -0,0 +1,47 @@
+import { FSharpRef } from "./Types.js";
+import { Exception } from "./Util.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 Exception(`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;
+}