@openclaw/slack 2026.8.1-beta.2 → 2026.8.1

package/node_modules/typebox/build/type/engine/evaluate/evaluate.mjs

@@ -2,29 +2,31 @@
 import { Guard } from '../../../guard/index.mjs';
 import { IsDependent } from '../../types/dependent.mjs';
 import { IsEnum } from '../../types/enum.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
 import { Literal } from '../../types/literal.mjs';
-import { IsIntersect, Intersect } from '../../types/intersect.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTemplateLiteral } from '../../types/template_literal.mjs';
 import { Union, IsUnion } from '../../types/union.mjs';
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
 import { Distribute } from './distribute.mjs';
 import { Broaden } from './broaden.mjs';
 import { ExcludeOperation } from '../exclude/operation.mjs';
 import { TemplateLiteralDecode } from '../template_literal/decode.mjs';
 export function EvaluateDependent(if_, then_, else_) {
-    const intersect = Intersect([if_, then_]);
+    const intersected = EvaluateIntersect([if_, then_]);
     const excluded = ExcludeOperation(else_, if_);
-    const result = EvaluateUnion([intersect, excluded]);
+    const result = EvaluateUnion([intersected, excluded]);
     return result;
 }
-export function EvaluateEnum(values) {
-    const result = values.map(value => Literal(value));
-    return EvaluateUnion(result);
+export function EvaluateEnum(values, result = []) {
+    return Guard.ShiftLeft(values, (left, right) => EvaluateEnum(right, [...result, Literal(left)]), () => EvaluateUnion(result));
 }
 export function EvaluateIntersect(types) {
     const distribution = Distribute(types);
     const broadend = Broaden(distribution);
-    const result = EvaluateUnionFast(broadend);
+    const result = EvaluateUnion(broadend);
     return result;
 }
 export function EvaluateTemplateLiteral(pattern) {
@@ -38,12 +40,13 @@ export function EvaluateUnion(types) {
     return result;
 }
 export function EvaluateType(type) {
-    return (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
+    const result = (IsDependent(type) ? EvaluateDependent(type.if, type.then, type.else) :
         IsEnum(type) ? EvaluateEnum(type.enum) :
             IsIntersect(type) ? EvaluateIntersect(type.allOf) :
                 IsTemplateLiteral(type) ? EvaluateTemplateLiteral(type.pattern) :
                     IsUnion(type) ? EvaluateUnion(type.anyOf) :
                         type);
+    return result;
 }
 export function EvaluateUnionFast(types) {
     const result = (Guard.IsEqual(types.length, 1) ? types[0] :

package/node_modules/typebox/build/type/engine/evaluate/flatten.d.mts

@@ -2,5 +2,5 @@ import { type TSchema } from '../../types/schema.mjs';
 import { type TUnion } from '../../types/union.mjs';
 type TFlattenType<Type extends TSchema, Result extends TSchema[] = Type extends TUnion<infer Types extends TSchema[]> ? TFlatten<Types> : [Type]> = Result;
 export type TFlatten<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFlatten<Right, [...Result, ...TFlattenType<Left>]> : Result);
-export declare function Flatten<Types extends TSchema[]>(types: [...Types]): TFlatten<Types>;
+export declare function Flatten<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TFlatten<Types>;
 export {};

package/node_modules/typebox/build/type/engine/evaluate/flatten.mjs

@@ -1,11 +1,10 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 function FlattenType(type) {
     const result = IsUnion(type) ? Flatten(type.anyOf) : [type];
     return result;
 }
-export function Flatten(types) {
-    return types.reduce((result, type) => {
-        return [...result, ...FlattenType(type)];
-    }, []);
+export function Flatten(types, result = []) {
+    return Guard.ShiftLeft(types, (left, right) => Flatten(right, [...result, ...FlattenType(left)]), () => result);
 }

package/node_modules/typebox/build/type/engine/evaluate/narrow.d.mts

@@ -1,5 +1,20 @@
 import { type TSchema } from '../../types/schema.mjs';
+import { type TAny } from '../../types/any.mjs';
 import { type TNever } from '../../types/never.mjs';
-import { type TCompare, type TCompareResult, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export type TNarrow<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof ResultLeftInside ? Left : Result extends typeof ResultRightInside ? Right : Result extends typeof ResultEqual ? Right : TNever);
+import { type TUnknown } from '../../types/unknown.mjs';
+import { type TCompare, type TCompareResult, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { type TComposite, type TCanComposite } from './composite.mjs';
+type TNarrowCompareRule<Left extends TSchema, Right extends TSchema, Result extends TCompareResult = TCompare<Left, Right>> = (Result extends typeof CompareResultLeftInside ? Left : Result extends typeof CompareResultRightInside ? Right : Result extends typeof CompareResultEqual ? Right : TNever);
+type TNarrowCompositeRule<Left extends TSchema, Right extends TSchema, CanCompositeLeft extends boolean = TCanComposite<Left>, CanCompositeRight extends boolean = TCanComposite<Right>> = ([
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, true] ? TComposite<Left, Right> : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [true, false] ? Left : [
+    CanCompositeLeft,
+    CanCompositeRight
+] extends [false, true] ? Right : TNarrowCompareRule<Left, Right>);
+export type TNarrow<Left extends TSchema, Right extends TSchema> = (Left extends TNever ? TNever : Left extends TAny ? TAny : Left extends TUnknown ? Right : Right extends TNever ? TNever : Right extends TAny ? TAny : Right extends TUnknown ? Left : TNarrowCompositeRule<Left, Right>);
 export declare function Narrow<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TNarrow<Left, Right>;
+export {};

package/node_modules/typebox/build/type/engine/evaluate/narrow.mjs

@@ -1,11 +1,31 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Never } from '../../types/never.mjs';
-import { Compare, ResultLeftInside, ResultRightInside, ResultEqual } from './compare.mjs';
-export function Narrow(left, right) {
+import { IsAny } from '../../types/any.mjs';
+import { Never, IsNever } from '../../types/never.mjs';
+import { IsUnknown } from '../../types/unknown.mjs';
+import { Compare, CompareResultLeftInside, CompareResultRightInside, CompareResultEqual } from './compare.mjs';
+import { Composite, CanComposite } from './composite.mjs';
+function NarrowCompareRule(left, right) {
     const result = Compare(left, right);
-    return (Guard.IsEqual(result, ResultLeftInside) ? left :
-        Guard.IsEqual(result, ResultRightInside) ? right :
-            Guard.IsEqual(result, ResultEqual) ? right :
+    return (Guard.IsEqual(result, CompareResultLeftInside) ? left :
+        Guard.IsEqual(result, CompareResultRightInside) ? right :
+            Guard.IsEqual(result, CompareResultEqual) ? right :
                 Never());
 }
+function NarrowCompositeRule(left, right) {
+    const canCompositeLeft = CanComposite(left);
+    const canCompositeRight = CanComposite(right);
+    return (canCompositeLeft && canCompositeRight ? Composite(left, right) :
+        canCompositeLeft && !canCompositeRight ? left :
+            !canCompositeLeft && canCompositeRight ? right :
+                NarrowCompareRule(left, right));
+}
+export function Narrow(left, right) {
+    return (IsNever(left) ? left :
+        IsAny(left) ? left :
+            IsUnknown(left) ? right :
+                IsNever(right) ? right :
+                    IsAny(right) ? right :
+                        IsUnknown(right) ? left :
+                            NarrowCompositeRule(left, right));
+}

package/node_modules/typebox/build/type/engine/exclude/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExcludeType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [] : [left];
     return result;
 }
-function ExcludeUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExcludeType(head, right)];
-    }, []);
+function ExcludeUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExcludeUnion(tail, right, [...result, ...ExcludeType(head, right)]), () => result);
 }
 export function ExcludeOperation(left, right) {
     const evaluated = EvaluateType(left);

package/node_modules/typebox/build/type/engine/extract/operation.d.mts

@@ -4,7 +4,7 @@ import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
 import { type TEvaluateType } from '../evaluate/evaluate.mjs';
 import { type TEvaluateUnion } from '../evaluate/evaluate.mjs';
 type TExtractType<Left extends TSchema, Right extends TSchema, Check extends ExtendsResult.TResult = TExtends<{}, Left, Right>, Result extends TSchema[] = Check extends ExtendsResult.TExtendsTrueLike ? [Left] : []> = Result;
-type TExtractUnion<Types extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Types extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
+type TExtractUnion<Left extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtractUnion<Tail, Right, [...Result, ...TExtractType<Head, Right>]> : Result);
 export type TExtractOperation<Left extends TSchema, Right extends TSchema, Evaluated extends TSchema = TEvaluateType<Left>, Canonical extends TSchema[] = Evaluated extends TUnion<infer Types extends TSchema[]> ? Types : [Evaluated], Remaining extends TSchema[] = TExtractUnion<Canonical, Right>, Result extends TSchema = TEvaluateUnion<Remaining>> = Result;
 export declare function ExtractOperation<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TExtractOperation<Left, Right>;
 export {};

package/node_modules/typebox/build/type/engine/extract/operation.mjs

@@ -1,5 +1,6 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
 import { IsUnion } from '../../types/union.mjs';
 import { Extends, ExtendsResult } from '../../extends/index.mjs';
 import { EvaluateType } from '../evaluate/evaluate.mjs';
@@ -9,10 +10,8 @@ function ExtractType(left, right) {
     const result = ExtendsResult.IsExtendsTrueLike(check) ? [left] : [];
     return result;
 }
-function ExtractUnion(types, right) {
-    return types.reduce((result, head) => {
-        return [...result, ...ExtractType(head, right)];
-    }, []);
+function ExtractUnion(left, right, result = []) {
+    return Guard.ShiftLeft(left, (head, tail) => ExtractUnion(tail, right, [...result, ...ExtractType(head, right)]), () => result);
 }
 export function ExtractOperation(left, right) {
     const evaluated = EvaluateType(left);

package/node_modules/typebox/build/type/engine/priority/priority.d.mts

@@ -1,6 +1,6 @@
 import { type TSchema } from '../../types/schema.mjs';
-import { type TCompare, type TCompareResult } from '../evaluate/compare.mjs';
-type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends 'right-inside' ? 1 : CompareResult extends 'disjoint' ? 1 : 0)> = Result;
+import { type TCompare, type TCompareResult, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
+type TComparer<Left extends TSchema, Right extends TSchema, CompareResult extends TCompareResult = TCompare<Left, Right>, Result extends 0 | 1 = (CompareResult extends typeof CompareResultRightInside ? 1 : CompareResult extends typeof CompareResultDisjoint ? 1 : 0)> = Result;
 type TInsert<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TComparer<Type, Left> extends 1 ? TInsert<Type, Right, [...Result, Left]> : [...Result, Type, ...Types] : [...Result, Type]);
 type TSort<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TSort<Right, TInsert<Left, Result>> : Result);
 /**

package/node_modules/typebox/build/type/engine/priority/priority.mjs

@@ -1,12 +1,11 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { Compare } from '../evaluate/compare.mjs';
+import { Compare, CompareResultRightInside, CompareResultDisjoint } from '../evaluate/compare.mjs';
 function Comparer(left, right) {
     const compareResult = Compare(left, right);
-    const result = (Guard.IsEqual(compareResult, 'right-inside') ? 1 :
-        Guard.IsEqual(compareResult, 'disjoint') ? 1 :
+    return (Guard.IsEqual(compareResult, CompareResultRightInside) ? 1 :
+        Guard.IsEqual(compareResult, CompareResultDisjoint) ? 1 :
             0);
-    return result;
 }
 function Insert(type, types, result = []) {
     return Guard.ShiftLeft(types, (left, right) => Guard.IsEqual(Comparer(type, left), 1)

package/node_modules/typebox/build/type/script/mapping.d.mts

@@ -65,8 +65,8 @@ type TIntrinsicOrCall<Target extends string, Parameters extends T.TSchema[]> = (
     Target,
     Parameters
 ] extends ['Uppercase', [infer Type extends T.TSchema]] ? S.TUppercaseDeferred<Type> : T.TCallConstruct<T.TRef<Target>, Parameters>);
-type TDelimitedDecode<Input extends ([unknown, unknown] | unknown)[], Result extends unknown[] = []> = (Input extends [infer Left, ...infer Right] ? Left extends [infer Item, infer _] ? TDelimitedDecode<Right, [...Result, Item]> : TDelimitedDecode<Right, [...Result, Left]> : Result);
-type TDelimited<Input extends [unknown, unknown]> = Input extends [infer Left extends unknown[], infer Right extends unknown[]] ? TDelimitedDecode<[...Left, ...Right]> : [];
+type TDelimitedDecode<Input extends [unknown, unknown][], Result extends unknown[] = []> = (Input extends [infer Left extends [unknown, unknown], ...infer Right extends [unknown, unknown][]] ? TDelimitedDecode<Right, [...Result, Left[1]]> : Result);
+type TDelimited<Input extends [unknown, unknown, unknown] | []> = (Input extends [infer Left extends unknown, infer Right extends [unknown, unknown][], infer _ extends unknown[]] ? [Left, ...TDelimitedDecode<Right>] : []);
 export type TGenericParameterExtendsEqualsMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema, '=', infer Equals extends T.TSchema] ? T.TParameter<Name, Extends, Equals> : never);
 export declare function GenericParameterExtendsEqualsMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TGenericParameterExtendsMapping<Input extends [unknown, unknown, unknown]> = (Input extends [infer Name extends string, 'extends', infer Extends extends T.TSchema] ? T.TParameter<Name, Extends, Extends> : never);
@@ -77,12 +77,12 @@ export type TGenericParameterIdentifierMapping<Input extends string, Result exte
 export declare function GenericParameterIdentifierMapping(input: string): unknown;
 export type TGenericParameterMapping<Input extends unknown> = (Input);
 export declare function GenericParameterMapping(input: unknown): unknown;
-export type TGenericParameterListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function GenericParameterListMapping(input: [unknown, unknown]): unknown;
+export type TGenericParameterListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function GenericParameterListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TGenericParametersMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['<', infer Parameters extends T.TParameter[], '>'] ? Parameters : never);
 export declare function GenericParametersMapping(input: [unknown, unknown, unknown]): unknown;
-export type TGenericCallArgumentListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function GenericCallArgumentListMapping(input: [unknown, unknown]): unknown;
+export type TGenericCallArgumentListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function GenericCallArgumentListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TGenericCallArgumentsMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['<', infer Arguments extends T.TSchema[], '>'] ? Arguments : never);
 export declare function GenericCallArgumentsMapping(input: [unknown, unknown, unknown]): unknown;
 export type TGenericCallMapping<Input extends [unknown, unknown], Result = Input extends [infer Ref extends string, infer Arguments extends T.TSchema[]] ? TIntrinsicOrCall<Ref, Arguments> : never> = Result;
@@ -202,8 +202,8 @@ export type TPropertyMapping<Input extends [unknown, unknown, unknown, unknown,
 export declare function PropertyMapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type TPropertyDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
 export declare function PropertyDelimiterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function PropertyListMapping(input: [unknown, unknown]): unknown;
+export type TPropertyListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function PropertyListMapping(input: [unknown, unknown, unknown] | []): unknown;
 type TPropertiesReduce<PropertiesList extends T.TProperties[], Result extends [properties: T.TProperties, patternProperties: T.TProperties] = [{}, {}]> = (PropertiesList extends [infer Left extends T.TProperties, ...infer Right extends T.TProperties[]] ? (Left extends {
     [_ in T.TIntegerKey]: T.TSchema;
 } ? TPropertiesReduce<Right, [Result[0], Memory.TAssign<Result[1], Left>]> : Left extends {
@@ -219,18 +219,21 @@ export type T_Object_Mapping<Input extends unknown> = (Input extends [infer Prop
 export declare function _Object_Mapping(input: unknown): unknown;
 export type TElementNamedMapping<Input extends [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : Input extends [string, /**/ ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : Input extends [string, '?', ':', /*      */ infer Type extends T.TSchema] ? S.TAddOptionalDeferred<Type> : Input extends [string, /**/ ':', /*      */ infer Type extends T.TSchema] ? Type : never);
 export declare function ElementNamedMapping(input: [unknown, unknown, unknown, unknown, unknown] | [unknown, unknown, unknown, unknown] | [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyOptionalMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema, '?'] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
-export declare function ElementReadonlyOptionalMapping(input: [unknown, unknown, unknown]): unknown;
-export type TElementReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<Type> : never);
-export declare function ElementReadonlyMapping(input: [unknown, unknown]): unknown;
-export type TElementOptionalMapping<Input extends [unknown, unknown]> = (Input extends [infer Type extends T.TSchema, '?'] ? S.TAddOptionalDeferred<Type> : never);
-export declare function ElementOptionalMapping(input: [unknown, unknown]): unknown;
-export type TElementBaseMapping<Input extends unknown> = (Input);
-export declare function ElementBaseMapping(input: unknown): unknown;
+export type TElementBaseMapping<Input extends unknown | [unknown, unknown, unknown]> = (Input extends [infer IsReadonly extends boolean, infer Type extends T.TSchema, infer IsOptional extends boolean] ? ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? S.TAddReadonlyDeferred<Type> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? S.TAddOptionalDeferred<Type> : Type) : Input);
+export declare function ElementBaseMapping(input: unknown | [unknown, unknown, unknown]): unknown;
 export type TElementMapping<Input extends [unknown, unknown] | [unknown]> = (Input extends ['...', infer Type extends T.TSchema] ? T.TRest<Type> : Input extends [infer Type extends T.TSchema] ? Type : never);
 export declare function ElementMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function ElementListMapping(input: [unknown, unknown]): unknown;
+export type TElementListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ElementListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type T_Tuple_Mapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Types extends T.TSchema[], ']'] ? T.TTuple<Types> : never);
 export declare function _Tuple_Mapping(input: [unknown, unknown, unknown]): unknown;
 export type TParameterReadonlyOptionalMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends [string, '?', ':', 'readonly', infer Type extends T.TSchema] ? S.TAddReadonlyDeferred<S.TAddOptionalDeferred<Type>> : never);
@@ -245,8 +248,8 @@ export type TParameterBaseMapping<Input extends unknown> = (Input);
 export declare function ParameterBaseMapping(input: unknown): unknown;
 export type TParameterMapping<Input extends [unknown, unknown] | [unknown]> = (Input extends ['...', infer Type extends T.TSchema] ? T.TRest<Type> : Input extends [infer Type extends T.TSchema] ? Type : never);
 export declare function ParameterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TParameterListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function ParameterListMapping(input: [unknown, unknown]): unknown;
+export type TParameterListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ParameterListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type T_Function_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['(', infer ParameterList extends T.TSchema[], ')', '=>', infer ReturnType extends T.TSchema] ? T.TFunction<ParameterList, ReturnType> : never);
 export declare function _Function_Mapping(input: [unknown, unknown, unknown, unknown, unknown]): unknown;
 export type T_Constructor_Mapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown]> = (Input extends ['new', '(', infer ParameterList extends T.TSchema[], ')', '=>', infer InstanceType extends T.TSchema] ? T.TConstructor<ParameterList, InstanceType> : never);
@@ -280,15 +283,15 @@ export type TWithPropertyMapping<Input extends [unknown, unknown, unknown]> = (I
     [_ in Key]: Value;
 } : never);
 export declare function WithPropertyMapping(input: [unknown, unknown, unknown]): unknown;
-export type TWithPropertyListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function WithPropertyListMapping(input: [unknown, unknown]): unknown;
+export type TWithPropertyListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function WithPropertyListMapping(input: [unknown, unknown, unknown] | []): unknown;
 type TWithObjectMappingReduce<PropertyList extends Record<PropertyKey, unknown>[], Result extends Record<PropertyKey, unknown> = {}> = (PropertyList extends [infer Left extends Record<PropertyKey, unknown>, ...infer Right extends Record<PropertyKey, unknown>[]] ? TWithObjectMappingReduce<Right, Memory.TAssign<Result, Left>> : {
     [Key in keyof Result]: Result[Key];
 });
 export type TWithObjectMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['{', infer PropertyList extends Record<PropertyKey, unknown>[], '}'] ? TWithObjectMappingReduce<PropertyList> : {});
 export declare function WithObjectMapping(input: [unknown, unknown, unknown]): unknown;
-export type TWithElementListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function WithElementListMapping(input: [unknown, unknown]): unknown;
+export type TWithElementListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function WithElementListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TWithArrayMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['[', infer Elements extends unknown[], ']'] ? Elements : never);
 export declare function WithArrayMapping(input: [unknown, unknown, unknown]): unknown;
 export type TWithValueMapping<Input extends unknown> = (Input);
@@ -318,8 +321,8 @@ export type TPatternBodyMapping<Input extends unknown> = (Input);
 export declare function PatternBodyMapping(input: unknown): unknown;
 export type TPatternMapping<Input extends [unknown, unknown, unknown]> = (Input extends ['^', infer Body extends T.TSchema[], '$'] ? Body : never);
 export declare function PatternMapping(input: [unknown, unknown, unknown]): unknown;
-export type TInterfaceDeclarationHeritageListMapping<Input extends [unknown, unknown]> = (TDelimited<Input>);
-export declare function InterfaceDeclarationHeritageListMapping(input: [unknown, unknown]): unknown;
+export type TInterfaceDeclarationHeritageListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function InterfaceDeclarationHeritageListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationHeritageMapping<Input extends [unknown, unknown] | []> = (Input extends ['extends', infer Heritage extends T.TSchema[]] ? Heritage : []);
 export declare function InterfaceDeclarationHeritageMapping(input: [unknown, unknown] | []): unknown;
 export type TInterfaceDeclarationGenericMapping<Input extends [unknown, unknown, unknown, unknown, unknown]> = (Input extends ['interface', infer Name extends string, infer Parameters extends T.TParameter[], infer Heritage extends T.TSchema[], infer Properties extends [T.TProperties, T.TProperties]] ? {
@@ -342,11 +345,11 @@ export type TExportKeywordMapping<Input extends [unknown] | []> = (null);
 export declare function ExportKeywordMapping(input: [unknown] | []): unknown;
 export type TModuleDeclarationDelimiterMapping<Input extends [unknown, unknown] | [unknown]> = (Input);
 export declare function ModuleDeclarationDelimiterMapping(input: [unknown, unknown] | [unknown]): unknown;
-export type TModuleDeclarationListMapping<Input extends [unknown, unknown]> = (TPropertiesReduce<TDelimited<Input>>);
-export declare function ModuleDeclarationListMapping(input: [unknown, unknown]): unknown;
+export type TModuleDeclarationListMapping<Input extends [unknown, unknown, unknown] | []> = (TDelimited<Input>);
+export declare function ModuleDeclarationListMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TModuleDeclarationMapping<Input extends [unknown, unknown, unknown]> = (Input extends [null, infer ModuleDeclaration extends T.TProperties, null] ? ModuleDeclaration : never);
 export declare function ModuleDeclarationMapping(input: [unknown, unknown, unknown]): unknown;
-export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends [T.TProperties, T.TProperties]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, ModuleDeclarationList[0]>> : never);
+export type TModuleMapping<Input extends [unknown, unknown]> = (Input extends [infer ModuleDeclaration extends T.TProperties, infer ModuleDeclarationList extends T.TProperties[]] ? S.TModuleDeferred<Memory.TAssign<ModuleDeclaration, TPropertiesReduce<ModuleDeclarationList>[0]>> : never);
 export declare function ModuleMapping(input: [unknown, unknown]): unknown;
 export type TScriptMapping<Input extends unknown> = (Input);
 export declare function ScriptMapping(input: unknown): unknown;

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

@@ -39,17 +39,14 @@ function IntrinsicOrCall(ref, parameters) {
 function Unreachable() {
     throw Error('Unreachable');
 }
-const DelimitedDecode = (input, result = []) => {
-    return input.reduce((result, left) => {
-        return Guard.IsArray(left) && Guard.IsEqual(left.length, 2)
-            ? [...result, left[0]]
-            : [...result, left];
-    }, []);
-};
-const Delimited = (input) => {
-    const [left, right] = input;
-    return DelimitedDecode([...left, ...right]);
-};
+function DelimitedDecode(input, result = []) {
+    return Guard.ShiftLeft(input, (left, right) => DelimitedDecode(right, [...result, left[1]]), () => result);
+}
+function Delimited(input) {
+    return Guard.IsEqual(input.length, 3)
+        ? [input[0], ...DelimitedDecode(input[1])]
+        : [];
+}
 export function GenericParameterExtendsEqualsMapping(input) {
     return T.Parameter(input[0], input[2], input[4]);
 }
@@ -322,17 +319,14 @@ export function ElementNamedMapping(input) {
             Guard.IsEqual(input.length, 4) ? (Guard.IsEqual(input[2], 'readonly') ? S.AddReadonlyDeferred(input[3]) : S.AddOptionalDeferred(input[3])) :
                 Unreachable());
 }
-export function ElementReadonlyOptionalMapping(input) {
-    return S.AddReadonlyDeferred(S.AddOptionalDeferred(input[1]));
-}
-export function ElementReadonlyMapping(input) {
-    return S.AddReadonlyDeferred(input[1]);
-}
-export function ElementOptionalMapping(input) {
-    return S.AddOptionalDeferred(input[0]);
-}
 export function ElementBaseMapping(input) {
-    return input;
+    if (!Guard.IsArray(input) || !Guard.IsEqual(input.length, 3))
+        return input;
+    const [isReadonly, type, isOptional] = input;
+    return (isReadonly && isOptional ? S.AddReadonlyDeferred(S.AddOptionalDeferred(type)) :
+        isReadonly && !isOptional ? S.AddReadonlyDeferred(type) :
+            !isReadonly && isOptional ? S.AddOptionalDeferred(type) :
+                type);
 }
 // deno-coverage-ignore-start
 export function ElementMapping(input) {
@@ -520,15 +514,14 @@ export function ModuleDeclarationDelimiterMapping(input) {
     return input;
 }
 export function ModuleDeclarationListMapping(input) {
-    return PropertiesReduce(Delimited(input));
+    return Delimited(input);
 }
 export function ModuleDeclarationMapping(input) {
     return input[1];
 }
 export function ModuleMapping(input) {
-    const moduleDeclaration = input[0];
-    const moduleDeclarationList = input[1];
-    return S.ModuleDeferred(Memory.Assign(moduleDeclaration, moduleDeclarationList[0]));
+    const [moduleDeclaration, moduleDeclarationList] = [input[0], input[1]];
+    return S.ModuleDeferred(Memory.Assign(moduleDeclaration, PropertiesReduce(moduleDeclarationList)[0]));
 }
 export function ScriptMapping(input) {
     return input;