pi-improve-interation 0.0.1

package/node_modules/typebox/build/type/script/script.mjs

@@ -0,0 +1,21 @@
+// deno-lint-ignore-file
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { InstantiateType } from '../engine/instantiate.mjs';
+import { Never } from '../types/index.mjs';
+import * as Parser from './parser.mjs';
+/** Parses a type from a TypeScript type expression */
+export function Script(...args) {
+    const [context, input, options] = Arguments.Match(args, {
+        2: (script, options) => Guard.IsString(script) ? [{}, script, options] : [script, options, {}],
+        3: (context, script, options) => [context, script, options],
+        1: (script) => [{}, script, {}],
+    });
+    const result = Parser.Script(input);
+    const parsed = Guard.IsArray(result) && Guard.IsEqual(result.length, 2)
+        ? InstantiateType(context, { callstack: [] }, result[0])
+        : Never();
+    return Memory.Update(parsed, {}, options);
+}

package/node_modules/typebox/build/type/script/token/bigint.d.mts

@@ -0,0 +1,8 @@
+import { type TTake } from './internal/take.mjs';
+import { type TInteger } from './integer.mjs';
+type TTakeBigInt<Input extends string> = (TInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string] ? TTake<['n'], IntegerRest> extends [infer _N extends string, infer NRest extends string] ? [`${Integer}`, NRest] : [] : []);
+/** Matches if next is a Integer literal with trailing 'n'. Trailing 'n' is omitted in result. */
+export type TBigInt<Input extends string> = (TTakeBigInt<Input>);
+/** Matches if next is a Integer literal with trailing 'n'. Trailing 'n' is omitted in result. */
+export declare function BigInt<Input extends string>(input: Input): TBigInt<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/bigint.mjs

@@ -0,0 +1,14 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Take } from './internal/take.mjs';
+import { Integer } from './integer.mjs';
+function TakeBigInt(input) {
+    return Match(Integer(input), (Integer, IntegerRest) => Match(Take(['n'], IntegerRest), (_N, NRest) => [`${Integer}`, NRest], () => []), // fail: did not match 'n'
+    () => []); // fail: did not match Integer
+}
+/** Matches if next is a Integer literal with trailing 'n'. Trailing 'n' is omitted in result. */
+export function BigInt(input) {
+    return TakeBigInt(input);
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/const.d.mts

@@ -0,0 +1,11 @@
+import { type TTrimWhitespace } from './internal/trim.mjs';
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TNewLine } from './internal/char.mjs';
+import { type TWhiteSpace } from './internal/char.mjs';
+type TTakeConst<Const extends string, Input extends string> = (TTake<[Const], Input>);
+/** Matches if next is the given Const value */
+export type TConst<Const extends string, Input extends string> = (Const extends '' ? ['', Input] : Const extends `${infer First extends string}${string}` ? (First extends TNewLine ? TTakeConst<Const, TTrimWhitespace<Input>> : First extends TWhiteSpace ? TTakeConst<Const, Input> : TTakeConst<Const, TTrim<Input>>) : never);
+/** Matches if next is the given Const value */
+export declare function Const<Const extends string, Input extends string>(const_: Const, input: Input): TConst<Const, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/const.mjs

@@ -0,0 +1,18 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { TrimWhitespace } from './internal/trim.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { NewLine } from './internal/char.mjs';
+import { WhiteSpace } from './internal/char.mjs';
+function TakeConst(const_, input) {
+    return Take([const_], input);
+}
+/** Matches if next is the given Const value */
+export function Const(const_, input) {
+    return (IsEqual(const_, '') ? ['', input] : (const_.startsWith(NewLine) ? TakeConst(const_, TrimWhitespace(input)) :
+        const_.startsWith(WhiteSpace) ? TakeConst(const_, input) :
+            TakeConst(const_, Trim(input))));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/ident.d.mts

@@ -0,0 +1,16 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TAlpha } from './internal/char.mjs';
+import { type TDigit } from './internal/char.mjs';
+import { type TUnderScore } from './internal/char.mjs';
+import { type TDollarSign } from './internal/char.mjs';
+type TInitial = [...TAlpha, TUnderScore, TDollarSign];
+type TTakeInitial<Input extends string> = (TTake<TInitial, Input>);
+type TRemaining = [...TInitial, ...TDigit];
+type TTakeRemaining<Input extends string, Result extends string = ''> = (TTake<TRemaining, Input> extends [infer Remaining extends string, infer RemainingRest extends string] ? TTakeRemaining<RemainingRest, `${Result}${Remaining}`> : [Result, Input]);
+type TTakeIdent<Input extends string> = (TTakeInitial<Input> extends [infer Initial extends string, infer InitialRest extends string] ? TTakeRemaining<InitialRest> extends [infer Remaining extends string, infer RemainingRest extends string] ? [`${Initial}${Remaining}`, RemainingRest] : [] : []);
+/** Matches if next is an Ident */
+export type TIdent<Input extends string> = (TTakeIdent<TTrim<Input>>);
+/** Matches if next is an Ident */
+export declare function Ident<Input extends string>(input: Input): TIdent<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/ident.mjs

@@ -0,0 +1,26 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Alpha } from './internal/char.mjs';
+import { Digit } from './internal/char.mjs';
+import { UnderScore } from './internal/char.mjs';
+import { DollarSign } from './internal/char.mjs';
+const Initial = [...Alpha, UnderScore, DollarSign];
+function TakeInitial(input) {
+    return Take(Initial, input);
+}
+const Remaining = [...Initial, ...Digit];
+function TakeRemaining(input, result = '') {
+    return Match(Take(Remaining, input), (Remaining, RemainingRest) => TakeRemaining(RemainingRest, `${result}${Remaining}`), () => [result, input]);
+}
+function TakeIdent(input) {
+    return Match(TakeInitial(input), (Initial, InitialRest) => Match(TakeRemaining(InitialRest), (Remaining, RemainingRest) => [`${Initial}${Remaining}`, RemainingRest], () => []), // fail: did not match Remaining
+    () => []); // fail: did not match Initial
+}
+/** Matches if next is an Ident */
+export function Ident(input) {
+    return TakeIdent(Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/index.d.mts

@@ -0,0 +1,12 @@
+export * from './bigint.mjs';
+export * from './const.mjs';
+export * from './ident.mjs';
+export * from './integer.mjs';
+export * from './number.mjs';
+export * from './rest.mjs';
+export * from './span.mjs';
+export * from './string.mjs';
+export * from './unsigned_integer.mjs';
+export * from './unsigned_number.mjs';
+export * from './until_1.mjs';
+export * from './until.mjs';

package/node_modules/typebox/build/type/script/token/index.mjs

@@ -0,0 +1,12 @@
+export * from './bigint.mjs';
+export * from './const.mjs';
+export * from './ident.mjs';
+export * from './integer.mjs';
+export * from './number.mjs';
+export * from './rest.mjs';
+export * from './span.mjs';
+export * from './string.mjs';
+export * from './unsigned_integer.mjs';
+export * from './unsigned_number.mjs';
+export * from './until_1.mjs';
+export * from './until.mjs';

package/node_modules/typebox/build/type/script/token/integer.d.mts

@@ -0,0 +1,11 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TOptional } from './internal/optional.mjs';
+import { type THyphen } from './internal/char.mjs';
+import { type TUnsignedInteger } from './unsigned_integer.mjs';
+type TTakeSign<Input extends string> = (TOptional<THyphen, Input>);
+type TTakeSignedInteger<Input extends string> = (TTakeSign<Input> extends [infer Sign extends string, infer SignRest extends string] ? TUnsignedInteger<SignRest> extends [infer UnsignedInteger extends string, infer UnsignedIntegerRest extends string] ? [`${Sign}${UnsignedInteger}`, UnsignedIntegerRest] : [] : []);
+/** Matches if next is a signed or unsigned Integer */
+export type TInteger<Input extends string> = (TTakeSignedInteger<TTrim<Input>>);
+/** Matches if next is a signed or unsigned Integer */
+export declare function Integer<Input extends string>(input: Input): TInteger<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/integer.mjs

@@ -0,0 +1,19 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Optional } from './internal/optional.mjs';
+import { Hyphen } from './internal/char.mjs';
+import { UnsignedInteger } from './unsigned_integer.mjs';
+function TakeSign(input) {
+    return Optional(Hyphen, input);
+}
+function TakeSignedInteger(input) {
+    return Match(TakeSign(input), (Sign, SignRest) => Match(UnsignedInteger(SignRest), (UnsignedInteger, UnsignedIntegerRest) => [`${Sign}${UnsignedInteger}`, UnsignedIntegerRest], () => []), // fail: did not match unsigned integer
+    () => []); // fail: did not match Sign
+}
+/** Matches if next is a signed or unsigned Integer */
+export function Integer(input) {
+    return TakeSignedInteger(Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/char.d.mts

@@ -0,0 +1,75 @@
+export type TAlpha = [
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z'
+];
+export declare const Alpha: TAlpha;
+export type TZero = typeof Zero;
+export type TNonZero = ['1', '2', '3', '4', '5', '6', '7', '8', '9'];
+export type TDigit = [TZero, ...TNonZero];
+export declare const Zero = "0";
+export declare const NonZero: TNonZero;
+export declare const Digit: TDigit;
+export declare const WhiteSpace = " ";
+export declare const NewLine = "\n";
+export declare const TabSpace = "\t";
+export declare const UnderScore = "_";
+export declare const Dot = ".";
+export declare const DollarSign = "$";
+export declare const Hyphen = "-";
+export type TWhiteSpace = typeof WhiteSpace;
+export type TNewLine = typeof NewLine;
+export type TTabSpace = typeof TabSpace;
+export type TUnderScore = typeof UnderScore;
+export type TDot = typeof Dot;
+export type TDollarSign = typeof DollarSign;
+export type THyphen = typeof Hyphen;

package/node_modules/typebox/build/type/script/token/internal/char.mjs

@@ -0,0 +1,26 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+// ------------------------------------------------------------------
+// Range
+// ------------------------------------------------------------------
+function Range(start, end) {
+    return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+export const Alpha = [
+    ...Range(97, 122), // Lowercase
+    ...Range(65, 90) // Uppercase
+];
+export const Zero = '0';
+export const NonZero = Range(49, 57); // 1 - 9
+export const Digit = [Zero, ...NonZero];
+// ------------------------------------------------------------------
+// Characters
+// ------------------------------------------------------------------
+export const WhiteSpace = ' ';
+export const NewLine = '\n';
+export const TabSpace = '\t';
+export const UnderScore = '_';
+export const Dot = '.';
+export const DollarSign = '$';
+export const Hyphen = '-';
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/guard.d.mts

@@ -0,0 +1 @@
+export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';

package/node_modules/typebox/build/type/script/token/internal/guard.mjs

@@ -0,0 +1,15 @@
+// deno-coverage-ignore-start - parsebox tested
+export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
+// ------------------------------------------------------------------
+// Internal Guards to ensure Token is portable.
+// ------------------------------------------------------------------
+// export function IsArray(value: unknown): value is unknown[] {
+//   return Array.isArray(value)
+// }
+// export function IsString(value: unknown): value is string {
+//   return IsEqual(typeof value, 'string')
+// }
+// export function IsEqual(left: unknown, right: unknown): boolean {
+//   return left === right
+// }
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/many.d.mts

@@ -0,0 +1,7 @@
+import { type TTake } from './take.mjs';
+type TIsDiscard<Discard extends string[], Input extends string> = (Discard extends [infer Left extends string, ...infer Right extends string[]] ? Input extends Left ? true : TIsDiscard<Right, Input> : false);
+/** Takes characters from the Input until no-match. The Discard set is used to omit characters from the match */
+export type TMany<Allowed extends string[], Discard extends string[], Input extends string, Result extends string = ''> = (TTake<Allowed, Input> extends [infer Char extends string, infer Rest extends string] ? TIsDiscard<Discard, Char> extends true ? TMany<Allowed, Discard, Rest, Result> : TMany<Allowed, Discard, Rest, `${Result}${Char}`> : [Result, Input]);
+/** Takes characters from the Input until no-match. The Discard set is used to omit characters from the match */
+export declare function Many<Allowed extends string[], Discard extends string[], Input extends string>(allowed: [...Allowed], discard: [...Discard], input: Input, result?: string): TMany<Allowed, Discard, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/internal/many.mjs

@@ -0,0 +1,14 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './match.mjs';
+import { Take } from './take.mjs';
+function IsDiscard(discard, input) {
+    return discard.includes(input);
+}
+/** Takes characters from the Input until no-match. The Discard set is used to omit characters from the match */
+export function Many(allowed, discard, input, result = '') {
+    return Match(Take(allowed, input), (Char, Rest) => IsDiscard(discard, Char)
+        ? Many(allowed, discard, Rest, result)
+        : Many(allowed, discard, Rest, `${result}${Char}`), () => [result, input]);
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/match.d.mts

@@ -0,0 +1,6 @@
+type TResult = [string, string] | [];
+/** Checks the value is a Tuple-2 [string, string] result */
+export declare function IsMatch(value: TResult): value is [string, string];
+/** Matches on a result and dispatches either left or right arm */
+export declare function Match(input: TResult, ok: (value: string, rest: string) => TResult, fail: () => TResult): TResult;
+export {};

package/node_modules/typebox/build/type/script/token/internal/match.mjs

@@ -0,0 +1,11 @@
+// deno-coverage-ignore-start - parsebox tested
+import { IsEqual } from './guard.mjs';
+/** Checks the value is a Tuple-2 [string, string] result */
+export function IsMatch(value) {
+    return IsEqual(value.length, 2);
+}
+/** Matches on a result and dispatches either left or right arm */
+export function Match(input, ok, fail) {
+    return IsMatch(input) ? ok(input[0], input[1]) : fail();
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/optional.d.mts

@@ -0,0 +1,5 @@
+import { type TTake } from './take.mjs';
+/** Matches the given Value or empty string if no match. This function never fails */
+export type TOptional<Value extends string, Input extends string> = (TTake<[Value], Input> extends [infer Optional extends string, infer Rest extends string] ? [Optional, Rest] : ['', Input]);
+/** Matches the given Value or empty string if no match. This function never fails */
+export declare function Optional<Value extends string, Input extends string>(value: Value, input: Input): TOptional<Value, Value>;

package/node_modules/typebox/build/type/script/token/internal/optional.mjs

@@ -0,0 +1,9 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './match.mjs';
+import { Take } from './take.mjs';
+/** Matches the given Value or empty string if no match. This function never fails */
+export function Optional(value, input) {
+    return Match(Take([value], input), (Optional, Rest) => [Optional, Rest], () => ['', input]);
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/take.d.mts

@@ -0,0 +1,6 @@
+type TTakeVariant<Variant extends string, Input extends string> = (Input extends `${Variant}${infer Rest extends string}` ? [Variant, Rest] : []);
+/** Takes one of the given variants or fail */
+export type TTake<Variants extends string[], Input extends string> = (Variants extends [infer ValueLeft extends string, ...infer ValueRight extends string[]] ? TTakeVariant<ValueLeft, Input> extends [infer Take extends string, infer Rest extends string] ? [Take, Rest] : TTake<ValueRight, Input> : []);
+/** Takes one of the given variants or fail */
+export declare function Take<Variants extends string[], Input extends string>(variants: [...Variants], input: Input): TTake<Variants, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/internal/take.mjs

@@ -0,0 +1,30 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsMatch } from './match.mjs';
+import { IsEqual } from './guard.mjs';
+function TakeVariant(variant, input) {
+    return (IsEqual(input.indexOf(variant), 0)
+        ? [variant, input.slice(variant.length)]
+        : []);
+}
+/** Takes one of the given variants or fail */
+export function Take(variants, input) {
+    // ----------------------------------------------------------------
+    // Symmetric
+    // ----------------------------------------------------------------
+    // return Guard.TakeLeft(variants, (valueLeft, valueRight) => 
+    //   Match(TakeVariant(valueLeft, input), (take, rest) => 
+    //     [take, rest],
+    //     () => Take(valueRight, input)),
+    //   () => []) as never
+    // ----------------------------------------------------------------
+    // Inline
+    // ----------------------------------------------------------------
+    for (let i = 0; i < variants.length; i++) {
+        const result = TakeVariant(variants[i], input);
+        if (IsMatch(result))
+            return result;
+    }
+    return [];
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/internal/trim.d.mts

@@ -0,0 +1,19 @@
+import * as Char from './char.mjs';
+type LineComment = typeof LineComment;
+type OpenComment = typeof OpenComment;
+type CloseComment = typeof CloseComment;
+declare const LineComment = "//";
+declare const OpenComment = "/*";
+declare const CloseComment = "*/";
+type TDiscardMultiLineComment<Input extends string> = (Input extends `${string}${CloseComment}${infer Rest extends string}` ? Rest : '');
+type TDiscardLineComment<Input extends string> = (Input extends `${string}${Char.TNewLine}${infer Rest extends string}` ? TTrimWhitespace<`${Char.TNewLine}${Rest}`> : '');
+type W4 = `${W3}${W3}`;
+type W3 = `${W2}${W2}`;
+type W2 = `${W1}${W1}`;
+type W1 = `${W0}${W0}`;
+type W0 = ` `;
+export type TTrimWhitespace<Input extends string> = (Input extends `${OpenComment}${infer Rest extends string}` ? TTrimWhitespace<TDiscardMultiLineComment<Rest>> : Input extends `${LineComment}${infer Rest extends string}` ? TTrimWhitespace<TDiscardLineComment<Rest>> : Input extends `${W4}${infer Rest extends string}` ? TTrimWhitespace<Rest> : Input extends `${W3}${infer Rest extends string}` ? TTrimWhitespace<Rest> : Input extends `${W1}${infer Rest extends string}` ? TTrimWhitespace<Rest> : Input extends `${W0}${infer Rest extends string}` ? TTrimWhitespace<Rest> : Input);
+export declare function TrimWhitespace<Input extends string>(input: Input): TTrimWhitespace<Input>;
+export type TTrim<Input extends string> = (Input extends `${OpenComment}${infer Rest extends string}` ? TTrim<TDiscardMultiLineComment<Rest>> : Input extends `${LineComment}${infer Rest extends string}` ? TTrim<TDiscardLineComment<Rest>> : Input extends `${Char.TNewLine}${infer Rest extends string}` ? TTrim<Rest> : Input extends `${Char.TTabSpace}${infer Rest extends string}` ? TTrim<Rest> : Input extends `${W4}${infer Rest extends string}` ? TTrim<Rest> : Input extends `${W3}${infer Rest extends string}` ? TTrim<Rest> : Input extends `${W1}${infer Rest extends string}` ? TTrim<Rest> : Input extends `${W0}${infer Rest extends string}` ? TTrim<Rest> : Input);
+export declare function Trim<Input extends string>(input: Input): TTrim<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/internal/trim.mjs

@@ -0,0 +1,34 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './guard.mjs';
+import * as Char from './char.mjs';
+const LineComment = '//';
+const OpenComment = '/*';
+const CloseComment = '*/';
+function DiscardMultilineComment(input) {
+    const index = input.indexOf(CloseComment);
+    const result = IsEqual(index, -1) ? '' : input.slice(index + 2);
+    return result;
+}
+function DiscardLineComment(input) {
+    const index = input.indexOf(Char.NewLine);
+    const result = IsEqual(index, -1) ? '' : input.slice(index);
+    return result;
+}
+// ...
+function TrimStartUntilNewline(input) {
+    return input.replace(/^[ \t\r\f\v]+/, '');
+}
+export function TrimWhitespace(input) {
+    const trimmed = TrimStartUntilNewline(input);
+    return (trimmed.startsWith(OpenComment) ? TrimWhitespace(DiscardMultilineComment(trimmed.slice(2))) :
+        trimmed.startsWith(LineComment) ? TrimWhitespace(DiscardLineComment(trimmed.slice(2))) :
+            trimmed);
+}
+export function Trim(input) {
+    const trimmed = input.trimStart();
+    return (trimmed.startsWith(OpenComment) ? Trim(DiscardMultilineComment(trimmed.slice(2))) :
+        trimmed.startsWith(LineComment) ? Trim(DiscardLineComment(trimmed.slice(2))) :
+            trimmed);
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/number.d.mts

@@ -0,0 +1,11 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TOptional } from './internal/optional.mjs';
+import { type THyphen } from './internal/char.mjs';
+import { type TUnsignedNumber } from './unsigned_number.mjs';
+type TTakeSign<Input extends string> = (TOptional<THyphen, Input>);
+type TTakeSignedNumber<Input extends string> = (TTakeSign<Input> extends [infer Sign extends string, infer SignRest extends string] ? TUnsignedNumber<SignRest> extends [infer UnsignedInteger extends string, infer UnsignedIntegerRest extends string] ? [`${Sign}${UnsignedInteger}`, UnsignedIntegerRest] : [] : []);
+/** Matches if next is a signed or unsigned Number */
+export type TNumber<Input extends string> = (TTakeSignedNumber<TTrim<Input>>);
+/** Matches if next is a signed or unsigned Number */
+export declare function Number<Input extends string>(input: Input): TNumber<Input>;
+export {};

package/node_modules/typebox/build/type/script/token/number.mjs

@@ -0,0 +1,19 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Optional } from './internal/optional.mjs';
+import { Hyphen } from './internal/char.mjs';
+import { UnsignedNumber } from './unsigned_number.mjs';
+function TakeSign(input) {
+    return Optional(Hyphen, input);
+}
+function TakeSignedNumber(input) {
+    return Match(TakeSign(input), (Sign, SignRest) => Match(UnsignedNumber(SignRest), (UnsignedInteger, UnsignedIntegerRest) => [`${Sign}${UnsignedInteger}`, UnsignedIntegerRest], () => []), // fail: did not match unsigned integer
+    () => []); // fail: did not match Sign
+}
+/** Matches if next is a signed or unsigned Number */
+export function Number(input) {
+    return TakeSignedNumber(Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/rest.d.mts

@@ -0,0 +1,4 @@
+/** Match remaining characters in the buffer until end. If no characters are in buffer, no match */
+export type TRest<Input extends string> = (Input extends '' ? [] : [Input, '']);
+/** Match remaining characters in the buffer until end. If no characters are in buffer, no match */
+export declare function Rest<Input extends string>(input: Input): TRest<Input>;

package/node_modules/typebox/build/type/script/token/rest.mjs

@@ -0,0 +1,9 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+/** Match remaining characters in the buffer until end. If no characters are in buffer, no match */
+export function Rest(input) {
+    const result = IsEqual(input, '') ? [] : [input, ''];
+    return result;
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/span.d.mts

@@ -0,0 +1,11 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TNewLine } from './internal/char.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TUntil } from './until.mjs';
+type TMultiLine<Start extends string, End extends string, Input extends string> = (TTake<[Start], Input> extends [infer _, infer Rest extends string] ? TUntil<[End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? TTake<[End], UntilRest> extends [infer _ extends string, infer Rest extends string] ? [`${Until}`, Rest] : [] : [] : []);
+type TSingleLine<Start extends string, End extends string, Input extends string> = (TTake<[Start], Input> extends [infer _ extends string, infer Rest extends string] ? TUntil<[TNewLine, End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? TTake<[End], UntilRest> extends [infer _ extends string, infer EndRest extends string] ? [`${Until}`, EndRest] : [] : [] : []);
+/** Matches from Start and End capturing everything in-between. Start and End are consumed. */
+export type TSpan<Start extends string, End extends string, MultiLine extends boolean, Input extends string> = (MultiLine extends true ? TMultiLine<Start, End, TTrim<Input>> : TSingleLine<Start, End, TTrim<Input>>);
+/** Matches from Start and End capturing everything in-between. Start and End are consumed. */
+export declare function Span<Start extends string, End extends string, MultiLine extends boolean, Input extends string>(start: Start, end: End, multiLine: MultiLine, input: Input): TSpan<Start, End, MultiLine, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/span.mjs

@@ -0,0 +1,24 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { NewLine } from './internal/char.mjs';
+import { Take } from './internal/take.mjs';
+import { Until } from './until.mjs';
+function MultiLine(start, end, input) {
+    return Match(Take([start], input), (_, Rest) => Match(Until([end], Rest), (Until, UntilRest) => Match(Take([end], UntilRest), (_, Rest) => [`${Until}`, Rest], () => []), // fail: did not match End
+    () => []), // fail: did not match Until
+    () => []); // fail: did not match Start
+}
+function SingleLine(start, end, input) {
+    return Match(Take([start], input), (_, Rest) => Match(Until([NewLine, end], Rest), (Until, UntilRest) => Match(Take([end], UntilRest), (_, EndRest) => [`${Until}`, EndRest], () => []), // fail: did not match End
+    () => []), // fail: did not match Until
+    () => []); // fail: not match Start
+}
+/** Matches from Start and End capturing everything in-between. Start and End are consumed. */
+export function Span(start, end, multiLine, input) {
+    return (multiLine
+        ? MultiLine(start, end, Trim(input))
+        : SingleLine(start, end, Trim(input)));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/string.d.mts

@@ -0,0 +1,11 @@
+import { type TTake } from './internal/take.mjs';
+import { type TTrim } from './internal/trim.mjs';
+import { type TSpan } from './span.mjs';
+type TTakeInitial<Quotes extends string[], Input extends string> = (TTake<Quotes, Input>);
+type TTakeSpan<Quote extends string, Input extends string> = (TSpan<Quote, Quote, false, Input>);
+type TTakeString<Quotes extends string[], Input extends string> = (TTakeInitial<Quotes, Input> extends [infer Initial extends string, infer InitialRest extends string] ? TTakeSpan<Initial, `${Initial}${InitialRest}`> : []);
+/** Matches a literal String with the given quotes */
+export type TString<Quotes extends string[], Input extends string> = (TTakeString<Quotes, TTrim<Input>>);
+/** Matches a literal String with the given quotes */
+export declare function String<Quotes extends string[], Input extends string>(quotes: [...Quotes], input: Input): TString<Quotes, Input>;
+export {};

package/node_modules/typebox/build/type/script/token/string.mjs

@@ -0,0 +1,20 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
+import { Take } from './internal/take.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Span } from './span.mjs';
+function TakeInitial(quotes, input) {
+    return Take(quotes, input);
+}
+function TakeSpan(quote, input) {
+    return Span(quote, quote, false, input);
+}
+function TakeString(quotes, input) {
+    return Match(TakeInitial(quotes, input), (Initial, InitialRest) => TakeSpan(Initial, `${Initial}${InitialRest}`), () => []); // fail: did not match Initial
+}
+/** Matches a literal String with the given quotes */
+export function String(quotes, input) {
+    return TakeString(quotes, Trim(input));
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/unsigned_integer.d.mts

@@ -0,0 +1,16 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TDigit } from './internal/char.mjs';
+import { type TZero } from './internal/char.mjs';
+import { type TNonZero } from './internal/char.mjs';
+import { type TUnderScore } from './internal/char.mjs';
+type TTakeNonZero<Input extends string> = (TTake<TNonZero, Input>);
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TTakeDigits<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input>);
+type TTakeUnsignedInteger<Input extends string> = (TTake<[TZero], Input> extends [infer Zero extends string, infer ZeroRest extends string] ? [Zero, ZeroRest] : TTakeNonZero<Input> extends [infer NonZero extends string, infer NonZeroRest extends string] ? TTakeDigits<NonZeroRest> extends [infer Digits extends string, infer DigitsRest extends string] ? [`${NonZero}${Digits}`, DigitsRest] : [] : []);
+/** Matches if next is a UnsignedInteger */
+export type TUnsignedInteger<Input extends string> = (TTakeUnsignedInteger<TTrim<Input>>);
+/** Matches if next is a UnsignedInteger */
+export declare function UnsignedInteger<Input extends string>(input: Input): TUnsignedInteger<Input>;
+export {};