@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/value/index.js

@@ -1,123 +0,0 @@
-"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.IsInteger = exports.IsFunction = exports.IsDate = exports.IsBoolean = exports.IsBigInt = exports.IsAsyncIterator = exports.IsArray = exports.HasPropertyKey = exports.TransformEncodeError = exports.TransformEncodeCheckError = exports.TransformDecodeError = exports.TransformDecodeCheckError = exports.HasTransform = exports.Encode = exports.Decode = exports.ValuePointer = exports.ValueMutateTypeMismatchError = exports.ValueMutateInvalidRootMutationError = exports.Mutate = exports.ValueHashError = exports.Hash = exports.Equal = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Update = exports.Insert = exports.Delete = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.ValueCreateUnknownTypeError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateIntersectTypeError = exports.Create = exports.ValueConvertUnknownTypeError = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.Cast = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
-exports.Value = exports.IsValueType = exports.IsUndefined = exports.IsUint8Array = exports.IsTypedArray = exports.IsSymbol = exports.IsString = exports.IsPromise = exports.IsPlainObject = exports.IsObject = exports.IsNumber = exports.IsNull = exports.IsIterator = void 0;
-// ------------------------------------------------------------------
-// Value Errors (re-export)
-// ------------------------------------------------------------------
-var index_1 = require("../errors/index");
-Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-// ------------------------------------------------------------------
-// Value Operators
-// ------------------------------------------------------------------
-var index_2 = require("./cast/index");
-Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return index_2.Cast; } });
-Object.defineProperty(exports, "ValueCastArrayUniqueItemsTypeError", { enumerable: true, get: function () { return index_2.ValueCastArrayUniqueItemsTypeError; } });
-Object.defineProperty(exports, "ValueCastNeverTypeError", { enumerable: true, get: function () { return index_2.ValueCastNeverTypeError; } });
-Object.defineProperty(exports, "ValueCastRecursiveTypeError", { enumerable: true, get: function () { return index_2.ValueCastRecursiveTypeError; } });
-Object.defineProperty(exports, "ValueCastUnknownTypeError", { enumerable: true, get: function () { return index_2.ValueCastUnknownTypeError; } });
-var index_3 = require("./check/index");
-Object.defineProperty(exports, "Check", { enumerable: true, get: function () { return index_3.Check; } });
-var index_4 = require("./clean/index");
-Object.defineProperty(exports, "Clean", { enumerable: true, get: function () { return index_4.Clean; } });
-var index_5 = require("./clone/index");
-Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return index_5.Clone; } });
-var index_6 = require("./convert/index");
-Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return index_6.Convert; } });
-Object.defineProperty(exports, "ValueConvertUnknownTypeError", { enumerable: true, get: function () { return index_6.ValueConvertUnknownTypeError; } });
-var index_7 = require("./create/index");
-Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return index_7.Create; } });
-Object.defineProperty(exports, "ValueCreateIntersectTypeError", { enumerable: true, get: function () { return index_7.ValueCreateIntersectTypeError; } });
-Object.defineProperty(exports, "ValueCreateNeverTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNeverTypeError; } });
-Object.defineProperty(exports, "ValueCreateNotTypeError", { enumerable: true, get: function () { return index_7.ValueCreateNotTypeError; } });
-Object.defineProperty(exports, "ValueCreateRecursiveInstantiationError", { enumerable: true, get: function () { return index_7.ValueCreateRecursiveInstantiationError; } });
-Object.defineProperty(exports, "ValueCreateTempateLiteralTypeError", { enumerable: true, get: function () { return index_7.ValueCreateTempateLiteralTypeError; } });
-Object.defineProperty(exports, "ValueCreateUnknownTypeError", { enumerable: true, get: function () { return index_7.ValueCreateUnknownTypeError; } });
-var index_8 = require("./default/index");
-Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_8.Default; } });
-var index_9 = require("./delta/index");
-Object.defineProperty(exports, "Diff", { enumerable: true, get: function () { return index_9.Diff; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return index_9.Patch; } });
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return index_9.Edit; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return index_9.Delete; } });
-Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return index_9.Insert; } });
-Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return index_9.Update; } });
-Object.defineProperty(exports, "ValueDeltaObjectWithSymbolKeyError", { enumerable: true, get: function () { return index_9.ValueDeltaObjectWithSymbolKeyError; } });
-Object.defineProperty(exports, "ValueDeltaUnableToDiffUnknownValue", { enumerable: true, get: function () { return index_9.ValueDeltaUnableToDiffUnknownValue; } });
-var index_10 = require("./equal/index");
-Object.defineProperty(exports, "Equal", { enumerable: true, get: function () { return index_10.Equal; } });
-var index_11 = require("./hash/index");
-Object.defineProperty(exports, "Hash", { enumerable: true, get: function () { return index_11.Hash; } });
-Object.defineProperty(exports, "ValueHashError", { enumerable: true, get: function () { return index_11.ValueHashError; } });
-var index_12 = require("./mutate/index");
-Object.defineProperty(exports, "Mutate", { enumerable: true, get: function () { return index_12.Mutate; } });
-Object.defineProperty(exports, "ValueMutateInvalidRootMutationError", { enumerable: true, get: function () { return index_12.ValueMutateInvalidRootMutationError; } });
-Object.defineProperty(exports, "ValueMutateTypeMismatchError", { enumerable: true, get: function () { return index_12.ValueMutateTypeMismatchError; } });
-var index_13 = require("./pointer/index");
-Object.defineProperty(exports, "ValuePointer", { enumerable: true, get: function () { return index_13.ValuePointer; } });
-var index_14 = require("./transform/index");
-Object.defineProperty(exports, "Decode", { enumerable: true, get: function () { return index_14.Decode; } });
-Object.defineProperty(exports, "Encode", { enumerable: true, get: function () { return index_14.Encode; } });
-Object.defineProperty(exports, "HasTransform", { enumerable: true, get: function () { return index_14.HasTransform; } });
-Object.defineProperty(exports, "TransformDecodeCheckError", { enumerable: true, get: function () { return index_14.TransformDecodeCheckError; } });
-Object.defineProperty(exports, "TransformDecodeError", { enumerable: true, get: function () { return index_14.TransformDecodeError; } });
-Object.defineProperty(exports, "TransformEncodeCheckError", { enumerable: true, get: function () { return index_14.TransformEncodeCheckError; } });
-Object.defineProperty(exports, "TransformEncodeError", { enumerable: true, get: function () { return index_14.TransformEncodeError; } });
-// ------------------------------------------------------------------
-// Value Guards
-// ------------------------------------------------------------------
-var index_15 = require("./guard/index");
-Object.defineProperty(exports, "HasPropertyKey", { enumerable: true, get: function () { return index_15.HasPropertyKey; } });
-Object.defineProperty(exports, "IsArray", { enumerable: true, get: function () { return index_15.IsArray; } });
-Object.defineProperty(exports, "IsAsyncIterator", { enumerable: true, get: function () { return index_15.IsAsyncIterator; } });
-Object.defineProperty(exports, "IsBigInt", { enumerable: true, get: function () { return index_15.IsBigInt; } });
-Object.defineProperty(exports, "IsBoolean", { enumerable: true, get: function () { return index_15.IsBoolean; } });
-Object.defineProperty(exports, "IsDate", { enumerable: true, get: function () { return index_15.IsDate; } });
-Object.defineProperty(exports, "IsFunction", { enumerable: true, get: function () { return index_15.IsFunction; } });
-Object.defineProperty(exports, "IsInteger", { enumerable: true, get: function () { return index_15.IsInteger; } });
-Object.defineProperty(exports, "IsIterator", { enumerable: true, get: function () { return index_15.IsIterator; } });
-Object.defineProperty(exports, "IsNull", { enumerable: true, get: function () { return index_15.IsNull; } });
-Object.defineProperty(exports, "IsNumber", { enumerable: true, get: function () { return index_15.IsNumber; } });
-Object.defineProperty(exports, "IsObject", { enumerable: true, get: function () { return index_15.IsObject; } });
-Object.defineProperty(exports, "IsPlainObject", { enumerable: true, get: function () { return index_15.IsPlainObject; } });
-Object.defineProperty(exports, "IsPromise", { enumerable: true, get: function () { return index_15.IsPromise; } });
-Object.defineProperty(exports, "IsString", { enumerable: true, get: function () { return index_15.IsString; } });
-Object.defineProperty(exports, "IsSymbol", { enumerable: true, get: function () { return index_15.IsSymbol; } });
-Object.defineProperty(exports, "IsTypedArray", { enumerable: true, get: function () { return index_15.IsTypedArray; } });
-Object.defineProperty(exports, "IsUint8Array", { enumerable: true, get: function () { return index_15.IsUint8Array; } });
-Object.defineProperty(exports, "IsUndefined", { enumerable: true, get: function () { return index_15.IsUndefined; } });
-Object.defineProperty(exports, "IsValueType", { enumerable: true, get: function () { return index_15.IsValueType; } });
-// ------------------------------------------------------------------
-// Value Namespace
-// ------------------------------------------------------------------
-const index_16 = require("./value/index");
-Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_16.Value; } });
-exports.default = index_16.Value;

package/value/mutate/index.d.ts

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

package/value/mutate/mutate.js

@@ -1,129 +0,0 @@
-"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.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
-const index_1 = require("../guard/index");
-const index_2 = require("../pointer/index");
-const index_3 = require("../clone/index");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValueMutateTypeMismatchError extends Error {
-    constructor() {
-        super('Cannot assign due type mismatch of assignable values');
-    }
-}
-exports.ValueMutateTypeMismatchError = ValueMutateTypeMismatchError;
-class ValueMutateInvalidRootMutationError extends Error {
-    constructor() {
-        super('Only object and array types can be mutated at the root level');
-    }
-}
-exports.ValueMutateInvalidRootMutationError = ValueMutateInvalidRootMutationError;
-function ObjectType(root, path, current, next) {
-    if (!(0, index_1.IsPlainObject)(current)) {
-        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
-    }
-    else {
-        const currentKeys = Object.keys(current);
-        const nextKeys = Object.keys(next);
-        for (const currentKey of currentKeys) {
-            if (!nextKeys.includes(currentKey)) {
-                delete current[currentKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            if (!currentKeys.includes(nextKey)) {
-                current[nextKey] = null;
-            }
-        }
-        for (const nextKey of nextKeys) {
-            Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}
-function ArrayType(root, path, current, next) {
-    if (!(0, index_1.IsArray)(current)) {
-        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            Visit(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}
-function TypedArrayType(root, path, current, next) {
-    if ((0, index_1.IsTypedArray)(current) && current.length === next.length) {
-        for (let i = 0; i < current.length; i++) {
-            current[i] = next[i];
-        }
-    }
-    else {
-        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
-    }
-}
-function ValueType(root, path, current, next) {
-    if (current === next)
-        return;
-    index_2.ValuePointer.Set(root, path, next);
-}
-function Visit(root, path, current, next) {
-    if ((0, index_1.IsArray)(next))
-        return ArrayType(root, path, current, next);
-    if ((0, index_1.IsTypedArray)(next))
-        return TypedArrayType(root, path, current, next);
-    if ((0, index_1.IsPlainObject)(next))
-        return ObjectType(root, path, current, next);
-    if ((0, index_1.IsValueType)(next))
-        return ValueType(root, path, current, next);
-}
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return (0, index_1.IsTypedArray)(value) || (0, index_1.IsValueType)(value);
-}
-function IsMismatchedValue(current, next) {
-    // prettier-ignore
-    return (((0, index_1.IsPlainObject)(current) && (0, index_1.IsArray)(next)) ||
-        ((0, index_1.IsArray)(current) && (0, index_1.IsPlainObject)(next)));
-}
-// ------------------------------------------------------------------
-// Mutate
-// ------------------------------------------------------------------
-/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
-function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new ValueMutateInvalidRootMutationError();
-    if (IsMismatchedValue(current, next))
-        throw new ValueMutateTypeMismatchError();
-    Visit(current, '', current, next);
-}
-exports.Mutate = Mutate;

package/value/pointer/index.d.ts

@@ -1 +0,0 @@
-export * as ValuePointer from './pointer';

package/value/transform/decode.d.ts

@@ -1,19 +0,0 @@
-import { ValueError } from '../../errors/index';
-import type { TSchema } from '../../type/schema/index';
-export declare class TransformDecodeCheckError extends Error {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformDecodeError extends Error {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
-}
-/**
- * `[Internal]` Decodes the value and returns the result. This function requires that
- * the caller `Check` the value before use. Passing unchecked values may result in
- * undefined behavior. Refer to the `Value.Decode()` for implementation details.
- */
-export declare function Decode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/value/transform/decode.js

@@ -1,211 +0,0 @@
-"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.Decode = exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
-const type_1 = require("../../type/guard/type");
-const index_1 = require("../../type/symbols/index");
-const index_2 = require("../guard/index");
-const index_3 = require("../../type/keyof/index");
-const index_4 = require("../../type/indexed/index");
-const index_5 = require("../deref/index");
-const index_6 = require("../check/index");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-// thrown externally
-class TransformDecodeCheckError extends Error {
-    constructor(schema, value, error) {
-        super(`Unable to decode due to invalid value`);
-        this.schema = schema;
-        this.value = value;
-        this.error = error;
-    }
-}
-exports.TransformDecodeCheckError = TransformDecodeCheckError;
-class TransformDecodeError extends Error {
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
-        this.schema = schema;
-        this.value = value;
-    }
-}
-exports.TransformDecodeError = TransformDecodeError;
-// ------------------------------------------------------------------
-// Decode
-// ------------------------------------------------------------------
-// prettier-ignore
-function Default(schema, value) {
-    try {
-        return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
-    }
-    catch (error) {
-        throw new TransformDecodeError(schema, value, error);
-    }
-}
-// prettier-ignore
-function TArray(schema, references, value) {
-    return ((0, index_2.IsArray)(value))
-        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
-        : Default(schema, value);
-}
-// prettier-ignore
-function TIntersect(schema, references, value) {
-    if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
-        return Default(schema, value);
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit((0, index_4.IndexedTypeResolve)(schema, [key]), references, value[key]) }
-            : value;
-    }, value);
-    if (!(0, type_1.TTransform)(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const unevaluatedProperties = schema.unevaluatedProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
-            : value;
-    }, knownProperties);
-    return Default(schema, unknownProperties);
-}
-function TNot(schema, references, value) {
-    return Default(schema, Visit(schema.not, references, value));
-}
-// prettier-ignore
-function TObject(schema, references, value) {
-    if (!(0, index_2.IsPlainObject)(value))
-        return Default(schema, value);
-    const knownKeys = (0, index_3.KeyOfStringResolve)(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
-            : value;
-    }, value);
-    if (!(0, type_1.TSchema)(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
-            : value;
-    }, knownProperties);
-    return Default(schema, unknownProperties);
-}
-// prettier-ignore
-function TRecord(schema, references, value) {
-    if (!(0, index_2.IsPlainObject)(value))
-        return Default(schema, value);
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-    const knownKeys = new RegExp(pattern);
-    const knownProperties = Object.getOwnPropertyNames(value).reduce((value, key) => {
-        return knownKeys.test(key)
-            ? { ...value, [key]: Visit(schema.patternProperties[pattern], references, value[key]) }
-            : value;
-    }, value);
-    if (!(0, type_1.TSchema)(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    const unknownProperties = unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
-            : value;
-    }, knownProperties);
-    return Default(schema, unknownProperties);
-}
-// prettier-ignore
-function TRef(schema, references, value) {
-    const target = (0, index_5.Deref)(schema, references);
-    return Default(schema, Visit(target, references, value));
-}
-// prettier-ignore
-function TThis(schema, references, value) {
-    const target = (0, index_5.Deref)(schema, references);
-    return Default(schema, Visit(target, references, value));
-}
-// prettier-ignore
-function TTuple(schema, references, value) {
-    return ((0, index_2.IsArray)(value) && (0, index_2.IsArray)(schema.items))
-        ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
-        : Default(schema, value);
-}
-// prettier-ignore
-function TUnion(schema, references, value) {
-    for (const subschema of schema.anyOf) {
-        if (!(0, index_6.Check)(subschema, references, value))
-            continue;
-        // note: ensure interior is decoded first
-        const decoded = Visit(subschema, references, value);
-        return Default(schema, decoded);
-    }
-    return Default(schema, value);
-}
-// prettier-ignore
-function Visit(schema, references, value) {
-    const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
-    const schema_ = schema;
-    switch (schema[index_1.Kind]) {
-        case 'Array':
-            return TArray(schema_, references_, value);
-        case 'Intersect':
-            return TIntersect(schema_, references_, value);
-        case 'Not':
-            return TNot(schema_, references_, value);
-        case 'Object':
-            return TObject(schema_, references_, value);
-        case 'Record':
-            return TRecord(schema_, references_, value);
-        case 'Ref':
-            return TRef(schema_, references_, value);
-        case 'Symbol':
-            return Default(schema_, value);
-        case 'This':
-            return TThis(schema_, references_, value);
-        case 'Tuple':
-            return TTuple(schema_, references_, value);
-        case 'Union':
-            return TUnion(schema_, references_, value);
-        default:
-            return Default(schema_, value);
-    }
-}
-/**
- * `[Internal]` Decodes the value and returns the result. This function requires that
- * the caller `Check` the value before use. Passing unchecked values may result in
- * undefined behavior. Refer to the `Value.Decode()` for implementation details.
- */
-function Decode(schema, references, value) {
-    return Visit(schema, references, value);
-}
-exports.Decode = Decode;

package/value/transform/encode.d.ts

@@ -1,20 +0,0 @@
-import { ValueError } from '../../errors/index';
-import type { TSchema } from '../../type/schema/index';
-export declare class TransformEncodeCheckError extends Error {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformEncodeError extends Error {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    constructor(schema: TSchema, value: unknown, error: any);
-}
-/**
- * `[Internal]` Encodes the value and returns the result. This function expects the
- * caller to pass a statically checked value. This function does not check the encoded
- * result, meaning the result should be passed to `Check` before use. Refer to the
- * `Value.Encode()` function for implementation details.
- */
-export declare function Encode(schema: TSchema, references: TSchema[], value: unknown): unknown;