typebox 1.1.6 → 1.1.8

package/build/type/engine/call/distribute-arguments.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDeferred } from '../../types/deferred.mjs';
+type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
+type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
+type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
+type TDistribute<Types extends TSchema[], Result extends TSchema[][] = [[]]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistribute<Right, TCross<Result, TExpand<Left>>> : Result);
+export type TDistributeArguments<Arguments extends TSchema[], Expression extends TSchema, Result extends TSchema[][] = Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<Arguments> : [Arguments]> = Result;
+export declare function DistributedArguments<Arguments extends TSchema[], Expression extends TSchema>(arguments_: [...Arguments], expression: Expression): TDistributeArguments<Arguments, Expression>;
+export {};

package/build/type/engine/call/distribute-arguments.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsDeferred } from '../../types/deferred.mjs';
+function Expand(type) {
+    return (IsUnion(type)
+        ? [...type.anyOf]
+        : [type]);
+}
+function Append(current, type) {
+    return current.reduce((result, left) => [...result, [...left, type]], []);
+}
+function Cross(current, variants) {
+    return variants.reduce((result, left) => {
+        return [...result, ...Append(current, left)];
+    }, []);
+}
+function Distribute(types) {
+    return types.reduce((result, type) => {
+        return Cross(result, Expand(type));
+    }, [[]]);
+}
+export function DistributedArguments(arguments_, expression) {
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? Distribute(arguments_)
+        : [arguments_]);
+}

package/build/type/engine/call/instantiate.d.mts

@@ -4,17 +4,20 @@ import { type TCallConstruct } from '../../types/call.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TGeneric } from '../../types/generic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/index.mjs';
 import { type TState } from '../instantiate.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TDistributeArguments } from './distribute-arguments.mjs';
 import { type TResolveTarget } from './resolve-target.mjs';
 import { type TResolveArgumentsContext } from './resolve-arguments.mjs';
-type TPeek<CallStack extends string[], Result extends string = CallStack extends [infer Left extends string, ...infer _ extends string[]] ? Left : ''> = Result;
-type TDeferredCall<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, DeferredCall extends TSchema = TCallConstruct<Target, InstantiatedArguments>> = DeferredCall;
-type TTailCall<Context extends TProperties, State extends TState, Name extends string, Arguments extends TSchema[], DeferredCall extends TSchema = TDeferredCall<Context, State, TRef<Name>, Arguments>> = DeferredCall;
-type THeadCall<Context extends TProperties, State extends TState, Name extends string, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, InstantiatedArguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
-    callstack: [...State['callstack'], Name];
+type TPeek<State extends TState, Result extends string = State['callstack'] extends [...infer _ extends string[], infer Top extends string] ? Top : ''> = Result;
+type TIsTailCall<State extends TState, Name extends string, Result extends boolean = TPeek<State> extends Name ? true : false> = Result;
+type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
+    callstack: [...State['callstack'], Target['$ref']];
 }, Expression>> = TInstantiateType<Context, State, ReturnType>;
-export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TPeek<State['callstack']> extends Name ? TTailCall<Context, State, Name, Arguments> : THeadCall<Context, State, Name, Parameters, Expression, Arguments> : TDeferredCall<Context, State, Target, Arguments>)> = Result;
+type TCallDistributed<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, DistributedArguments extends TSchema[][], Result extends TSchema[] = []> = (DistributedArguments extends [infer Arguments extends TSchema[], ...infer DistributedArguments extends TSchema[][]] ? TCallDispatch<Context, State, Target, Parameters, Expression, Arguments> extends infer ReturnType extends TSchema ? TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments, [...Result, ReturnType]> : never : Result);
+type TCallImmediate<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, InstantiatedArguments extends TSchema[], DistributedArguments extends TSchema[][] = TDistributeArguments<InstantiatedArguments, Expression>, ReturnTypes extends TSchema[] = TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments>, Result extends TSchema = ReturnTypes['length'] extends 1 ? ReturnTypes[0] : TEvaluateUnion<ReturnTypes>> = Result;
+export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TIsTailCall<State, Name> extends true ? TCallConstruct<TRef<Name>, InstantiatedArguments> : TCallImmediate<Context, State, TRef<Name>, Parameters, Expression, InstantiatedArguments> : TCallConstruct<Target, InstantiatedArguments>)> = Result;
 export declare function CallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[]>(context: Context, state: State, target: Target, arguments_: [...Arguments]): TCallInstantiate<Context, State, Target, Arguments>;
 export {};

package/build/type/engine/call/instantiate.mjs

@@ -3,36 +3,46 @@ import { Guard } from '../../../guard/index.mjs';
 import { CallConstruct } from '../../types/call.mjs';
 import { Ref } from '../../types/ref.mjs';
 import { IsGeneric } from '../../types/generic.mjs';
+import { EvaluateUnion } from '../evaluate/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
-// ----------------------------------------------------------------------------
-// Call: Infrastructure
-// ----------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { DistributedArguments } from './distribute-arguments.mjs';
 import { ResolveTarget } from './resolve-target.mjs';
 import { ResolveArgumentsContext } from './resolve-arguments.mjs';
-function Peek(callstack) {
-    return (Guard.IsGreaterThan(callstack.length, 0) ? callstack[0] : '');
+function Peek(state) {
+    const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
+    return result;
 }
-function DeferredCall(context, state, target, arguments_) {
-    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
-    const deferredCall = CallConstruct(target, instantiatedArguments);
-    return deferredCall;
-}
-function TailCall(context, state, name, arguments_) {
-    const deferredCall = DeferredCall(context, state, Ref(name), arguments_);
-    return deferredCall;
+function IsTailCall(state, name) {
+    const result = Guard.IsEqual(Peek(state), name);
+    return result;
 }
-function HeadCall(context, state, name, parameters, expression, arguments_) {
-    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
-    const argumentsContext = ResolveArgumentsContext(context, state, parameters, instantiatedArguments);
-    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, name] }, expression);
+function CallDispatch(context, state, target, parameters, expression, arguments_) {
+    const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, target.$ref] }, expression);
     return InstantiateType(context, state, returnType);
 }
+function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
+    return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);
+}
+function CallImmediate(context, state, target, parameters, expression, arguments_) {
+    const distributedArguments = DistributedArguments(arguments_, expression);
+    const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
+    const result = returnTypes.length === 1 ? returnTypes[0] : EvaluateUnion(returnTypes);
+    return result;
+}
 export function CallInstantiate(context, state, target, arguments_) {
-    const [name, type] = ResolveTarget(context, target, arguments_);
-    return (IsGeneric(type)
-        ? Guard.IsEqual(Peek(state.callstack), name)
-            ? TailCall(context, state, name, arguments_)
-            : HeadCall(context, state, name, type.parameters, type.expression, arguments_)
-        : DeferredCall(context, state, target, arguments_));
+    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
+    const resolved = ResolveTarget(context, target, arguments_);
+    const name = resolved[0];
+    const type = resolved[1];
+    const result = (IsGeneric(type)
+        ? IsTailCall(state, name)
+            ? CallConstruct(Ref(name), instantiatedArguments)
+            : CallImmediate(context, state, Ref(name), type.parameters, type.expression, instantiatedArguments)
+        : CallConstruct(target, instantiatedArguments));
+    return result;
 }

package/build/type/engine/evaluate/broaden.d.mts

@@ -9,7 +9,7 @@ import { type TEvaluateType } from './evaluate.mjs';
 type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
 type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
 type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
-type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : TBroadenTypes<Right, TBroadenType<Left, Result>> : Result);
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
 export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>, Result extends TSchema = (Flattened extends [] ? TNever : Flattened extends [infer Type extends TSchema] ? Type : TUnion<Flattened>)> = Result;
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;

package/build/type/engine/evaluate/broaden.mjs

@@ -1,8 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { IsAny } from '../../types/any.mjs';
-import { Never } from '../../types/never.mjs';
+import { Never, IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { Union } from '../../types/union.mjs';
 import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
@@ -30,12 +29,12 @@ function BroadenType(type, types) {
             : types);
 }
 function BroadenTypes(types, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? IsObject(left)
-            ? BroadenTypes(right, [...result, left]) // special: push object type
-            : BroadenTypes(right, BroadenType(left, result))
-        : result);
+    return types.reduce((result, left) => {
+        return (IsObject(left) ? [...result, left] : // push
+            IsNever(left) ? result : // ignore
+                BroadenType(left, result) // broaden
+        );
+    }, []);
 }
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export function Broaden(types) {

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

@@ -1,6 +1,6 @@
 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] : [] : []);
+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. */

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

@@ -1,17 +1,11 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.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
-    );
+    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) {

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

@@ -1,6 +1,6 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.mjs';
 import { Trim } from './internal/trim.mjs';
 import { Take } from './internal/take.mjs';
 import { Alpha } from './internal/char.mjs';
@@ -13,20 +13,11 @@ function TakeInitial(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]);
+    return Match(Take(Remaining, input), (Remaining, RemainingRest) => TakeRemaining(RemainingRest, `${result}${Remaining}`), () => [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
-    );
+    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) {

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

@@ -3,7 +3,10 @@ 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/build/type/script/token/index.mjs

@@ -3,7 +3,10 @@ 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/build/type/script/token/integer.d.mts

@@ -1,19 +1,11 @@
 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';
+import { type TUnsignedInteger } from './unsigned_integer.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 */
+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/build/type/script/token/integer.mjs

@@ -1,45 +1,19 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.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';
+import { UnsignedInteger } from './unsigned_integer.mjs';
 function TakeSign(input) {
     return Optional(Hyphen, input);
 }
-function TakeNonZero(input) {
-    return Take(NonZero, 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
 }
-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 */
+/** Matches if next is a signed or unsigned Integer */
 export function Integer(input) {
-    return TakeInteger(Trim(input));
+    return TakeSignedInteger(Trim(input));
 }
 // deno-coverage-ignore-stop

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

@@ -1,17 +1,14 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './result.mjs';
+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 = '') {
-    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]);
+    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/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/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/build/type/script/token/internal/optional.mjs

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

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

@@ -1,6 +1,7 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsEqual, IsString } from './guard.mjs';
+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)]
@@ -8,12 +9,26 @@ function TakeVariant(variant, input) {
 }
 /** 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);
-        })()
-        : []);
+    // ----------------------------------------------------------------
+    // Symmetric
+    // ----------------------------------------------------------------
+    // const [left, ...right] = variants
+    // return (
+    //   IsString(left)
+    //     ? (() => {
+    //       const result = TakeVariant(left, input)
+    //       return IsEqual(result.length, 2) ? result : Take(right, 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/build/type/script/token/number.d.mts

@@ -1,20 +1,11 @@
 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];
+import { type TUnsignedNumber } from './unsigned_number.mjs';
 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 */
+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/build/type/script/token/number.mjs

@@ -1,65 +1,19 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsEqual } from './internal/guard.mjs';
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.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];
+import { UnsignedNumber } from './unsigned_number.mjs';
 function TakeSign(input) {
     return Optional(Hyphen, input);
 }
-function IsLeadingDot(input) {
-    return IsResult(Take([Dot], 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
 }
-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 */
+/** Matches if next is a signed or unsigned Number */
 export function Number(input) {
-    return TakeNumber(Trim(input));
+    return TakeSignedNumber(Trim(input));
 }
 // deno-coverage-ignore-stop

package/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/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/build/type/script/token/span.d.mts

@@ -1,8 +1,9 @@
 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> = (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] : [] : [] : []);
+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. */

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

@@ -1,30 +1,19 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './internal/result.mjs';
+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 (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
-    );
+    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 (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
-    );
+    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) {

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

@@ -1,6 +1,6 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.mjs';
 import { Take } from './internal/take.mjs';
 import { Trim } from './internal/trim.mjs';
 import { Span } from './span.mjs';
@@ -11,11 +11,7 @@ function TakeSpan(quote, input) {
     return Span(quote, quote, false, input);
 }
 function TakeString(quotes, input) {
-    const initial = TakeInitial(quotes, input);
-    return (IsResult(initial)
-        ? TakeSpan(initial[0], `${initial[0]}${initial[1]}`)
-        : [] // fail: did not match Initial
-    );
+    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) {

package/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 {};

package/build/type/script/token/unsigned_integer.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 { Many } from './internal/many.mjs';
+import { Digit } from './internal/char.mjs';
+import { Zero } from './internal/char.mjs';
+import { NonZero } from './internal/char.mjs';
+import { UnderScore } from './internal/char.mjs';
+function TakeNonZero(input) {
+    return Take(NonZero, input);
+}
+const AllowedDigits = [...Digit, UnderScore];
+function TakeDigits(input) {
+    return Many(AllowedDigits, [UnderScore], input);
+}
+function TakeUnsignedInteger(input) {
+    return Match(Take([Zero], input), (Zero, ZeroRest) => [Zero, ZeroRest], () => Match(TakeNonZero(input), (NonZero, NonZeroRest) => Match(TakeDigits(NonZeroRest), (Digits, DigitsRest) => [`${NonZero}${Digits}`, DigitsRest], () => []), // fail: did not match Digits
+    () => [])); // fail: did not match NonZero
+}
+/** Matches if next is a UnsignedInteger */
+export function UnsignedInteger(input) {
+    return TakeUnsignedInteger(Trim(input));
+}
+// deno-coverage-ignore-stop

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

@@ -0,0 +1,17 @@
+import { type TTrim } from './internal/trim.mjs';
+import { type TTake } from './internal/take.mjs';
+import { type TMany } from './internal/many.mjs';
+import { type TDigit, type TUnderScore } from './internal/char.mjs';
+import { type TDot } from './internal/char.mjs';
+import { type TUnsignedInteger } from './unsigned_integer.mjs';
+type TAllowedDigits = [...TDigit, TUnderScore];
+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 DigitsRest extends string] ? Digits extends '' ? [] : [Digits, DigitsRest] : []);
+type TLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`0${Dot}${Fractional}`, FractionalRest] : [] : []);
+type TLeadingInteger<Input extends string> = (TUnsignedInteger<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] ? [`${Integer}${Dot}${Fractional}`, FractionalRest] : [`${Integer}`, DotRest] : [`${Integer}`, IntegerRest] : []);
+type TTakeUnsignedNumber<Input extends string> = (TIsLeadingDot<Input> extends true ? TLeadingDot<Input> : TLeadingInteger<Input>);
+/** Matches if next is a UnsignedNumber */
+export type TUnsignedNumber<Input extends string> = (TTakeUnsignedNumber<TTrim<Input>>);
+/** Matches if next is a UnsignedNumber */
+export declare function UnsignedNumber<Input extends string>(input: Input): TUnsignedNumber<Input>;
+export {};

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

@@ -0,0 +1,38 @@
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+import { IsEqual } from './internal/guard.mjs';
+import { IsMatch, Match } from './internal/match.mjs';
+import { Trim } from './internal/trim.mjs';
+import { Take } from './internal/take.mjs';
+import { Many } from './internal/many.mjs';
+import { Digit, UnderScore } from './internal/char.mjs';
+import { Dot } from './internal/char.mjs';
+import { UnsignedInteger } from './unsigned_integer.mjs';
+const AllowedDigits = [...Digit, UnderScore];
+function IsLeadingDot(input) {
+    return IsMatch(Take([Dot], input));
+}
+function TakeFractional(input) {
+    return Match(Many(AllowedDigits, [UnderScore], input), (Digits, DigitsRest) => IsEqual(Digits, '')
+        ? [] // fail: no Digits
+        : [Digits, DigitsRest], () => []); // fail: did not match Digits
+}
+function LeadingDot(input) {
+    return Match(Take([Dot], input), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`0${Dot}${Fractional}`, FractionalRest], () => []), // fail: did not match Fractional
+    () => []); // fail: did not match Dot
+}
+function LeadingInteger(input) {
+    return Match(UnsignedInteger(input), (Integer, IntegerRest) => Match(Take([Dot], IntegerRest), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`${Integer}${Dot}${Fractional}`, FractionalRest], () => [`${Integer}`, DotRest]), // fail: did not match Fractional, use Integer
+    () => [`${Integer}`, IntegerRest]), // fail: did not match Dot, use Integer
+    () => []); // fail: did not match Integer
+}
+function TakeUnsignedNumber(input) {
+    return (IsLeadingDot(input)
+        ? LeadingDot(input)
+        : LeadingInteger(input));
+}
+/** Matches if next is a UnsignedNumber */
+export function UnsignedNumber(input) {
+    return TakeUnsignedNumber(Trim(input));
+}
+// deno-coverage-ignore-stop

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

@@ -1,6 +1,7 @@
-type TIsEnd<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsEnd<Right, Input> : false);
+type TTakeOne<Input extends string> = (Input extends `${infer Left extends string}${infer Right extends string}` ? [Left, Right] : []);
+type TIsInputMatchSentinal<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsInputMatchSentinal<Right, Input> : false);
 /** Match Input until but not including End. No match if End not found. */
-export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (Input extends `` ? [] : TIsEnd<End, Input> extends true ? [Result, Input] : Input extends `${infer Left extends string}${infer Right extends string}` ? TUntil<End, Right, `${Result}${Left}`> : []);
+export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (TTakeOne<Input> extends [infer One extends string, infer Rest extends string] ? TIsInputMatchSentinal<End, Input> extends true ? [Result, Input] : TUntil<End, Rest, `${Result}${One}`> : []);
 /** Match Input until but not including End. No match if End not found. */
 export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
 export {};

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

@@ -1,21 +1,24 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
+import { Match } from './internal/match.mjs';
 import { IsEqual, IsString } from './internal/guard.mjs';
-function IsEnd(end, input) {
+function TakeOne(input) {
+    const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
+    return result;
+}
+function IsInputMatchSentinal(end, input) {
     const [left, ...right] = end;
     return (IsString(left)
         ? input.startsWith(left)
             ? true
-            : IsEnd(right, input)
+            : IsInputMatchSentinal(right, input)
         : false);
 }
 /** Match Input until but not including End. No match if End not found. */
 export function Until(end, input, result = '') {
-    return (IsEqual(input, '')
-        ? [] // fail: Input is empty
-        : IsEnd(end, input) ? [result, input] : (() => {
-            const [left, right] = [input.slice(0, 1), input.slice(1)];
-            return Until(end, right, `${result}${left}`);
-        })());
+    return Match(TakeOne(input), (One, Rest) => IsInputMatchSentinal(end, input)
+        ? [result, input] // ok: at sentinal 
+        : Until(end, Rest, `${result}${One}`) // fail: advance + 1
+    , () => []);
 }
 // deno-coverage-ignore-stop

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

@@ -1,16 +1,12 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
 import { IsEqual } from './internal/guard.mjs';
-import { IsResult } from './internal/result.mjs';
+import { Match } from './internal/match.mjs';
 import { Until } from './until.mjs';
 /** Match Input until but not including End. No match if End not found or match is zero-length. */
 export function Until_1(end, input) {
-    const until = Until(end, input);
-    return (IsResult(until)
-        ? IsEqual(until[0], '')
-            ? [] // fail: match has no characters
-            : until
-        : [] // fail: did not match Until
-    );
+    return Match(Until(end, input), (Until, UntilRest) => IsEqual(Until, '')
+        ? [] // fail: match has no characters
+        : [Until, UntilRest], () => []); // fail: did not match Until
 }
 // deno-coverage-ignore-stop

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,38 +16,38 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./type": {
-      "import": "./build/type/index.mjs",
-      "default": "./build/type/index.mjs"
-    },
-    "./value": {
-      "import": "./build/value/index.mjs",
-      "default": "./build/value/index.mjs"
-    },
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
     "./system": {
       "import": "./build/system/index.mjs",
       "default": "./build/system/index.mjs"
     },
-    "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
-    },
     "./compile": {
       "import": "./build/compile/index.mjs",
       "default": "./build/compile/index.mjs"
     },
+    "./value": {
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
+    },
     "./error": {
       "import": "./build/error/index.mjs",
       "default": "./build/error/index.mjs"
     },
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
     "./schema": {
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
+    "./format": {
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
+    },
+    "./type": {
+      "import": "./build/type/index.mjs",
+      "default": "./build/type/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,30 +55,30 @@
   },
   "typesVersions": {
     "*": {
-      "type": [
-        "./build/type/index.d.mts"
-      ],
-      "value": [
-        "./build/value/index.d.mts"
-      ],
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
       "system": [
         "./build/system/index.d.mts"
       ],
-      "format": [
-        "./build/format/index.d.mts"
-      ],
       "compile": [
         "./build/compile/index.d.mts"
       ],
+      "value": [
+        "./build/value/index.d.mts"
+      ],
       "error": [
         "./build/error/index.d.mts"
       ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
       "schema": [
         "./build/schema/index.d.mts"
       ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
+      "type": [
+        "./build/type/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]

package/readme.md

@@ -57,12 +57,11 @@ License: MIT
 
 ## Contents
 
-
 - [Type](#Type)
 - [Value](#Value)
 - [Script](#Script)
 - [Schema](#Schema)
-- [Legacy](#Legacy)
+- [Versions](#Versions)
 - [Contribute](#Contribute)
 
 
@@ -70,7 +69,7 @@ License: MIT
 
 ## Type
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview) | [Example](https://tsplay.dev/NaMoBN)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/type/overview)
 
 TypeBox provides many functions to create JSON Schema types. Each function returns a small JSON Schema fragment that can be composed into more complex types. TypeBox includes a set of functions that are used to construct JSON Schema compliant schematics as well as a set of extended functions that return schematics for constructs native to JavaScript.
 
@@ -117,7 +116,7 @@ const S = Type.Number({                             // const S = {
 
 ## Value
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://tsplay.dev/W4YE1w)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview)
 
 The Value submodule provides functions for validation and other typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, and Decode, as well as advanced functions for performing structural Diff and Patch operations on dynamic JavaScript values.
 
@@ -145,7 +144,7 @@ const A = Value.Parse(T, {                          // const A: {
 
 ## Script
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://tsplay.dev/N9rQ8m) | [Example 2](https://tsplay.dev/NnrJoN)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview)
 
 TypeBox includes a runtime TypeScript DSL engine that can transform TypeScript syntax into JSON Schema. The engine is implemented at runtime and within the TypeScript type system.
 
@@ -223,62 +222,31 @@ const R = C.Parse({  x: 0, y: 0, z: 0 })            // const R: {
                                                     // } = ...
 ```
 
-## Legacy
-
-If upgrading from `@sinclair/typebox` 0.34.x refer to the 1.0 migration guide at the following URL.
-
-[Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
+<a name="Versions"></a>
 
-Most types created with 0.34.x are compatible with V1, and it is possible to run both `typebox` and `@sinclair/typebox` packages side by side. 
-
-[Compatibility](https://tsplay.dev/Wzr2rW)
-
-```typescript
-import { Type } from '@sinclair/typebox'            // TB: 0.34.x
-import { Static } from 'typebox'                    // TB: 1.0.0
+## Versions
 
-// ----------------------------------------------------------
-// Legacy Types
-// ----------------------------------------------------------
-const A = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
+TypeBox provides two distinct versions that span two generations of the TypeScript compiler.
 
-const B = Type.Object({
-  a: Type.Number(),
-  b: Type.Number(),
-  c: Type.Number()
-})
+### Version 0.x
 
-const C = Type.Composite([A, B])
+```bash
+$ npm install @sinclair/typebox                     # 0.x - LTS    | TS 4-6
+```
 
-// ----------------------------------------------------------
-// Modern Inference
-// ----------------------------------------------------------
-type C = Static<typeof C>                           // type C = {
-                                                    //   x: number;
-                                                    //   y: number;
-                                                    //   z: number;
-                                                    //   a: number;
-                                                    //   b: number;
-                                                    //   c: number;
-                                                    // }
+Developed against TypeScript 4-6 and maintained under Long Term Support (LTS) for existing infrastructure on the 0.x revision line. ESM and CJS compatible.
 
-// ----------------------------------------------------------
-// Modern Compile
-// ----------------------------------------------------------
-import Schema from 'typebox/schema'
+### Version 1.x
 
-const R = Schema.Compile(C).Check({ ... })
+```bash
+$ npm install typebox                               # 1.x - Latest | TS 7 Native
 ```
 
-Revision 0.34.x is actively maintained at the following URL.
+Developed against the TypeScript 7 native compiler with advanced type inference and JSON Schema 2020-12 compliant validation, with backwards compatibility for `0.x` types. ESM only.
 
-[TypeBox 0.34.x](https://github.com/sinclairzx81/typebox-legacy)
+### Additional
 
-Please submit non-1.0 issues to this repository.
+The `1.x` version is recommended for most new projects and is the active development line that targets optimizations enabled by the TypeScript 7 native compiler. The `0.x` version is maintained under LTS for environments requiring CJS and ESM compatibility as well as support for older TypeScript compiler versions. For issues relating to `0.x` please submit them to the [TypeBox 0.x](https://github.com/sinclairzx81/sinclair-typebox) repository.
 
 ## Contribute
 

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

@@ -1,2 +0,0 @@
-/** 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

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