compostjs 0.0.11 → 0.1.0

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

@@ -0,0 +1,63 @@
+/**
+ * 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 { int64 } from "./BigInt.js";
+import { FSharpRef } from "./Types.js";
+import { IDateTime, IDateTimeOffset } from "./Util.js";
+export default function DateTimeOffset(value: number, offset?: number): IDateTimeOffset;
+export declare function offset(value: IDateTimeOffset): number;
+export declare function fromDate(date: IDateTime, offset?: number): IDateTimeOffset;
+export declare function fromTicks(ticks: int64, offset: number): IDateTimeOffset;
+export declare function fromUnixTimeMilliseconds(ms: int64): IDateTimeOffset;
+export declare function fromUnixTimeSeconds(seconds: int64): IDateTimeOffset;
+export declare function getUtcTicks(date: IDateTimeOffset): bigint;
+export declare function minValue(): IDateTimeOffset;
+export declare function maxValue(): IDateTimeOffset;
+export declare function parse(str: string): IDateTimeOffset;
+export declare function tryParse(v: string, defValue: FSharpRef<IDateTimeOffset>): boolean;
+export declare function create(year: number, month: number, day: number, h: number, m: number, s: number, ms: number, offset?: number): IDateTimeOffset;
+export declare function now(): IDateTimeOffset;
+export declare function utcNow(): IDateTimeOffset;
+export declare function toUniversalTime(date: IDateTimeOffset): Date;
+export declare function toLocalTime(date: IDateTimeOffset): Date;
+export declare function timeOfDay(d: IDateTimeOffset): number;
+export declare function date(d: IDateTimeOffset): IDateTime;
+export declare function day(d: IDateTimeOffset): number;
+export declare function hour(d: IDateTimeOffset): number;
+export declare function millisecond(d: IDateTimeOffset): number;
+export declare function minute(d: IDateTimeOffset): number;
+export declare function month(d: IDateTimeOffset): number;
+export declare function second(d: IDateTimeOffset): number;
+export declare function year(d: IDateTimeOffset): number;
+export declare function dayOfWeek(d: IDateTimeOffset): number;
+export declare function dayOfYear(d: IDateTimeOffset): number;
+export declare function add(d: IDateTimeOffset, ts: number): IDateTimeOffset;
+export declare function addDays(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addHours(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addMinutes(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addSeconds(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addMilliseconds(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addTicks(d: IDateTimeOffset, v: int64): IDateTimeOffset;
+export declare function addYears(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function addMonths(d: IDateTimeOffset, v: number): IDateTimeOffset;
+export declare function subtract<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(d: IDateTimeOffset, that: Input): Output;
+export declare function equals(d1: IDateTimeOffset, d2: IDateTimeOffset): boolean;
+export declare function equalsExact(d1: IDateTimeOffset, d2: IDateTimeOffset): boolean;
+export declare function compare(d1: IDateTimeOffset, d2: IDateTimeOffset): 0 | 1 | -1;
+export declare const compareTo: typeof compare;
+export declare function op_Addition(x: IDateTimeOffset, y: number): IDateTimeOffset;
+export declare function op_Subtraction<Input extends number | IDateTimeOffset, Output = Input extends number ? IDateTimeOffset : number>(x: IDateTimeOffset, y: Input): Output;
+export declare function toOffset(d: IDateTimeOffset, offset: number): IDateTimeOffset;
+export declare function toUnixTimeMilliseconds(d: IDateTimeOffset): int64;
+export declare function toUnixTimeSeconds(d: IDateTimeOffset): int64;

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

@@ -0,0 +1,268 @@
+/**
+ * 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, dateOffsetToString, daysInMonth, parseRaw, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from "./Date.js";
+import { compareDates, padWithZeros } 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 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.");
+        }
+    }
+}
+export 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);
+}
+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;
+    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);
+}
+export function now() {
+    const date = new Date();
+    const offset = date.getTimezoneOffset() * -60000;
+    return DateTimeOffset(date.getTime(), offset);
+}
+export function utcNow() {
+    const date = now();
+    return DateTimeOffset(date.getTime(), 0);
+}
+export function toUniversalTime(date) {
+    return DateTime(date.getTime(), 1 /* DateKind.UTC */);
+}
+export function toLocalTime(date) {
+    return DateTime(date.getTime(), 2 /* DateKind.Local */);
+}
+export function timeOfDay(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return d2.getUTCHours() * 3600000
+        + d2.getUTCMinutes() * 60000
+        + d2.getUTCSeconds() * 1000
+        + d2.getUTCMilliseconds();
+}
+export function date(d) {
+    const d2 = new Date(d.getTime() + (d.offset ?? 0));
+    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);
+}
+export function day(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDate();
+}
+export function hour(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCHours();
+}
+export function millisecond(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMilliseconds();
+}
+export function minute(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMinutes();
+}
+export function month(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCMonth() + 1;
+}
+export function second(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCSeconds();
+}
+export function year(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCFullYear();
+}
+export function dayOfWeek(d) {
+    return new Date(d.getTime() + (d.offset ?? 0)).getUTCDay();
+}
+export 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;
+}
+export function add(d, ts) {
+    return DateTimeOffset(d.getTime() + ts, (d.offset ?? 0));
+}
+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(), (d.offset ?? 0));
+}
+export 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));
+}
+export function subtract(d, that) {
+    return typeof that === "number"
+        ? DateTimeOffset(d.getTime() - that, (d.offset ?? 0))
+        : 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.4.28.0/DateOnly.d.ts

@@ -0,0 +1,18 @@
+import { FSharpRef } from "./Types.js";
+import { IDateTime, DateKind } from "./Util.js";
+export declare function fromUnixMilliseconds(value: number): IDateTime;
+export declare function create(year: number, month: number, day: number): IDateTime;
+export declare function maxValue(): IDateTime;
+export declare function minValue(): IDateTime;
+export declare function dayNumber(d: IDateTime): number;
+export declare function fromDayNumber(dayNumber: number): IDateTime;
+export declare function fromDateTime(d: IDateTime): IDateTime;
+export declare function day(d: IDateTime): number;
+export declare function month(d: IDateTime): number;
+export declare function year(d: IDateTime): number;
+export declare function dayOfWeek(d: IDateTime): number;
+export declare function dayOfYear(d: IDateTime): number;
+export declare function toDateTime(d: IDateTime, time: number, kind?: DateKind): IDateTime;
+export declare function toString(d: IDateTime, format?: string, _provider?: any): string;
+export declare function parse(str: string): IDateTime;
+export declare function tryParse(v: string, defValue: FSharpRef<IDateTime>): boolean;

package/dist/fable_modules/fable-library-js.4.28.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 { padWithZeros } from "./Util.js";
+export function fromUnixMilliseconds(value) {
+    return DateTime(value, 1 /* DateKind.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 = 0 /* DateKind.Unspecified */) {
+    return DateTime(d.getTime() + time + (kind !== 1 /* DateKind.UTC */ ? d.getTimezoneOffset() : 0) * 60000, kind);
+}
+export function toString(d, format = "d", _provider) {
+    if (["d", "o", "O"].indexOf(format) === -1) {
+        throw new Error("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 Error(`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.4.28.0/Decimal.d.ts

@@ -0,0 +1,45 @@
+import Decimal from "./lib/big.js";
+import { FSharpRef } from "./Types.js";
+export default Decimal;
+export type decimal = Decimal;
+export declare const get_Zero: Decimal;
+export declare const get_One: Decimal;
+export declare const get_MinusOne: Decimal;
+export declare const get_MaxValue: Decimal;
+export declare const get_MinValue: Decimal;
+export declare function compare(x: Decimal, y: Decimal): import("./lib/big.js").Comparison;
+export declare function equals(x: Decimal, y: Decimal): boolean;
+export declare function abs(x: Decimal): Decimal;
+export declare function sign(x: Decimal): number;
+export declare function max(x: Decimal, y: Decimal): Decimal;
+export declare function min(x: Decimal, y: Decimal): Decimal;
+export declare function maxMagnitude(x: Decimal, y: Decimal): Decimal;
+export declare function minMagnitude(x: Decimal, y: Decimal): Decimal;
+export declare function clamp(x: Decimal, min: Decimal, max: Decimal): Decimal;
+export declare function round(x: Decimal, digits?: number): Decimal;
+export declare function truncate(x: Decimal): Decimal;
+export declare function ceiling(x: Decimal): Decimal;
+export declare function floor(x: Decimal): Decimal;
+export declare function pow(x: Decimal, n: number): Decimal;
+export declare function sqrt(x: Decimal): Decimal;
+export declare function op_Addition(x: Decimal, y: Decimal): Decimal;
+export declare function op_Subtraction(x: Decimal, y: Decimal): Decimal;
+export declare function op_Multiply(x: Decimal, y: Decimal): Decimal;
+export declare function op_Division(x: Decimal, y: Decimal): Decimal;
+export declare function op_Modulus(x: Decimal, y: Decimal): Decimal;
+export declare function op_UnaryNegation(x: Decimal): Decimal;
+export declare function op_UnaryPlus(x: Decimal): Decimal;
+export declare const add: typeof op_Addition;
+export declare const subtract: typeof op_Subtraction;
+export declare const multiply: typeof op_Multiply;
+export declare const divide: typeof op_Division;
+export declare const remainder: typeof op_Modulus;
+export declare const negate: typeof op_UnaryNegation;
+export declare function toString(x: Decimal): string;
+export declare function tryParse(str: string, defValue: FSharpRef<Decimal>): boolean;
+export declare function parse(str: string): Decimal;
+export declare function toNumber(x: Decimal): number;
+export declare function fromIntArray(bits: ArrayLike<number>): Decimal;
+export declare function fromInts(low: number, mid: number, high: number, signExp: number): Decimal;
+export declare function fromParts(low: number, mid: number, high: number, isNegative: boolean, scale: number): Decimal;
+export declare function getBits(d: Decimal): number[];