@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/esm/value/pointer/index.mjs

@@ -1,28 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-export * as ValuePointer from './pointer.mjs';

package/esm/value/pointer/pointer.d.mts

@@ -1,21 +0,0 @@
-export declare class ValuePointerRootSetError extends Error {
-    readonly value: unknown;
-    readonly path: string;
-    readonly update: unknown;
-    constructor(value: unknown, path: string, update: unknown);
-}
-export declare class ValuePointerRootDeleteError extends Error {
-    readonly value: unknown;
-    readonly path: string;
-    constructor(value: unknown, path: string);
-}
-/** Formats the given pointer into navigable key components */
-export declare function Format(pointer: string): IterableIterator<string>;
-/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-export declare function Set(value: any, pointer: string, update: unknown): void;
-/** Deletes a value at the given pointer */
-export declare function Delete(value: any, pointer: string): void;
-/** Returns true if a value exists at the given pointer */
-export declare function Has(value: any, pointer: string): boolean;
-/** Gets the value at the given pointer */
-export declare function Get(value: any, pointer: string): any;

package/esm/value/pointer/pointer.mjs

@@ -1,146 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValuePointerRootSetError extends Error {
-    value;
-    path;
-    update;
-    constructor(value, path, update) {
-        super('Cannot set root value');
-        this.value = value;
-        this.path = path;
-        this.update = update;
-    }
-}
-export class ValuePointerRootDeleteError extends Error {
-    value;
-    path;
-    constructor(value, path) {
-        super('Cannot delete root value');
-        this.value = value;
-        this.path = path;
-    }
-}
-// ------------------------------------------------------------------
-// ValuePointer
-// ------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-// prettier-ignore
-function Escape(component) {
-    return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-/** Formats the given pointer into navigable key components */
-// prettier-ignore
-export function* Format(pointer) {
-    if (pointer === '')
-        return;
-    let [start, end] = [0, 0];
-    for (let i = 0; i < pointer.length; i++) {
-        const char = pointer.charAt(i);
-        if (char === '/') {
-            if (i === 0) {
-                start = i + 1;
-            }
-            else {
-                end = i;
-                yield Escape(pointer.slice(start, end));
-                start = i + 1;
-            }
-        }
-        else {
-            end = i;
-        }
-    }
-    yield Escape(pointer.slice(start));
-}
-/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-// prettier-ignore
-export function Set(value, pointer, update) {
-    if (pointer === '')
-        throw new ValuePointerRootSetError(value, pointer, update);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined)
-            next[component] = {};
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    owner[key] = update;
-}
-/** Deletes a value at the given pointer */
-// prettier-ignore
-export function Delete(value, pointer) {
-    if (pointer === '')
-        throw new ValuePointerRootDeleteError(value, pointer);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined || next[component] === null)
-            return;
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (Array.isArray(owner)) {
-        const index = parseInt(key);
-        owner.splice(index, 1);
-    }
-    else {
-        delete owner[key];
-    }
-}
-/** Returns true if a value exists at the given pointer */
-// prettier-ignore
-export function Has(value, pointer) {
-    if (pointer === '')
-        return true;
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined)
-            return false;
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    return Object.getOwnPropertyNames(owner).includes(key);
-}
-/** Gets the value at the given pointer */
-// prettier-ignore
-export function Get(value, pointer) {
-    if (pointer === '')
-        return value;
-    let current = value;
-    for (const component of Format(pointer)) {
-        if (current[component] === undefined)
-            return undefined;
-        current = current[component];
-    }
-    return current;
-}

package/esm/value/transform/decode.d.mts

@@ -1,19 +0,0 @@
-import { ValueError } from '../../errors/index.mjs';
-import type { TSchema } from '../../type/schema/index.mjs';
-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/esm/value/transform/decode.mjs

@@ -1,210 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
-import { Kind, TransformKind } from '../../type/symbols/index.mjs';
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
-import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
-import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
-import { Deref } from '../deref/index.mjs';
-import { Check } from '../check/index.mjs';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-// thrown externally
-export class TransformDecodeCheckError extends Error {
-    schema;
-    value;
-    error;
-    constructor(schema, value, error) {
-        super(`Unable to decode due to invalid value`);
-        this.schema = schema;
-        this.value = value;
-        this.error = error;
-    }
-}
-export class TransformDecodeError extends Error {
-    schema;
-    value;
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
-        this.schema = schema;
-        this.value = value;
-    }
-}
-// ------------------------------------------------------------------
-// Decode
-// ------------------------------------------------------------------
-// prettier-ignore
-function Default(schema, value) {
-    try {
-        return IsTransformType(schema) ? schema[TransformKind].Decode(value) : value;
-    }
-    catch (error) {
-        throw new TransformDecodeError(schema, value, error);
-    }
-}
-// prettier-ignore
-function TArray(schema, references, value) {
-    return (IsArray(value))
-        ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
-        : Default(schema, value);
-}
-// prettier-ignore
-function TIntersect(schema, references, value) {
-    if (!IsPlainObject(value) || IsValueType(value))
-        return Default(schema, value);
-    const knownKeys = KeyOfStringResolve(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
-            : value;
-    }, value);
-    if (!IsTransformType(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 (!IsPlainObject(value))
-        return Default(schema, value);
-    const knownKeys = KeyOfStringResolve(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return (key in value)
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
-            : value;
-    }, value);
-    if (!IsSchemaType(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 (!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 (!IsSchemaType(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 = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
-}
-// prettier-ignore
-function TThis(schema, references, value) {
-    const target = Deref(schema, references);
-    return Default(schema, Visit(target, references, value));
-}
-// prettier-ignore
-function TTuple(schema, references, value) {
-    return (IsArray(value) && 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 (!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[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.
- */
-export function Decode(schema, references, value) {
-    return Visit(schema, references, value);
-}

package/esm/value/transform/encode.d.mts

@@ -1,20 +0,0 @@
-import { ValueError } from '../../errors/index.mjs';
-import type { TSchema } from '../../type/schema/index.mjs';
-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;

package/esm/value/transform/encode.mjs

@@ -1,218 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-import { TTransform as IsTransformType, TSchema as IsSchemaType } from '../../type/guard/type.mjs';
-import { Kind, TransformKind } from '../../type/symbols/index.mjs';
-import { IsPlainObject, IsArray, IsValueType } from '../guard/index.mjs';
-import { KeyOfStringResolve } from '../../type/keyof/index.mjs';
-import { IndexedTypeResolve } from '../../type/indexed/index.mjs';
-import { Deref } from '../deref/index.mjs';
-import { Check } from '../check/index.mjs';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class TransformEncodeCheckError extends Error {
-    schema;
-    value;
-    error;
-    constructor(schema, value, error) {
-        super(`Unable to encode due to invalid value`);
-        this.schema = schema;
-        this.value = value;
-        this.error = error;
-    }
-}
-export class TransformEncodeError extends Error {
-    schema;
-    value;
-    constructor(schema, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
-        this.schema = schema;
-        this.value = value;
-    }
-}
-// ------------------------------------------------------------------
-// Encode
-// ------------------------------------------------------------------
-// prettier-ignore
-function Default(schema, value) {
-    try {
-        return IsTransformType(schema) ? schema[TransformKind].Encode(value) : value;
-    }
-    catch (error) {
-        throw new TransformEncodeError(schema, value, error);
-    }
-}
-// prettier-ignore
-function TArray(schema, references, value) {
-    const defaulted = Default(schema, value);
-    return IsArray(defaulted)
-        ? defaulted.map((value) => Visit(schema.items, references, value))
-        : defaulted;
-}
-// prettier-ignore
-function TIntersect(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value) || IsValueType(value))
-        return defaulted;
-    const knownKeys = KeyOfStringResolve(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in defaulted
-            ? { ...value, [key]: Visit(IndexedTypeResolve(schema, [key]), references, value[key]) }
-            : value;
-    }, defaulted);
-    if (!IsTransformType(schema.unevaluatedProperties)) {
-        return Default(schema, knownProperties);
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const unevaluatedProperties = schema.unevaluatedProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(unevaluatedProperties, value[key]) }
-            : value;
-    }, knownProperties);
-}
-// prettier-ignore
-function TNot(schema, references, value) {
-    return Default(schema.not, Default(schema, value));
-}
-// prettier-ignore
-function TObject(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
-        return defaulted;
-    const knownKeys = KeyOfStringResolve(schema);
-    const knownProperties = knownKeys.reduce((value, key) => {
-        return key in value
-            ? { ...value, [key]: Visit(schema.properties[key], references, value[key]) }
-            : value;
-    }, defaulted);
-    if (!IsSchemaType(schema.additionalProperties)) {
-        return knownProperties;
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.includes(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
-            : value;
-    }, knownProperties);
-}
-// prettier-ignore
-function TRecord(schema, references, value) {
-    const defaulted = Default(schema, value);
-    if (!IsPlainObject(value))
-        return defaulted;
-    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;
-    }, defaulted);
-    if (!IsSchemaType(schema.additionalProperties)) {
-        return Default(schema, knownProperties);
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    return unknownKeys.reduce((value, key) => {
-        return !knownKeys.test(key)
-            ? { ...value, [key]: Default(additionalProperties, value[key]) }
-            : value;
-    }, knownProperties);
-}
-// prettier-ignore
-function TRef(schema, references, value) {
-    const target = Deref(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
-}
-// prettier-ignore
-function TThis(schema, references, value) {
-    const target = Deref(schema, references);
-    const resolved = Visit(target, references, value);
-    return Default(schema, resolved);
-}
-// prettier-ignore
-function TTuple(schema, references, value) {
-    const value1 = Default(schema, value);
-    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
-}
-// prettier-ignore
-function TUnion(schema, references, value) {
-    // test value against union variants
-    for (const subschema of schema.anyOf) {
-        if (!Check(subschema, references, value))
-            continue;
-        const value1 = Visit(subschema, references, value);
-        return Default(schema, value1);
-    }
-    // test transformed value against union variants
-    for (const subschema of schema.anyOf) {
-        const value1 = Visit(subschema, references, value);
-        if (!Check(schema, references, value1))
-            continue;
-        return Default(schema, value1);
-    }
-    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[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 '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]` 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 function Encode(schema, references, value) {
-    return Visit(schema, references, value);
-}

package/esm/value/transform/has.d.mts

@@ -1,3 +0,0 @@
-import type { TSchema } from '../../type/schema/index.mjs';
-/** Returns true if this schema contains a transform codec */
-export declare function HasTransform(schema: TSchema, references: TSchema[]): boolean;