@nfdi4plants/arctrl 2.5.1 → 3.0.0-alpha.2

package/fable_modules/fable-library-js.4.24.0/BigInt.js

@@ -1,283 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/BitConverter.d.ts

@@ -1,27 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/BitConverter.js

@@ -1,138 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/Boolean.d.ts

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

package/fable_modules/fable-library-js.4.24.0/Boolean.js

@@ -1,21 +0,0 @@
-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/fable_modules/fable-library-js.4.24.0/CHANGELOG.md

@@ -1,92 +0,0 @@
-# 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.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/fable_modules/fable-library-js.4.24.0/Char.d.ts

@@ -1,65 +0,0 @@
-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;