@sinclair/typebox 0.33.2 → 0.33.4

package/build/esm/value/convert/convert.mjs

@@ -5,7 +5,7 @@ import { Kind } from '../../type/symbols/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol, HasPropertyKey } from '../guard/index.mjs';
+import { IsArray, IsObject, IsDate, IsUndefined, IsString, IsNumber, IsBoolean, IsBigInt, IsSymbol } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // Conversions
 // ------------------------------------------------------------------
@@ -56,7 +56,7 @@ function TryConvertLiteral(schema, value) {
     return (IsString(schema.const) ? TryConvertLiteralString(value, schema.const) :
         IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
             IsBoolean(schema.const) ? TryConvertLiteralBoolean(value, schema.const) :
-                Clone(value));
+                value);
 }
 function TryConvertBoolean(value) {
     return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
@@ -139,16 +139,12 @@ function FromNumber(schema, references, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, value) {
-    const isConvertable = IsObject(value);
-    if (!isConvertable)
+    if (!IsObject(value))
         return value;
-    const result = {};
-    for (const key of Object.keys(value)) {
-        result[key] = 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 = IsObject(value);
@@ -156,11 +152,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(Deref(schema, references), references, value);
@@ -190,15 +185,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, Clone(value));
         if (!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_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema[Kind]) {
         case 'Array':
@@ -241,10 +240,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
 export 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/esm/value/create/create.mjs

@@ -380,8 +380,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_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Any':

package/build/esm/value/default/default.mjs

@@ -9,7 +9,7 @@ import { IsString, IsObject, IsArray, IsUndefined } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsSchema } from '../../type/guard/type.mjs';
+import { IsKind } from '../../type/guard/kind.mjs';
 // ------------------------------------------------------------------
 // ValueOrDefault
 // ------------------------------------------------------------------
@@ -17,16 +17,10 @@ function ValueOrDefault(schema, value) {
     return value === undefined && 'default' in schema ? Clone(schema.default) : value;
 }
 // ------------------------------------------------------------------
-// IsCheckable
+// HasDefaultProperty
 // ------------------------------------------------------------------
-function IsCheckable(schema) {
-    return IsSchema(schema) && schema[Kind] !== 'Unsafe';
-}
-// ------------------------------------------------------------------
-// IsDefaultSchema
-// ------------------------------------------------------------------
-function IsDefaultSchema(value) {
-    return IsSchema(value) && 'default' in value;
+function HasDefaultProperty(schema) {
+    return IsKind(schema) && 'default' in schema;
 }
 // ------------------------------------------------------------------
 // Types
@@ -55,12 +49,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)) {
@@ -79,12 +73,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)) {
@@ -115,14 +109,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) && Check(inner, result)) {
+        if (Check(inner, result)) {
             return result;
         }
     }
     return defaulted;
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 function Visit(schema, references, value) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     switch (schema_[Kind]) {
         case 'Array':

package/build/esm/value/delta/delta.d.mts

@@ -24,13 +24,9 @@ export declare const Delete: TObject<{
 }>;
 export type Edit = Static<typeof Edit>;
 export declare const Edit: TUnion<[typeof Insert, typeof Update, typeof Delete]>;
-export declare class ValueDeltaError extends TypeBoxError {
+export declare class ValueDiffError extends TypeBoxError {
     readonly value: unknown;
     constructor(value: unknown, message: string);
 }
-export declare class ValueDeltaSymbolError extends ValueDeltaError {
-    readonly value: unknown;
-    constructor(value: unknown);
-}
 export declare function Diff(current: unknown, next: unknown): Edit[];
 export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/build/esm/value/delta/delta.mjs

@@ -1,6 +1,7 @@
-import { IsStandardObject, IsArray, IsTypedArray, IsValueType, IsSymbol, IsUndefined } from '../guard/index.mjs';
+import { HasPropertyKey, IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
+import { Equal } from '../equal/equal.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 import { Literal } from '../../type/literal/index.mjs';
 import { Object } from '../../type/object/index.mjs';
@@ -25,18 +26,12 @@ export const Edit = Union([Insert, Update, Delete]);
 // ------------------------------------------------------------------
 // Errors
 // ------------------------------------------------------------------
-export class ValueDeltaError extends TypeBoxError {
+export class ValueDiffError extends TypeBoxError {
     constructor(value, message) {
         super(message);
         this.value = value;
     }
 }
-export class ValueDeltaSymbolError extends ValueDeltaError {
-    constructor(value) {
-        super(value, 'Cannot diff objects with symbol keys');
-        this.value = value;
-    }
-}
 // ------------------------------------------------------------------
 // Command Factory
 // ------------------------------------------------------------------
@@ -50,37 +45,47 @@ function CreateDelete(path) {
     return { type: 'delete', path };
 }
 // ------------------------------------------------------------------
+// AssertDiffable
+// ------------------------------------------------------------------
+function AssertDiffable(value) {
+    if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
+        throw new ValueDiffError(value, 'Cannot diff objects with symbols');
+}
+// ------------------------------------------------------------------
 // Diffing Generators
 // ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
+    AssertDiffable(current);
+    AssertDiffable(next);
     if (!IsStandardObject(next))
         return yield CreateUpdate(path, next);
-    const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
-    const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
-    for (const key of currentKeys) {
-        if (IsSymbol(key))
-            throw new ValueDeltaSymbolError(key);
-        if (IsUndefined(next[key]) && nextKeys.includes(key))
-            yield CreateUpdate(`${path}/${globalThis.String(key)}`, undefined);
-    }
+    const currentKeys = globalThis.Object.getOwnPropertyNames(current);
+    const nextKeys = globalThis.Object.getOwnPropertyNames(next);
+    // ----------------------------------------------------------------
+    // inserts
+    // ----------------------------------------------------------------
     for (const key of nextKeys) {
-        if (IsUndefined(current[key]) || IsUndefined(next[key]))
+        if (HasPropertyKey(current, key))
             continue;
-        if (IsSymbol(key))
-            throw new ValueDeltaSymbolError(key);
-        yield* Visit(`${path}/${globalThis.String(key)}`, current[key], next[key]);
+        yield CreateInsert(`${path}/${key}`, next[key]);
     }
-    for (const key of nextKeys) {
-        if (IsSymbol(key))
-            throw new ValueDeltaSymbolError(key);
-        if (IsUndefined(current[key]))
-            yield CreateInsert(`${path}/${globalThis.String(key)}`, next[key]);
+    // ----------------------------------------------------------------
+    // updates
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if (!HasPropertyKey(next, key))
+            continue;
+        if (Equal(current, next))
+            continue;
+        yield* Visit(`${path}/${key}`, current[key], next[key]);
     }
-    for (const key of currentKeys.reverse()) {
-        if (IsSymbol(key))
-            throw new ValueDeltaSymbolError(key);
-        if (IsUndefined(next[key]) && !nextKeys.includes(key))
-            yield CreateDelete(`${path}/${globalThis.String(key)}`);
+    // ----------------------------------------------------------------
+    // deletes
+    // ----------------------------------------------------------------
+    for (const key of currentKeys) {
+        if (HasPropertyKey(next, key))
+            continue;
+        yield CreateDelete(`${path}/${key}`);
     }
 }
 function* ArrayType(path, current, next) {
@@ -121,7 +126,7 @@ function* Visit(path, current, next) {
         return yield* TypedArrayType(path, current, next);
     if (IsValueType(current))
         return yield* ValueType(path, current, next);
-    throw new ValueDeltaError(current, 'Unable to create diff edits for unknown value');
+    throw new ValueDiffError(current, 'Unable to diff value');
 }
 // ------------------------------------------------------------------
 // Diff

package/build/esm/value/equal/equal.mjs

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

package/build/esm/value/hash/hash.mjs

@@ -1,4 +1,4 @@
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsStandardObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
 // ------------------------------------------------------------------
 // Errors
@@ -119,7 +119,7 @@ function Visit(value) {
         return NullType(value);
     if (IsNumber(value))
         return NumberType(value);
-    if (IsStandardObject(value))
+    if (IsObject(value))
         return ObjectType(value);
     if (IsString(value))
         return StringType(value);

package/build/esm/value/index.d.mts

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

package/build/esm/value/index.mjs

@@ -9,6 +9,7 @@ export * from './guard/index.mjs';
 // ------------------------------------------------------------------
 // Operators
 // ------------------------------------------------------------------
+export * from './assert/index.mjs';
 export * from './cast/index.mjs';
 export * from './check/index.mjs';
 export * from './clean/index.mjs';
@@ -20,6 +21,7 @@ export * from './delta/index.mjs';
 export * from './equal/index.mjs';
 export * from './hash/index.mjs';
 export * from './mutate/index.mjs';
+export * from './parse/index.mjs';
 export * from './pointer/index.mjs';
 export * from './transform/index.mjs';
 // ------------------------------------------------------------------

package/build/esm/value/mutate/mutate.mjs

@@ -1,4 +1,4 @@
-import { IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+import { IsObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
 import { TypeBoxError } from '../../type/error/index.mjs';
@@ -11,7 +11,7 @@ export class ValueMutateError extends TypeBoxError {
     }
 }
 function ObjectType(root, path, current, next) {
-    if (!IsStandardObject(current)) {
+    if (!IsObject(current)) {
         ValuePointer.Set(root, path, Clone(next));
     }
     else {
@@ -63,7 +63,7 @@ function Visit(root, path, current, next) {
         return ArrayType(root, path, current, next);
     if (IsTypedArray(next))
         return TypedArrayType(root, path, current, next);
-    if (IsStandardObject(next))
+    if (IsObject(next))
         return ObjectType(root, path, current, next);
     if (IsValueType(next))
         return ValueType(root, path, current, next);
@@ -76,8 +76,8 @@ function IsNonMutableValue(value) {
 }
 function IsMismatchedValue(current, next) {
     // prettier-ignore
-    return ((IsStandardObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsStandardObject(next)));
+    return ((IsObject(current) && IsArray(next)) ||
+        (IsArray(current) && IsObject(next)));
 }
 // ------------------------------------------------------------------
 // Mutate

package/build/esm/value/parse/index.d.mts

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

package/build/esm/value/parse/index.mjs

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

package/build/esm/value/parse/parse.d.mts

@@ -0,0 +1,6 @@
+import { TSchema } from '../../type/schema/index.mjs';
+import { StaticDecode } from '../../type/static/index.mjs';
+/** 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/esm/value/parse/parse.mjs

@@ -0,0 +1,25 @@
+import { TransformDecode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/assert.mjs';
+import { Default } from '../default/default.mjs';
+import { Convert } from '../convert/convert.mjs';
+import { Clean } from '../clean/clean.mjs';
+import { Clone } from '../clone/index.mjs';
+// prettier-ignore
+const ParseReducer = [
+    (_schema, _references, value) => Clone(value),
+    (schema, references, value) => Default(schema, references, value),
+    (schema, references, value) => Clean(schema, references, value),
+    (schema, references, value) => Convert(schema, references, value),
+    (schema, references, value) => { Assert(schema, references, value); return value; },
+    (schema, references, value) => (HasTransform(schema, references) ? 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. */
+export function Parse(...args) {
+    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+}

package/build/esm/value/transform/decode.mjs

@@ -6,7 +6,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -54,7 +54,7 @@ function FromArray(schema, references, path, value) {
 }
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
-    if (!IsStandardObject(value) || IsValueType(value))
+    if (!IsObject(value) || IsValueType(value))
         return Default(schema, path, value);
     const knownEntries = KeyOfPropertyEntries(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -80,7 +80,7 @@ function FromNot(schema, references, path, value) {
 }
 // prettier-ignore
 function FromObject(schema, references, path, value) {
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return Default(schema, path, value);
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...value };
@@ -102,7 +102,7 @@ function FromObject(schema, references, path, value) {
 }
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return Default(schema, path, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -150,9 +150,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[Kind]) {
         case 'Array':

package/build/esm/value/transform/encode.mjs

@@ -6,7 +6,7 @@ import { Check } from '../check/index.mjs';
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
-import { IsStandardObject, IsArray, IsValueType } from '../guard/index.mjs';
+import { IsObject, IsArray, IsValueType } from '../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -55,7 +55,7 @@ function FromArray(schema, references, path, value) {
 // prettier-ignore
 function FromIntersect(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(value) || IsValueType(value))
+    if (!IsObject(value) || IsValueType(value))
         return defaulted;
     const knownEntries = KeyOfPropertyEntries(schema);
     const knownKeys = knownEntries.map(entry => entry[0]);
@@ -83,7 +83,7 @@ function FromNot(schema, references, path, value) {
 // prettier-ignore
 function FromObject(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(defaulted))
+    if (!IsObject(defaulted))
         return defaulted;
     const knownKeys = KeyOfPropertyKeys(schema);
     const knownProperties = { ...defaulted };
@@ -106,7 +106,7 @@ function FromObject(schema, references, path, value) {
 // prettier-ignore
 function FromRecord(schema, references, path, value) {
     const defaulted = Default(schema, path, value);
-    if (!IsStandardObject(value))
+    if (!IsObject(value))
         return defaulted;
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const knownKeys = new RegExp(pattern);
@@ -116,7 +116,7 @@ function FromRecord(schema, references, path, value) {
             knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
         }
     if (!IsSchema(schema.additionalProperties)) {
-        return Default(schema, path, knownProperties);
+        return knownProperties;
     }
     const unknownKeys = Object.getOwnPropertyNames(knownProperties);
     const additionalProperties = schema.additionalProperties;
@@ -162,9 +162,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[Kind]) {
         case 'Array':

package/build/esm/value/transform/has.mjs

@@ -72,9 +72,13 @@ function FromTuple(schema, references) {
 function FromUnion(schema, references) {
     return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+function AddReference(references, schema) {
+    references.push(schema);
+    return references;
+}
 // prettier-ignore
 function Visit(schema, references) {
-    const references_ = IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = IsString(schema.$id) ? AddReference(references, schema) : references;
     const schema_ = schema;
     if (schema.$id && visited.has(schema.$id))
         return false;

package/build/esm/value/value/value.d.mts

@@ -3,6 +3,10 @@ import { Edit } from '../delta/index.mjs';
 import { ValueErrorIterator } from '../../errors/index.mjs';
 import type { TSchema } from '../../type/schema/index.mjs';
 import type { Static, StaticDecode, StaticEncode } from '../../type/static/index.mjs';
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, references: TSchema[], value: unknown): asserts value is R;
+/** Asserts a value matches the given type or throws an `AssertError` if invalid. */
+export declare function Assert<T extends TSchema, R = Static<T>>(schema: T, value: unknown): asserts value is R;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
 export declare function Cast<T extends TSchema>(schema: T, references: TSchema[], value: unknown): Static<T>;
 /** Casts a value into a given type. The return value will retain as much information of the original value as possible. */
@@ -19,9 +23,9 @@ export declare function Check<T extends TSchema>(schema: T, value: unknown): val
 export declare function Clean(schema: TSchema, references: TSchema[], value: unknown): unknown;
 /** `[Mutable]` Removes excess properties from a value and returns the result. This function does not check the value and returns an unknown type. You should Check the result before use. Clean is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Clean(schema: 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, 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;
 /** Returns a structural clone of the given value */
 export declare function Clone<T>(value: T): T;
@@ -37,6 +41,10 @@ export declare function Default(schema: TSchema, value: unknown): unknown;
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, references: TSchema[], value: unknown): R;
 /** Encodes a value or throws if error */
 export declare function Encode<T extends TSchema, R = StaticEncode<T>>(schema: T, value: unknown): R;
+/** 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;
 /** Returns an iterator for each error in this value. */
 export declare function Errors<T extends TSchema>(schema: T, references: TSchema[], value: unknown): ValueErrorIterator;
 /** Returns an iterator for each error in this value. */