typebox 0.0.1 → 1.0.0

package/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/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/build/type/script/token/bigint.mjs

@@ -0,0 +1,20 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './internal/result.mjs';
+import { Take } from './internal/take.mjs';
+import { Integer } from './integer.mjs';
+function TakeBigInt(input) {
+    const integer = Integer(input);
+    return (IsResult(integer) ? (() => {
+        const n = Take(['n'], integer[1]);
+        return IsResult(n)
+            ? [`${integer[0]}`, n[1]]
+            : []; // 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/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/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/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/build/type/script/token/ident.mjs

@@ -0,0 +1,35 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './internal/result.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 = '') {
+    const remaining = Take(Remaining, input);
+    return (IsResult(remaining)
+        ? TakeRemaining(remaining[1], `${result}${remaining[0]}`)
+        : [result, input]);
+}
+function TakeIdent(input) {
+    const initial = TakeInitial(input);
+    return (IsResult(initial) ? (() => {
+        const remaining = TakeRemaining(initial[1]);
+        return IsResult(remaining)
+            ? [`${initial[0]}${remaining[0]}`, remaining[1]]
+            : []; // 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/build/type/script/token/index.d.mts

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

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

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

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

@@ -0,0 +1,19 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TOptional } from './internal/optional.mjs';
+import { type TDigit } from './internal/char.mjs';
+import { type THyphen } 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 TTakeSign<Input extends string> = (TOptional<THyphen, Input>);
+type TTakeNonZero<Input extends string> = (TTake<TNonZero, Input>);
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TTakeDigits<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input>);
+type TTakeInteger<Input extends string> = (TTakeSign<Input> extends [infer Sign extends string, infer SignRest extends string] ? TTake<[TZero], SignRest> extends [infer Zero extends string, infer ZeroRest extends string] ? [`${Sign}${Zero}`, ZeroRest] : TTakeNonZero<SignRest> extends [infer NonZero extends string, infer NonZeroRest extends string] ? TTakeDigits<NonZeroRest> extends [infer Digits extends string, infer DigitsRest extends string] ? [`${Sign}${NonZero}${Digits}`, DigitsRest] : [] : [] : []);
+/** Matches if next is a Integer */
+export type TInteger<Input extends string> = (TTakeInteger<TTrim<Input>>);
+/** Matches if next is a Integer */
+export declare function Integer<Input extends string>(input: Input): TInteger<Input>;
+export {};

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

@@ -0,0 +1,45 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './internal/result.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Many } from './internal/many.mjs';
+import { Optional } from './internal/optional.mjs';
+import { Digit } from './internal/char.mjs';
+import { Hyphen } from './internal/char.mjs';
+import { Zero } from './internal/char.mjs';
+import { NonZero } from './internal/char.mjs';
+import { UnderScore } from './internal/char.mjs';
+function TakeSign(input) {
+    return Optional(Hyphen, input);
+}
+function TakeNonZero(input) {
+    return Take(NonZero, input);
+}
+const AllowedDigits = [...Digit, UnderScore];
+function TakeDigits(input) {
+    return Many(AllowedDigits, [UnderScore], input);
+}
+function TakeInteger(input) {
+    const sign = TakeSign(input);
+    return (IsResult(sign) ? (() => {
+        const zero = Take([Zero], sign[1]);
+        return IsResult(zero)
+            ? [`${sign[0]}${zero[0]}`, zero[1]]
+            : (() => {
+                const nonZero = TakeNonZero(sign[1]);
+                return IsResult(nonZero) ? (() => {
+                    const digits = TakeDigits(nonZero[1]);
+                    return IsResult(digits)
+                        ? [`${sign[0]}${nonZero[0]}${digits[0]}`, digits[1]]
+                        : []; // fail: did not match Digits
+                })() : []; // fail: did not match NonZero
+            })();
+    })() : [] // fail: did not match Sign
+    );
+}
+/** Matches if next is a Integer */
+export function Integer(input) {
+    return TakeInteger(Trim(input));
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,73 @@
+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 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 TUnderScore = typeof UnderScore;
+export type TDot = typeof Dot;
+export type TDollarSign = typeof DollarSign;
+export type THyphen = typeof Hyphen;

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

@@ -0,0 +1,25 @@
+// 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 UnderScore = '_';
+export const Dot = '.';
+export const DollarSign = '$';
+export const Hyphen = '-';
+// deno-coverage-ignore-stop

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

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

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

@@ -0,0 +1,15 @@
+// deno-coverage-ignore-start - parsebox tested
+export { IsArray, IsEqual, IsString } 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/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/build/type/script/token/internal/many.mjs

@@ -0,0 +1,17 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './result.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 = '') {
+    const takeResult = Take(allowed, input);
+    return (IsResult(takeResult)
+        ? IsDiscard(discard, takeResult[0])
+            ? Many(allowed, discard, takeResult[1], result)
+            : Many(allowed, discard, takeResult[1], `${result}${takeResult[0]}`)
+        : [result, input]);
+}
+// deno-coverage-ignore-stop

package/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/build/type/script/token/internal/optional.mjs

@@ -0,0 +1,12 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './result.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) {
+    const result = Take([value], input);
+    return (IsResult(result)
+        ? result
+        : ['', input]);
+}
+// deno-coverage-ignore-stop

package/build/type/script/token/internal/result.d.mts

@@ -0,0 +1,2 @@
+/** Checks the value is a Tuple-2 [string, string] result */
+export declare function IsResult(value: unknown): value is [string, string];

package/build/type/script/token/internal/result.mjs

@@ -0,0 +1,7 @@
+// deno-coverage-ignore-start - parsebox tested
+import { IsArray, IsEqual } from './guard.mjs';
+/** Checks the value is a Tuple-2 [string, string] result */
+export function IsResult(value) {
+    return IsArray(value) && IsEqual(value.length, 2);
+}
+// deno-coverage-ignore-stop

package/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/build/type/script/token/internal/take.mjs

@@ -0,0 +1,19 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual, IsString } 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) {
+    const [left, ...right] = variants;
+    return (IsString(left)
+        ? (() => {
+            const result = TakeVariant(left, input);
+            return IsEqual(result.length, 2) ? result : Take(right, input);
+        })()
+        : []);
+}
+// deno-coverage-ignore-stop

package/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 `${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/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/build/type/script/token/number.d.mts

@@ -0,0 +1,20 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TOptional } from './internal/optional.mjs';
+import { type TDigit, TUnderScore } from './internal/char.mjs';
+import { type TDot } from './internal/char.mjs';
+import { type THyphen } from './internal/char.mjs';
+import { type TInteger } from './integer.mjs';
+type TAllowedDigits = [...TDigit, TUnderScore];
+type TTakeSign<Input extends string> = (TOptional<THyphen, Input>);
+type TIsLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [string, string] ? true : false);
+type TTakeFractional<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input> extends [infer Digits extends string, infer Rest extends string] ? Digits extends '' ? [] : [Digits, Rest] : []);
+type TLeadingDot<Sign extends string, Input extends string> = (TTake<[TDot], Input> extends [infer Dot extends string, infer Rest extends string] ? TTakeFractional<Rest> extends [infer Fractional extends string, infer Rest extends string] ? [`${Sign}0${Dot}${Fractional}`, Rest] : [] : []);
+type TLeadingInteger<Sign extends string, Input extends string> = (TInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string] ? TTake<[TDot], IntegerRest> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`${Sign}${Integer}${Dot}${Fractional}`, FractionalRest] : [`${Sign}${Integer}`, DotRest] : [`${Sign}${Integer}`, IntegerRest] : []);
+type TTakeNumber<Input extends string> = (TTakeSign<Input> extends [infer Sign extends string, infer SignRest extends string] ? TIsLeadingDot<SignRest> extends true ? TLeadingDot<Sign, SignRest> : TLeadingInteger<Sign, SignRest> : []);
+/** Matches if next is a literal Number */
+export type TNumber<Input extends string> = (TTakeNumber<TTrim<Input>>);
+/** Matches if next is a literal Number */
+export declare function Number<Input extends string>(input: Input): TNumber<Input>;
+export {};

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

@@ -0,0 +1,65 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { IsResult } from './internal/result.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Many } from './internal/many.mjs';
+import { Optional } from './internal/optional.mjs';
+import { Digit, UnderScore } from './internal/char.mjs';
+import { Dot } from './internal/char.mjs';
+import { Hyphen } from './internal/char.mjs';
+import { Integer } from './integer.mjs';
+const AllowedDigits = [...Digit, UnderScore];
+function TakeSign(input) {
+    return Optional(Hyphen, input);
+}
+function IsLeadingDot(input) {
+    return IsResult(Take([Dot], input));
+}
+function TakeFractional(input) {
+    const digits = Many(AllowedDigits, [UnderScore], input);
+    return (IsResult(digits)
+        ? IsEqual(digits[0], '')
+            ? [] // fail: no Digits
+            : [digits[0], digits[1]]
+        : [] // fail: did not match Digits
+    );
+}
+function LeadingDot(sign, input) {
+    const dot = Take([Dot], input);
+    return (IsResult(dot) ? (() => {
+        const fractional = TakeFractional(dot[1]);
+        return IsResult(fractional)
+            ? [`${sign}0${dot[0]}${fractional[0]}`, fractional[1]]
+            : []; // fail: did not match Fractional
+    })() : [] // fail: did not match Dot
+    );
+}
+function LeadingInteger(sign, input) {
+    const integer = Integer(input);
+    return (IsResult(integer) ? (() => {
+        const dot = Take([Dot], integer[1]);
+        return IsResult(dot) ? (() => {
+            const fractional = TakeFractional(dot[1]);
+            return IsResult(fractional)
+                ? [`${sign}${integer[0]}${dot[0]}${fractional[0]}`, fractional[1]]
+                : [`${sign}${integer[0]}`, dot[1]]; // fail: did not match Fractional, use Integer
+        })() : [`${sign}${integer[0]}`, integer[1]]; // fail: did not match Dot, use Integer
+    })() : [] // fail: did not match Integer
+    );
+}
+function TakeNumber(input) {
+    const sign = TakeSign(input);
+    return (IsResult(sign)
+        ? IsLeadingDot(sign[1])
+            ? LeadingDot(sign[0], sign[1])
+            : LeadingInteger(sign[0], sign[1])
+        : [] // fail: did not match Sign
+    );
+}
+/** Matches if next is a literal Number */
+export function Number(input) {
+    return TakeNumber(Trim(input));
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,10 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TNewLine } from './internal/char.mjs';
+import { type TUntil } from './until.mjs';
+type TMultiLine<Start extends string, End extends string, Input extends string> = (Input extends `${Start}${infer Rest extends string}` ? TUntil<[End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? UntilRest extends `${End}${infer Rest extends string}` ? [`${Until}`, Rest] : [] : [] : []);
+type TSingleLine<Start extends string, End extends string, Input extends string> = (Input extends `${Start}${infer Rest extends string}` ? TUntil<[TNewLine, End], Rest> extends [infer Until extends string, infer UntilRest extends string] ? UntilRest extends `${End}${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/build/type/script/token/span.mjs

@@ -0,0 +1,35 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsResult } from './internal/result.mjs';
+import { Trim } from './internal/trim.mjs';
+import { NewLine } from './internal/char.mjs';
+import { Until } from './until.mjs';
+function MultiLine(start, end, input) {
+    return (input.startsWith(start) ? (() => {
+        const until = Until([end], input.slice(start.length));
+        return IsResult(until) ? (() => {
+            return until[1].startsWith(end)
+                ? [`${until[0]}`, until[1].slice(end.length)]
+                : []; // fail: did not match End
+        })() : []; // fail: did not match Until
+    })() : [] // fail: did not match Start
+    );
+}
+function SingleLine(start, end, input) {
+    return (input.startsWith(start) ? (() => {
+        const until = Until([NewLine, end], input.slice(start.length));
+        return IsResult(until) ? (() => {
+            return until[1].startsWith(end)
+                ? [`${until[0]}`, until[1].slice(end.length)]
+                : []; // 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