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

package/Double.ts

@@ -0,0 +1,55 @@
+import { FSharpRef } from "./Types.js";
+
+export function tryParse(str: string, defValue: FSharpRef<number>): boolean {
+  // 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: string): number {
+  const defValue = new FSharpRef(0);
+  if (tryParse(str, defValue)) {
+    return defValue.contents;
+  } else {
+    throw new Error(`The input string ${str} was not in a correct format.`);
+  }
+}
+
+// JS Number.isFinite function evals false for NaN
+export function isPositiveInfinity(x: number) {
+  return x === Number.POSITIVE_INFINITY;
+}
+
+export function isNegativeInfinity(x: number) {
+  return x === Number.NEGATIVE_INFINITY;
+}
+
+export function isInfinity(x: number) {
+  return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;
+}
+
+export function max(x: number, y: number): number {
+  return x > y ? x : y;
+}
+
+export function min(x: number, y: number): number {
+  return x < y ? x : y;
+}
+
+export function maxMagnitude(x: number, y: number): number {
+  return Math.abs(x) > Math.abs(y) ? x : y;
+}
+
+export function minMagnitude(x: number, y: number): number {
+  return Math.abs(x) < Math.abs(y) ? x : y;
+}
+
+export function clamp(x: number, min: number, max: number): number {
+  return x < min ? min : x > max ? max : x;
+}

package/Encoding.ts

@@ -0,0 +1,170 @@
+import { uint8 } from "./Int32.js";
+
+const littleEndian = true;
+
+function utf16le_encode(str: string) {
+  const bytes = new Uint8Array(str.length * 2);
+  const view = new DataView(bytes.buffer);
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    view.setUint16(i * 2, code, littleEndian);
+  }
+  return bytes;
+}
+
+function utf16le_decode(bytes: ArrayLike<uint8>) {
+  const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+  const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+  const chars = new Array<string>(view.byteLength / 2);
+  for (let i = 0; i < chars.length; i++) {
+    const code = view.getUint16(i * 2, littleEndian);
+    chars[i] = String.fromCharCode(code);
+  }
+  return chars.join("");
+}
+
+function utf8_encode(str: string) {
+  let pos = 0;
+  let buf = new Uint8Array(str.length * 3);
+  for (let i = 0; i < str.length; i++) {
+    let code = str.charCodeAt(i);
+    if (code >= 0xD800 && code <= 0xDBFF) {
+      const nextCode = (i < str.length) ? str.charCodeAt(i + 1) : 0;
+      if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
+        i += 1;
+        code = (code - 0xD800) * 0x400 + nextCode - 0xDC00 + 0x10000;
+        if (code > 0xFFFF) {
+          buf[pos++] = (0x1E << 3) | (code >>> 18);
+          buf[pos++] = (0x2 << 6) | ((code >>> 12) & 0x3F);
+          buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+          buf[pos++] = (0x2 << 6) | (code & 0x3F);
+        }
+      } else {
+        buf[pos++] = 0xEF;
+        buf[pos++] = 0xBF;
+        buf[pos++] = 0xBD;
+      }
+    } else if (code <= 0x007F) {
+      buf[pos++] = (0x0 << 7) | code;
+    } else if (code <= 0x07FF) {
+      buf[pos++] = (0x6 << 5) | (code >>> 6);
+      buf[pos++] = (0x2 << 6) | (code & 0x3F);
+    } else {
+      buf[pos++] = (0xE << 4) | (code >>> 12);
+      buf[pos++] = (0x2 << 6) | ((code >>> 6) & 0x3F);
+      buf[pos++] = (0x2 << 6) | (code & 0x3F);
+    }
+  }
+  buf = new Uint8Array(buf.buffer.slice(0, pos));
+  return buf;
+}
+
+function utf8_decode(bytes: ArrayLike<uint8>) {
+  let pos = 0;
+  const decodeUtf8 = () => {
+    const i1 = bytes[pos++];
+    if ((i1 & 0x80) === 0) {
+      return i1;
+    } else if ((i1 & 0xE0) === 0xC0) {
+      const i2 = bytes[pos++];
+      return ((i1 & 0x1F) << 6) | (i2 & 0x3F);
+    } else if ((i1 & 0xF0) === 0xE0) {
+      const i2 = bytes[pos++];
+      const i3 = bytes[pos++];
+      return ((i1 & 0x0F) << 12) | ((i2 & 0x3F) << 6) | (i3 & 0x3F);
+    } else if ((i1 & 0xF8) === 0xF0) {
+      const i2 = bytes[pos++];
+      const i3 = bytes[pos++];
+      const i4 = bytes[pos++];
+      return ((i1 & 0x07) << 18) | ((i2 & 0x3F) << 12) | ((i3 & 0x3F) << 6) | (i4 & 0x3F);
+    } else {
+      throw new RangeError("Invalid UTF8 byte: " + i1);
+    }
+  };
+  const chars = new Array<string>();
+  while (pos < bytes.length) {
+    const code = decodeUtf8();
+    chars.push(String.fromCodePoint(code));
+  }
+  return chars.join("");
+}
+
+class UTF16LE {
+
+  public getBytes(str: string | string[], index?: number, count?: number) {
+    str = Array.isArray(str) ? str.join("") : str;
+    if (index != null && count != null) {
+      str = str.substring(index, index + count);
+    } else if (index != null) {
+      str = str.substring(index);
+    }
+    if (typeof Buffer !== "undefined") {
+      const bytes = Buffer.from(str, "utf16le");
+      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    } else {
+      return utf16le_encode(str); // polyfill
+    }
+  }
+
+  public getString(bytes: ArrayLike<uint8>, index?: number, count?: number) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    if (index != null && count != null) {
+      buffer = buffer.subarray(index, index + count);
+    } else if (index != null) {
+      buffer = buffer.subarray(index);
+    }
+    if (typeof TextDecoder !== "undefined") {
+      return new TextDecoder("utf-16le").decode(buffer);
+    } else if (typeof Buffer !== "undefined") {
+      return Buffer.from(buffer).toString("utf16le");
+    } else {
+      return utf16le_decode(buffer); // polyfill
+    }
+  }
+
+}
+
+class UTF8 {
+
+  public getBytes(str: string | string[], index?: number, count?: number) {
+    str = Array.isArray(str) ? str.join("") : str;
+    if (index != null && count != null) {
+      str = str.substring(index, index + count);
+    } else if (index != null) {
+      str = str.substring(index);
+    }
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(str);
+    } else if (typeof Buffer !== "undefined") {
+      const bytes = Buffer.from(str, "utf8");
+      return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    } else {
+      return utf8_encode(str); // polyfill
+    }
+  }
+
+  public getString(bytes: ArrayLike<uint8>, index?: number, count?: number) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    if (index != null && count != null) {
+      buffer = buffer.subarray(index, index + count);
+    } else if (index != null) {
+      buffer = buffer.subarray(index);
+    }
+    if (typeof TextDecoder !== "undefined") {
+      return new TextDecoder().decode(buffer);
+    } else if (typeof Buffer !== "undefined") {
+      return Buffer.from(buffer).toString("utf8");
+    } else {
+      return utf8_decode(buffer); // polyfill
+    }
+  }
+
+}
+
+const _UTF16 = new UTF16LE();
+const _UTF8 = new UTF8();
+
+export function get_Unicode() { return _UTF16; }
+export function get_UTF8() { return _UTF8; }

package/Event.ts

@@ -0,0 +1,119 @@
+import { IObservable, subscribe } from "./Observable.js";
+import { Option, some, value } from "./Option.js";
+import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+
+export type Handler<T> = (sender: any, x: T) => void;
+
+export interface IDelegateEvent<Delegate extends Function> {
+  AddHandler(d: Delegate): void;
+  RemoveHandler(d: Delegate): void;
+}
+
+export interface IEvent$2<Delegate extends Function, Args> extends IDelegateEvent<Delegate>, IObservable<Args> {
+}
+
+export type IEvent<T> = IEvent$2<Handler<T>, T>
+
+export class Event$2<Delegate extends Function, Args> {
+  private delegates: Delegate[] = [];
+
+  private _add(d: Delegate) {
+    this.delegates.push(d);
+  }
+
+  private _remove(d: Delegate) {
+    const index = this.delegates.indexOf(d);
+    if (index > -1) {
+      this.delegates.splice(index, 1);
+    }
+  }
+
+  get Publish(): IEvent$2<Delegate, Args> {
+    return createEvent(h => { this._add(h) }, h => { this._remove(h) });
+  }
+
+  public Trigger(value: Args): void;
+  public Trigger(sender: any, value: Args): void
+  public Trigger(senderOrValue: any, valueOrUndefined?: Args): void {
+    let sender: any = null;
+    const value = valueOrUndefined === undefined ? senderOrValue as Args : (sender = senderOrValue, valueOrUndefined);
+    this.delegates.forEach(f => { f(sender, value) });
+  }
+}
+
+export class Event<T> extends Event$2<Handler<T>, T> {
+}
+
+export function add<Del extends Function, T>(callback: (x: T) => void, sourceEvent: IEvent$2<Del, T>): void {
+  subscribe(callback, sourceEvent);
+}
+
+export function choose<Del extends Function, T, U>(chooser: (x: T) => Option<U>, sourceEvent: IEvent$2<Del, T>): IEvent<U> {
+  const ev = new Event<U>();
+  add((t) => {
+    const u = chooser(t);
+    if (u != null) { ev.Trigger(value(u)); }
+  }, sourceEvent);
+  return ev.Publish;
+}
+
+export function filter<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): IEvent<T> {
+  return choose((x) => predicate(x) ? some(x) : undefined, sourceEvent);
+}
+
+export function map<Del extends Function, T, U>(mapping: (x: T) => U, sourceEvent: IEvent$2<Del, T>): IEvent<U> {
+  const ev = new Event<U>();
+  add((t) => ev.Trigger(mapping(t)), sourceEvent);
+  return ev.Publish;
+}
+
+export function merge<Del1 extends Function, Del2 extends Function, T>(event1: IEvent$2<Del1, T>, event2: IEvent$2<Del2, T>): IEvent<T> {
+  const ev = new Event<T>();
+  const fn = (x: T) => ev.Trigger(x);
+  add(fn, event1);
+  add(fn, event2);
+  return ev.Publish;
+}
+
+export function pairwise<Del extends Function, T>(sourceEvent: IEvent$2<Del, T>): IEvent<[T, T]> {
+  const ev = new Event<[T, T]>();
+  let last: T;
+  let haveLast = false;
+  add((next) => {
+    if (haveLast) {
+      ev.Trigger([last, next]);
+    }
+    last = next;
+    haveLast = true;
+  }, sourceEvent);
+  return ev.Publish;
+}
+
+export function partition<Del extends Function, T>(predicate: (x: T) => boolean, sourceEvent: IEvent$2<Del, T>): [IEvent<T>, IEvent<T>] {
+  return [filter(predicate, sourceEvent), filter((x) => !predicate(x), sourceEvent)];
+}
+
+export function scan<Del extends Function, U, T>(collector: (u: U, t: T) => U, state: U, sourceEvent: IEvent$2<Del, T>): IEvent<U> {
+  return map((t) => state = collector(state, t), sourceEvent);
+}
+
+export function split<Del extends Function, T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, sourceEvent: IEvent$2<Del, T>): [IEvent<U1>, IEvent<U2>] {
+  return [
+    choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), sourceEvent),
+    choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), sourceEvent),
+  ];
+}
+
+export function createEvent<Del extends Function, T>(addHandler: (h: Del) => void, removeHandler: (h: Del) => void): IEvent$2<Del, T> {
+  return {
+    AddHandler(h) { addHandler(h); },
+    RemoveHandler(h) { removeHandler(h); },
+    Subscribe(r) {
+      const h = ((_: any, args: T) => r.OnNext(args)) as unknown as Del;
+      addHandler(h);
+      return {
+        Dispose() { removeHandler(h); }
+      };
+    }
+  };
+}

package/FSharp.Collections.ts

@@ -0,0 +1,34 @@
+import { int32 } from "./Int32.js";
+import { compare, IComparer, physicalHash, equals, structuralHash, IEqualityComparer } from "./Util.js";
+
+export function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T> {
+    return {
+        Equals(x: T, y: T): boolean {
+            return eq(x, y);
+        },
+        GetHashCode(x_1: T): int32 {
+            return hash(x_1);
+        },
+    };
+}
+
+export function HashIdentity_Structural<T>(): IEqualityComparer<T> {
+    return HashIdentity_FromFunctions<T>(structuralHash, equals);
+}
+
+export function HashIdentity_Reference<T>(): IEqualityComparer<T> {
+    return HashIdentity_FromFunctions<T>(physicalHash, (e: T, e_1: T): boolean => (e === e_1));
+}
+
+export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T> {
+    return {
+        Compare(x: T, y: T): int32 {
+            return comparer(x, y);
+        },
+    };
+}
+
+export function ComparisonIdentity_Structural<T>(): IComparer<T> {
+    return ComparisonIdentity_FromFunction<T>(compare);
+}
+

package/FSharp.Core.CompilerServices.ts

@@ -0,0 +1,37 @@
+import { class_type, TypeInfo } from "./Reflection.js";
+import { addRangeInPlace } from "./Array.js";
+import { toList } from "./Seq.js";
+import { FSharpList } from "./List.js";
+
+export class ListCollector$1<T> {
+    readonly collector: T[];
+    constructor() {
+        this.collector = [];
+    }
+}
+
+export function ListCollector$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
+}
+
+export function ListCollector$1_$ctor<T>(): ListCollector$1<T> {
+    return new ListCollector$1();
+}
+
+export function ListCollector$1__Add_2B595<T>(this$: ListCollector$1<T>, value: T): void {
+    void (this$.collector.push(value));
+}
+
+export function ListCollector$1__AddMany_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): void {
+    addRangeInPlace(values, this$.collector);
+}
+
+export function ListCollector$1__AddManyAndClose_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): FSharpList<T> {
+    addRangeInPlace(values, this$.collector);
+    return toList<T>(this$.collector);
+}
+
+export function ListCollector$1__Close<T>(this$: ListCollector$1<T>): FSharpList<T> {
+    return toList<T>(this$.collector);
+}
+

package/FSharp.Core.ts

@@ -0,0 +1,86 @@
+import { IDisposable, disposeSafe, defaultOf, IEqualityComparer, IComparer, structuralHash, equals } from "./Util.js";
+import { int32 } from "./Int32.js";
+import { HashIdentity_Structural, ComparisonIdentity_Structural } from "./FSharp.Collections.js";
+import { Option } from "./Option.js";
+import { StringBuilder, StringBuilder__Append_Z721C83C5 } from "./System.Text.js";
+
+export const LanguagePrimitives_GenericEqualityComparer: any = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x: any, y: any): boolean {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
+        return structuralHash(x_1);
+    },
+};
+
+export const LanguagePrimitives_GenericEqualityERComparer: any = {
+    "System.Collections.IEqualityComparer.Equals541DA560"(x: any, y: any): boolean {
+        return equals(x, y);
+    },
+    "System.Collections.IEqualityComparer.GetHashCode4E60E31B"(x_1: any): int32 {
+        return structuralHash(x_1);
+    },
+};
+
+export function LanguagePrimitives_FastGenericComparer<T>(): IComparer<T> {
+    return ComparisonIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericComparerFromTable<T>(): IComparer<T> {
+    return ComparisonIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericEqualityComparer<T>(): IEqualityComparer<T> {
+    return HashIdentity_Structural<T>();
+}
+
+export function LanguagePrimitives_FastGenericEqualityComparerFromTable<T>(): IEqualityComparer<T> {
+    return HashIdentity_Structural<T>();
+}
+
+export function Operators_Failure(message: string): Error {
+    return new Error(message);
+}
+
+export function Operators_FailurePattern(exn: Error): Option<string> {
+    return exn.message;
+}
+
+export function Operators_NullArg<$a>(x: string): $a {
+    throw new Error(x);
+}
+
+export function Operators_Using<T extends IDisposable, R>(resource: T, action: ((arg0: T) => R)): R {
+    try {
+        return action(resource);
+    }
+    finally {
+        if (equals(resource, defaultOf())) {
+        }
+        else {
+            let copyOfStruct: T = resource;
+            disposeSafe(copyOfStruct);
+        }
+    }
+}
+
+export function Operators_Lock<$a, $b>(_lockObj: $a, action: (() => $b)): $b {
+    return action();
+}
+
+export function ExtraTopLevelOperators_LazyPattern<$a>(input: any): $a {
+    return input.Value;
+}
+
+export function PrintfModule_PrintFormatToStringBuilderThen<$a, $b>(continuation: (() => $a), builder: StringBuilder, format: any): $b {
+    return format.cont((s: string): $a => {
+        StringBuilder__Append_Z721C83C5(builder, s);
+        return continuation();
+    });
+}
+
+export function PrintfModule_PrintFormatToStringBuilder<$a>(builder: StringBuilder, format: any): $a {
+    return PrintfModule_PrintFormatToStringBuilderThen<void, $a>((): void => {
+    }, builder, format);
+}
+

package/Global.ts

@@ -0,0 +1,37 @@
+import { int32 } from "./Int32.js";
+
+export interface Fable_Core_IGenericAdder$1<T> {
+    Add(arg0: T, arg1: T): T,
+    GetZero(): T
+}
+
+export interface Fable_Core_IGenericAverager$1<T> {
+    Add(arg0: T, arg1: T): T,
+    DivideByInt(arg0: T, arg1: int32): T,
+    GetZero(): T
+}
+
+export interface Fable_Core_Symbol_wellknown {
+    [Symbol.toStringTag]: string
+}
+
+export interface Fable_Core_IJsonSerializable {
+    toJSON(): any
+}
+
+export const SR_indexOutOfBounds = "The index was outside the range of elements in the collection.";
+
+export const SR_inputWasEmpty = "Collection was empty.";
+
+export const SR_inputMustBeNonNegative = "The input must be non-negative.";
+
+export const SR_inputSequenceEmpty = "The input sequence was empty.";
+
+export const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+
+export const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+
+export const SR_differentLengths = "The collections had different lengths.";
+
+export const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+

package/Guid.ts

@@ -0,0 +1,143 @@
+import { trim } from "./String.js";
+import { FSharpRef } from "./Types.js";
+
+// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220
+// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+// Relax GUID parsing, see #1637
+const guidRegex = /^[\(\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\)\}]{0,2}$/;
+const guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;
+const guidRegexHex = /^\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\}\}$/;
+const guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;
+
+export function toString(str: string, format?: string, _provider?: any) {
+  if (format && format?.length > 0) {
+    switch (format) {
+      case "N":
+        return str.replace(/-/g, '');
+      case "D":
+        return str;
+      case "B":
+        return "{" + str + "}";
+      case "P":
+        return "(" + str + ")";
+      case "X":
+        return str.replace(guidHexCaptures, "{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}");
+      default:
+        throw new Error("Unrecognized Guid print format");
+    }
+  }
+  else {
+    return str;
+  }
+}
+
+/** Validates UUID as specified in RFC4122 (versions 1-5). */
+export function parse(str: string): string {
+  function hyphenateGuid(str: string) {
+    return str.replace(guidRegexNoHyphen, "$1-$2-$3-$4-$5");
+  }
+
+  const wsTrimAndLowered = str.trim().toLowerCase();
+
+  if (guidRegex.test(wsTrimAndLowered)) {
+    return trim(wsTrimAndLowered, "{", "}", "(", ")");
+  }
+  else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {
+    return hyphenateGuid(wsTrimAndLowered);
+  }
+  else if (guidRegexHex.test(wsTrimAndLowered)) {
+    return hyphenateGuid(wsTrimAndLowered.replace(/[\{\},]|0x/g, ''));
+  }
+  else {
+    throw new Error("Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
+  }
+}
+
+export function tryParse(str: string, defValue: FSharpRef<string>): boolean {
+  try {
+    defValue.contents = parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// From https://gist.github.com/LeverOne/1308368
+export function newGuid() {
+  let b = "";
+  for (let a = 0; a++ < 36;) {
+    b += a * 51 & 52
+      ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)
+      : "-";
+  }
+  return b;
+}
+
+// Maps for number <-> hex string conversion
+let _convertMapsInitialized = false;
+let _byteToHex: string[];
+let _hexToByte: { [k: string]: number };
+
+function initConvertMaps() {
+  _byteToHex = new Array(256);
+  _hexToByte = {};
+  for (let i = 0; i < 256; i++) {
+    _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+    _hexToByte[_byteToHex[i]] = i;
+  }
+  _convertMapsInitialized = true;
+}
+
+/** Parse a UUID into it's component bytes */
+// Adapted from https://github.com/zefferus/uuid-parse
+export function guidToArray(s: string): number[] {
+  if (!_convertMapsInitialized) {
+    initConvertMaps();
+  }
+  let i = 0;
+  const buf = new Uint8Array(16);
+  s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct: number) => {
+    switch (i) {
+      // .NET saves first three byte groups with different endianness
+      // See https://stackoverflow.com/a/16722909/3922220
+      case 0: case 1: case 2: case 3:
+        buf[3 - i++] = _hexToByte[oct];
+        break;
+      case 4: case 5:
+        buf[9 - i++] = _hexToByte[oct];
+        break;
+      case 6: case 7:
+        buf[13 - i++] = _hexToByte[oct];
+        break;
+      case 8: case 9: case 10: case 11:
+      case 12: case 13: case 14: case 15:
+        buf[i++] = _hexToByte[oct];
+        break;
+    }
+  }) as any);
+  // Zero out remaining bytes if string was short
+  while (i < 16) {
+    buf[i++] = 0;
+  }
+  return buf as any as number[];
+}
+
+/** Convert UUID byte array into a string */
+export function arrayToGuid(buf: ArrayLike<number>) {
+  if (buf.length !== 16) {
+    throw new Error("Byte array for GUID must be exactly 16 bytes long");
+  }
+  if (!_convertMapsInitialized) {
+    initConvertMaps();
+  }
+  const guid =
+    _byteToHex[buf[3]] + _byteToHex[buf[2]] +
+    _byteToHex[buf[1]] + _byteToHex[buf[0]] + "-" +
+    _byteToHex[buf[5]] + _byteToHex[buf[4]] + "-" +
+    _byteToHex[buf[7]] + _byteToHex[buf[6]] + "-" +
+    _byteToHex[buf[8]] + _byteToHex[buf[9]] + "-" +
+    _byteToHex[buf[10]] + _byteToHex[buf[11]] +
+    _byteToHex[buf[12]] + _byteToHex[buf[13]] +
+    _byteToHex[buf[14]] + _byteToHex[buf[15]];
+  return guid;
+}