@nfdi4plants/arctrl 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/ts/node_modules/@fable-org/fable-library-js/Async.js

@@ -1,16 +1,134 @@
-import { Trampoline, CancellationToken, protectedCont, OperationCanceledError } from './AsyncBuilder.js';
+import { protectedCont, protectedBind, CancellationToken, OperationCanceledError, protectedReturn, Trampoline } from './AsyncBuilder.js';
+import { Choice_makeChoice2Of2, Choice_makeChoice1Of2 } from './Choice.js';
+import { TimeoutException } from './SystemException.js';
 
 function emptyContinuation(_x) {
     // NOP
 }
+// see AsyncBuilder.Delay
+function delay(generator) {
+    return protectedCont((ctx) => generator()(ctx));
+}
+// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
+function makeAsync(body) {
+    return body;
+}
+// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn
+function invoke(computation, ctx) {
+    return computation(ctx);
+}
+// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn
+function callThenInvoke(ctx, result1, part2) {
+    return part2(result1)(ctx);
+}
+// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn
+function bind(ctx, part1, part2) {
+    return protectedBind(part1, part2)(ctx);
+}
+function createCancellationToken(arg) {
+    const token = new CancellationToken(typeof arg === "boolean" ? arg : false);
+    if (typeof arg === "number") {
+        setTimeout(() => { token.cancel(); }, arg);
+    }
+    return token;
+}
+function cancel(token) {
+    token.cancel();
+}
+function cancelAfter(token, ms) {
+    setTimeout(() => { token.cancel(); }, ms);
+}
+function isCancellationRequested(token) {
+    return token != null && token.isCancelled;
+}
+function throwIfCancellationRequested(token) {
+    if (token != null && token.isCancelled) {
+        throw new Error("Operation is cancelled");
+    }
+}
+function throwAfter(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onError(new TimeoutException());
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+function startChild(computation, ms) {
+    if (ms) {
+        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));
+        return startChild(computationWithTimeout);
+    }
+    const promise = startAsPromise(computation);
+    // JS Promises are hot, computation has already started
+    // but we delay returning the result
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));
+}
 function awaitPromise(p) {
     return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError
         ? conts[2] : conts[1])(err)));
 }
+function cancellationToken() {
+    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));
+}
 const defaultCancellationToken = new CancellationToken();
+function catchAsync(work) {
+    return protectedCont((ctx) => {
+        work({
+            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
+            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),
+            onCancel: ctx.onCancel,
+            cancelToken: ctx.cancelToken,
+            trampoline: ctx.trampoline,
+        });
+    });
+}
 function fromContinuations(f) {
     return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));
 }
+function ignore(computation) {
+    return protectedBind(computation, (_x) => protectedReturn(void 0));
+}
+function parallel(computations) {
+    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
+}
+function parallel2(a, b) {
+    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
+}
+function sequential(computations) {
+    function _sequential(computations) {
+        let pr = Promise.resolve([]);
+        for (const c of computations) {
+            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));
+        }
+        return pr;
+    }
+    return delay(() => awaitPromise(_sequential(computations)));
+}
+function sleep(millisecondsDueTime) {
+    return protectedCont((ctx) => {
+        let tokenId;
+        const timeoutId = setTimeout(() => {
+            ctx.cancelToken.removeListener(tokenId);
+            ctx.onSuccess(void 0);
+        }, millisecondsDueTime);
+        tokenId = ctx.cancelToken.addListener(() => {
+            clearTimeout(timeoutId);
+            ctx.onCancel(new OperationCanceledError());
+        });
+    });
+}
+function start(computation, cancellationToken) {
+    return startWithContinuations(computation, emptyContinuation, function (err) { throw err; }, emptyContinuation, cancellationToken);
+}
+function startImmediate(computation, cancellationToken) {
+    return start(computation, cancellationToken);
+}
 function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
     const trampoline = new Trampoline();
     computation({
@@ -22,7 +140,7 @@ function startWithContinuations(computation, continuation, exceptionContinuation
     });
 }
 function startAsPromise(computation, cancellationToken) {
-    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, defaultCancellationToken));
+    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
 }
 
-export { awaitPromise, defaultCancellationToken, fromContinuations, startAsPromise, startWithContinuations };
+export { awaitPromise, bind, callThenInvoke, cancel, cancelAfter, cancellationToken, catchAsync, createCancellationToken, defaultCancellationToken, fromContinuations, ignore, invoke, isCancellationRequested, makeAsync, parallel, sequential, sleep, start, startAsPromise, startChild, startImmediate, startWithContinuations, throwIfCancellationRequested };

package/dist/ts/node_modules/@fable-org/fable-library-js/BigInt.js

@@ -1,8 +1,286 @@
+import { truncate, fromParts } 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;
+function isBigInt(x) {
+    return typeof x === "bigint";
+}
+function hash(x) {
+    return bigintHash(x);
+}
+function equals(x, y) {
+    return x === y;
+}
+function compare(x, y) {
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+function abs(x) { return x < zero ? -x : x; }
+function sign(x) { return x < zero ? -1 : x > zero ? 1 : 0; }
+function max(x, y) { return x > y ? x : y; }
+function min(x, y) { return x < y ? x : y; }
+function maxMagnitude(x, y) { return abs(x) > abs(y) ? x : y; }
+function minMagnitude(x, y) { return abs(x) < abs(y) ? x : y; }
+function clamp(x, min, max) {
+    return x < min ? min : x > max ? max : x;
+}
+function add(x, y) { return x + y; }
+function subtract(x, y) { return x - y; }
+function multiply(x, y) { return x * y; }
+function divide(x, y) { return x / y; }
+function remainder(x, y) { return x % y; }
+function negate(x) { return -x; }
+function op_UnaryNegation(x) { return -x; }
+function op_LogicalNot(x) { return ~x; }
+function op_UnaryPlus(x) { return x; }
+function op_Addition(x, y) { return x + y; }
+function op_Subtraction(x, y) { return x - y; }
+function op_Multiply(x, y) { return x * y; }
+function op_Division(x, y) { return x / y; }
+function op_Modulus(x, y) { return x % y; }
+function op_RightShift(x, n) { return x >> BigInt(n); }
+function op_LeftShift(x, n) { return x << BigInt(n); }
+function op_BitwiseAnd(x, y) { return x & y; }
+function op_BitwiseOr(x, y) { return x | y; }
+function op_ExclusiveOr(x, y) { return x ^ y; }
+function op_LessThan(x, y) { return x < y; }
+function op_LessThanOrEqual(x, y) { return x <= y; }
+function op_GreaterThan(x, y) { return x > y; }
+function op_GreaterThanOrEqual(x, y) { return x >= y; }
+function op_Equality(x, y) { return x === y; }
+function op_Inequality(x, y) { return x !== y; }
+function get_Zero() { return zero; }
+function get_One() { return one; }
+function get_MinusOne() { return minusOne; }
+function get_IsZero(x) { return x === zero; }
+function get_IsOne(x) { return x === one; }
+function get_IsEven(x) { return isEvenInteger(x); }
+function get_IsPowerOfTwo(x) { return isPow2(x); }
+function get_Sign(x) { return sign(x); }
+function isNegative(x) { return x < zero; }
+function isPositive(x) { return x > zero; }
+function isEvenInteger(x) { return (x % two) === zero; }
+function isOddInteger(x) { return (x % two) !== zero; }
+function isPow2(x) { return (x & (x - one)) === zero; }
+function fromZero() { return zero; }
+function fromOne() { return one; }
+function fromInt8(n) { return BigInt(n); }
+function fromUInt8(n) { return BigInt(n); }
+function fromInt16(n) { return BigInt(n); }
+function fromUInt16(n) { return BigInt(n); }
+function fromInt32(n) { return BigInt(n); }
+function fromUInt32(n) { return BigInt(n); }
+function fromInt64(n) { return n; }
+function fromUInt64(n) { return n; }
+function fromInt128(n) { return n; }
+function fromUInt128(n) { return n; }
+function fromNativeInt(n) { return n; }
+function fromUNativeInt(n) { return n; }
+function fromFloat16(n) { return BigInt(Math.trunc(n)); }
+function fromFloat32(n) { return BigInt(Math.trunc(n)); }
+function fromFloat64(n) { return BigInt(Math.trunc(n)); }
+function fromDecimal(d) { return BigInt(truncate(d).toString()); }
+function fromBigInt(x) { return x; }
+function fromBoolean(b) { return BigInt(b); }
+function fromChar(c) { return BigInt(c.charCodeAt(0)); }
 function fromString(s) { return BigInt(s); }
+function fromByteArray(bytes) {
+    return fromSignedBytes(bytes, isBigEndian);
+}
+function toByteArray(value) {
+    return toSignedBytes(value, isBigEndian);
+}
+function toInt8(x) { return Number(BigInt.asIntN(8, x)); }
+function toUInt8(x) { return Number(BigInt.asUintN(8, x)); }
+function toInt16(x) { return Number(BigInt.asIntN(16, x)); }
+function toUInt16(x) { return Number(BigInt.asUintN(16, x)); }
+function toInt32(x) { return Number(BigInt.asIntN(32, x)); }
+function toUInt32(x) { return Number(BigInt.asUintN(32, x)); }
 function toInt64(x) { return BigInt.asIntN(64, x); }
 function toUInt64(x) { return BigInt.asUintN(64, x); }
+function toInt128(x) { return BigInt.asIntN(128, x); }
+function toUInt128(x) { return BigInt.asUintN(128, x); }
+function toNativeInt(x) { return BigInt.asIntN(64, x); }
+function toUNativeInt(x) { return BigInt.asUintN(64, x); }
+function toFloat16(x) { return Number(x); }
+function toFloat32(x) { return Number(x); }
+function toFloat64(x) { return Number(x); }
+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);
+}
+function toBigInt(x) { return x; }
+function toBoolean(x) { return x !== zero; }
+function toChar(x) {
+    return String.fromCharCode(toUInt16(x));
+}
+function toString(x) { return x.toString(); }
+function tryParse(s, res) {
+    try {
+        res.contents = BigInt(s);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+function parse(s) {
+    return BigInt(s);
+}
+function pow(x, n) {
+    return x ** BigInt(n);
+}
+function modPow(x, e, m) {
+    return (x ** e) % m;
+}
+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;
+    }
+}
+function greatestCommonDivisor(x, y) {
+    while (y > zero) {
+        const q = x / y;
+        const r = x - q * y;
+        x = y;
+        y = r;
+    }
+    return x;
+}
+function getBitLength(x) {
+    return fromFloat64(x === zero ? 1 : log2(abs(x)) + 1);
+}
+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);
+}
+function log10(x) {
+    return log2(x) * Math.log10(2);
+}
+function ln(x) {
+    return log2(x) * Math.log(2);
+}
+function log(x, base) {
+    return log2(x) / Math.log2(base);
+}
+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;
+}
 
-export { fromString, toInt64, toUInt64 };
+export { abs, add, clamp, compare, divRem, divide, equals, fromBigInt, fromBoolean, fromByteArray, fromChar, fromDecimal, fromFloat16, fromFloat32, fromFloat64, fromInt128, fromInt16, fromInt32, fromInt64, fromInt8, fromNativeInt, fromOne, fromString, fromUInt128, fromUInt16, fromUInt32, fromUInt64, fromUInt8, fromUNativeInt, fromZero, getBitLength, get_IsEven, get_IsOne, get_IsPowerOfTwo, get_IsZero, get_MinusOne, get_One, get_Sign, get_Zero, greatestCommonDivisor, hash, ilog2, isBigInt, isEvenInteger, isNegative, isOddInteger, isPositive, isPow2, ln, log, log10, log2, max, maxMagnitude, min, minMagnitude, modPow, multiply, negate, op_Addition, op_BitwiseAnd, op_BitwiseOr, op_Division, op_Equality, op_ExclusiveOr, op_GreaterThan, op_GreaterThanOrEqual, op_Inequality, op_LeftShift, op_LessThan, op_LessThanOrEqual, op_LogicalNot, op_Modulus, op_Multiply, op_RightShift, op_Subtraction, op_UnaryNegation, op_UnaryPlus, parse, pow, remainder, sign, subtract, toBigInt, toBoolean, toByteArray, toChar, toDecimal, toFloat16, toFloat32, toFloat64, toInt128, toInt16, toInt32, toInt64, toInt8, toNativeInt, toString, toUInt128, toUInt16, toUInt32, toUInt64, toUInt8, toUNativeInt, tryParse };

package/dist/ts/node_modules/@fable-org/fable-library-js/Char.js

@@ -31,6 +31,7 @@ function getCategoryFunc() {
         return categories$1[lo];
     };
 }
+const isControlMask = 1 << 14 /* UnicodeCategory.Control */;
 const isDigitMask = 1 << 8 /* UnicodeCategory.DecimalDigitNumber */;
 const isLetterMask = 0
     | 1 << 0 /* UnicodeCategory.UppercaseLetter */
@@ -38,21 +39,66 @@ const isLetterMask = 0
     | 1 << 2 /* UnicodeCategory.TitlecaseLetter */
     | 1 << 3 /* UnicodeCategory.ModifierLetter */
     | 1 << 4 /* UnicodeCategory.OtherLetter */;
+const isLetterOrDigitMask = isLetterMask | isDigitMask;
+const isUpperMask = 1 << 0 /* UnicodeCategory.UppercaseLetter */;
+const isLowerMask = 1 << 1 /* UnicodeCategory.LowercaseLetter */;
+const isNumberMask = 0
+    | 1 << 8 /* UnicodeCategory.DecimalDigitNumber */
+    | 1 << 9 /* UnicodeCategory.LetterNumber */
+    | 1 << 10 /* UnicodeCategory.OtherNumber */;
+const isPunctuationMask = 0
+    | 1 << 18 /* UnicodeCategory.ConnectorPunctuation */
+    | 1 << 19 /* UnicodeCategory.DashPunctuation */
+    | 1 << 20 /* UnicodeCategory.OpenPunctuation */
+    | 1 << 21 /* UnicodeCategory.ClosePunctuation */
+    | 1 << 22 /* UnicodeCategory.InitialQuotePunctuation */
+    | 1 << 23 /* UnicodeCategory.FinalQuotePunctuation */
+    | 1 << 24 /* UnicodeCategory.OtherPunctuation */;
+const isSeparatorMask = 0
+    | 1 << 11 /* UnicodeCategory.SpaceSeparator */
+    | 1 << 12 /* UnicodeCategory.LineSeparator */
+    | 1 << 13 /* UnicodeCategory.ParagraphSeparator */;
+const isSymbolMask = 0
+    | 1 << 25 /* UnicodeCategory.MathSymbol */
+    | 1 << 26 /* UnicodeCategory.CurrencySymbol */
+    | 1 << 27 /* UnicodeCategory.ModifierSymbol */
+    | 1 << 28 /* UnicodeCategory.OtherSymbol */;
+const isWhiteSpaceMask = 0
+    | 1 << 11 /* UnicodeCategory.SpaceSeparator */
+    | 1 << 12 /* UnicodeCategory.LineSeparator */
+    | 1 << 13 /* UnicodeCategory.ParagraphSeparator */;
 const unicodeCategoryFunc = getCategoryFunc();
 function charCodeAt(s, index) {
-    if (index < s.length) {
+    if (index >= 0 && index < s.length) {
         return s.charCodeAt(index);
     }
     else {
         throw new Error("Index out of range.");
     }
 }
+const getUnicodeCategory = (s) => getUnicodeCategory2(s, 0);
+const isControl = (s) => isControl2(s, 0);
 const isDigit = (s) => isDigit2(s, 0);
 const isLetter = (s) => isLetter2(s, 0);
+const isLetterOrDigit = (s) => isLetterOrDigit2(s, 0);
+const isUpper = (s) => isUpper2(s, 0);
+const isLower = (s) => isLower2(s, 0);
+const isNumber = (s) => isNumber2(s, 0);
+const isPunctuation = (s) => isPunctuation2(s, 0);
+const isSeparator = (s) => isSeparator2(s, 0);
+const isSymbol = (s) => isSymbol2(s, 0);
+const isWhiteSpace = (s) => isWhiteSpace2(s, 0);
+const isHighSurrogate = (s) => isHighSurrogate2(s, 0);
+const isLowSurrogate = (s) => isLowSurrogate2(s, 0);
+const isSurrogate = (s) => isSurrogate2(s, 0);
 function getUnicodeCategory2(s, index) {
     const cp = charCodeAt(s, index);
     return unicodeCategoryFunc(cp);
 }
+function isControl2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isControlMask) !== 0;
+}
 function isDigit2(s, index) {
     const test = 1 << getUnicodeCategory2(s, index);
     return (test & isDigitMask) !== 0;
@@ -61,6 +107,59 @@ function isLetter2(s, index) {
     const test = 1 << getUnicodeCategory2(s, index);
     return (test & isLetterMask) !== 0;
 }
+function isLetterOrDigit2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLetterOrDigitMask) !== 0;
+}
+function isUpper2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isUpperMask) !== 0;
+}
+function isLower2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLowerMask) !== 0;
+}
+function isNumber2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isNumberMask) !== 0;
+}
+function isPunctuation2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isPunctuationMask) !== 0;
+}
+function isSeparator2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSeparatorMask) !== 0;
+}
+function isSymbol2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSymbolMask) !== 0;
+}
+function isWhiteSpace2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    if ((test & isWhiteSpaceMask) !== 0) {
+        return true;
+    }
+    const cp = charCodeAt(s, index);
+    return (0x09 <= cp && cp <= 0x0D) || cp === 0x85 || cp === 0xA0;
+}
+function isHighSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDBFF);
+}
+function isLowSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xDC00 <= cp && cp <= 0xDFFF);
+}
+function isSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDFFF);
+}
+function isSurrogatePair(s, index) {
+    return typeof index === "number"
+        ? isHighSurrogate2(s, index) && isLowSurrogate2(s, index + 1)
+        : isHighSurrogate(s) && isLowSurrogate(index);
+}
 function parse(input) {
     if (input.length === 1) {
         return input[0];
@@ -70,4 +169,4 @@ function parse(input) {
     }
 }
 
-export { getUnicodeCategory2, isDigit, isDigit2, isLetter, isLetter2, parse };
+export { getUnicodeCategory, getUnicodeCategory2, isControl, isControl2, isDigit, isDigit2, isHighSurrogate, isHighSurrogate2, isLetter, isLetter2, isLetterOrDigit, isLetterOrDigit2, isLowSurrogate, isLowSurrogate2, isLower, isLower2, isNumber, isNumber2, isPunctuation, isPunctuation2, isSeparator, isSeparator2, isSurrogate, isSurrogate2, isSurrogatePair, isSymbol, isSymbol2, isUpper, isUpper2, isWhiteSpace, isWhiteSpace2, parse };