typebox 1.0.31 → 1.0.33

package/build/cjs/type/script/token/internal/char.js

@@ -0,0 +1,28 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hyphen = exports.DollarSign = exports.Dot = exports.UnderScore = exports.NewLine = exports.WhiteSpace = exports.Digit = exports.NonZero = exports.Zero = exports.Alpha = void 0;
+// ------------------------------------------------------------------
+// Range
+// ------------------------------------------------------------------
+function Range(start, end) {
+    return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+exports.Alpha = [
+    ...Range(97, 122), // Lowercase
+    ...Range(65, 90) // Uppercase
+];
+exports.Zero = '0';
+exports.NonZero = Range(49, 57); // 1 - 9
+exports.Digit = [exports.Zero, ...exports.NonZero];
+// ------------------------------------------------------------------
+// Characters
+// ------------------------------------------------------------------
+exports.WhiteSpace = ' ';
+exports.NewLine = '\n';
+exports.UnderScore = '_';
+exports.Dot = '.';
+exports.DollarSign = '$';
+exports.Hyphen = '-';
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/internal/guard.d.ts

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

package/build/cjs/type/script/token/internal/guard.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsString = exports.IsEqual = exports.IsArray = void 0;
+var guard_1 = require("../../../../guard/guard");
+Object.defineProperty(exports, "IsArray", { enumerable: true, get: function () { return guard_1.IsArray; } });
+Object.defineProperty(exports, "IsEqual", { enumerable: true, get: function () { return guard_1.IsEqual; } });
+Object.defineProperty(exports, "IsString", { enumerable: true, get: function () { return guard_1.IsString; } });
+// ------------------------------------------------------------------
+// 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/cjs/type/script/token/internal/many.d.ts

@@ -0,0 +1,7 @@
+import { type TTake } from './take';
+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/cjs/type/script/token/internal/many.js

@@ -0,0 +1,20 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Many = Many;
+const result_1 = require("./result");
+const take_1 = require("./take");
+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 */
+function Many(allowed, discard, input, result = '') {
+    const takeResult = (0, take_1.Take)(allowed, input);
+    return ((0, result_1.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/cjs/type/script/token/internal/optional.d.ts

@@ -0,0 +1,5 @@
+import { type TTake } from './take';
+/** 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/cjs/type/script/token/internal/optional.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = Optional;
+const result_1 = require("./result");
+const take_1 = require("./take");
+/** Matches the given Value or empty string if no match. This function never fails */
+function Optional(value, input) {
+    const result = (0, take_1.Take)([value], input);
+    return ((0, result_1.IsResult)(result)
+        ? result
+        : ['', input]);
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/internal/result.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsResult = IsResult;
+const guard_1 = require("./guard");
+/** Checks the value is a Tuple-2 [string, string] result */
+function IsResult(value) {
+    return (0, guard_1.IsArray)(value) && (0, guard_1.IsEqual)(value.length, 2);
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/internal/take.js

@@ -0,0 +1,22 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Take = Take;
+const guard_1 = require("./guard");
+function TakeVariant(variant, input) {
+    return ((0, guard_1.IsEqual)(input.indexOf(variant), 0)
+        ? [variant, input.slice(variant.length)]
+        : []);
+}
+/** Takes one of the given variants or fail */
+function Take(variants, input) {
+    const [left, ...right] = variants;
+    return ((0, guard_1.IsString)(left)
+        ? (() => {
+            const result = TakeVariant(left, input);
+            return (0, guard_1.IsEqual)(result.length, 2) ? result : Take(right, input);
+        })()
+        : []);
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/internal/trim.d.ts

@@ -0,0 +1,19 @@
+import * as Char from './char';
+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/cjs/type/script/token/internal/trim.js

@@ -0,0 +1,38 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrimWhitespace = TrimWhitespace;
+exports.Trim = Trim;
+const guard_1 = require("./guard");
+const Char = require("./char");
+const LineComment = '//';
+const OpenComment = '/*';
+const CloseComment = '*/';
+function DiscardMultilineComment(input) {
+    const index = input.indexOf(CloseComment);
+    const result = (0, guard_1.IsEqual)(index, -1) ? '' : input.slice(index + 2);
+    return result;
+}
+function DiscardLineComment(input) {
+    const index = input.indexOf(Char.NewLine);
+    const result = (0, guard_1.IsEqual)(index, -1) ? '' : input.slice(index);
+    return result;
+}
+// ...
+function TrimStartUntilNewline(input) {
+    return input.replace(/^[ \t\r\f\v]+/, '');
+}
+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);
+}
+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/cjs/type/script/token/number.d.ts

@@ -0,0 +1,20 @@
+import { type TTrim } from './internal/trim';
+import { type TTake } from './internal/take';
+import { type TMany } from './internal/many';
+import { type TOptional } from './internal/optional';
+import { type TDigit, TUnderScore } from './internal/char';
+import { type TDot } from './internal/char';
+import { type THyphen } from './internal/char';
+import { type TInteger } from './integer';
+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/cjs/type/script/token/number.js

@@ -0,0 +1,68 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Number = Number;
+const guard_1 = require("./internal/guard");
+const result_1 = require("./internal/result");
+const trim_1 = require("./internal/trim");
+const take_1 = require("./internal/take");
+const many_1 = require("./internal/many");
+const optional_1 = require("./internal/optional");
+const char_1 = require("./internal/char");
+const char_2 = require("./internal/char");
+const char_3 = require("./internal/char");
+const integer_1 = require("./integer");
+const AllowedDigits = [...char_1.Digit, char_1.UnderScore];
+function TakeSign(input) {
+    return (0, optional_1.Optional)(char_3.Hyphen, input);
+}
+function IsLeadingDot(input) {
+    return (0, result_1.IsResult)((0, take_1.Take)([char_2.Dot], input));
+}
+function TakeFractional(input) {
+    const digits = (0, many_1.Many)(AllowedDigits, [char_1.UnderScore], input);
+    return ((0, result_1.IsResult)(digits)
+        ? (0, guard_1.IsEqual)(digits[0], '')
+            ? [] // fail: no Digits
+            : [digits[0], digits[1]]
+        : [] // fail: did not match Digits
+    );
+}
+function LeadingDot(sign, input) {
+    const dot = (0, take_1.Take)([char_2.Dot], input);
+    return ((0, result_1.IsResult)(dot) ? (() => {
+        const fractional = TakeFractional(dot[1]);
+        return (0, result_1.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 = (0, integer_1.Integer)(input);
+    return ((0, result_1.IsResult)(integer) ? (() => {
+        const dot = (0, take_1.Take)([char_2.Dot], integer[1]);
+        return (0, result_1.IsResult)(dot) ? (() => {
+            const fractional = TakeFractional(dot[1]);
+            return (0, result_1.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 ((0, result_1.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 */
+function Number(input) {
+    return TakeNumber((0, trim_1.Trim)(input));
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/span.d.ts

@@ -0,0 +1,10 @@
+import { type TTrim } from './internal/trim';
+import { type TNewLine } from './internal/char';
+import { type TUntil } from './until';
+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/cjs/type/script/token/span.js

@@ -0,0 +1,38 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Span = Span;
+const result_1 = require("./internal/result");
+const trim_1 = require("./internal/trim");
+const char_1 = require("./internal/char");
+const until_1 = require("./until");
+function MultiLine(start, end, input) {
+    return (input.startsWith(start) ? (() => {
+        const until = (0, until_1.Until)([end], input.slice(start.length));
+        return (0, result_1.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 = (0, until_1.Until)([char_1.NewLine, end], input.slice(start.length));
+        return (0, result_1.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. */
+function Span(start, end, multiLine, input) {
+    return (multiLine
+        ? MultiLine(start, end, (0, trim_1.Trim)(input))
+        : SingleLine(start, end, (0, trim_1.Trim)(input)));
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/string.d.ts

@@ -0,0 +1,11 @@
+import { type TTake } from './internal/take';
+import { type TTrim } from './internal/trim';
+import { type TSpan } from './span';
+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/build/cjs/type/script/token/string.js

@@ -0,0 +1,27 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.String = String;
+const result_1 = require("./internal/result");
+const take_1 = require("./internal/take");
+const trim_1 = require("./internal/trim");
+const span_1 = require("./span");
+function TakeInitial(quotes, input) {
+    return (0, take_1.Take)(quotes, input);
+}
+function TakeSpan(quote, input) {
+    return (0, span_1.Span)(quote, quote, false, input);
+}
+function TakeString(quotes, input) {
+    const initial = TakeInitial(quotes, input);
+    return ((0, result_1.IsResult)(initial)
+        ? TakeSpan(initial[0], `${initial[0]}${initial[1]}`)
+        : [] // fail: did not match Initial
+    );
+}
+/** Matches a literal String with the given quotes */
+function String(quotes, input) {
+    return TakeString(quotes, (0, trim_1.Trim)(input));
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/until.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Until = Until;
+const guard_1 = require("./internal/guard");
+function IsEnd(end, input) {
+    const [left, ...right] = end;
+    return ((0, guard_1.IsString)(left)
+        ? input.startsWith(left)
+            ? true
+            : IsEnd(right, input)
+        : false);
+}
+/** Match Input until but not including End. No match if End not found. */
+function Until(end, input, result = '') {
+    return ((0, guard_1.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}`);
+        })());
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/script/token/until_1.d.ts

@@ -0,0 +1,5 @@
+import { type TUntil } from './until';
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export type TUntil_1<End extends string[], Input extends string> = (TUntil<End, Input> extends [infer Until extends string, infer UntilRest extends string] ? Until extends '' ? [] : [Until, UntilRest] : []);
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+export declare function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input>;

package/build/cjs/type/script/token/until_1.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-coverage-ignore-start - parsebox tested
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Until_1 = Until_1;
+const guard_1 = require("./internal/guard");
+const result_1 = require("./internal/result");
+const until_1 = require("./until");
+/** Match Input until but not including End. No match if End not found or match is zero-length. */
+function Until_1(end, input) {
+    const until = (0, until_1.Until)(end, input);
+    return ((0, result_1.IsResult)(until)
+        ? (0, guard_1.IsEqual)(until[0], '')
+            ? [] // fail: match has no characters
+            : until
+        : [] // fail: did not match Until
+    );
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/types/_codec.d.ts

@@ -0,0 +1,30 @@
+import { type StaticDirection, type StaticType } from './static';
+import { type TSchema } from './schema';
+import { type TProperties } from './properties';
+export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Type>;
+export type TDecodeCallback<Type extends TSchema, Decoded = unknown> = (input: StaticType<[], 'Decode', {}, {}, Type>) => Decoded;
+export type TEncodeCallback<Type extends TSchema, Decoded = unknown> = (input: Decoded) => StaticType<[], 'Decode', {}, {}, Type>;
+export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
+    '~codec': {
+        encode: TDecodeCallback<Type, Decoded>;
+        decode: TEncodeCallback<Type, Decoded>;
+    };
+};
+export declare class EncodeBuilder<Type extends TSchema, Decoded extends unknown> {
+    private readonly type;
+    private readonly decode;
+    constructor(type: Type, decode: Function);
+    Encode<Callback extends TEncodeCallback<Type, Decoded>>(callback: Callback): TCodec<Type, Decoded>;
+}
+export declare class DecodeBuilder<Type extends TSchema> {
+    private readonly type;
+    constructor(type: Type);
+    Decode<Callback extends TDecodeCallback<Type>>(callback: Callback): EncodeBuilder<Type, ReturnType<Callback>>;
+}
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type>;
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<Type>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+export declare function Encode<Type extends TSchema, Callback extends TEncodeCallback<Type, unknown>>(type: Type, callback: Callback): TCodec<Type, unknown>;
+export declare function IsCodec(value: unknown): value is TCodec;

package/build/cjs/type/types/_codec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecodeBuilder = exports.EncodeBuilder = void 0;
+exports.Codec = Codec;
+exports.Decode = Decode;
+exports.Encode = Encode;
+exports.IsCodec = IsCodec;
+const index_1 = require("../../system/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+class EncodeBuilder {
+    constructor(type, decode) {
+        this.type = type;
+        this.decode = decode;
+    }
+    Encode(callback) {
+        const type = this.type;
+        const decode = IsCodec(type) ? (value) => this.decode(type['~codec'].decode(value)) : this.decode;
+        const encode = IsCodec(type) ? (value) => type['~codec'].encode(callback(value)) : callback;
+        const codec = { decode, encode };
+        return index_1.Memory.Update(this.type, { '~codec': codec }, {});
+    }
+}
+exports.EncodeBuilder = EncodeBuilder;
+class DecodeBuilder {
+    constructor(type) {
+        this.type = type;
+    }
+    Decode(callback) {
+        return new EncodeBuilder(this.type, callback);
+    }
+}
+exports.DecodeBuilder = DecodeBuilder;
+// ------------------------------------------------------------------
+// Bidirectional
+// ------------------------------------------------------------------
+/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
+function Codec(type) {
+    return new DecodeBuilder(type);
+}
+// ------------------------------------------------------------------
+// Unidirectional
+// ------------------------------------------------------------------
+/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
+function Decode(type, callback) {
+    return Codec(type).Decode(callback).Encode(() => {
+        throw Error('Encode not implemented');
+    });
+}
+/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
+function Encode(type, callback) {
+    return Codec(type).Decode(() => {
+        throw Error('Decode not implemented');
+    }).Encode(callback);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+function IsCodec(value) {
+    return (0, schema_1.IsSchema)(value) &&
+        index_2.Guard.HasPropertyKey(value, '~codec') &&
+        index_2.Guard.IsObject(value['~codec']) &&
+        index_2.Guard.HasPropertyKey(value['~codec'], 'encode') &&
+        index_2.Guard.HasPropertyKey(value['~codec'], 'decode');
+}

package/build/cjs/type/types/_optional.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema';
+/** Removes Optional from the given type. */
+export type TOptionalRemove<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Optional from the given type. */
+export declare function OptionalRemove<Type extends TSchema>(type: Type): TOptionalRemove<Type>;
+/** Adds Optional to the given type. */
+export type TOptionalAdd<Type extends TSchema = TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
+/** Adds Optional to the given type. */
+export declare function OptionalAdd<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+export type TOptional<Type extends TSchema = TSchema> = (Type & {
+    '~optional': true;
+});
+/** Applies an Optional modifier to the given type. */
+export declare function Optional<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+/** Returns true if the given value is TOptional */
+export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

package/build/cjs/type/types/_optional.js

@@ -0,0 +1,33 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalRemove = OptionalRemove;
+exports.OptionalAdd = OptionalAdd;
+exports.Optional = Optional;
+exports.IsOptional = IsOptional;
+const index_1 = require("../../guard/index");
+const index_2 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+/** Removes Optional from the given type. */
+function OptionalRemove(type) {
+    const result = index_2.Memory.Discard(type, ['~optional']);
+    return result;
+}
+/** Adds Optional to the given type. */
+function OptionalAdd(type) {
+    return index_2.Memory.Update(type, { '~optional': true }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Optional modifier to the given type. */
+function Optional(type) {
+    return OptionalAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TOptional */
+function IsOptional(value) {
+    return (0, schema_1.IsSchema)(value) && index_1.Guard.HasPropertyKey(value, '~optional');
+}

package/build/cjs/type/types/_readonly.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema } from './schema';
+/** Removes Readaonly from the given type. */
+export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
+/** Removes Readaonly from the given type. */
+export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
+/** Adds Readonly to the given type. */
+export type TReadonlyAdd<Type extends TSchema = TSchema> = ('readOnly' extends keyof Type ? Type : TReadonly<Type>);
+/** Adds Readonly to the given type. */
+export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+export type TReadonly<Type extends TSchema = TSchema> = (Type & {
+    readOnly: true;
+});
+/** Applies an Readonly modifier to the given type. */
+export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+/** Returns true if the given value is a TReadonly */
+export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;