@fable-org/fable-library-ts 1.0.0-beta-001

package/System.Collections.Generic.ts

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

package/System.Text.ts

@@ -0,0 +1,137 @@
+import { replace, format, substring, isNullOrEmpty, join } from "./String.js";
+import { float64, int32 } from "./Int32.js";
+import { class_type, TypeInfo } from "./Reflection.js";
+import { clear, int32ToString } from "./Util.js";
+import { toString } from "./Types.js";
+
+export class StringBuilder {
+    readonly buf: string[];
+    constructor(value: string, capacity: int32) {
+        this.buf = [];
+        if (!isNullOrEmpty(value)) {
+            void (this.buf.push(value));
+        }
+    }
+    toString(): string {
+        const _: StringBuilder = this;
+        return join("", _.buf);
+    }
+}
+
+export function StringBuilder_$reflection(): TypeInfo {
+    return class_type("System.Text.StringBuilder", void 0, StringBuilder);
+}
+
+export function StringBuilder_$ctor_Z18115A39(value: string, capacity: int32): StringBuilder {
+    return new StringBuilder(value, capacity);
+}
+
+export function StringBuilder_$ctor_Z524259A4(capacity: int32): StringBuilder {
+    return StringBuilder_$ctor_Z18115A39("", capacity);
+}
+
+export function StringBuilder_$ctor_Z721C83C5(value: string): StringBuilder {
+    return StringBuilder_$ctor_Z18115A39(value, 16);
+}
+
+export function StringBuilder_$ctor(): StringBuilder {
+    return StringBuilder_$ctor_Z18115A39("", 16);
+}
+
+export function StringBuilder__Append_Z721C83C5(x: StringBuilder, s: string): StringBuilder {
+    void (x.buf.push(s));
+    return x;
+}
+
+export function StringBuilder__Append_487EF8FB(x: StringBuilder, s: string, startIndex: int32, count: int32): StringBuilder {
+    void (x.buf.push(substring(s, startIndex, count)));
+    return x;
+}
+
+export function StringBuilder__Append_244C7CD6(x: StringBuilder, c: string): StringBuilder {
+    void (x.buf.push(c));
+    return x;
+}
+
+export function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder {
+    void (x.buf.push(int32ToString(o)));
+    return x;
+}
+
+export function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
+export function StringBuilder__Append_Z1FBCCD16(x: StringBuilder, o: boolean): StringBuilder {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+
+export function StringBuilder__Append_4E60E31B(x: StringBuilder, o: any): StringBuilder {
+    void (x.buf.push(toString(o)));
+    return x;
+}
+
+export function StringBuilder__Append_Z372E4D23(x: StringBuilder, cs: string[]): StringBuilder {
+    void (x.buf.push(cs.join('')));
+    return x;
+}
+
+export function StringBuilder__Append_43A65C09(x: StringBuilder, s: StringBuilder): StringBuilder {
+    void (x.buf.push(toString(s)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_433E080(x: StringBuilder, fmt: string, o: any): StringBuilder {
+    void (x.buf.push(format(fmt, o)));
+    return x;
+}
+
+export function StringBuilder__AppendFormat_Z696D8D1B(x: StringBuilder, provider: any, fmt: string, o: any): StringBuilder {
+    void (x.buf.push(format(provider, fmt, o)));
+    return x;
+}
+
+export function StringBuilder__AppendLine(x: StringBuilder): StringBuilder {
+    void (x.buf.push("\n"));
+    return x;
+}
+
+export function StringBuilder__AppendLine_Z721C83C5(x: StringBuilder, s: string): StringBuilder {
+    void (x.buf.push(s));
+    void (x.buf.push("\n"));
+    return x;
+}
+
+export function StringBuilder__Replace_Z766F94C0(x: StringBuilder, oldValue: string, newValue: string): StringBuilder {
+    for (let i: int32 = x.buf.length - 1; i >= 0; i--) {
+        x.buf[i] = replace(x.buf[i], oldValue, newValue);
+    }
+    return x;
+}
+
+export function StringBuilder__Replace_Z384F8060(x: StringBuilder, oldValue: string, newValue: string): StringBuilder {
+    for (let i: int32 = x.buf.length - 1; i >= 0; i--) {
+        x.buf[i] = replace(x.buf[i], oldValue, newValue);
+    }
+    return x;
+}
+
+export function StringBuilder__get_Length(x: StringBuilder): int32 {
+    let len = 0;
+    for (let i: int32 = x.buf.length - 1; i >= 0; i--) {
+        len = ((len + x.buf[i].length) | 0);
+    }
+    return len | 0;
+}
+
+export function StringBuilder__ToString_Z37302880(x: StringBuilder, firstIndex: int32, length: int32): string {
+    return substring(toString(x), firstIndex, length);
+}
+
+export function StringBuilder__Clear(x: StringBuilder): StringBuilder {
+    clear(x.buf);
+    return x;
+}
+

package/SystemException.ts

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

package/TimeOnly.ts

@@ -0,0 +1,131 @@
+import { FSharpRef } from "./Types.js";
+import { hours, minutes, seconds, milliseconds } from "./TimeSpan.js";
+import { DateKind, IDateTime, padWithZeros } from "./Util.js";
+
+const millisecondsPerDay = 86400000;
+
+export function create(h: number = 0, m: number = 0, s: number = 0, ms: number = 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: number | bigint) {
+  return Number(BigInt(ticks) / 10000n);
+}
+
+export function fromTimeSpan(timeSpan: number) {
+  if (timeSpan < 0 || timeSpan >= millisecondsPerDay)
+    throw new Error("The TimeSpan describes an unrepresentable TimeOnly.");
+
+  return timeSpan;
+}
+
+export function fromDateTime(d: IDateTime) {
+  return d.kind === 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: number, ts: number, wrappedDays?: FSharpRef<number>) {
+  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: number, h: number) {
+  return add(t, h * 3600000);
+}
+
+export function addMinutes(t: number, m: number) {
+  return add(t, m * 60000);
+}
+
+export function isBetween(t: number, start: number, end: number) {
+  return start <= end
+    ? (start <= t && end > t)
+    : (start <= t || end > t);
+}
+
+export function toString(t: number, format = "t", _provider?: any) {
+  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: string) {
+  // 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: string, defValue: FSharpRef<number>): boolean {
+  try {
+    defValue.contents = parse(v);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function op_Subtraction(left: number, right: number) {
+  return add(left, -right);
+}