@sinclair/typebox 0.26.0-dev.2 → 0.26.0-dev.4

package/value/create.js

@@ -1,430 +1,430 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
-const Types = require("../typebox");
-const check_1 = require("./check");
-// --------------------------------------------------------------------------
-// Errors
-// --------------------------------------------------------------------------
-class ValueCreateUnknownTypeError extends Error {
-    constructor(schema) {
-        super('ValueCreate: Unknown type');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
-class ValueCreateNeverTypeError extends Error {
-    constructor(schema) {
-        super('ValueCreate: Never types cannot be created');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
-class ValueCreateIntersectTypeError extends Error {
-    constructor(schema) {
-        super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.');
-        this.schema = schema;
-    }
-}
-exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
-// --------------------------------------------------------------------------
-// ValueCreate
-// --------------------------------------------------------------------------
-var ValueCreate;
-(function (ValueCreate) {
-    function Any(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return {};
-        }
-    }
-    function Array(schema) {
-        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 ValueCreate.Create(schema.items);
-            });
-        }
-        else {
-            return [];
-        }
-    }
-    function BigInt(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return globalThis.BigInt(0);
-        }
-    }
-    function Boolean(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return false;
-        }
-    }
-    function Constructor(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const value = ValueCreate.Create(schema.returns);
-            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 {
-                };
-            }
-        }
-    }
-    function Date(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimumTimestamp !== undefined) {
-            return new globalThis.Date(schema.minimumTimestamp);
-        }
-        else {
-            return new globalThis.Date(0);
-        }
-    }
-    function Function(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return () => ValueCreate.Create(schema.returns);
-        }
-    }
-    function Integer(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimum !== undefined) {
-            return schema.minimum;
-        }
-        else {
-            return 0;
-        }
-    }
-    function Intersect(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...Visit(schema) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema), undefined);
-            if (!check_1.ValueCheck.Check(schema, value))
-                throw new ValueCreateIntersectTypeError(schema);
-            return value;
-        }
-    }
-    function Literal(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return schema.const;
-        }
-    }
-    function Never(schema) {
-        throw new ValueCreateNeverTypeError(schema);
-    }
-    function Not(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return Visit(schema.allOf[1]);
-        }
-    }
-    function Null(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return null;
-        }
-    }
-    function Number(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minimum !== undefined) {
-            return schema.minimum;
-        }
-        else {
-            return 0;
-        }
-    }
-    function Object(schema) {
-        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]: ValueCreate.Create(schema) } : { ...acc };
-                }, {}));
-        }
-    }
-    function Promise(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return globalThis.Promise.resolve(ValueCreate.Create(schema.item));
-        }
-    }
-    function Record(schema) {
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
-            const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
-            return propertyKeys.reduce((acc, key) => {
-                return { ...acc, [key]: Create(valueSchema) };
-            }, {});
-        }
-        else {
-            return {};
-        }
-    }
-    function Ref(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return Visit(Types.ReferenceRegistry.DerefOne(schema));
-        }
-    }
-    function Self(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return Visit(Types.ReferenceRegistry.DerefOne(schema));
-        }
-    }
-    function String(schema) {
-        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 '';
-            }
-        }
-    }
-    function Symbol(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if ('value' in schema) {
-            return globalThis.Symbol.for(schema.value);
-        }
-        else {
-            return globalThis.Symbol();
-        }
-    }
-    function Tuple(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        if (schema.items === undefined) {
-            return [];
-        }
-        else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index]));
-        }
-    }
-    function Undefined(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return undefined;
-        }
-    }
-    function Union(schema) {
-        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 {
-            return ValueCreate.Create(schema.anyOf[0]);
-        }
-    }
-    function Uint8Array(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else if (schema.minByteLength !== undefined) {
-            return new globalThis.Uint8Array(schema.minByteLength);
-        }
-        else {
-            return new globalThis.Uint8Array(0);
-        }
-    }
-    function Unknown(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return {};
-        }
-    }
-    function Void(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            return void 0;
-        }
-    }
-    function UserDefined(schema) {
-        if ('default' in schema) {
-            return schema.default;
-        }
-        else {
-            throw new Error('ValueCreate.UserDefined: 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) {
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
-            case 'Any':
-                return Any(anySchema);
-            case 'Array':
-                return Array(anySchema);
-            case 'BigInt':
-                return BigInt(anySchema);
-            case 'Boolean':
-                return Boolean(anySchema);
-            case 'Constructor':
-                return Constructor(anySchema);
-            case 'Date':
-                return Date(anySchema);
-            case 'Function':
-                return Function(anySchema);
-            case 'Integer':
-                return Integer(anySchema);
-            case 'Intersect':
-                return Intersect(anySchema);
-            case 'Literal':
-                return Literal(anySchema);
-            case 'Never':
-                return Never(anySchema);
-            case 'Not':
-                return Not(anySchema);
-            case 'Null':
-                return Null(anySchema);
-            case 'Number':
-                return Number(anySchema);
-            case 'Object':
-                return Object(anySchema);
-            case 'Promise':
-                return Promise(anySchema);
-            case 'Record':
-                return Record(anySchema);
-            case 'Ref':
-                return Ref(anySchema);
-            case 'Self':
-                return Self(anySchema);
-            case 'String':
-                return String(anySchema);
-            case 'Symbol':
-                return Symbol(anySchema);
-            case 'Tuple':
-                return Tuple(anySchema);
-            case 'Undefined':
-                return Undefined(anySchema);
-            case 'Union':
-                return Union(anySchema);
-            case 'Uint8Array':
-                return Uint8Array(anySchema);
-            case 'Unknown':
-                return Unknown(anySchema);
-            case 'Void':
-                return Void(anySchema);
-            default:
-                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
-                    throw new ValueCreateUnknownTypeError(anySchema);
-                return UserDefined(anySchema);
-        }
-    }
-    ValueCreate.Visit = Visit;
-    function Create(schema) {
-        return Visit(schema);
-    }
-    ValueCreate.Create = Create;
-})(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueCreate = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+const Types = require("../typebox");
+const check_1 = require("./check");
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
+class ValueCreateUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
+class ValueCreateNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Never types cannot be created');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
+class ValueCreateIntersectTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+// --------------------------------------------------------------------------
+// ValueCreate
+// --------------------------------------------------------------------------
+var ValueCreate;
+(function (ValueCreate) {
+    function Any(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return {};
+        }
+    }
+    function Array(schema) {
+        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 ValueCreate.Create(schema.items);
+            });
+        }
+        else {
+            return [];
+        }
+    }
+    function BigInt(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return globalThis.BigInt(0);
+        }
+    }
+    function Boolean(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return false;
+        }
+    }
+    function Constructor(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const value = ValueCreate.Create(schema.returns);
+            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 {
+                };
+            }
+        }
+    }
+    function Date(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimumTimestamp !== undefined) {
+            return new globalThis.Date(schema.minimumTimestamp);
+        }
+        else {
+            return new globalThis.Date(0);
+        }
+    }
+    function Function(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return () => ValueCreate.Create(schema.returns);
+        }
+    }
+    function Integer(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimum !== undefined) {
+            return schema.minimum;
+        }
+        else {
+            return 0;
+        }
+    }
+    function Intersect(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...Visit(schema) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema), undefined);
+            if (!check_1.ValueCheck.Check(schema, value))
+                throw new ValueCreateIntersectTypeError(schema);
+            return value;
+        }
+    }
+    function Literal(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return schema.const;
+        }
+    }
+    function Never(schema) {
+        throw new ValueCreateNeverTypeError(schema);
+    }
+    function Not(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return Visit(schema.allOf[1]);
+        }
+    }
+    function Null(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return null;
+        }
+    }
+    function Number(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minimum !== undefined) {
+            return schema.minimum;
+        }
+        else {
+            return 0;
+        }
+    }
+    function Object(schema) {
+        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]: ValueCreate.Create(schema) } : { ...acc };
+                }, {}));
+        }
+    }
+    function Promise(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return globalThis.Promise.resolve(ValueCreate.Create(schema.item));
+        }
+    }
+    function Record(schema) {
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
+            const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
+            return propertyKeys.reduce((acc, key) => {
+                return { ...acc, [key]: Create(valueSchema) };
+            }, {});
+        }
+        else {
+            return {};
+        }
+    }
+    function Ref(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return Visit(Types.ReferenceRegistry.DerefOne(schema));
+        }
+    }
+    function Self(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return Visit(Types.ReferenceRegistry.DerefOne(schema));
+        }
+    }
+    function String(schema) {
+        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 '';
+            }
+        }
+    }
+    function Symbol(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if ('value' in schema) {
+            return globalThis.Symbol.for(schema.value);
+        }
+        else {
+            return globalThis.Symbol();
+        }
+    }
+    function Tuple(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        if (schema.items === undefined) {
+            return [];
+        }
+        else {
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index]));
+        }
+    }
+    function Undefined(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return undefined;
+        }
+    }
+    function Union(schema) {
+        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 {
+            return ValueCreate.Create(schema.anyOf[0]);
+        }
+    }
+    function Uint8Array(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if (schema.minByteLength !== undefined) {
+            return new globalThis.Uint8Array(schema.minByteLength);
+        }
+        else {
+            return new globalThis.Uint8Array(0);
+        }
+    }
+    function Unknown(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return {};
+        }
+    }
+    function Void(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return void 0;
+        }
+    }
+    function UserDefined(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            throw new Error('ValueCreate.UserDefined: 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) {
+        const anySchema = schema;
+        switch (anySchema[Types.Kind]) {
+            case 'Any':
+                return Any(anySchema);
+            case 'Array':
+                return Array(anySchema);
+            case 'BigInt':
+                return BigInt(anySchema);
+            case 'Boolean':
+                return Boolean(anySchema);
+            case 'Constructor':
+                return Constructor(anySchema);
+            case 'Date':
+                return Date(anySchema);
+            case 'Function':
+                return Function(anySchema);
+            case 'Integer':
+                return Integer(anySchema);
+            case 'Intersect':
+                return Intersect(anySchema);
+            case 'Literal':
+                return Literal(anySchema);
+            case 'Never':
+                return Never(anySchema);
+            case 'Not':
+                return Not(anySchema);
+            case 'Null':
+                return Null(anySchema);
+            case 'Number':
+                return Number(anySchema);
+            case 'Object':
+                return Object(anySchema);
+            case 'Promise':
+                return Promise(anySchema);
+            case 'Record':
+                return Record(anySchema);
+            case 'Ref':
+                return Ref(anySchema);
+            case 'Self':
+                return Self(anySchema);
+            case 'String':
+                return String(anySchema);
+            case 'Symbol':
+                return Symbol(anySchema);
+            case 'Tuple':
+                return Tuple(anySchema);
+            case 'Undefined':
+                return Undefined(anySchema);
+            case 'Union':
+                return Union(anySchema);
+            case 'Uint8Array':
+                return Uint8Array(anySchema);
+            case 'Unknown':
+                return Unknown(anySchema);
+            case 'Void':
+                return Void(anySchema);
+            default:
+                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
+                    throw new ValueCreateUnknownTypeError(anySchema);
+                return UserDefined(anySchema);
+        }
+    }
+    ValueCreate.Visit = Visit;
+    function Create(schema) {
+        return Visit(schema);
+    }
+    ValueCreate.Create = Create;
+})(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));