compostjs 0.0.11 → 0.1.0

package/dist/fable_modules/fable-library-js.4.28.0/System.Collections.Generic.js

@@ -0,0 +1,317 @@
+import { disposeSafe, defaultOf, toIterator, getEnumerator, structuralHash, equals as equals_1, compare } from "./Util.js";
+import { class_type } from "./Reflection.js";
+import { toArray, empty, singleton, append, enumerateWhile, delay } from "./Seq.js";
+import { setItem, initialize, copyTo, fill, item as item_1 } from "./Array.js";
+import { max } from "./Double.js";
+export class Comparer$1 {
+    constructor(comparison) {
+        this.comparison = comparison;
+    }
+    Compare(x, y) {
+        const _ = this;
+        return _.comparison(x, y) | 0;
+    }
+}
+export function Comparer$1_$reflection(gen0) {
+    return class_type("System.Collections.Generic.Comparer`1", [gen0], Comparer$1);
+}
+export function Comparer$1_$ctor_47C913C(comparison) {
+    return new Comparer$1(comparison);
+}
+export function Comparer$1_get_Default() {
+    return Comparer$1_$ctor_47C913C(compare);
+}
+export function Comparer$1_Create_47C913C(comparison) {
+    return Comparer$1_$ctor_47C913C(comparison);
+}
+export function Comparer$1__Compare_5BDDA0(_, x, y) {
+    return _.comparison(x, y);
+}
+export class EqualityComparer$1 {
+    constructor(equals, getHashCode) {
+        this.equals = equals;
+        this.getHashCode = getHashCode;
+    }
+    Equals(x, y) {
+        const _ = this;
+        return _.equals(x, y);
+    }
+    GetHashCode(x) {
+        const _ = this;
+        return _.getHashCode(x) | 0;
+    }
+}
+export function EqualityComparer$1_$reflection(gen0) {
+    return class_type("System.Collections.Generic.EqualityComparer`1", [gen0], EqualityComparer$1);
+}
+export function EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode) {
+    return new EqualityComparer$1(equals, getHashCode);
+}
+export function EqualityComparer$1_get_Default() {
+    return EqualityComparer$1_$ctor_Z6EE254AB(equals_1, structuralHash);
+}
+export function EqualityComparer$1_Create_Z6EE254AB(equals, getHashCode) {
+    return EqualityComparer$1_$ctor_Z6EE254AB(equals, getHashCode);
+}
+export function EqualityComparer$1__Equals_5BDDA0(_, x, y) {
+    return _.equals(x, y);
+}
+export function EqualityComparer$1__GetHashCode_2B595(_, x) {
+    return _.getHashCode(x);
+}
+export class Stack$1 {
+    constructor(initialContents, initialCount) {
+        this.contents = initialContents;
+        this.count = (initialCount | 0);
+    }
+    GetEnumerator() {
+        const _ = this;
+        return getEnumerator(delay(() => {
+            let index = _.count - 1;
+            return enumerateWhile(() => (index >= 0), delay(() => append(singleton(item_1(index, _.contents)), delay(() => {
+                index = ((index - 1) | 0);
+                return empty();
+            }))));
+        }));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+}
+export function Stack$1_$reflection(gen0) {
+    return class_type("System.Collections.Generic.Stack`1", [gen0], Stack$1);
+}
+function Stack$1_$ctor_Z3B4C077E(initialContents, initialCount) {
+    return new Stack$1(initialContents, initialCount);
+}
+export function Stack$1_$ctor_Z524259A4(initialCapacity) {
+    return Stack$1_$ctor_Z3B4C077E(fill(new Array(initialCapacity), 0, initialCapacity, null), 0);
+}
+export function Stack$1_$ctor() {
+    return Stack$1_$ctor_Z524259A4(4);
+}
+export function Stack$1_$ctor_BB573A(xs) {
+    const arr = Array.from(xs);
+    return Stack$1_$ctor_Z3B4C077E(arr, arr.length);
+}
+export function Stack$1__Ensure_Z524259A4(_, newSize) {
+    const oldSize = _.contents.length | 0;
+    if (newSize > oldSize) {
+        const old = _.contents;
+        _.contents = fill(new Array(max(newSize, oldSize * 2)), 0, max(newSize, oldSize * 2), null);
+        copyTo(old, 0, _.contents, 0, _.count);
+    }
+}
+export function Stack$1__get_Count(_) {
+    return _.count;
+}
+export function Stack$1__Pop(_) {
+    _.count = ((_.count - 1) | 0);
+    return item_1(_.count, _.contents);
+}
+export function Stack$1__Peek(_) {
+    return item_1(_.count - 1, _.contents);
+}
+export function Stack$1__Contains_2B595(_, x) {
+    let found = false;
+    let i = 0;
+    while ((i < _.count) && !found) {
+        if (equals_1(x, item_1(i, _.contents))) {
+            found = true;
+        }
+        else {
+            i = ((i + 1) | 0);
+        }
+    }
+    return found;
+}
+export function Stack$1__TryPeek_1F3DB691(this$, result) {
+    if (this$.count > 0) {
+        result.contents = Stack$1__Peek(this$);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Stack$1__TryPop_1F3DB691(this$, result) {
+    if (this$.count > 0) {
+        result.contents = Stack$1__Pop(this$);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function Stack$1__Push_2B595(this$, x) {
+    Stack$1__Ensure_Z524259A4(this$, this$.count + 1);
+    this$.contents[this$.count] = x;
+    this$.count = ((this$.count + 1) | 0);
+}
+export function Stack$1__Clear(_) {
+    _.count = 0;
+    fill(_.contents, 0, _.contents.length, defaultOf());
+}
+export function Stack$1__TrimExcess(this$) {
+    if ((this$.count / this$.contents.length) > 0.9) {
+        Stack$1__Ensure_Z524259A4(this$, this$.count);
+    }
+}
+export function Stack$1__ToArray(_) {
+    return initialize(_.count, (i) => item_1((_.count - 1) - i, _.contents));
+}
+export class Queue$1 {
+    constructor(initialContents, initialCount) {
+        this.contents = initialContents;
+        this.count = (initialCount | 0);
+        this.head = 0;
+        this.tail = (((initialCount === this.contents.length) ? 0 : initialCount) | 0);
+    }
+    GetEnumerator() {
+        const _ = this;
+        return getEnumerator(Queue$1__toSeq(_));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+}
+export function Queue$1_$reflection(gen0) {
+    return class_type("System.Collections.Generic.Queue`1", [gen0], Queue$1);
+}
+function Queue$1_$ctor_Z3B4C077E(initialContents, initialCount) {
+    return new Queue$1(initialContents, initialCount);
+}
+export function Queue$1_$ctor_Z524259A4(initialCapacity) {
+    if (initialCapacity < 0) {
+        throw new Error("capacity is less than 0");
+    }
+    return Queue$1_$ctor_Z3B4C077E(fill(new Array(initialCapacity), 0, initialCapacity, null), 0);
+}
+export function Queue$1_$ctor() {
+    return Queue$1_$ctor_Z524259A4(4);
+}
+export function Queue$1_$ctor_BB573A(xs) {
+    const arr = Array.from(xs);
+    return Queue$1_$ctor_Z3B4C077E(arr, arr.length);
+}
+export function Queue$1__get_Count(_) {
+    return _.count;
+}
+export function Queue$1__Enqueue_2B595(_, value) {
+    if (_.count === Queue$1__size(_)) {
+        Queue$1__ensure_Z524259A4(_, _.count + 1);
+    }
+    _.contents[_.tail] = value;
+    _.tail = (((_.tail + 1) % Queue$1__size(_)) | 0);
+    _.count = ((_.count + 1) | 0);
+}
+export function Queue$1__Dequeue(_) {
+    if (_.count === 0) {
+        throw new Error("Queue is empty");
+    }
+    const value = item_1(_.head, _.contents);
+    _.head = (((_.head + 1) % Queue$1__size(_)) | 0);
+    _.count = ((_.count - 1) | 0);
+    return value;
+}
+export function Queue$1__Peek(_) {
+    if (_.count === 0) {
+        throw new Error("Queue is empty");
+    }
+    return item_1(_.head, _.contents);
+}
+export function Queue$1__TryDequeue_1F3DB691(this$, result) {
+    if (this$.count === 0) {
+        return false;
+    }
+    else {
+        result.contents = Queue$1__Dequeue(this$);
+        return true;
+    }
+}
+export function Queue$1__TryPeek_1F3DB691(this$, result) {
+    if (this$.count === 0) {
+        return false;
+    }
+    else {
+        result.contents = Queue$1__Peek(this$);
+        return true;
+    }
+}
+export function Queue$1__Contains_2B595(_, x) {
+    let found = false;
+    let i = 0;
+    while ((i < _.count) && !found) {
+        if (equals_1(x, item_1(Queue$1__toIndex_Z524259A4(_, i), _.contents))) {
+            found = true;
+        }
+        else {
+            i = ((i + 1) | 0);
+        }
+    }
+    return found;
+}
+export function Queue$1__Clear(_) {
+    _.count = 0;
+    _.head = 0;
+    _.tail = 0;
+    fill(_.contents, 0, Queue$1__size(_), defaultOf());
+}
+export function Queue$1__TrimExcess(_) {
+    if ((_.count / _.contents.length) > 0.9) {
+        Queue$1__ensure_Z524259A4(_, _.count);
+    }
+}
+export function Queue$1__ToArray(_) {
+    return toArray(Queue$1__toSeq(_));
+}
+export function Queue$1__CopyTo_Z3B4C077E(_, target, start) {
+    let i = start;
+    const enumerator = getEnumerator(Queue$1__toSeq(_));
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            setItem(target, i, item);
+            i = ((i + 1) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+}
+export function Queue$1__size(this$) {
+    return this$.contents.length;
+}
+export function Queue$1__toIndex_Z524259A4(this$, i) {
+    return (this$.head + i) % Queue$1__size(this$);
+}
+export function Queue$1__ensure_Z524259A4(this$, requiredSize) {
+    const newBuffer = fill(new Array(requiredSize), 0, requiredSize, null);
+    if (this$.head < this$.tail) {
+        copyTo(this$.contents, this$.head, newBuffer, 0, this$.count);
+    }
+    else {
+        copyTo(this$.contents, this$.head, newBuffer, 0, Queue$1__size(this$) - this$.head);
+        copyTo(this$.contents, 0, newBuffer, Queue$1__size(this$) - this$.head, this$.tail);
+    }
+    this$.head = 0;
+    this$.contents = newBuffer;
+    this$.tail = (((this$.count === Queue$1__size(this$)) ? 0 : this$.count) | 0);
+}
+export function Queue$1__toSeq(this$) {
+    return delay(() => {
+        let i = 0;
+        return enumerateWhile(() => (i < this$.count), delay(() => append(singleton(item_1(Queue$1__toIndex_Z524259A4(this$, i), this$.contents)), delay(() => {
+            i = ((i + 1) | 0);
+            return empty();
+        }))));
+    });
+}

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

@@ -0,0 +1,38 @@
+import { float64, int32 } from "./Int32.js";
+import { TypeInfo } from "./Reflection.js";
+export declare class StringBuilder {
+    readonly buf: string[];
+    constructor(value: string, capacity: int32);
+    toString(): string;
+}
+export declare function StringBuilder_$reflection(): TypeInfo;
+export declare function StringBuilder_$ctor_Z18115A39(value: string, capacity: int32): StringBuilder;
+export declare function StringBuilder_$ctor_Z524259A4(capacity: int32): StringBuilder;
+export declare function StringBuilder_$ctor_Z721C83C5(value: string): StringBuilder;
+export declare function StringBuilder_$ctor(): StringBuilder;
+export declare function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
+export declare function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder;
+export declare function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder;
+export declare function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder;
+export declare function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder;
+export declare function StringBuilder__Append_Z1FBCCD16(x: StringBuilder, o: boolean): StringBuilder;
+export declare function StringBuilder__Append_4E60E31B(x: StringBuilder, o: any): StringBuilder;
+export declare function StringBuilder__Append_Z372E4D23(x: StringBuilder, cs: string[]): StringBuilder;
+export declare function StringBuilder__Append_43A65C09(x: StringBuilder, s: StringBuilder): StringBuilder;
+export declare function StringBuilder__AppendFormat_433E080(x: StringBuilder, fmt: string, o: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z3B30EC65(x: StringBuilder, fmt: string, o1: any, o2: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_10D165E0(x: StringBuilder, fmt: string, o1: any, o2: any, o3: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z17053F5(x: StringBuilder, fmt: string, arr: any[]): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z696D8D1B(x: StringBuilder, provider: any, fmt: string, o: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_26802C9E(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_Z471ADCBB(x: StringBuilder, provider: any, fmt: string, o1: any, o2: any, o3: any): StringBuilder;
+export declare function StringBuilder__AppendFormat_6C2E3E6E(x: StringBuilder, provider: any, fmt: string, arr: any[]): StringBuilder;
+export declare function StringBuilder__AppendLine(x: StringBuilder): StringBuilder;
+export declare function StringBuilder__AppendLine_Z721C83C5(x: StringBuilder, s: string): StringBuilder;
+export declare function StringBuilder__Clear(x: StringBuilder): StringBuilder;
+export declare function StringBuilder__get_Chars_Z524259A4(x: StringBuilder, index: int32): string;
+export declare function StringBuilder__set_Chars_413E0D0A(x: StringBuilder, index: int32, value: string): void;
+export declare function StringBuilder__Replace_Z766F94C0(x: StringBuilder, oldValue: string, newValue: string): StringBuilder;
+export declare function StringBuilder__Replace_Z384F8060(x: StringBuilder, oldValue: string, newValue: string): StringBuilder;
+export declare function StringBuilder__get_Length(x: StringBuilder): int32;
+export declare function StringBuilder__ToString_Z37302880(x: StringBuilder, firstIndex: int32, length: int32): string;

package/dist/fable_modules/fable-library-js.4.28.0/System.Text.js

@@ -0,0 +1,162 @@
+import { replace, format, substring, isNullOrEmpty, join } from "./String.js";
+import { class_type } from "./Reflection.js";
+import { clear, int32ToString } from "./Util.js";
+import { toString } from "./Types.js";
+export class StringBuilder {
+    constructor(value, capacity) {
+        this.buf = [];
+        if (!isNullOrEmpty(value)) {
+            void (this.buf.push(value));
+        }
+    }
+    toString() {
+        const _ = this;
+        return join("", _.buf);
+    }
+}
+export function StringBuilder_$reflection() {
+    return class_type("System.Text.StringBuilder", undefined, StringBuilder);
+}
+export function StringBuilder_$ctor_Z18115A39(value, capacity) {
+    return new StringBuilder(value, capacity);
+}
+export function StringBuilder_$ctor_Z524259A4(capacity) {
+    return StringBuilder_$ctor_Z18115A39("", capacity);
+}
+export function StringBuilder_$ctor_Z721C83C5(value) {
+    return StringBuilder_$ctor_Z18115A39(value, 16);
+}
+export function StringBuilder_$ctor() {
+    return StringBuilder_$ctor_Z18115A39("", 16);
+}
+export function StringBuilder__Append_Z721C83C5(x, s) {
+    void (x.buf.push(s));
+    return x;
+}
+export function StringBuilder__Append_487EF8FB(x, s, startIndex, count) {
+    void (x.buf.push(substring(s, startIndex, count)));
+    return x;
+}
+export function StringBuilder__Append_244C7CD6(x, c) {
+    void (x.buf.push(c));
+    return x;
+}
+export function StringBuilder__Append_Z524259A4(x, o) {
+    void (x.buf.push(int32ToString(o)));
+    return x;
+}
+export function StringBuilder__Append_5E38073B(x, o) {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+export function StringBuilder__Append_Z1FBCCD16(x, o) {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+export function StringBuilder__Append_4E60E31B(x, o) {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+export function StringBuilder__Append_Z372E4D23(x, cs) {
+    void (x.buf.push(cs.join('')));
+    return x;
+}
+export function StringBuilder__Append_43A65C09(x, s) {
+    void (x.buf.push(toString(s)));
+    return x;
+}
+export function StringBuilder__AppendFormat_433E080(x, fmt, o) {
+    void (x.buf.push(format(fmt, o)));
+    return x;
+}
+export function StringBuilder__AppendFormat_Z3B30EC65(x, fmt, o1, o2) {
+    void (x.buf.push(format(fmt, o1, o2)));
+    return x;
+}
+export function StringBuilder__AppendFormat_10D165E0(x, fmt, o1, o2, o3) {
+    void (x.buf.push(format(fmt, o1, o2, o3)));
+    return x;
+}
+export function StringBuilder__AppendFormat_Z17053F5(x, fmt, arr) {
+    void (x.buf.push(format(fmt, ...arr)));
+    return x;
+}
+export function StringBuilder__AppendFormat_Z696D8D1B(x, provider, fmt, o) {
+    void (x.buf.push(format(provider, fmt, o)));
+    return x;
+}
+export function StringBuilder__AppendFormat_26802C9E(x, provider, fmt, o1, o2) {
+    void (x.buf.push(format(provider, fmt, o1, o2)));
+    return x;
+}
+export function StringBuilder__AppendFormat_Z471ADCBB(x, provider, fmt, o1, o2, o3) {
+    void (x.buf.push(format(provider, fmt, o1, o2, o3)));
+    return x;
+}
+export function StringBuilder__AppendFormat_6C2E3E6E(x, provider, fmt, arr) {
+    void (x.buf.push(format(provider, fmt, ...arr)));
+    return x;
+}
+export function StringBuilder__AppendLine(x) {
+    void (x.buf.push("\n"));
+    return x;
+}
+export function StringBuilder__AppendLine_Z721C83C5(x, s) {
+    void (x.buf.push(s));
+    void (x.buf.push("\n"));
+    return x;
+}
+export function StringBuilder__Clear(x) {
+    clear(x.buf);
+    return x;
+}
+export function StringBuilder__get_Chars_Z524259A4(x, index) {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos = ((len - index) - 1) | 0;
+        return x.buf[i][pos];
+    }
+}
+export function StringBuilder__set_Chars_413E0D0A(x, index, value) {
+    let len = 0;
+    let i = -1;
+    while (((i + 1) < x.buf.length) && (len < index)) {
+        i = ((i + 1) | 0);
+        len = ((len + x.buf[i].length) | 0);
+    }
+    if (((index < 0) ? true : (i < 0)) ? true : (i >= x.buf.length)) {
+        throw new Error("Index was outside the bounds of the array");
+    }
+    else {
+        const pos = ((len - index) - 1) | 0;
+        x.buf[i] = ((x.buf[i].slice(0, (pos - 1) + 1) + value) + x.buf[i].slice(pos + 1, x.buf[i].length));
+    }
+}
+export function StringBuilder__Replace_Z766F94C0(x, oldValue, newValue) {
+    for (let i = x.buf.length - 1; i >= 0; i--) {
+        x.buf[i] = replace(x.buf[i], oldValue, newValue);
+    }
+    return x;
+}
+export function StringBuilder__Replace_Z384F8060(x, oldValue, newValue) {
+    const str = replace(toString(x), oldValue, newValue);
+    return StringBuilder__Append_Z721C83C5(StringBuilder__Clear(x), str);
+}
+export function StringBuilder__get_Length(x) {
+    let len = 0;
+    for (let i = x.buf.length - 1; i >= 0; i--) {
+        len = ((len + x.buf[i].length) | 0);
+    }
+    return len | 0;
+}
+export function StringBuilder__ToString_Z37302880(x, firstIndex, length) {
+    return substring(toString(x), firstIndex, length);
+}

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

@@ -0,0 +1,5 @@
+import { Exception } from "./Types.js";
+export declare class SystemException extends Exception {
+}
+export declare class TimeoutException extends SystemException {
+}

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

@@ -0,0 +1,5 @@
+import { Exception } from "./Types.js";
+export class SystemException extends Exception {
+}
+export class TimeoutException extends SystemException {
+}

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

@@ -0,0 +1,15 @@
+import { FSharpRef } from "./Types.js";
+import { IDateTime } from "./Util.js";
+export declare function create(h?: number, m?: number, s?: number, ms?: number): number;
+export declare function fromTicks(ticks: number | bigint): number;
+export declare function fromTimeSpan(timeSpan: number): number;
+export declare function fromDateTime(d: IDateTime): number;
+export declare function maxValue(): number;
+export declare function add(t: number, ts: number, wrappedDays?: FSharpRef<number>): number;
+export declare function addHours(t: number, h: number): number;
+export declare function addMinutes(t: number, m: number): number;
+export declare function isBetween(t: number, start: number, end: number): boolean;
+export declare function toString(t: number, format?: string, _provider?: any): string;
+export declare function parse(str: string): number;
+export declare function tryParse(v: string, defValue: FSharpRef<number>): boolean;
+export declare function op_Subtraction(left: number, right: number): number;

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

@@ -0,0 +1,122 @@
+import { hours, minutes, seconds, milliseconds } from "./TimeSpan.js";
+import { padWithZeros } from "./Util.js";
+const millisecondsPerDay = 86400000;
+export function create(h = 0, m = 0, s = 0, ms = 0) {
+    if (h < 0 || m < 0 || s < 0 || ms < 0)
+        throw new Error("The parameters describe an unrepresentable TimeOnly.");
+    return h * 3600000 + m * 60000 + s * 1000 + ms;
+}
+export function fromTicks(ticks) {
+    return Number(BigInt(ticks) / 10000n);
+}
+export function fromTimeSpan(timeSpan) {
+    if (timeSpan < 0 || timeSpan >= millisecondsPerDay)
+        throw new Error("The TimeSpan describes an unrepresentable TimeOnly.");
+    return timeSpan;
+}
+export function fromDateTime(d) {
+    return d.kind === 1 /* DateKind.UTC */
+        ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())
+        : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+}
+export function maxValue() {
+    // This is "23:59:59.999"
+    return millisecondsPerDay - 1;
+}
+export function add(t, ts, wrappedDays) {
+    if (wrappedDays === undefined) {
+        const t2 = (t + ts) % millisecondsPerDay;
+        return t2 < 0 ? millisecondsPerDay + t2 : t2;
+    }
+    wrappedDays.contents = ts / millisecondsPerDay;
+    let newMs = t + ts % millisecondsPerDay;
+    if (newMs < 0) {
+        wrappedDays.contents--;
+        newMs += millisecondsPerDay;
+    }
+    else {
+        if (newMs >= millisecondsPerDay) {
+            wrappedDays.contents++;
+            newMs -= millisecondsPerDay;
+        }
+    }
+    return newMs;
+}
+export function addHours(t, h) {
+    return add(t, h * 3600000);
+}
+export function addMinutes(t, m) {
+    return add(t, m * 60000);
+}
+export function isBetween(t, start, end) {
+    return start <= end
+        ? (start <= t && end > t)
+        : (start <= t || end > t);
+}
+export function toString(t, format = "t", _provider) {
+    if (["r", "R", "o", "O", "t", "T"].indexOf(format) === -1) {
+        throw new Error("Custom formats are not supported");
+    }
+    const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;
+    if (format === "t")
+        return base;
+    const s = padWithZeros(seconds(t), 2);
+    // We're limited to millisecond precision, so the last 4 digits will always be 0
+    return `${base}${format === "o" || format === "O" ? `:${s}.${padWithZeros(milliseconds(t), 3)}0000` : `:${s}`}`;
+}
+export function parse(str) {
+    // Allowed format types:
+    // hh:mm
+    // hh:mm:ss
+    // hh:mm:ss.fffffff
+    const r = /^\s*([0-1]?\d|2[0-3])\s*:\s*([0-5]?\d)(\s*:\s*([0-5]?\d)(\.(\d+))?)?\s*$/.exec(str);
+    if (r != null && r[1] != null && r[2] != null) {
+        let ms = 0;
+        let s = 0;
+        const h = +r[1];
+        const m = +r[2];
+        if (r[4] != null) {
+            s = +r[4];
+        }
+        if (r[6] != null) {
+            // Depending on the number of decimals passed, we need to adapt the numbers
+            switch (r[6].length) {
+                case 1:
+                    ms = +r[6] * 100;
+                    break;
+                case 2:
+                    ms = +r[6] * 10;
+                    break;
+                case 3:
+                    ms = +r[6];
+                    break;
+                case 4:
+                    ms = +r[6] / 10;
+                    break;
+                case 5:
+                    ms = +r[6] / 100;
+                    break;
+                case 6:
+                    ms = +r[6] / 1000;
+                    break;
+                default:
+                    ms = +r[6].substring(0, 7) / 10000;
+                    break;
+            }
+        }
+        return create(h, m, s, Math.trunc(ms));
+    }
+    throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function op_Subtraction(left, right) {
+    return add(left, -right);
+}