@blade-hq/agent-client 1.1.1 → 1.1.3

package/node_modules/@ark/util/out/functions.d.ts

@@ -0,0 +1,33 @@
+export type Fn<args extends readonly any[] = readonly any[], returns = unknown> = (...args: args) => returns;
+export declare const cached: <t>(thunk: () => t) => (() => t);
+export declare const isThunk: <value>(value: value) => value is Extract<value, Thunk> extends never ? value & Thunk : Extract<value, Thunk>;
+export type Thunk<ret = unknown> = () => ret;
+export type thunkable<t> = t | Thunk<t>;
+export declare const tryCatch: <returns, onError = never>(fn: () => returns, onError?: (e: unknown) => onError) => returns | onError;
+export declare const DynamicFunction: DynamicFunction;
+export type DynamicFunction = new <fn extends Fn>(...args: ConstructorParameters<typeof Function>) => fn & {
+    apply(thisArg: null, args: Parameters<fn>): ReturnType<fn>;
+    call(thisArg: null, ...args: Parameters<fn>): ReturnType<fn>;
+};
+export type CallableOptions<attachments extends object> = {
+    attach?: attachments;
+    bind?: object;
+};
+/** @ts-ignore required to cast function type */
+export interface Callable<fn extends Fn, attachments extends object> extends fn, attachments {
+}
+export declare class Callable<fn extends Fn, attachments extends object = {}> {
+    constructor(fn: fn, ...[opts]: {} extends attachments ? [opts?: CallableOptions<attachments>] : [opts: CallableOptions<attachments>]);
+}
+export type GuardablePredicate<input = unknown, narrowed extends input = input> = ((In: input) => In is narrowed) | ((In: input) => boolean);
+export type TypeGuard<input = unknown, narrowed extends input = input> = (In: input) => In is narrowed;
+/**
+ * Checks if the environment has Content Security Policy (CSP) enabled,
+ * preventing JIT-optimized code from being compiled via new Function().
+ *
+ * @returns `true` if a function created using new Function() can be
+ * successfully invoked in the environment, `false` otherwise.
+ *
+ * The result is cached for subsequent invocations.
+ */
+export declare const envHasCsp: () => boolean;

package/node_modules/@ark/util/out/functions.js

@@ -0,0 +1,53 @@
+import { throwInternalError } from "./errors.js";
+import { unset } from "./records.js";
+export const cached = (thunk) => {
+    let result = unset;
+    return () => (result === unset ? (result = thunk()) : result);
+};
+export const isThunk = (value) => typeof value === "function" && value.length === 0;
+export const tryCatch = (fn, onError) => {
+    try {
+        return fn();
+    }
+    catch (e) {
+        return onError?.(e);
+    }
+};
+export const DynamicFunction = class extends Function {
+    constructor(...args) {
+        const params = args.slice(0, -1);
+        const body = args[args.length - 1];
+        try {
+            super(...params, body);
+        }
+        catch (e) {
+            return throwInternalError(`Encountered an unexpected error while compiling your definition:
+                Message: ${e} 
+                Source: (${args.slice(0, -1)}) => {
+                    ${args[args.length - 1]}
+                }`);
+        }
+    }
+};
+export class Callable {
+    constructor(fn, ...[opts]) {
+        return Object.assign(Object.setPrototypeOf(fn.bind(opts?.bind ?? this), this.constructor.prototype), opts?.attach);
+    }
+}
+/**
+ * Checks if the environment has Content Security Policy (CSP) enabled,
+ * preventing JIT-optimized code from being compiled via new Function().
+ *
+ * @returns `true` if a function created using new Function() can be
+ * successfully invoked in the environment, `false` otherwise.
+ *
+ * The result is cached for subsequent invocations.
+ */
+export const envHasCsp = cached(() => {
+    try {
+        return new Function("return false")();
+    }
+    catch {
+        return true;
+    }
+});

package/node_modules/@ark/util/out/generics.d.ts

@@ -0,0 +1,59 @@
+import type { Primitive } from "./domain.ts";
+import { type ErrorMessage } from "./errors.ts";
+import type { unionToTuple } from "./unionToTuple.ts";
+export type Stringifiable = string | boolean | number | bigint | null | undefined;
+/** Force an operation like `{ a: 0 } & { b: 1 }` to be computed so that it displays `{ a: 0; b: 1 }`. */
+export type show<t> = {
+    [k in keyof t]: t[k];
+} & unknown;
+/** @deprecated use "show" instead */
+export type evaluate<t> = {
+    [k in keyof t]: t[k];
+} & unknown;
+export type get<t, k extends PropertyKey> = t[k & keyof t];
+export type exact<t extends object, u extends object> = {
+    [k in keyof t]: k extends keyof u ? conform<t[k], u[k]> : never;
+};
+export type exactMessageOnError<t extends object, u extends object> = {
+    [k in keyof t]: k extends keyof u ? conform<t[k], u[k]> : ErrorMessage<`'${k & string}' is not a valid key`>;
+} & u;
+export type promisable<t> = t | Promise<t>;
+export type leftIfEqual<l, r> = [l, r] extends [r, l] ? l : r;
+export type UnknownUnion = string | number | symbol | bigint | boolean | object | null | undefined;
+/**
+ * Interesection (`&`) that avoids evaluating `unknown` to `{}`
+ */
+export type andPreserveUnknown<l, r> = unknown extends l & r ? unknown : show<l & r>;
+/** Can be used to test for the universal subtypes, `any` and `never`, e.g.:
+ *
+ * ```ts
+ * type isAnyOrNever<t> = [t] extends [anyOrNever] ? true : false
+ * ```
+ *
+ *  The actual value is a string literal, but the only realistic subtypes
+ *  of that literal are `any` and `never`.
+ */
+export type anyOrNever = " anyOrNever";
+export type conform<t, base> = t extends base ? t : base;
+export type equals<l, r> = [l, r] extends [r, l] ? true : false;
+export type exactEquals<l, r> = (<_>() => _ extends l ? 1 : 2) extends <_>() => _ extends r ? 1 : 2 ? true : false;
+export declare const brand: " brand";
+export type Brand<t = unknown, id = unknown> = t & {
+    readonly [brand]: [t, id];
+};
+export type unbrand<t> = t extends Brand<infer base, string> ? base : never;
+export type satisfy<base, t extends base> = t;
+export type defined<t> = t & ({} | null);
+export type autocomplete<suggestions extends string> = suggestions | (string & {});
+export type widen<t, supertypes> = collectWidenedType<t, unionToTuple<supertypes>>;
+type collectWidenedType<t, remaining extends unknown[], result = never> = remaining extends [infer head, ...infer tail] ? collectWidenedType<t, tail, t extends head ? result | head : result> : result;
+type narrowTuple<t extends readonly unknown[]> = t extends readonly [infer head, ...infer tail] ? readonly [head, ...narrowTuple<tail>] : [];
+export type narrow<t> = t extends Primitive ? t : t extends readonly unknown[] ? narrowTuple<t> : {
+    [k in keyof t]: narrow<t[k]>;
+};
+export declare const narrow: <t>(t: narrow<t>) => t;
+/** primitive key used to represent an inferred type at compile-time */
+export declare const inferred: " arkInferred";
+/** primitive key used to represent an inferred type at compile-time */
+export type inferred = typeof inferred;
+export {};

package/node_modules/@ark/util/out/generics.js

@@ -0,0 +1,5 @@
+import { noSuggest } from "./errors.js";
+export const brand = noSuggest("brand");
+export const narrow = (t) => t;
+/** primitive key used to represent an inferred type at compile-time */
+export const inferred = noSuggest("arkInferred");

package/node_modules/@ark/util/out/get.d.ts

@@ -0,0 +1,9 @@
+import type { conform } from "./generics.ts";
+import type { keyOf } from "./records.ts";
+type getKey<o, k> = k extends keyof o ? o[k] : k extends `${infer n extends number & keyof o}` ? o[n] : never;
+type getPath<o, path extends string> = path extends `${infer head}.${infer tail}` ? getPath<getKey<o, head>, tail> : getKey<o, path>;
+type validatePath<o, path extends string, prefix extends string = ""> = path extends `${infer head}.${infer tail}` ? head extends keyOf<o> ? validatePath<getKey<o, head>, tail, `${prefix}${head}.`> : `Key '${head}' is not valid following '${prefix}'` : {
+    [k in keyOf<o>]: k extends `${path}${string}` ? `${prefix}${k}` : never;
+}[keyOf<o>];
+export declare const get: <const o extends object, path extends string>(data: o, pathStr: conform<path, string & validatePath<o, path>>) => getPath<o, path>;
+export {};

package/node_modules/@ark/util/out/get.js

@@ -0,0 +1,7 @@
+export const get = (data, pathStr) => {
+    let target = data;
+    const path = pathStr.split(".");
+    while (path.length)
+        target = target[path.shift()];
+    return target;
+};

package/node_modules/@ark/util/out/hkt.d.ts

@@ -0,0 +1,27 @@
+declare const args: " args";
+type args = typeof args;
+export declare abstract class Hkt<constraints extends unknown[] = any> {
+    [args]: unknown[];
+    constraints: constraints;
+    args: this[args] extends infer args extends unknown[] ? args : never;
+    0: this[args] extends [infer arg, ...any] ? arg : never;
+    1: this[args] extends [any, infer arg, ...any] ? arg : never;
+    2: this[args] extends [any, any, infer arg, ...any] ? arg : never;
+    3: this[args] extends [any, any, any, infer arg, ...any] ? arg : never;
+    abstract body: unknown;
+    description?: string;
+    constructor();
+}
+/** A small set of HKT utility types based on https://github.com/gvergnaud/hotscript
+ *  See https://github.com/gvergnaud/hotscript/blob/main/src/internals/core/Core.ts
+ */
+export declare namespace Hkt {
+    type constructor<constraints extends unknown[] = any> = new () => Hkt<constraints>;
+    type args = typeof args;
+    type apply<hkt extends Hkt, args extends {
+        [i in keyof args]: hkt["constraints"][i];
+    }> = (hkt & {
+        [args]: args;
+    })["body"];
+}
+export {};

package/node_modules/@ark/util/out/hkt.js

@@ -0,0 +1,5 @@
+import { noSuggest } from "./errors.js";
+const args = noSuggest("args");
+export class Hkt {
+    constructor() { }
+}

package/node_modules/@ark/util/out/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./arrays.ts";
+export * from "./clone.ts";
+export * from "./describe.ts";
+export * from "./domain.ts";
+export * from "./errors.ts";
+export * from "./flatMorph.ts";
+export * from "./functions.ts";
+export * from "./generics.ts";
+export * from "./hkt.ts";
+export * from "./intersections.ts";
+export * from "./isomorphic.ts";
+export * from "./keys.ts";
+export * from "./lazily.ts";
+export * from "./numbers.ts";
+export * from "./objectKinds.ts";
+export * from "./path.ts";
+export * from "./primitive.ts";
+export * from "./records.ts";
+export * from "./registry.ts";
+export * from "./scanner.ts";
+export * from "./serialize.ts";
+export * from "./strings.ts";
+export * from "./traits.ts";
+export * from "./unionToTuple.ts";

package/node_modules/@ark/util/out/index.js

@@ -0,0 +1,24 @@
+export * from "./arrays.js";
+export * from "./clone.js";
+export * from "./describe.js";
+export * from "./domain.js";
+export * from "./errors.js";
+export * from "./flatMorph.js";
+export * from "./functions.js";
+export * from "./generics.js";
+export * from "./hkt.js";
+export * from "./intersections.js";
+export * from "./isomorphic.js";
+export * from "./keys.js";
+export * from "./lazily.js";
+export * from "./numbers.js";
+export * from "./objectKinds.js";
+export * from "./path.js";
+export * from "./primitive.js";
+export * from "./records.js";
+export * from "./registry.js";
+export * from "./scanner.js";
+export * from "./serialize.js";
+export * from "./strings.js";
+export * from "./traits.js";
+export * from "./unionToTuple.js";

package/node_modules/@ark/util/out/intersections.d.ts

@@ -0,0 +1,50 @@
+import type { array } from "./arrays.ts";
+import type { domainOf } from "./domain.ts";
+import type { andPreserveUnknown } from "./generics.ts";
+import type { Hkt } from "./hkt.ts";
+import type { propValueOf, requiredKeyOf } from "./records.ts";
+export interface AndPreserveUnknown extends Hkt<[unknown, unknown]> {
+    body: andPreserveUnknown<this[0], this[1]>;
+}
+type SequenceIntersectionKind = "array" | "parameters";
+export type intersectArrays<l extends array, r extends array, operator extends Hkt = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "array">;
+export type intersectParameters<l extends array, r extends array, operator extends Hkt = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "parameters">;
+type intersectSequences<l extends array, r extends array, acc extends array, postfix extends array, operation extends Hkt, kind extends SequenceIntersectionKind> = l extends readonly [] ? kind extends "array" ? [
+] extends r ? [
+    ...acc,
+    ...postfix
+] : never : [...acc, ...r, ...postfix] : r extends readonly [] ? kind extends "array" ? [
+] extends l ? [
+    ...acc,
+    ...postfix
+] : never : [...acc, ...l, ...postfix] : [
+    l,
+    r
+] extends ([
+    readonly [(infer lHead)?, ...infer lTail],
+    readonly [(infer rHead)?, ...infer rTail]
+]) ? [
+    "0",
+    lHead,
+    rHead
+] extends [keyof l | keyof r, l[0], r[0]] ? intersectSequences<lTail, rTail, [
+    [],
+    []
+] extends [l, r] ? [
+    ...acc,
+    Hkt.apply<operation, [lHead, rHead]>?
+] : [...acc, Hkt.apply<operation, [lHead, rHead]>], postfix, operation, kind> : l extends readonly [...infer lInit, infer lLast] ? r extends readonly [...infer rInit, infer rLast] ? intersectSequences<lInit, rInit, acc, [
+    Hkt.apply<operation, [lLast, rLast]>,
+    ...postfix
+], operation, kind> : intersectSequences<lInit, r, acc, [
+    Hkt.apply<operation, [lLast, r[number]]>,
+    ...postfix
+], operation, kind> : r extends readonly [...infer rInit, infer rLast] ? intersectSequences<l, rInit, acc, [
+    Hkt.apply<operation, [l[number], rLast]>,
+    ...postfix
+], operation, kind> : [...acc, ...Hkt.apply<operation, [lHead, rHead]>[], ...postfix] : never;
+export type isDisjoint<l, r> = overlaps<l, r> extends true ? false : true;
+export type overlaps<l, r> = l & r extends never ? false : domainOf<l> & domainOf<r> extends never ? false : [l, r] extends [object, object] ? false extends (propValueOf<{
+    [k in Extract<keyof l & keyof r, requiredKeyOf<l> | requiredKeyOf<r>>]: overlaps<l[k], r[k]>;
+}>) ? false : true : true;
+export {};

package/node_modules/@ark/util/out/intersections.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@ark/util/out/isomorphic.d.ts

@@ -0,0 +1,5 @@
+import type { autocomplete } from "./generics.ts";
+export declare const isomorphic: {
+    fileName: () => string;
+    env: Record<autocomplete<"ARK_DEBUG">, string | undefined>;
+};

package/node_modules/@ark/util/out/isomorphic.js

@@ -0,0 +1,19 @@
+// based on the util of the same name in @ark/fs
+// isolated here for use with registry
+/** get a CJS/ESM compatible string representing the current file */
+const fileName = () => {
+    try {
+        const error = new Error();
+        const stackLine = error.stack?.split("\n")[2]?.trim() || ""; // [1]=this func, [2]=caller
+        const filePath = stackLine.match(/\(?(.+?)(?::\d+:\d+)?\)?$/)?.[1] || "unknown";
+        return filePath.replace(/^file:\/\//, "");
+    }
+    catch {
+        return "unknown";
+    }
+};
+const env = globalThis.process?.env ?? {};
+export const isomorphic = {
+    fileName,
+    env
+};

package/node_modules/@ark/util/out/keys.d.ts

@@ -0,0 +1,18 @@
+import type { array, join } from "./arrays.ts";
+import type { NonNegativeIntegerLiteral } from "./numbers.ts";
+export type Key = string | symbol;
+export type toArkKey<o, k extends keyof o> = k extends number ? [
+    o,
+    number
+] extends [array, k] ? NonNegativeIntegerLiteral : `${k}` : k;
+export type arkIndexableOf<o> = arkKeyOf<o> extends infer k ? k extends `${infer index extends number}` ? index | k : k : never;
+export type arkKeyOf<o> = [
+    o
+] extends [object] ? [
+    o
+] extends [array] ? arkArrayKeyOf<o> : arkObjectLiteralKeyOf<o> : never;
+type arkArrayKeyOf<a extends array> = number extends a["length"] ? NonNegativeIntegerLiteral : keyof a extends infer i ? i extends `${number}` ? i : never : never;
+type arkObjectLiteralKeyOf<o extends object> = keyof o extends infer k ? k extends number ? `${k}` : k : never;
+export type arkGet<o, k extends arkIndexableOf<o>> = o[k extends keyof o ? k : NonNegativeIntegerLiteral extends k ? number & keyof o : k extends number ? `${k}` & keyof o : never];
+export type writeInvalidKeysMessage<o extends string, keys extends array<string>> = `Key${keys["length"] extends 1 ? "" : "s"} ${join<keys, ", ">} ${keys["length"] extends 1 ? "does" : "do"} not exist on ${o}`;
+export {};

package/node_modules/@ark/util/out/keys.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@ark/util/out/lazily.d.ts

@@ -0,0 +1 @@
+export declare const lazily: <t extends object>(thunk: () => t) => t;

package/node_modules/@ark/util/out/lazily.js

@@ -0,0 +1,16 @@
+export const lazily = (thunk) => {
+    let cached;
+    return new Proxy({}, {
+        get: (_, prop) => {
+            if (!cached)
+                cached = thunk();
+            return cached[prop];
+        },
+        set: (_, prop, value) => {
+            if (!cached)
+                cached = thunk();
+            cached[prop] = value;
+            return true;
+        }
+    });
+};

package/node_modules/@ark/util/out/numbers.d.ts

@@ -0,0 +1,72 @@
+export type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type NumberLiteral<n extends number = number> = `${n}`;
+export type BigintLiteral<n extends bigint = bigint> = `${n}n`;
+export type IntegerLiteral<n extends bigint = bigint> = `${n}`;
+export type NonNegativeIntegerLiteral<n extends bigint = bigint> = `${Digit}` | (`${Exclude<Digit, 0>}${string}` & `${n}`);
+/**
+ *  Matches a well-formatted numeric expression according to the following rules:
+ *    1. Must include an integer portion (i.e. '.321' must be written as '0.321')
+ *    2. The first digit of the value must not be 0, unless the entire integer portion is 0
+ *    3. If the value includes a decimal, its last digit may not be 0
+ *    4. The value may not be "-0"
+ */
+export declare const wellFormedNumberMatcher: RegExp;
+export declare const isWellFormedNumber: RegExp["test"];
+/**
+ * Similar to wellFormedNumber but more permissive in the following ways:
+ *
+ *  - Allows numbers without an integer portion like ".5" (well-formed equivalent is "0.5")
+ *  - Allows decimals with trailing zeroes like "0.10" (well-formed equivalent is "0.1")
+ */
+export declare const numericStringMatcher: RegExp;
+export declare const isNumericString: (string: string) => boolean;
+export declare const numberLikeMatcher: RegExp;
+/**
+ *  Matches a well-formatted integer according to the following rules:
+ *    1. must begin with an integer, the first digit of which cannot be 0 unless the entire value is 0
+ *    2. The value may not be "-0"
+ */
+export declare const wellFormedIntegerMatcher: RegExp;
+export declare const isWellFormedInteger: RegExp["test"];
+export declare const integerLikeMatcher: RegExp;
+type NumericLiteralKind = "number" | "bigint" | "integer";
+declare const numericLiteralDescriptions: {
+    readonly number: "a number";
+    readonly bigint: "a bigint";
+    readonly integer: "an integer";
+};
+type numericLiteralDescriptions = typeof numericLiteralDescriptions;
+export type writeMalformedNumericLiteralMessage<def extends string, kind extends NumericLiteralKind> = `'${def}' was parsed as ${numericLiteralDescriptions[kind]} but could not be narrowed to a literal value. Avoid unnecessary leading or trailing zeros and other abnormal notation`;
+export declare const writeMalformedNumericLiteralMessage: <def extends string, kind extends NumericLiteralKind>(def: def, kind: kind) => writeMalformedNumericLiteralMessage<def, kind>;
+export declare const tryParseNumber: <errorOnFail extends boolean | string>(token: string, options?: NumericParseOptions<errorOnFail>) => errorOnFail extends true | string ? number : number | undefined;
+export declare const tryParseWellFormedNumber: typeof tryParseNumber;
+export type tryParseNumber<token extends string, messageOnFail extends string> = token extends `${infer n extends number}` ? number extends n ? writeMalformedNumericLiteralMessage<token, "number"> : n : messageOnFail;
+export type parseNumber<token extends string> = token extends `${infer n extends number}` ? n : never;
+export declare const tryParseInteger: <errorOnFail extends boolean | string>(token: string, options?: NumericParseOptions<errorOnFail>) => errorOnFail extends true | string ? number : number | undefined;
+export type tryParseInteger<token extends string, messageOnFail extends string> = token extends `${infer b extends bigint}` ? bigint extends b ? writeMalformedNumericLiteralMessage<token, "integer"> : token extends `${infer n extends number}` ? n : never : messageOnFail;
+export type parseInteger<token extends string> = token extends `${bigint}` ? token extends `${infer n extends number}` ? n : never : never;
+export type parseNonNegativeInteger<token extends string> = token extends `-${string}` ? never : parseInteger<token>;
+export type NumericParseOptions<errorOnFail extends boolean | string> = {
+    errorOnFail?: errorOnFail;
+    strict?: boolean;
+};
+export declare const tryParseWellFormedBigint: (def: string) => bigint | undefined;
+/**
+ * Returns the next or previous representable floating-point number after the given input.
+ *
+ * @param {"+" | "-"} [direction="+"] - The direction to find the nearest float. "+" for the next float, "-" for the previous float.
+ * @throws {Error} If the input is not a finite number.
+ *
+ * @example
+ * console.log(nearestFloat(0)); // Smallest positive number
+ * console.log(nearestFloat(2)); // 2.0000000000000004
+ * console.log(nearestFloat(2.1)); // 2.1000000000000005
+ * console.log(nearestFloat(2, "-")); // 1.9999999999999998
+ * console.log(nearestFloat(2.1, "-")); // 2.0999999999999996
+ * // as size of input increases, the increments become larger to stay within what
+ * // JS can represent in a numeric value
+ * console.log(nearestFloat(5555555555555555)); // 5555555555555556
+ * console.log(nearestFloat(5555555555555555, "-")); // 5555555555555554
+ */
+export declare const nearestFloat: (n: number, direction?: "+" | "-") => number;
+export {};

package/node_modules/@ark/util/out/numbers.js

@@ -0,0 +1,138 @@
+import { throwParseError } from "./errors.js";
+import { anchoredRegex, RegexPatterns } from "./strings.js";
+/*
+ * The goal of the number literal and bigint literal regular expressions is to:
+ *
+ *   1. Ensure definitions form a bijection with the values they represent.
+ *   2. Attempt to mirror TypeScript's own format for stringification of numeric
+ *      values such that the regex should match a given definition if any only if
+ *      a precise literal type will be inferred (in TS4.8+).
+ */
+const anchoredNegativeZeroPattern = /^-0\.?0*$/.source;
+const positiveIntegerPattern = /[1-9]\d*/.source;
+const looseDecimalPattern = /\.\d+/.source;
+const strictDecimalPattern = /\.\d*[1-9]/.source;
+const createNumberMatcher = (opts) => anchoredRegex(RegexPatterns.negativeLookahead(anchoredNegativeZeroPattern) +
+    RegexPatterns.nonCapturingGroup("-?" +
+        RegexPatterns.nonCapturingGroup(RegexPatterns.nonCapturingGroup("0|" + positiveIntegerPattern) +
+            RegexPatterns.nonCapturingGroup(opts.decimalPattern) +
+            "?") +
+        (opts.allowDecimalOnly ? "|" + opts.decimalPattern : "") +
+        "?"));
+/**
+ *  Matches a well-formatted numeric expression according to the following rules:
+ *    1. Must include an integer portion (i.e. '.321' must be written as '0.321')
+ *    2. The first digit of the value must not be 0, unless the entire integer portion is 0
+ *    3. If the value includes a decimal, its last digit may not be 0
+ *    4. The value may not be "-0"
+ */
+export const wellFormedNumberMatcher = createNumberMatcher({
+    decimalPattern: strictDecimalPattern,
+    allowDecimalOnly: false
+});
+export const isWellFormedNumber = wellFormedNumberMatcher.test.bind(wellFormedNumberMatcher);
+/**
+ * Similar to wellFormedNumber but more permissive in the following ways:
+ *
+ *  - Allows numbers without an integer portion like ".5" (well-formed equivalent is "0.5")
+ *  - Allows decimals with trailing zeroes like "0.10" (well-formed equivalent is "0.1")
+ */
+export const numericStringMatcher = createNumberMatcher({
+    decimalPattern: looseDecimalPattern,
+    allowDecimalOnly: true
+});
+export const isNumericString = numericStringMatcher.test.bind(numericStringMatcher);
+export const numberLikeMatcher = /^-?\d*\.?\d*$/;
+const isNumberLike = (s) => s.length !== 0 && numberLikeMatcher.test(s);
+/**
+ *  Matches a well-formatted integer according to the following rules:
+ *    1. must begin with an integer, the first digit of which cannot be 0 unless the entire value is 0
+ *    2. The value may not be "-0"
+ */
+export const wellFormedIntegerMatcher = anchoredRegex(RegexPatterns.negativeLookahead("^-0$") +
+    "-?" +
+    RegexPatterns.nonCapturingGroup(RegexPatterns.nonCapturingGroup("0|" + positiveIntegerPattern)));
+export const isWellFormedInteger = wellFormedIntegerMatcher.test.bind(wellFormedIntegerMatcher);
+export const integerLikeMatcher = /^-?\d+$/;
+const isIntegerLike = integerLikeMatcher.test.bind(integerLikeMatcher);
+const numericLiteralDescriptions = {
+    number: "a number",
+    bigint: "a bigint",
+    integer: "an integer"
+};
+export const writeMalformedNumericLiteralMessage = (def, kind) => `'${def}' was parsed as ${numericLiteralDescriptions[kind]} but could not be narrowed to a literal value. Avoid unnecessary leading or trailing zeros and other abnormal notation`;
+const isWellFormed = (def, kind) => kind === "number" ? isWellFormedNumber(def) : isWellFormedInteger(def);
+const parseKind = (def, kind) => kind === "number" ? Number(def) : Number.parseInt(def);
+const isKindLike = (def, kind) => kind === "number" ? isNumberLike(def) : isIntegerLike(def);
+export const tryParseNumber = (token, options) => parseNumeric(token, "number", options);
+export const tryParseWellFormedNumber = (token, options) => parseNumeric(token, "number", { ...options, strict: true });
+export const tryParseInteger = (token, options) => parseNumeric(token, "integer", options);
+const parseNumeric = (token, kind, options) => {
+    const value = parseKind(token, kind);
+    if (!Number.isNaN(value)) {
+        if (isKindLike(token, kind)) {
+            if (options?.strict) {
+                return isWellFormed(token, kind) ? value : (throwParseError(writeMalformedNumericLiteralMessage(token, kind)));
+            }
+            return value;
+        }
+    }
+    return (options?.errorOnFail ?
+        throwParseError(options?.errorOnFail === true ?
+            `Failed to parse ${numericLiteralDescriptions[kind]} from '${token}'`
+            : options?.errorOnFail)
+        : undefined);
+};
+export const tryParseWellFormedBigint = (def) => {
+    if (def[def.length - 1] !== "n")
+        return;
+    const maybeIntegerLiteral = def.slice(0, -1);
+    let value;
+    try {
+        value = BigInt(maybeIntegerLiteral);
+    }
+    catch {
+        return;
+    }
+    if (wellFormedIntegerMatcher.test(maybeIntegerLiteral))
+        return value;
+    if (integerLikeMatcher.test(maybeIntegerLiteral)) {
+        // If the definition looks like a bigint but is
+        // not well-formed, throw.
+        return throwParseError(writeMalformedNumericLiteralMessage(def, "bigint"));
+    }
+};
+/**
+ * Returns the next or previous representable floating-point number after the given input.
+ *
+ * @param {"+" | "-"} [direction="+"] - The direction to find the nearest float. "+" for the next float, "-" for the previous float.
+ * @throws {Error} If the input is not a finite number.
+ *
+ * @example
+ * console.log(nearestFloat(0)); // Smallest positive number
+ * console.log(nearestFloat(2)); // 2.0000000000000004
+ * console.log(nearestFloat(2.1)); // 2.1000000000000005
+ * console.log(nearestFloat(2, "-")); // 1.9999999999999998
+ * console.log(nearestFloat(2.1, "-")); // 2.0999999999999996
+ * // as size of input increases, the increments become larger to stay within what
+ * // JS can represent in a numeric value
+ * console.log(nearestFloat(5555555555555555)); // 5555555555555556
+ * console.log(nearestFloat(5555555555555555, "-")); // 5555555555555554
+ */
+export const nearestFloat = (n, direction = "+") => {
+    const buffer = new ArrayBuffer(8);
+    const f64 = new Float64Array(buffer);
+    const u32 = new Uint32Array(buffer);
+    f64[0] = n;
+    if (n === 0) {
+        u32[0] = 1;
+        u32[1] = direction === "-" ? 1 << 31 : 0;
+    }
+    else if ((n > 0 && direction === "+") || (n < 0 && direction === "-")) {
+        if (u32[0]++ === 0xffffffff)
+            u32[1]++;
+    }
+    else if (u32[0]-- === 0)
+        u32[1]--;
+    return f64[0];
+};