compostjs 0.0.11 → 0.1.0

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

@@ -0,0 +1,283 @@
+import { fromParts, truncate } from "./Decimal.js";
+import { bigintHash } from "./Util.js";
+const isBigEndian = false;
+BigInt.prototype.toJSON = function () {
+    return `${this.toString()}`;
+};
+const zero = 0n;
+const one = 1n;
+const two = 2n;
+const minusOne = -1n;
+export function isBigInt(x) {
+    return typeof x === "bigint";
+}
+export function hash(x) {
+    return bigintHash(x);
+}
+export function equals(x, y) {
+    return x === y;
+}
+export function compare(x, y) {
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+export function abs(x) { return x < zero ? -x : x; }
+export function sign(x) { return x < zero ? -1 : x > zero ? 1 : 0; }
+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 abs(x) > abs(y) ? x : y; }
+export function minMagnitude(x, y) { return abs(x) < abs(y) ? x : y; }
+export function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
+export function add(x, y) { return x + y; }
+export function subtract(x, y) { return x - y; }
+export function multiply(x, y) { return x * y; }
+export function divide(x, y) { return x / y; }
+export function remainder(x, y) { return x % y; }
+export function negate(x) { return -x; }
+export function op_UnaryNegation(x) { return -x; }
+export function op_LogicalNot(x) { return ~x; }
+export function op_UnaryPlus(x) { return x; }
+export function op_Addition(x, y) { return x + y; }
+export function op_Subtraction(x, y) { return x - y; }
+export function op_Multiply(x, y) { return x * y; }
+export function op_Division(x, y) { return x / y; }
+export function op_Modulus(x, y) { return x % y; }
+export function op_RightShift(x, n) { return x >> BigInt(n); }
+export function op_LeftShift(x, n) { return x << BigInt(n); }
+export function op_BitwiseAnd(x, y) { return x & y; }
+export function op_BitwiseOr(x, y) { return x | y; }
+export function op_ExclusiveOr(x, y) { return x ^ y; }
+export function op_LessThan(x, y) { return x < y; }
+export function op_LessThanOrEqual(x, y) { return x <= y; }
+export function op_GreaterThan(x, y) { return x > y; }
+export function op_GreaterThanOrEqual(x, y) { return x >= y; }
+export function op_Equality(x, y) { return x === y; }
+export function op_Inequality(x, y) { return x !== y; }
+export function get_Zero() { return zero; }
+export function get_One() { return one; }
+export function get_MinusOne() { return minusOne; }
+export function get_IsZero(x) { return x === zero; }
+export function get_IsOne(x) { return x === one; }
+export function get_IsEven(x) { return isEvenInteger(x); }
+export function get_IsPowerOfTwo(x) { return isPow2(x); }
+export function get_Sign(x) { return sign(x); }
+export function isNegative(x) { return x < zero; }
+export function isPositive(x) { return x > zero; }
+export function isEvenInteger(x) { return (x % two) === zero; }
+export function isOddInteger(x) { return (x % two) !== zero; }
+export function isPow2(x) { return (x & (x - one)) === zero; }
+export function fromZero() { return zero; }
+export function fromOne() { return one; }
+export function fromInt8(n) { return BigInt(n); }
+export function fromUInt8(n) { return BigInt(n); }
+export function fromInt16(n) { return BigInt(n); }
+export function fromUInt16(n) { return BigInt(n); }
+export function fromInt32(n) { return BigInt(n); }
+export function fromUInt32(n) { return BigInt(n); }
+export function fromInt64(n) { return n; }
+export function fromUInt64(n) { return n; }
+export function fromInt128(n) { return n; }
+export function fromUInt128(n) { return n; }
+export function fromNativeInt(n) { return n; }
+export function fromUNativeInt(n) { return n; }
+export function fromFloat16(n) { return BigInt(Math.trunc(n)); }
+export function fromFloat32(n) { return BigInt(Math.trunc(n)); }
+export function fromFloat64(n) { return BigInt(Math.trunc(n)); }
+export function fromDecimal(d) { return BigInt(truncate(d).toString()); }
+export function fromBigInt(x) { return x; }
+export function fromBoolean(b) { return BigInt(b); }
+export function fromChar(c) { return BigInt(c.charCodeAt(0)); }
+export function fromString(s) { return BigInt(s); }
+export function fromByteArray(bytes) {
+    return fromSignedBytes(bytes, isBigEndian);
+}
+export function toByteArray(value) {
+    return toSignedBytes(value, isBigEndian);
+}
+export function toInt8(x) { return Number(BigInt.asIntN(8, x)); }
+export function toUInt8(x) { return Number(BigInt.asUintN(8, x)); }
+export function toInt16(x) { return Number(BigInt.asIntN(16, x)); }
+export function toUInt16(x) { return Number(BigInt.asUintN(16, x)); }
+export function toInt32(x) { return Number(BigInt.asIntN(32, x)); }
+export function toUInt32(x) { return Number(BigInt.asUintN(32, x)); }
+export function toInt64(x) { return BigInt.asIntN(64, x); }
+export function toUInt64(x) { return BigInt.asUintN(64, x); }
+export function toInt128(x) { return BigInt.asIntN(128, x); }
+export function toUInt128(x) { return BigInt.asUintN(128, x); }
+export function toNativeInt(x) { return BigInt.asIntN(64, x); }
+export function toUNativeInt(x) { return BigInt.asUintN(64, x); }
+export function toFloat16(x) { return Number(x); }
+export function toFloat32(x) { return Number(x); }
+export function toFloat64(x) { return Number(x); }
+export function toDecimal(x) {
+    const isNegative = x < zero;
+    const bits = abs(x);
+    const low = Number(BigInt.asUintN(32, bits));
+    const mid = Number(BigInt.asUintN(32, bits >> 32n));
+    const high = Number(BigInt.asUintN(32, bits >> 64n));
+    const scale = 0;
+    return fromParts(low, mid, high, isNegative, scale);
+}
+export function toBigInt(x) { return x; }
+export function toBoolean(x) { return x !== zero; }
+export function toChar(x) {
+    return String.fromCharCode(toUInt16(x));
+}
+export function toString(x) { return x.toString(); }
+export function tryParse(s, res) {
+    try {
+        res.contents = BigInt(s);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+export function parse(s) {
+    return BigInt(s);
+}
+export function pow(x, n) {
+    return x ** BigInt(n);
+}
+export function modPow(x, e, m) {
+    return (x ** e) % m;
+}
+export function divRem(x, y, out) {
+    const div = x / y;
+    const rem = x % y;
+    if (out === void 0) {
+        return [div, rem];
+    }
+    else {
+        out.contents = rem;
+        return div;
+    }
+}
+export function greatestCommonDivisor(x, y) {
+    while (y > zero) {
+        const q = x / y;
+        const r = x - q * y;
+        x = y;
+        y = r;
+    }
+    return x;
+}
+export function getBitLength(x) {
+    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+}
+export function log2(x) {
+    const n = Number(x);
+    if (Number.isFinite(n))
+        return Math.log2(n); // fast path
+    if (x < zero)
+        return Number.NaN;
+    let shift = one;
+    while (x >= (one << shift)) {
+        shift = shift << one;
+    }
+    let log = zero;
+    while (shift > one) {
+        shift = shift >> one;
+        if (x >= (one << shift)) {
+            log = log + shift;
+            x = x >> shift;
+        }
+    }
+    return Number(log);
+}
+export function log10(x) {
+    return log2(x) * Math.log10(2);
+}
+export function ln(x) {
+    return log2(x) * Math.log(2);
+}
+export function log(x, base) {
+    return log2(x) / Math.log2(base);
+}
+export function ilog2(x) {
+    return BigInt(log2(x));
+}
+// export function copySign
+// export function createChecked
+// export function createSaturating
+// export function createTruncating
+// export function getByteCount
+// export function leadingZeroCount
+// export function popCount
+// export function rotateLeft
+// export function rotateRight
+// export function trailingZeroCount
+// export function tryFormat
+// export function tryWriteBytes
+// -------------------------------------------------
+// Binary serialization
+// -------------------------------------------------
+const hexCodes = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102]);
+function fromHexCode(code) {
+    if (48 <= code && code <= 57)
+        return code - 48;
+    if (97 <= code && code <= 102)
+        return code - 97 + 10;
+    if (65 <= code && code <= 70)
+        return code - 65 + 10;
+    throw Error(`Invalid hex code: ${code}`);
+}
+function toSignedBytes(x, isBigEndian) {
+    const isNeg = x < 0n;
+    if (isNeg) {
+        const len = log2(-x);
+        const bits = len + (8 - len % 8);
+        const pow2 = (1n << BigInt(bits));
+        x = x + pow2; // two's complement
+    }
+    const hex = x.toString(16);
+    const len = hex.length;
+    const odd = len % 2;
+    const first = hex.charCodeAt(0);
+    const isLow = 48 <= first && first <= 55; // 0..7
+    const start = (isNeg && isLow) || (!isNeg && !isLow) ? 1 : 0;
+    const bytes = new Uint8Array(start + (len + odd) / 2);
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : bytes.length - 1;
+    if (start > 0) {
+        bytes[pos] = isNeg ? 255 : 0;
+        pos += inc;
+    }
+    if (odd > 0) {
+        bytes[pos] = fromHexCode(first);
+        pos += inc;
+    }
+    for (let i = odd; i < len; i += 2, pos += inc) {
+        const a = fromHexCode(hex.charCodeAt(i));
+        const b = fromHexCode(hex.charCodeAt(i + 1));
+        bytes[pos] = (a << 4) | b;
+    }
+    return bytes;
+}
+function fromSignedBytes(bytes, isBigEndian) {
+    if (bytes == null) {
+        throw new Error("bytes is null");
+    }
+    const len = bytes.length;
+    const first = isBigEndian ? 0 : len - 1;
+    const isNeg = bytes[first] > 127;
+    const codes = new Uint16Array(len * 2 + 2);
+    codes[0] = 48; // 0
+    codes[1] = 120; // x
+    const inc = isBigEndian ? 1 : -1;
+    let pos = isBigEndian ? 0 : len - 1;
+    for (let i = 0; i < bytes.length; i++, pos += inc) {
+        const byte = bytes[pos];
+        codes[2 * i + 2] = hexCodes[byte >> 4];
+        codes[2 * i + 3] = hexCodes[byte & 15];
+    }
+    const str = String.fromCharCode.apply(null, codes);
+    let x = BigInt(str);
+    if (isNeg) {
+        const bits = len * 8;
+        const pow2 = (1n << BigInt(bits));
+        x = x - pow2; // two's complement
+    }
+    return x;
+}

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

@@ -0,0 +1,27 @@
+import { uint8, int16, uint16, int32, uint32, float32, float64 } from "./Int32.js";
+import { int64, uint64 } from "./BigInt.js";
+import { char } from "./Char.js";
+export declare function isLittleEndian(): boolean;
+export declare function getBytesBoolean(value: boolean): Uint8Array;
+export declare function getBytesChar(value: char): Uint8Array;
+export declare function getBytesInt16(value: int16): Uint8Array;
+export declare function getBytesInt32(value: int32): Uint8Array;
+export declare function getBytesInt64(value: int64): Uint8Array;
+export declare function getBytesUInt16(value: uint16): Uint8Array;
+export declare function getBytesUInt32(value: uint32): Uint8Array;
+export declare function getBytesUInt64(value: uint64): Uint8Array;
+export declare function getBytesSingle(value: float32): Uint8Array;
+export declare function getBytesDouble(value: float64): Uint8Array;
+export declare function int64BitsToDouble(value: int64): float64;
+export declare function doubleToInt64Bits(value: float64): int64;
+export declare function toBoolean(bytes: ArrayLike<uint8>, offset: int32): boolean;
+export declare function toChar(bytes: ArrayLike<uint8>, offset: int32): char;
+export declare function toInt16(bytes: ArrayLike<uint8>, offset: int32): int16;
+export declare function toInt32(bytes: ArrayLike<uint8>, offset: int32): int32;
+export declare function toInt64(bytes: ArrayLike<uint8>, offset: int32): int64;
+export declare function toUInt16(bytes: ArrayLike<uint8>, offset: int32): uint16;
+export declare function toUInt32(bytes: ArrayLike<uint8>, offset: int32): uint32;
+export declare function toUInt64(bytes: ArrayLike<uint8>, offset: int32): uint64;
+export declare function toSingle(bytes: ArrayLike<uint8>, offset: int32): float32;
+export declare function toDouble(bytes: ArrayLike<uint8>, offset: int32): float64;
+export declare function toString(bytes: ArrayLike<uint8>, offset?: int32, count?: int32): string;

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

@@ -0,0 +1,138 @@
+const littleEndian = true;
+export function isLittleEndian() {
+    return littleEndian;
+}
+export function getBytesBoolean(value) {
+    const bytes = new Uint8Array(1);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint8(0, value ? 1 : 0);
+    return bytes;
+}
+export function getBytesChar(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint16(0, value.charCodeAt(0), littleEndian);
+    return bytes;
+}
+export function getBytesInt16(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setInt16(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesInt32(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setInt32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesInt64(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setBigInt64(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt16(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint16(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt32(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt64(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setBigUint64(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesSingle(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setFloat32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesDouble(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setFloat64(0, value, littleEndian);
+    return bytes;
+}
+export function int64BitsToDouble(value) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setBigInt64(0, value, littleEndian);
+    return view.getFloat64(0, littleEndian);
+}
+export function doubleToInt64Bits(value) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, value, littleEndian);
+    return view.getBigInt64(0, littleEndian);
+}
+export function toBoolean(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint8(offset) === 1 ? true : false;
+}
+export function toChar(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    const code = view.getUint16(offset, littleEndian);
+    return String.fromCharCode(code);
+}
+export function toInt16(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getInt16(offset, littleEndian);
+}
+export function toInt32(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getInt32(offset, littleEndian);
+}
+export function toInt64(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getBigInt64(offset, littleEndian);
+}
+export function toUInt16(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint16(offset, littleEndian);
+}
+export function toUInt32(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint32(offset, littleEndian);
+}
+export function toUInt64(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getBigUint64(offset, littleEndian);
+}
+export function toSingle(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getFloat32(offset, littleEndian);
+}
+export function toDouble(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getFloat64(offset, littleEndian);
+}
+export function toString(bytes, offset, count) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    if (offset != null && count != null) {
+        buffer = buffer.subarray(offset, offset + count);
+    }
+    else if (offset != null) {
+        buffer = buffer.subarray(offset);
+    }
+    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2)).join("-");
+}

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

@@ -0,0 +1,3 @@
+import { FSharpRef } from "./Types.js";
+export declare function tryParse(str: string, defValue: FSharpRef<boolean>): boolean;
+export declare function parse(str: string): boolean;

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

@@ -0,0 +1,21 @@
+import { FSharpRef } from "./Types.js";
+export function tryParse(str, defValue) {
+    if (str != null && str.match(/^\s*true\s*$/i)) {
+        defValue.contents = true;
+        return true;
+    }
+    else if (str != null && str.match(/^\s*false\s*$/i)) {
+        defValue.contents = false;
+        return true;
+    }
+    return false;
+}
+export function parse(str) {
+    const defValue = new FSharpRef(false);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Error(`String '${str}' was not recognized as a valid Boolean.`);
+    }
+}

package/dist/fable_modules/fable-library-js.4.28.0/CHANGELOG.md

@@ -0,0 +1,100 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 1.11.0- 2025-04-26
+
+### Fixed
+
+* [JS/TS] Propagate non-captured exception when running `Async.Start` or `Async.StartImmediate` (by @MangelMaxime)
+* [JS/TS] Remove `Async.RunSynchronously` (by @MangelMaxime)
+* [JS/TS] Change signature of `startWithContinuations` to always require all its arguments (by @MangelMaxime)
+
+## 1.7.0 - 2024-11-19
+
+### Fixed
+
+* [JS/TS] Added missing IReadOnlyCollection helpers (#3953)
+
+## 1.6.0 - 2024-10-02
+
+### Removed
+
+* Remove `Async` (from `Async.ts`) class (by @MangelMaxime)
+
+### Changed
+
+* Renamed `IAsync` to `Async` in `AsyncBuilder.ts` (#3906) (by @ncave)
+
+## 1.5.0 - 2024-09-19
+
+### Added
+
+* [JS/TS] Add support for `OrdinalIgnoreCase` overload for `String.EndsWith` (#3892) (by @goswinr)
+* [JS/TS] Add `uri.Port`, `uri.IsDefaultPort` (by @MangelMaxime)
+
+### Fixed
+
+* [JS/TS] Fix escaping of `{` and `}` in FormattableString (#3890) (by @roboz0r)
+* [JS/TS] Fix `uri.Host` to return the host name without the port (by @MangelMaxime)
+* [JS/TS] Fix TypeScript compilation by resolving type of `jsOptions` (#3894) (by @ManngelMaxime)
+
+## 1.4.3 - 2024-09-04
+
+* [JS/TS] Fixed Decimal comparisons (#3884) (by @ncave)
+
+## 1.4.2 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed BigInt.ToDecimal with negative values (#3500) (by @ncave)
+
+## 1.4.1 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed DateTime.MinValue, DateTime.MaxValue (#3836) (by @ncave)
+
+## 1.4.0 - 2024-03-20
+
+### Added
+
+* [JS/TS] Add `ConditionalWeakTable` (by @chkn)
+
+## 1.3.0 - 2024-03-18
+
+* [JS/TS] `Boolean.tryParse` should not crash on `null` string (@goswinr)
+
+## 1.2.0 - 2024-03-01
+
+### Fixed
+
+* [GH-3772](https://github.com/fable-compiler/Fable/pull/3772) [JS/TS] Re-implement `DateTime.ToString` custom format handling (by @MangelMaxime)
+
+    It now supports all custom format specifiers, and behave as if `CultureInfo.InvariantCulture` was used (Fable does not support Globalization).
+
+## 1.1.0 - 2024-02-20
+
+### Added
+
+#### JavaScript
+
+* [GH-3759](https://github.com/fable-compiler/Fable/issues/3759) Add `StringBuilder.Chars` (by @MangelMaxime)
+* Add `StringBuilder.AppendFormat` (by @ncave)
+* [GH-3748](https://github.com/fable-compiler/Fable/pull/3748) Add `Array.getItem` and `Array.setItem` (by @MangelMaxime)
+
+## 1.0.0 - 2024-02-13
+
+* Release stable version
+
+## 1.0.0-beta-001 - 2024-02-12
+
+### Changed
+
+* Separate `Result` from `Choice`
+* Released as part of Fable 4.12.0

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

@@ -0,0 +1,65 @@
+export type char = string;
+export declare const enum UnicodeCategory {
+    UppercaseLetter = 0,
+    LowercaseLetter = 1,
+    TitlecaseLetter = 2,
+    ModifierLetter = 3,
+    OtherLetter = 4,
+    NonSpacingMark = 5,
+    SpacingCombiningMark = 6,
+    EnclosingMark = 7,
+    DecimalDigitNumber = 8,
+    LetterNumber = 9,
+    OtherNumber = 10,
+    SpaceSeparator = 11,
+    LineSeparator = 12,
+    ParagraphSeparator = 13,
+    Control = 14,
+    Format = 15,
+    Surrogate = 16,
+    PrivateUse = 17,
+    ConnectorPunctuation = 18,
+    DashPunctuation = 19,
+    OpenPunctuation = 20,
+    ClosePunctuation = 21,
+    InitialQuotePunctuation = 22,
+    FinalQuotePunctuation = 23,
+    OtherPunctuation = 24,
+    MathSymbol = 25,
+    CurrencySymbol = 26,
+    ModifierSymbol = 27,
+    OtherSymbol = 28,
+    OtherNotAssigned = 29
+}
+export declare const getUnicodeCategory: (s: string) => number;
+export declare const isControl: (s: string) => boolean;
+export declare const isDigit: (s: string) => boolean;
+export declare const isLetter: (s: string) => boolean;
+export declare const isLetterOrDigit: (s: string) => boolean;
+export declare const isUpper: (s: string) => boolean;
+export declare const isLower: (s: string) => boolean;
+export declare const isNumber: (s: string) => boolean;
+export declare const isPunctuation: (s: string) => boolean;
+export declare const isSeparator: (s: string) => boolean;
+export declare const isSymbol: (s: string) => boolean;
+export declare const isWhiteSpace: (s: string) => boolean;
+export declare const isHighSurrogate: (s: string) => boolean;
+export declare const isLowSurrogate: (s: string) => boolean;
+export declare const isSurrogate: (s: string) => boolean;
+export declare function getUnicodeCategory2(s: string, index: number): number;
+export declare function isControl2(s: string, index: number): boolean;
+export declare function isDigit2(s: string, index: number): boolean;
+export declare function isLetter2(s: string, index: number): boolean;
+export declare function isLetterOrDigit2(s: string, index: number): boolean;
+export declare function isUpper2(s: string, index: number): boolean;
+export declare function isLower2(s: string, index: number): boolean;
+export declare function isNumber2(s: string, index: number): boolean;
+export declare function isPunctuation2(s: string, index: number): boolean;
+export declare function isSeparator2(s: string, index: number): boolean;
+export declare function isSymbol2(s: string, index: number): boolean;
+export declare function isWhiteSpace2(s: string, index: number): boolean;
+export declare function isHighSurrogate2(s: string, index: number): boolean;
+export declare function isLowSurrogate2(s: string, index: number): boolean;
+export declare function isSurrogate2(s: string, index: number): boolean;
+export declare function isSurrogatePair(s: string, index: string | number): boolean;
+export declare function parse(input: string): string;