@sinclair/typebox 0.29.5 → 0.30.0-dev-1

package/value/create.js

@@ -27,9 +27,10 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.Create = exports.Visit = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
-const check_1 = require("./check");
+const ValueCheck = require("./check");
+const ValueGuard = require("./guard");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
@@ -84,421 +85,432 @@ class ValueCreateRecursiveInstantiationError extends Error {
 }
 exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiationError;
 // --------------------------------------------------------------------------
-// ValueCreate
+// Types
 // --------------------------------------------------------------------------
-var ValueCreate;
-(function (ValueCreate) {
-    // --------------------------------------------------------
-    // Guards
-    // --------------------------------------------------------
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    // --------------------------------------------------------
-    // Types
-    // --------------------------------------------------------
-    function Any(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return {};
-        }
+function TAny(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Array(schema, references) {
-        if (schema.uniqueItems === true && schema.default === undefined) {
-            throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value');
-        }
-        else if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minItems !== undefined) {
-            return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-                return Visit(schema.items, references);
-            });
-        }
-        else {
-            return [];
-        }
+    else {
+        return {};
     }
-    function BigInt(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return globalThis.BigInt(0);
-        }
+}
+function TArray(schema, references) {
+    if (schema.uniqueItems === true && !ValueGuard.HasPropertyKey(schema, 'default')) {
+        throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
     }
-    function Boolean(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return false;
-        }
+    else if ('contains' in schema && !ValueGuard.HasPropertyKey(schema, 'default')) {
+        throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value');
     }
-    function Constructor(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const value = Visit(schema.returns, references);
-            if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
-                return class {
-                    constructor() {
-                        for (const [key, val] of globalThis.Object.entries(value)) {
-                            const self = this;
-                            self[key] = val;
-                        }
-                    }
-                };
-            }
-            else {
-                return class {
-                };
-            }
-        }
+    else if ('default' in schema) {
+        return schema.default;
     }
-    function Date(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimumTimestamp !== undefined) {
-            return new globalThis.Date(schema.minimumTimestamp);
-        }
-        else {
-            return new globalThis.Date(0);
-        }
+    else if (schema.minItems !== undefined) {
+        return Array.from({ length: schema.minItems }).map((item) => {
+            return Visit(schema.items, references);
+        });
     }
-    function Function(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return () => Visit(schema.returns, references);
-        }
+    else {
+        return [];
     }
-    function Integer(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimum !== undefined) {
-            return schema.minimum;
-        }
-        else {
-            return 0;
-        }
+}
+function TAsyncIterator(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Intersect(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
-            // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
-            // be a consequence of an illogical intersection.
-            const value = schema.allOf.reduce((acc, schema) => {
-                const next = Visit(schema, references);
-                return typeof next === 'object' ? { ...acc, ...next } : next;
-            }, {});
-            if (!check_1.ValueCheck.Check(schema, references, value))
-                throw new ValueCreateIntersectTypeError(schema);
-            return value;
-        }
+    else {
+        return (async function* () { })();
     }
-    function Literal(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return schema.const;
-        }
+}
+function TBigInt(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Never(schema, references) {
-        throw new ValueCreateNeverTypeError(schema);
+    else {
+        return BigInt(0);
     }
-    function Not(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            throw new ValueCreateNotTypeError(schema);
-        }
+}
+function TBoolean(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Null(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return null;
-        }
+    else {
+        return false;
     }
-    function Number(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimum !== undefined) {
-            return schema.minimum;
+}
+function TConstructor(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        const value = Visit(schema.returns, references);
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            return class {
+                constructor() {
+                    for (const [key, val] of Object.entries(value)) {
+                        const self = this;
+                        self[key] = val;
+                    }
+                }
+            };
         }
         else {
-            return 0;
+            return class {
+            };
         }
     }
-    function Object(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const required = new Set(schema.required);
-            return (schema.default ||
-                globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                    return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
-                }, {}));
-        }
+}
+function TDate(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Promise(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return globalThis.Promise.resolve(Visit(schema.item, references));
-        }
+    else if (schema.minimumTimestamp !== undefined) {
+        return new Date(schema.minimumTimestamp);
     }
-    function Record(schema, references) {
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
-            const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
-            return propertyKeys.reduce((acc, key) => {
-                return { ...acc, [key]: Visit(valueSchema, references) };
-            }, {});
-        }
-        else {
-            return {};
-        }
+    else {
+        return new Date(0);
     }
-    function Ref(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-            if (index === -1)
-                throw new ValueCreateDereferenceError(schema);
-            const target = references[index];
-            return Visit(target, references);
-        }
+}
+function TFunction(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function String(schema, references) {
-        if (schema.pattern !== undefined) {
-            if (!('default' in schema)) {
-                throw new Error('ValueCreate.String: String types with patterns must specify a default value');
-            }
-            else {
-                return schema.default;
-            }
-        }
-        else if (schema.format !== undefined) {
-            if (!('default' in schema)) {
-                throw new Error('ValueCreate.String: String types with formats must specify a default value');
-            }
-            else {
-                return schema.default;
-            }
-        }
-        else {
-            if ('default' in schema) {
-                return schema.default;
-            }
-            else if (schema.minLength !== undefined) {
-                return globalThis.Array.from({ length: schema.minLength })
-                    .map(() => '.')
-                    .join('');
-            }
-            else {
-                return '';
-            }
-        }
+    else {
+        return () => Visit(schema.returns, references);
     }
-    function Symbol(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if ('value' in schema) {
-            return globalThis.Symbol.for(schema.value);
-        }
-        else {
-            return globalThis.Symbol();
-        }
+}
+function TInteger(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function TemplateLiteral(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
-        if (!Types.TemplateLiteralFinite.Check(expression))
-            throw new ValueCreateTempateLiteralTypeError(schema);
-        const sequence = Types.TemplateLiteralGenerator.Generate(expression);
-        return sequence.next().value;
-    }
-    function This(schema, references) {
-        if (recursiveDepth++ > recursiveMaxDepth)
-            throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-            if (index === -1)
-                throw new ValueCreateDereferenceError(schema);
-            const target = references[index];
-            return Visit(target, references);
-        }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
     }
-    function Tuple(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        if (schema.items === undefined) {
-            return [];
-        }
-        else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => Visit(schema.items[index], references));
-        }
+    else {
+        return 0;
     }
-    function Undefined(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
+}
+function TIntersect(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        // Note: The best we can do here is attempt to instance each sub type and apply through object assign. For non-object
+        // sub types, we just escape the assignment and just return the value. In the latter case, this is typically going to
+        // be a consequence of an illogical intersection.
+        const value = schema.allOf.reduce((acc, schema) => {
+            const next = Visit(schema, references);
+            return typeof next === 'object' ? { ...acc, ...next } : next;
+        }, {});
+        if (!ValueCheck.Check(schema, references, value))
+            throw new ValueCreateIntersectTypeError(schema);
+        return value;
+    }
+}
+function TIterator(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return (function* () { })();
+    }
+}
+function TLiteral(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return schema.const;
+    }
+}
+function TNever(schema, references) {
+    throw new ValueCreateNeverTypeError(schema);
+}
+function TNot(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new ValueCreateNotTypeError(schema);
+    }
+}
+function TNull(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return null;
+    }
+}
+function TNumber(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else {
+        return 0;
+    }
+}
+function TObject(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        const required = new Set(schema.required);
+        return (schema.default ||
+            Object.entries(schema.properties).reduce((acc, [key, schema]) => {
+                return required.has(key) ? { ...acc, [key]: Visit(schema, references) } : { ...acc };
+            }, {}));
+    }
+}
+function TPromise(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return Promise.resolve(Visit(schema.item, references));
+    }
+}
+function TRecord(schema, references) {
+    const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0];
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
+        const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
+        return propertyKeys.reduce((acc, key) => {
+            return { ...acc, [key]: Visit(valueSchema, references) };
+        }, {});
+    }
+    else {
+        return {};
+    }
+}
+function TRef(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCreateDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references);
+    }
+}
+function TString(schema, references) {
+    if (schema.pattern !== undefined) {
+        if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+            throw new Error('ValueCreate.String: String types with patterns must specify a default value');
         }
         else {
-            return undefined;
-        }
-    }
-    function Union(schema, references) {
-        if ('default' in schema) {
             return schema.default;
         }
-        else if (schema.anyOf.length === 0) {
-            throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
+    }
+    else if (schema.format !== undefined) {
+        if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+            throw new Error('ValueCreate.String: String types with formats must specify a default value');
         }
         else {
-            return Visit(schema.anyOf[0], references);
+            return schema.default;
         }
     }
-    function Uint8Array(schema, references) {
-        if ('default' in schema) {
+    else {
+        if (ValueGuard.HasPropertyKey(schema, 'default')) {
             return schema.default;
         }
-        else if (schema.minByteLength !== undefined) {
-            return new globalThis.Uint8Array(schema.minByteLength);
+        else if (schema.minLength !== undefined) {
+            return Array.from({ length: schema.minLength })
+                .map(() => '.')
+                .join('');
         }
         else {
-            return new globalThis.Uint8Array(0);
+            return '';
         }
     }
-    function Unknown(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return {};
-        }
+}
+function TSymbol(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
     }
-    function Void(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return void 0;
-        }
+    else if ('value' in schema) {
+        return Symbol.for(schema.value);
     }
-    function UserDefined(schema, references) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            throw new Error('ValueCreate.UserDefined: User defined types must specify a default value');
-        }
+    else {
+        return Symbol();
     }
-    /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit(schema, references) {
-        const references_ = IsString(schema.$id) ? [...references, schema] : references;
-        const schema_ = schema;
-        switch (schema_[Types.Kind]) {
-            case 'Any':
-                return Any(schema_, references_);
-            case 'Array':
-                return Array(schema_, references_);
-            case 'BigInt':
-                return BigInt(schema_, references_);
-            case 'Boolean':
-                return Boolean(schema_, references_);
-            case 'Constructor':
-                return Constructor(schema_, references_);
-            case 'Date':
-                return Date(schema_, references_);
-            case 'Function':
-                return Function(schema_, references_);
-            case 'Integer':
-                return Integer(schema_, references_);
-            case 'Intersect':
-                return Intersect(schema_, references_);
-            case 'Literal':
-                return Literal(schema_, references_);
-            case 'Never':
-                return Never(schema_, references_);
-            case 'Not':
-                return Not(schema_, references_);
-            case 'Null':
-                return Null(schema_, references_);
-            case 'Number':
-                return Number(schema_, references_);
-            case 'Object':
-                return Object(schema_, references_);
-            case 'Promise':
-                return Promise(schema_, references_);
-            case 'Record':
-                return Record(schema_, references_);
-            case 'Ref':
-                return Ref(schema_, references_);
-            case 'String':
-                return String(schema_, references_);
-            case 'Symbol':
-                return Symbol(schema_, references_);
-            case 'TemplateLiteral':
-                return TemplateLiteral(schema_, references_);
-            case 'This':
-                return This(schema_, references_);
-            case 'Tuple':
-                return Tuple(schema_, references_);
-            case 'Undefined':
-                return Undefined(schema_, references_);
-            case 'Union':
-                return Union(schema_, references_);
-            case 'Uint8Array':
-                return Uint8Array(schema_, references_);
-            case 'Unknown':
-                return Unknown(schema_, references_);
-            case 'Void':
-                return Void(schema_, references_);
-            default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new ValueCreateUnknownTypeError(schema_);
-                return UserDefined(schema_, references_);
-        }
+}
+function TTemplateLiteral(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
+    if (!Types.TemplateLiteralFinite.Check(expression))
+        throw new ValueCreateTempateLiteralTypeError(schema);
+    const sequence = Types.TemplateLiteralGenerator.Generate(expression);
+    return sequence.next().value;
+}
+function TThis(schema, references) {
+    if (recursiveDepth++ > recursiveMaxDepth)
+        throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCreateDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references);
+    }
+}
+function TTuple(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    if (schema.items === undefined) {
+        return [];
+    }
+    else {
+        return Array.from({ length: schema.minItems }).map((_, index) => Visit(schema.items[index], references));
+    }
+}
+function TUndefined(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return undefined;
     }
-    ValueCreate.Visit = Visit;
-    // --------------------------------------------------------
-    // State
-    // --------------------------------------------------------
-    const recursiveMaxDepth = 512;
-    let recursiveDepth = 0;
-    /** Creates a value from the given schema and references */
-    function Create(schema, references) {
-        recursiveDepth = 0;
-        return Visit(schema, references);
-    }
-    ValueCreate.Create = Create;
-})(ValueCreate || (exports.ValueCreate = ValueCreate = {}));
+}
+function TUnion(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else if (schema.anyOf.length === 0) {
+        throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
+    }
+    else {
+        return Visit(schema.anyOf[0], references);
+    }
+}
+function TUint8Array(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else if (schema.minByteLength !== undefined) {
+        return new Uint8Array(schema.minByteLength);
+    }
+    else {
+        return new Uint8Array(0);
+    }
+}
+function TUnknown(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return {};
+    }
+}
+function TVoid(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        return void 0;
+    }
+}
+function TKind(schema, references) {
+    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        return schema.default;
+    }
+    else {
+        throw new Error('ValueCreate: User defined types must specify a default value');
+    }
+}
+/** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
+function Visit(schema, references) {
+    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
+    const schema_ = schema;
+    switch (schema_[Types.Kind]) {
+        case 'Any':
+            return TAny(schema_, references_);
+        case 'Array':
+            return TArray(schema_, references_);
+        case 'AsyncIterator':
+            return TAsyncIterator(schema_, references_);
+        case 'BigInt':
+            return TBigInt(schema_, references_);
+        case 'Boolean':
+            return TBoolean(schema_, references_);
+        case 'Constructor':
+            return TConstructor(schema_, references_);
+        case 'Date':
+            return TDate(schema_, references_);
+        case 'Function':
+            return TFunction(schema_, references_);
+        case 'Integer':
+            return TInteger(schema_, references_);
+        case 'Intersect':
+            return TIntersect(schema_, references_);
+        case 'Iterator':
+            return TIterator(schema_, references_);
+        case 'Literal':
+            return TLiteral(schema_, references_);
+        case 'Never':
+            return TNever(schema_, references_);
+        case 'Not':
+            return TNot(schema_, references_);
+        case 'Null':
+            return TNull(schema_, references_);
+        case 'Number':
+            return TNumber(schema_, references_);
+        case 'Object':
+            return TObject(schema_, references_);
+        case 'Promise':
+            return TPromise(schema_, references_);
+        case 'Record':
+            return TRecord(schema_, references_);
+        case 'Ref':
+            return TRef(schema_, references_);
+        case 'String':
+            return TString(schema_, references_);
+        case 'Symbol':
+            return TSymbol(schema_, references_);
+        case 'TemplateLiteral':
+            return TTemplateLiteral(schema_, references_);
+        case 'This':
+            return TThis(schema_, references_);
+        case 'Tuple':
+            return TTuple(schema_, references_);
+        case 'Undefined':
+            return TUndefined(schema_, references_);
+        case 'Union':
+            return TUnion(schema_, references_);
+        case 'Uint8Array':
+            return TUint8Array(schema_, references_);
+        case 'Unknown':
+            return TUnknown(schema_, references_);
+        case 'Void':
+            return TVoid(schema_, references_);
+        default:
+            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                throw new ValueCreateUnknownTypeError(schema_);
+            return TKind(schema_, references_);
+    }
+}
+exports.Visit = Visit;
+// --------------------------------------------------------------------------
+// State
+// --------------------------------------------------------------------------
+const recursiveMaxDepth = 512;
+let recursiveDepth = 0;
+/** Creates a value from the given schema */
+function Create(...args) {
+    recursiveDepth = 0;
+    return args.length === 2 ? Visit(args[0], args[1]) : Visit(args[0], []);
+}
+exports.Create = Create;