@depup/typebox 1.1.23-depup.0 → 1.3.9-depup.0

package/build/type/script/mapping.mjs

@@ -2,39 +2,34 @@
 // deno-lint-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import * as C from '../action/index.mjs';
 import * as T from '../types/index.mjs';
+import * as S from '../action/index.mjs';
 function IntrinsicOrCall(ref, parameters) {
     // deno-coverage-ignore-start
     //
     // Have extensively tested but reports show no Omit coverage (review)
     return (Guard.IsEqual(ref, 'Array') ? T.Array(parameters[0]) :
-        Guard.IsEqual(ref, 'AsyncIterator') ? T.AsyncIterator(parameters[0]) :
-            Guard.IsEqual(ref, 'Iterator') ? T.Iterator(parameters[0]) :
-                Guard.IsEqual(ref, 'Promise') ? T.Promise(parameters[0]) :
-                    Guard.IsEqual(ref, 'Awaited') ? C.AwaitedDeferred(parameters[0]) :
-                        Guard.IsEqual(ref, 'Capitalize') ? C.CapitalizeDeferred(parameters[0]) :
-                            Guard.IsEqual(ref, 'ConstructorParameters') ? C.ConstructorParametersDeferred(parameters[0]) :
-                                Guard.IsEqual(ref, 'Evaluate') ? C.EvaluateDeferred(parameters[0]) :
-                                    Guard.IsEqual(ref, 'Exclude') ? C.ExcludeDeferred(parameters[0], parameters[1]) :
-                                        Guard.IsEqual(ref, 'Extract') ? C.ExtractDeferred(parameters[0], parameters[1]) :
-                                            Guard.IsEqual(ref, 'Index') ? C.IndexDeferred(parameters[0], parameters[1]) :
-                                                Guard.IsEqual(ref, 'InstanceType') ? C.InstanceTypeDeferred(parameters[0]) :
-                                                    Guard.IsEqual(ref, 'Lowercase') ? C.LowercaseDeferred(parameters[0]) :
-                                                        Guard.IsEqual(ref, 'NonNullable') ? C.NonNullableDeferred(parameters[0]) :
-                                                            Guard.IsEqual(ref, 'Omit') ? C.OmitDeferred(parameters[0], parameters[1]) :
-                                                                Guard.IsEqual(ref, 'Options') ? C.OptionsDeferred(parameters[0], parameters[1]) :
-                                                                    Guard.IsEqual(ref, 'Parameters') ? C.ParametersDeferred(parameters[0]) :
-                                                                        Guard.IsEqual(ref, 'Partial') ? C.PartialDeferred(parameters[0]) :
-                                                                            Guard.IsEqual(ref, 'Pick') ? C.PickDeferred(parameters[0], parameters[1]) :
-                                                                                Guard.IsEqual(ref, 'Readonly') ? C.ReadonlyTypeDeferred(parameters[0]) :
-                                                                                    Guard.IsEqual(ref, 'KeyOf') ? C.KeyOfDeferred(parameters[0]) :
-                                                                                        Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
-                                                                                            Guard.IsEqual(ref, 'Required') ? C.RequiredDeferred(parameters[0]) :
-                                                                                                Guard.IsEqual(ref, 'ReturnType') ? C.ReturnTypeDeferred(parameters[0]) :
-                                                                                                    Guard.IsEqual(ref, 'Uncapitalize') ? C.UncapitalizeDeferred(parameters[0]) :
-                                                                                                        Guard.IsEqual(ref, 'Uppercase') ? C.UppercaseDeferred(parameters[0]) :
-                                                                                                            T.CallConstruct(T.Ref(ref), parameters));
+        Guard.IsEqual(ref, 'Capitalize') ? S.CapitalizeDeferred(parameters[0]) :
+            Guard.IsEqual(ref, 'ConstructorParameters') ? S.ConstructorParametersDeferred(parameters[0]) :
+                Guard.IsEqual(ref, 'Evaluate') ? S.EvaluateDeferred(parameters[0]) :
+                    Guard.IsEqual(ref, 'Exclude') ? S.ExcludeDeferred(parameters[0], parameters[1]) :
+                        Guard.IsEqual(ref, 'Extract') ? S.ExtractDeferred(parameters[0], parameters[1]) :
+                            Guard.IsEqual(ref, 'Index') ? S.IndexDeferred(parameters[0], parameters[1]) :
+                                Guard.IsEqual(ref, 'InstanceType') ? S.InstanceTypeDeferred(parameters[0]) :
+                                    Guard.IsEqual(ref, 'Lowercase') ? S.LowercaseDeferred(parameters[0]) :
+                                        Guard.IsEqual(ref, 'NonNullable') ? S.NonNullableDeferred(parameters[0]) :
+                                            Guard.IsEqual(ref, 'Omit') ? S.OmitDeferred(parameters[0], parameters[1]) :
+                                                Guard.IsEqual(ref, 'Parameters') ? S.ParametersDeferred(parameters[0]) :
+                                                    Guard.IsEqual(ref, 'Partial') ? S.PartialDeferred(parameters[0]) :
+                                                        Guard.IsEqual(ref, 'Pick') ? S.PickDeferred(parameters[0], parameters[1]) :
+                                                            Guard.IsEqual(ref, 'Readonly') ? S.ReadonlyObjectDeferred(parameters[0]) :
+                                                                Guard.IsEqual(ref, 'KeyOf') ? S.KeyOfDeferred(parameters[0]) :
+                                                                    Guard.IsEqual(ref, 'Record') ? T.RecordDeferred(parameters[0], parameters[1]) :
+                                                                        Guard.IsEqual(ref, 'Required') ? S.RequiredDeferred(parameters[0]) :
+                                                                            Guard.IsEqual(ref, 'ReturnType') ? S.ReturnTypeDeferred(parameters[0]) :
+                                                                                Guard.IsEqual(ref, 'Uncapitalize') ? S.UncapitalizeDeferred(parameters[0]) :
+                                                                                    Guard.IsEqual(ref, 'Uppercase') ? S.UppercaseDeferred(parameters[0]) :
+                                                                                        T.CallConstruct(T.Ref(ref), parameters));
     // deno-coverage-ignore-stop
 }
 // ------------------------------------------------------------------
@@ -44,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]);
 }
@@ -130,8 +122,17 @@ export function KeywordVoidMapping(input) {
 export function KeywordThisMapping(input) {
     return T.This();
 }
-export function KeywordMapping(input) {
-    return input;
+export function LiteralBigIntMapping(input) {
+    return T.Literal(BigInt(input));
+}
+export function LiteralBooleanMapping(input) {
+    return T.Literal(Guard.IsEqual(input, 'true'));
+}
+export function LiteralNumberMapping(input) {
+    return T.Literal(parseFloat(input));
+}
+export function LiteralStringMapping(input) {
+    return T.Literal(input);
 }
 export function TemplateInterpolateMapping(input) {
     return input[1];
@@ -150,20 +151,9 @@ export function TemplateLiteralTypesMapping(input) {
 export function TemplateLiteralMapping(input) {
     return T.TemplateLiteralDeferred(input);
 }
-export function LiteralBigIntMapping(input) {
-    return T.Literal(BigInt(input));
-}
-export function LiteralBooleanMapping(input) {
-    return T.Literal(Guard.IsEqual(input, 'true'));
-}
-export function LiteralNumberMapping(input) {
-    return T.Literal(parseFloat(input));
-}
-export function LiteralStringMapping(input) {
-    return T.Literal(input);
-}
-export function LiteralMapping(input) {
-    return input;
+export function DependentMapping(input) {
+    return (Guard.IsEqual(input.length, 6) ? T.Dependent(input[1], input[3], input[5]) :
+        T.Dependent(input[1], input[3], T.Unknown()));
 }
 export function KeyOfMapping(input) {
     return input.length > 0;
@@ -185,27 +175,34 @@ export function BaseMapping(input) {
         ? input[1]
         : input;
 }
+export function WithMapping(input) {
+    return Guard.IsEqual(input.length, 2) ? input[1] : [];
+}
 // deno-coverage-ignore-start
-// ...
-const FactorIndexArray = (Type, indexArray) => {
+function FactorIndexArray(Type, indexArray) {
     return indexArray.reduce((result, left) => {
         const _left = left;
-        return (Guard.IsEqual(_left.length, 1) ? C.IndexDeferred(result, _left[0]) :
+        return (Guard.IsEqual(_left.length, 1) ? S.IndexDeferred(result, _left[0]) :
             Guard.IsEqual(_left.length, 0) ? T.Array(result) :
                 Unreachable());
     }, Type);
-};
+}
 // deno-coverage-ignore-stop
-const FactorExtends = (type, extend) => {
+function FactorExtends(type, extend) {
     return Guard.IsEqual(extend.length, 3)
-        ? C.ConditionalDeferred(type, extend[0], extend[1], extend[2])
+        ? S.ConditionalDeferred(type, extend[0], extend[1], extend[2])
         : type;
-};
+}
+function FactorWith(type, withClause) {
+    return Guard.IsArray(withClause) && Guard.IsEqual(withClause.length, 0)
+        ? type
+        : S.WithDeferred(type, withClause);
+}
 export function FactorMapping(input) {
-    const [keyOf, type, indexArray, extend] = input;
-    return keyOf
-        ? FactorExtends(C.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
-        : FactorExtends(FactorIndexArray(type, indexArray), extend);
+    const [keyOf, type, indexArray, extend, withClause] = input;
+    return FactorWith(keyOf
+        ? FactorExtends(S.KeyOfDeferred(FactorIndexArray(type, indexArray)), extend)
+        : FactorExtends(FactorIndexArray(type, indexArray), extend), withClause);
 }
 // deno-coverage-ignore-start
 function ExprBinaryMapping(left, rest) {
@@ -240,7 +237,7 @@ export function ExprMapping(input) {
     return ExprBinaryMapping(left, rest);
 }
 export function ExprReadonlyMapping(input) {
-    return T.ImmutableAdd(input[1]);
+    return S.AddImmutableDeferred(input[1]);
 }
 export function ExprPipeMapping(input) {
     return input[1];
@@ -286,9 +283,9 @@ export function OptionalMapping(input) {
 export function PropertyMapping(input) {
     const [isReadonly, key, isOptional, _colon, type] = input;
     return {
-        [key]: (isReadonly && isOptional ? T.ReadonlyAdd(T.OptionalAdd(type)) :
-            isReadonly && !isOptional ? T.ReadonlyAdd(type) :
-                !isReadonly && isOptional ? T.OptionalAdd(type) :
+        [key]: (isReadonly && isOptional ? S.AddReadonlyDeferred(S.AddOptionalDeferred(type)) :
+            isReadonly && !isOptional ? S.AddReadonlyDeferred(type) :
+                !isReadonly && isOptional ? S.AddOptionalDeferred(type) :
                     type)
     };
 }
@@ -317,22 +314,19 @@ export function _Object_Mapping(input) {
 }
 // deno-coverage-ignore-start
 export function ElementNamedMapping(input) {
-    return (Guard.IsEqual(input.length, 5) ? T.ReadonlyAdd(T.OptionalAdd(input[4])) :
+    return (Guard.IsEqual(input.length, 5) ? S.AddReadonlyDeferred(S.AddOptionalDeferred(input[4])) :
         Guard.IsEqual(input.length, 3) ? input[2] :
-            Guard.IsEqual(input.length, 4) ? (Guard.IsEqual(input[2], 'readonly') ? T.ReadonlyAdd(input[3]) : T.OptionalAdd(input[3])) :
+            Guard.IsEqual(input.length, 4) ? (Guard.IsEqual(input[2], 'readonly') ? S.AddReadonlyDeferred(input[3]) : S.AddOptionalDeferred(input[3])) :
                 Unreachable());
 }
-export function ElementReadonlyOptionalMapping(input) {
-    return T.ReadonlyAdd(T.OptionalAdd(input[1]));
-}
-export function ElementReadonlyMapping(input) {
-    return T.ReadonlyAdd(input[1]);
-}
-export function ElementOptionalMapping(input) {
-    return T.OptionalAdd(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) {
@@ -343,17 +337,17 @@ export function ElementMapping(input) {
 export function ElementListMapping(input) {
     return Delimited(input);
 }
-export function TupleMapping(input) {
+export function _Tuple_Mapping(input) {
     return T.Tuple(input[1]);
 }
 export function ParameterReadonlyOptionalMapping(input) {
-    return T.ReadonlyAdd(T.OptionalAdd(input[4]));
+    return S.AddReadonlyDeferred(S.AddOptionalDeferred(input[4]));
 }
 export function ParameterReadonlyMapping(input) {
-    return T.ReadonlyAdd(input[3]);
+    return S.AddReadonlyDeferred(input[3]);
 }
 export function ParameterOptionalMapping(input) {
-    return T.OptionalAdd(input[3]);
+    return S.AddOptionalDeferred(input[3]);
 }
 export function ParameterTypeMapping(input) {
     return input[2];
@@ -373,12 +367,12 @@ export function ParameterListMapping(input) {
 export function _Function_Mapping(input) {
     return T._Function_(input[1], input[4]);
 }
-export function ConstructorMapping(input) {
+export function _Constructor_Mapping(input) {
     return T.Constructor(input[2], input[5]);
 }
 function ApplyReadonly(state, type) {
-    return (Guard.IsEqual(state, 'remove') ? C.ReadonlyRemoveAction(type) :
-        Guard.IsEqual(state, 'add') ? C.ReadonlyAddAction(type) :
+    return (Guard.IsEqual(state, 'remove') ? S.RemoveReadonlyDeferred(type) :
+        Guard.IsEqual(state, 'add') ? S.AddReadonlyDeferred(type) :
             type);
 }
 export function MappedReadonlyMapping(input) {
@@ -388,8 +382,8 @@ export function MappedReadonlyMapping(input) {
                 'none');
 }
 function ApplyOptional(state, type) {
-    return (Guard.IsEqual(state, 'remove') ? C.OptionalRemoveAction(type) :
-        Guard.IsEqual(state, 'add') ? C.OptionalAddAction(type) :
+    return (Guard.IsEqual(state, 'remove') ? S.RemoveOptionalDeferred(type) :
+        Guard.IsEqual(state, 'add') ? S.AddOptionalDeferred(type) :
             type);
 }
 export function MappedOptionalMapping(input) {
@@ -401,50 +395,53 @@ export function MappedOptionalMapping(input) {
 export function MappedAsMapping(input) {
     return Guard.IsEqual(input.length, 2) ? [input[1]] : [];
 }
-export function MappedMapping(input) {
+export function _Mapped_Mapping(input) {
     return (Guard.IsArray(input[6]) && Guard.IsEqual(input[6].length, 1)
-        ? C.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
-        : C.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
+        ? S.MappedDeferred(T.Identifier(input[3]), input[5], input[6][0], ApplyReadonly(input[1], ApplyOptional(input[8], input[10])))
+        : S.MappedDeferred(T.Identifier(input[3]), input[5], T.Ref(input[3]), ApplyReadonly(input[1], ApplyOptional(input[8], input[10]))));
 }
 export function ReferenceMapping(input) {
     return T.Ref(input);
 }
-export function OptionsMapping(input) {
-    return C.OptionsDeferred(input[2], input[4]);
+export function WithBigIntMapping(input) {
+    return BigInt(input);
 }
-export function JsonNumberMapping(input) {
+export function WithNumberMapping(input) {
     return parseFloat(input);
 }
-export function JsonBooleanMapping(input) {
+export function WithBooleanMapping(input) {
     return Guard.IsEqual(input, 'true');
 }
-export function JsonStringMapping(input) {
+export function WithStringMapping(input) {
     return input;
 }
-export function JsonNullMapping(input) {
+export function WithNullMapping(input) {
     return null;
 }
-export function JsonPropertyMapping(input) {
+export function WithUndefinedMapping(input) {
+    return undefined;
+}
+export function WithPropertyMapping(input) {
     return { [input[0]]: input[2] };
 }
-export function JsonPropertyListMapping(input) {
+export function WithPropertyListMapping(input) {
     return Delimited(input);
 }
-function JsonObjectMappingReduce(propertyList) {
+function WithObjectMappingReduce(propertyList) {
     return propertyList.reduce((result, left) => {
         return Memory.Assign(result, left);
     }, {});
 }
-export function JsonObjectMapping(input) {
-    return JsonObjectMappingReduce(input[1]);
+export function WithObjectMapping(input) {
+    return WithObjectMappingReduce(input[1]);
 }
-export function JsonElementListMapping(input) {
+export function WithElementListMapping(input) {
     return Delimited(input);
 }
-export function JsonArrayMapping(input) {
+export function WithArrayMapping(input) {
     return input[1];
 }
-export function JsonMapping(input) {
+export function WithValueMapping(input) {
     return input;
 }
 export function PatternBigIntMapping(input) {
@@ -496,13 +493,13 @@ export function InterfaceDeclarationGenericMapping(input) {
     const heritage = input[3];
     const [properties, patternProperties] = input[4];
     const options = Guard.IsEqual(Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
-    return { [input[1]]: T.Generic(parameters, C.InterfaceDeferred(heritage, properties, options)) };
+    return { [input[1]]: T.Generic(parameters, S.InterfaceDeferred(heritage, properties, options)) };
 }
 export function InterfaceDeclarationMapping(input) {
     const heritage = input[2];
     const [properties, patternProperties] = input[3];
     const options = Guard.IsEqual(Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
-    return { [input[1]]: C.InterfaceDeferred(heritage, properties, options) };
+    return { [input[1]]: S.InterfaceDeferred(heritage, properties, options) };
 }
 export function TypeAliasDeclarationGenericMapping(input) {
     return { [input[1]]: T.Generic(input[2], input[4]) };
@@ -517,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 C.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;