@sinclair/typebox 0.33.3 → 0.33.4

package/build/cjs/compiler/compiler.d.ts

@@ -17,9 +17,9 @@ export declare class TypeCheck<T extends TSchema> {
     /** Returns true if the value matches the compiled type. */
     Check(value: unknown): value is Static<T>;
     /** Decodes a value or throws if error */
-    Decode(value: unknown): StaticDecode<T>;
+    Decode<R = StaticDecode<T>>(value: unknown): R;
     /** Encodes a value or throws if error */
-    Encode(value: unknown): StaticEncode<T>;
+    Encode<R = StaticEncode<T>>(value: unknown): R;
 }
 export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
     readonly schema: TSchema;

package/build/cjs/compiler/compiler.js

@@ -48,7 +48,7 @@ class TypeCheck {
     Decode(value) {
         if (!this.checkFunc(value))
             throw new index_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
-        return this.hasTransform ? (0, index_1.TransformDecode)(this.schema, this.references, value) : value;
+        return (this.hasTransform ? (0, index_1.TransformDecode)(this.schema, this.references, value) : value);
     }
     /** Encodes a value or throws if error */
     Encode(value) {

package/build/cjs/value/assert/assert.d.ts

@@ -0,0 +1,15 @@
+import { ValueErrorIterator, ValueError } from '../../errors/index';
+import { TypeBoxError } from '../../type/error/error';
+import { TSchema } from '../../type/schema/index';
+import { Static } from '../../type/static/index';
+export declare class AssertError extends TypeBoxError {
+    #private;
+    error: ValueError | undefined;
+    constructor(iterator: ValueErrorIterator);
+    /** Returns an iterator for each error in this value. */
+    Errors(): ValueErrorIterator;
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, references: TSchema[], value: unknown): asserts value is Static<T>;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+export declare function Assert<T extends TSchema>(schema: T, value: unknown): asserts value is Static<T>;

package/build/cjs/value/assert/assert.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertError_instances, _AssertError_iterator, _AssertError_Iterator;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertError = void 0;
+exports.Assert = Assert;
+const index_1 = require("../../errors/index");
+const error_1 = require("../../type/error/error");
+const check_1 = require("../check/check");
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+class AssertError extends error_1.TypeBoxError {
+    constructor(iterator) {
+        const error = iterator.First();
+        super(error === undefined ? 'Invalid Value' : error.message);
+        _AssertError_instances.add(this);
+        _AssertError_iterator.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertError_iterator, iterator, "f");
+        this.error = error;
+    }
+    /** Returns an iterator for each error in this value. */
+    Errors() {
+        return new index_1.ValueErrorIterator(__classPrivateFieldGet(this, _AssertError_instances, "m", _AssertError_Iterator).call(this));
+    }
+}
+exports.AssertError = AssertError;
+_AssertError_iterator = new WeakMap(), _AssertError_instances = new WeakSet(), _AssertError_Iterator = function* _AssertError_Iterator() {
+    if (this.error)
+        yield this.error;
+    yield* __classPrivateFieldGet(this, _AssertError_iterator, "f");
+};
+// ------------------------------------------------------------------
+// AssertValue
+// ------------------------------------------------------------------
+function AssertValue(schema, references, value) {
+    if ((0, check_1.Check)(schema, references, value))
+        return;
+    throw new AssertError((0, index_1.Errors)(schema, references, value));
+}
+/** Asserts a value matches the given type or throws an `AssertError` if invalid */
+function Assert(...args) {
+    return args.length === 3 ? AssertValue(args[0], args[1], args[2]) : AssertValue(args[0], [], args[1]);
+}

package/build/cjs/value/assert/index.d.ts

@@ -0,0 +1 @@
+export * from './assert';

package/build/cjs/value/assert/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assert"), exports);

package/build/cjs/value/cast/cast.js

@@ -106,7 +106,7 @@ function FromConstructor(schema, references, value) {
 }
 function FromIntersect(schema, references, value) {
     const created = (0, index_4.Create)(schema, references);
-    const mapped = (0, index_1.IsStandardObject)(created) && (0, index_1.IsStandardObject)(value) ? { ...created, ...value } : value;
+    const mapped = (0, index_1.IsObject)(created) && (0, index_1.IsObject)(value) ? { ...created, ...value } : value;
     return (0, index_5.Check)(schema, references, mapped) ? mapped : (0, index_4.Create)(schema, references);
 }
 function FromNever(schema, references, value) {

package/build/cjs/value/clean/clean.js

@@ -16,12 +16,12 @@ const index_6 = require("../guard/index");
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // IsCheckable
 // ------------------------------------------------------------------
 function IsCheckable(schema) {
-    return (0, type_1.IsSchema)(schema) && schema[index_5.Kind] !== 'Unsafe';
+    return (0, kind_1.IsKind)(schema) && schema[index_5.Kind] !== 'Unsafe';
 }
 // ------------------------------------------------------------------
 // Types
@@ -35,7 +35,7 @@ function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
     const composite = intersections.reduce((acc, value) => ((0, index_6.IsObject)(value) ? { ...acc, ...value } : value), {});
-    if (!(0, index_6.IsObject)(value) || !(0, index_6.IsObject)(composite) || !(0, type_1.IsSchema)(unevaluatedProperties))
+    if (!(0, index_6.IsObject)(value) || !(0, index_6.IsObject)(composite) || !(0, kind_1.IsKind)(unevaluatedProperties))
         return composite;
     const knownkeys = (0, index_1.KeyOfPropertyKeys)(schema);
     for (const key of Object.getOwnPropertyNames(value)) {
@@ -52,11 +52,11 @@ function FromObject(schema, references, value) {
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
     for (const key of Object.getOwnPropertyNames(value)) {
-        if (key in schema.properties) {
+        if ((0, index_6.HasPropertyKey)(schema.properties, key)) {
             value[key] = Visit(schema.properties[key], references, value[key]);
             continue;
         }
-        if ((0, type_1.IsSchema)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+        if ((0, kind_1.IsKind)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }
@@ -76,7 +76,7 @@ function FromRecord(schema, references, value) {
             value[key] = Visit(propertySchema, references, value[key]);
             continue;
         }
-        if ((0, type_1.IsSchema)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
+        if ((0, kind_1.IsKind)(additionalProperties) && (0, index_2.Check)(additionalProperties, references, value[key])) {
             value[key] = Visit(additionalProperties, references, value[key]);
             continue;
         }

package/build/cjs/value/clone/clone.js

@@ -9,7 +9,7 @@ const index_1 = require("../guard/index");
 // ------------------------------------------------------------------
 // Clonable
 // ------------------------------------------------------------------
-function ObjectType(value) {
+function FromObject(value) {
     const Acc = {};
     for (const key of Object.getOwnPropertyNames(value)) {
         Acc[key] = Clone(value[key]);
@@ -19,16 +19,22 @@ function ObjectType(value) {
     }
     return Acc;
 }
-function ArrayType(value) {
+function FromArray(value) {
     return value.map((element) => Clone(element));
 }
-function TypedArrayType(value) {
+function FromTypedArray(value) {
     return value.slice();
 }
-function DateType(value) {
+function FromMap(value) {
+    return new Map(Clone([...value.entries()]));
+}
+function FromSet(value) {
+    return new Set(Clone([...value.entries()]));
+}
+function FromDate(value) {
     return new Date(value.toISOString());
 }
-function ValueType(value) {
+function FromValue(value) {
     return value;
 }
 // ------------------------------------------------------------------
@@ -37,14 +43,18 @@ function ValueType(value) {
 /** Returns a clone of the given value */
 function Clone(value) {
     if ((0, index_1.IsArray)(value))
-        return ArrayType(value);
+        return FromArray(value);
     if ((0, index_1.IsDate)(value))
-        return DateType(value);
-    if ((0, index_1.IsStandardObject)(value))
-        return ObjectType(value);
+        return FromDate(value);
     if ((0, index_1.IsTypedArray)(value))
-        return TypedArrayType(value);
+        return FromTypedArray(value);
+    if ((0, index_1.IsMap)(value))
+        return FromMap(value);
+    if ((0, index_1.IsSet)(value))
+        return FromSet(value);
+    if ((0, index_1.IsObject)(value))
+        return FromObject(value);
     if ((0, index_1.IsValueType)(value))
-        return ValueType(value);
+        return FromValue(value);
     throw new Error('ValueClone: Unable to clone value');
 }

package/build/cjs/value/convert/convert.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from '../../type/schema/index';
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, references: TSchema[], value: unknown): unknown;
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 export declare function Convert(schema: TSchema, value: unknown): unknown;

package/build/cjs/value/convert/convert.js

@@ -60,7 +60,7 @@ function TryConvertLiteral(schema, value) {
     return ((0, index_5.IsString)(schema.const) ? TryConvertLiteralString(value, schema.const) :
         (0, index_5.IsNumber)(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
             (0, index_5.IsBoolean)(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
-                (0, index_1.Clone)(value));
+                value);
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
@@ -143,16 +143,12 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = (0, index_5.IsObject)(value);
-    if (!isConvertable)
+    if (!(0, index_5.IsObject)(value))
         return value;
-    const result = {};
-    for (const key of Object.keys(value)) {
-        result[key] = (0, index_5.HasPropertyKey)(schema.properties, key)
-            ? Visit(schema.properties[key], references, value[key])
-            : value[key];
+    for (const key of Object.getOwnPropertyNames(schema.properties)) {
+        value[key] = Visit(schema.properties[key], references, value[key]);
     }
-    return result;
+    return value;
 }
 function FromRecord(schema, references, value) {
     const isConvertable = (0, index_5.IsObject)(value);
@@ -160,11 +156,10 @@ function FromRecord(schema, references, value) {
         return value;
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
-    const result = {};
     for (const [propKey, propValue] of Object.entries(value)) {
-        result[propKey] = Visit(property, references, propValue);
+        value[propKey] = Visit(property, references, propValue);
     }
-    return result;
+    return value;
 }
 function FromRef(schema, references, value) {
     return Visit((0, index_3.Deref)(schema, references), references, value);
@@ -194,15 +189,19 @@ function FromUndefined(schema, references, value) {
 }
 function FromUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
-        const converted = Visit(subschema, references, value);
+        const converted = Visit(subschema, references, (0, index_1.Clone)(value));
         if (!(0, index_2.Check)(subschema, references, converted))
             continue;
         return converted;
     }
     return value;
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references, value) {
-    const references_ = (0, index_5.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_5.IsString)(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[index_4.Kind]) {
         case 'Array':
@@ -245,10 +244,8 @@ function Visit(schema, references, value) {
             return Default(value);
     }
 }
-/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+/** `[Mutable]` Converts any type mismatched values to their target type if a reasonable conversion is possible. */
 // prettier-ignore
 function Convert(...args) {
-    return args.length === 3
-        ? Visit(args[0], args[1], args[2])
-        : Visit(args[0], [], args[1]);
+    return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
 }

package/build/cjs/value/create/create.js

@@ -386,8 +386,12 @@ function FromKind(schema, references) {
         throw new Error('User defined types must specify a default value');
     }
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references) {
-    const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_1.IsString)(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[index_8.Kind]) {
         case 'Any':

package/build/cjs/value/default/default.js

@@ -13,7 +13,7 @@ const index_5 = require("../guard/index");
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-const type_1 = require("../../type/guard/type");
+const kind_1 = require("../../type/guard/kind");
 // ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
@@ -21,16 +21,10 @@ function ValueOrDefault(schema, value) {
     return value === undefined && 'default' in schema ? (0, index_2.Clone)(schema.default) : value;
 }
 // ------------------------------------------------------------------
-// IsCheckable
+// HasDefaultProperty
 // ------------------------------------------------------------------
-function IsCheckable(schema) {
-    return (0, type_1.IsSchema)(schema) && schema[index_4.Kind] !== 'Unsafe';
-}
-// ------------------------------------------------------------------
-// IsDefaultSchema
-// ------------------------------------------------------------------
-function IsDefaultSchema(value) {
-    return (0, type_1.IsSchema)(value) && 'default' in value;
+function HasDefaultProperty(schema) {
+    return (0, kind_1.IsKind)(schema) && 'default' in schema;
 }
 // ------------------------------------------------------------------
 // Types
@@ -59,12 +53,12 @@ function FromObject(schema, references, value) {
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
     // properties
     for (const key of knownPropertyKeys) {
-        if (!IsDefaultSchema(schema.properties[key]))
+        if (!HasDefaultProperty(schema.properties[key]))
             continue;
         defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
     }
     // return if not additional properties
-    if (!IsDefaultSchema(additionalPropertiesSchema))
+    if (!HasDefaultProperty(additionalPropertiesSchema))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
@@ -83,12 +77,12 @@ function FromRecord(schema, references, value) {
     const knownPropertyKey = new RegExp(propertyKeyPattern);
     // properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
-        if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema)))
+        if (!(knownPropertyKey.test(key) && HasDefaultProperty(propertySchema)))
             continue;
         defaulted[key] = Visit(propertySchema, references, defaulted[key]);
     }
     // return if not additional properties
-    if (!IsDefaultSchema(additionalPropertiesSchema))
+    if (!HasDefaultProperty(additionalPropertiesSchema))
         return defaulted;
     // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
@@ -119,14 +113,18 @@ function FromUnion(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     for (const inner of schema.anyOf) {
         const result = Visit(inner, references, defaulted);
-        if (IsCheckable(inner) && (0, index_1.Check)(inner, result)) {
+        if ((0, index_1.Check)(inner, result)) {
             return result;
         }
     }
     return defaulted;
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references, value) {
-    const references_ = (0, index_5.IsString)(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, index_5.IsString)(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[index_4.Kind]) {
         case 'Array':

package/build/cjs/value/equal/equal.js

@@ -7,7 +7,7 @@ const index_1 = require("../guard/index");
 // Equality Checks
 // ------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!(0, index_1.IsStandardObject)(right))
+    if (!(0, index_1.IsObject)(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -36,14 +36,14 @@ function ValueType(left, right) {
 // ------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 function Equal(left, right) {
-    if ((0, index_1.IsStandardObject)(left))
-        return ObjectType(left, right);
     if ((0, index_1.IsDate)(left))
         return DateType(left, right);
     if ((0, index_1.IsTypedArray)(left))
         return TypedArrayType(left, right);
     if ((0, index_1.IsArray)(left))
         return ArrayType(left, right);
+    if ((0, index_1.IsObject)(left))
+        return ObjectType(left, right);
     if ((0, index_1.IsValueType)(left))
         return ValueType(left, right);
     throw new Error('ValueEquals: Unable to compare value');

package/build/cjs/value/hash/hash.js

@@ -125,7 +125,7 @@ function Visit(value) {
         return NullType(value);
     if ((0, index_1.IsNumber)(value))
         return NumberType(value);
-    if ((0, index_1.IsStandardObject)(value))
+    if ((0, index_1.IsObject)(value))
         return ObjectType(value);
     if ((0, index_1.IsString)(value))
         return StringType(value);

package/build/cjs/value/index.d.ts

@@ -1,5 +1,6 @@
 export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
 export * from './guard/index';
+export * from './assert/index';
 export * from './cast/index';
 export * from './check/index';
 export * from './clean/index';
@@ -11,6 +12,7 @@ export * from './delta/index';
 export * from './equal/index';
 export * from './hash/index';
 export * from './mutate/index';
+export * from './parse/index';
 export * from './pointer/index';
 export * from './transform/index';
 export { Value } from './value/index';

package/build/cjs/value/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./guard/index"), exports);
 // ------------------------------------------------------------------
 // Operators
 // ------------------------------------------------------------------
+__exportStar(require("./assert/index"), exports);
 __exportStar(require("./cast/index"), exports);
 __exportStar(require("./check/index"), exports);
 __exportStar(require("./clean/index"), exports);
@@ -40,6 +41,7 @@ __exportStar(require("./delta/index"), exports);
 __exportStar(require("./equal/index"), exports);
 __exportStar(require("./hash/index"), exports);
 __exportStar(require("./mutate/index"), exports);
+__exportStar(require("./parse/index"), exports);
 __exportStar(require("./pointer/index"), exports);
 __exportStar(require("./transform/index"), exports);
 // ------------------------------------------------------------------

package/build/cjs/value/mutate/mutate.js

@@ -17,7 +17,7 @@ class ValueMutateError extends index_4.TypeBoxError {
 }
 exports.ValueMutateError = ValueMutateError;
 function ObjectType(root, path, current, next) {
-    if (!(0, index_1.IsStandardObject)(current)) {
+    if (!(0, index_1.IsObject)(current)) {
         index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
     }
     else {
@@ -69,7 +69,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if ((0, index_1.IsTypedArray)(next))
         return TypedArrayType(root, path, current, next);
-    if ((0, index_1.IsStandardObject)(next))
+    if ((0, index_1.IsObject)(next))
         return ObjectType(root, path, current, next);
     if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
@@ -82,8 +82,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return (((0, index_1.IsStandardObject)(current) && (0, index_1.IsArray)(next)) ||
-        ((0, index_1.IsArray)(current) && (0, index_1.IsStandardObject)(next)));
+    return (((0, index_1.IsObject)(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && (0, index_1.IsObject)(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/cjs/value/parse/index.d.ts

@@ -0,0 +1 @@
+export * from './parse';

package/build/cjs/value/parse/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parse"), exports);

package/build/cjs/value/parse/parse.d.ts

@@ -0,0 +1,6 @@
+import { TSchema } from '../../type/schema/index';
+import { StaticDecode } from '../../type/static/index';
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
+/** Parses a value or throws an `AssertError` if invalid. */
+export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;

package/build/cjs/value/parse/parse.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parse = Parse;
+const index_1 = require("../transform/index");
+const assert_1 = require("../assert/assert");
+const default_1 = require("../default/default");
+const convert_1 = require("../convert/convert");
+const clean_1 = require("../clean/clean");
+const index_2 = require("../clone/index");
+// prettier-ignore
+const ParseReducer = [
+    (_schema, _references, value) => (0, index_2.Clone)(value),
+    (schema, references, value) => (0, default_1.Default)(schema, references, value),
+    (schema, references, value) => (0, clean_1.Clean)(schema, references, value),
+    (schema, references, value) => (0, convert_1.Convert)(schema, references, value),
+    (schema, references, value) => { (0, assert_1.Assert)(schema, references, value); return value; },
+    (schema, references, value) => ((0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value),
+];
+// ------------------------------------------------------------------
+// ParseValue
+// ------------------------------------------------------------------
+function ParseValue(schema, references, value) {
+    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+}
+/** Parses a value or throws an `AssertError` if invalid. */
+function Parse(...args) {
+    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+}

package/build/cjs/value/transform/decode.js

@@ -61,7 +61,7 @@ function FromArray(schema, references, path, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value) || (0, index_6.IsValueType)(value))
+    if (!(0, index_6.IsObject)(value) || (0, index_6.IsValueType)(value))
         return Default(schema, path, value);
     const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -87,7 +87,7 @@ function FromNot(schema, references, path, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return Default(schema, path, value);
     const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
     const knownProperties = { ...value };
@@ -109,7 +109,7 @@ function FromObject(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
-    if (!(0, index_6.IsStandardObject)(value))
+    if (!(0, index_6.IsObject)(value))
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -157,9 +157,13 @@ function FromUnion(schema, references, path, value) {
     }
     return Default(schema, path, value);
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references, path, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
+    const references_ = typeof schema.$id === 'string' ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[index_1.Kind]) {
         case 'Array':