@depup/sinclair__typebox 0.34.48-depup.0

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

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueMutateError = void 0;
+exports.Mutate = Mutate;
+const index_1 = require("../guard/index");
+const index_2 = require("../pointer/index");
+const index_3 = require("../clone/index");
+const index_4 = require("../../type/error/index");
+// ------------------------------------------------------------------
+// IsStandardObject
+// ------------------------------------------------------------------
+function IsStandardObject(value) {
+    return (0, index_1.IsObject)(value) && !(0, index_1.IsArray)(value);
+}
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class ValueMutateError extends index_4.TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ValueMutateError = ValueMutateError;
+function ObjectType(root, path, current, next) {
+    if (!IsStandardObject(current)) {
+        index_2.ValuePointer.Set(root, path, (0, index_3.Clone)(next));
+    }
+    else {
+        const currentKeys = Object.getOwnPropertyNames(current);
+        const nextKeys = Object.getOwnPropertyNames(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 (IsStandardObject(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 ((IsStandardObject(current) && (0, index_1.IsArray)(next)) ||
+        ((0, index_1.IsArray)(current) && IsStandardObject(next)));
+}
+// ------------------------------------------------------------------
+// Mutate
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
+function Mutate(current, next) {
+    if (IsNonMutableValue(current) || IsNonMutableValue(next))
+        throw new ValueMutateError('Only object and array types can be mutated at the root level');
+    if (IsMismatchedValue(current, next))
+        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
+    Visit(current, '', current, next);
+}

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,22 @@
+import { TypeBoxError } from '../../type/error/index';
+import { TSchema } from '../../type/schema/index';
+import { StaticDecode } from '../../type/static/index';
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Assert' | 'Cast' | 'Clean' | 'Clone' | 'Convert' | 'Decode' | 'Default' | 'Encode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

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

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDefault = exports.ParseRegistry = exports.ParseError = void 0;
+exports.Parse = Parse;
+const index_1 = require("../../type/error/index");
+const index_2 = require("../transform/index");
+const index_3 = require("../assert/index");
+const index_4 = require("../cast/index");
+const index_5 = require("../clean/index");
+const index_6 = require("../clone/index");
+const index_7 = require("../convert/index");
+const index_8 = require("../default/index");
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+const index_9 = require("../guard/index");
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+class ParseError extends index_1.TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ParseError = ParseError;
+// prettier-ignore
+var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Assert', (type, references, value) => { (0, index_3.Assert)(type, references, value); return value; }],
+        ['Cast', (type, references, value) => (0, index_4.Cast)(type, references, value)],
+        ['Clean', (type, references, value) => (0, index_5.Clean)(type, references, value)],
+        ['Clone', (_type, _references, value) => (0, index_6.Clone)(value)],
+        ['Convert', (type, references, value) => (0, index_7.Convert)(type, references, value)],
+        ['Decode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformDecode)(type, references, value) : value)],
+        ['Default', (type, references, value) => (0, index_8.Default)(type, references, value)],
+        ['Encode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformEncode)(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (exports.ParseRegistry = ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Pipeline
+// ------------------------------------------------------------------
+// prettier-ignore
+exports.ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
+];
+// ------------------------------------------------------------------
+// ParseValue
+// ------------------------------------------------------------------
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if ((0, index_9.IsUndefined)(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
+}
+/** Parses a value */
+function Parse(...args) {
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? (0, index_9.IsArray)(args[0]) ? [args[0], args[1], [], args[2]] : [exports.ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [exports.ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
+}

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

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

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

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuePointer = void 0;
+exports.ValuePointer = __importStar(require("./pointer"));

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

@@ -0,0 +1,22 @@
+import { TypeBoxError } from '../../type/error/index';
+export declare class ValuePointerRootSetError extends TypeBoxError {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends TypeBoxError {
+    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/build/cjs/value/pointer/pointer.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+exports.Format = Format;
+exports.Set = Set;
+exports.Delete = Delete;
+exports.Has = Has;
+exports.Get = Get;
+const index_1 = require("../../type/error/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class ValuePointerRootSetError extends index_1.TypeBoxError {
+    constructor(value, path, update) {
+        super('Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+exports.ValuePointerRootSetError = ValuePointerRootSetError;
+class ValuePointerRootDeleteError extends index_1.TypeBoxError {
+    constructor(value, path) {
+        super('Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+// ------------------------------------------------------------------
+// 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
+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
+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
+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
+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
+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/build/cjs/value/transform/decode.d.ts

@@ -0,0 +1,22 @@
+import { TypeBoxError } from '../../type/error/index';
+import { ValueError } from '../../errors/index';
+import type { TSchema } from '../../type/schema/index';
+export declare class TransformDecodeCheckError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    readonly error: ValueError;
+    constructor(schema: TSchema, value: unknown, error: ValueError);
+}
+export declare class TransformDecodeError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly path: string;
+    readonly value: unknown;
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
+}
+/**
+ * `[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 TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;

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

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
+exports.TransformDecode = TransformDecode;
+const policy_1 = require("../../system/policy");
+const index_1 = require("../../type/symbols/index");
+const index_2 = require("../../type/error/index");
+const index_3 = require("../../type/keyof/index");
+const index_4 = require("../deref/index");
+const index_5 = require("../check/index");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+const index_6 = require("../guard/index");
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../../type/guard/kind");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// thrown externally
+// prettier-ignore
+class TransformDecodeCheckError extends index_2.TypeBoxError {
+    constructor(schema, value, error) {
+        super(`Unable to decode value as it does not match the expected schema`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+    }
+}
+exports.TransformDecodeCheckError = TransformDecodeCheckError;
+// prettier-ignore
+class TransformDecodeError extends index_2.TypeBoxError {
+    constructor(schema, path, value, error) {
+        super(error instanceof Error ? error.message : 'Unknown error');
+        this.schema = schema;
+        this.path = path;
+        this.value = value;
+        this.error = error;
+    }
+}
+exports.TransformDecodeError = TransformDecodeError;
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
+function Default(schema, path, value) {
+    try {
+        return (0, kind_1.IsTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
+    }
+    catch (error) {
+        throw new TransformDecodeError(schema, path, value, error);
+    }
+}
+// prettier-ignore
+function FromArray(schema, references, path, value) {
+    return ((0, index_6.IsArray)(value))
+        ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+        : Default(schema, path, value);
+}
+// prettier-ignore
+function FromIntersect(schema, references, path, 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]);
+    const knownProperties = { ...value };
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+        }
+    if (!(0, kind_1.IsTransform)(schema.unevaluatedProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromImport(schema, references, path, value) {
+    const additional = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const result = Visit(target, [...references, ...additional], path, value);
+    return Default(schema, path, result);
+}
+function FromNot(schema, references, path, value) {
+    return Default(schema, path, Visit(schema.not, references, path, value));
+}
+// prettier-ignore
+function FromObject(schema, references, path, value) {
+    if (!(0, index_6.IsObject)(value))
+        return Default(schema, path, value);
+    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
+    const knownProperties = { ...value };
+    for (const key of knownKeys) {
+        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, kind_1.IsUndefined)(schema.properties[key]) ||
+            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromRecord(schema, references, path, value) {
+    if (!(0, index_6.IsObject)(value))
+        return Default(schema, path, value);
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const knownKeys = new RegExp(pattern);
+    const knownProperties = { ...value };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
+    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromRef(schema, references, path, value) {
+    const target = (0, index_4.Deref)(schema, references);
+    return Default(schema, path, Visit(target, references, path, value));
+}
+// prettier-ignore
+function FromThis(schema, references, path, value) {
+    const target = (0, index_4.Deref)(schema, references);
+    return Default(schema, path, Visit(target, references, path, value));
+}
+// prettier-ignore
+function FromTuple(schema, references, path, value) {
+    return ((0, index_6.IsArray)(value) && (0, index_6.IsArray)(schema.items))
+        ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+        : Default(schema, path, value);
+}
+// prettier-ignore
+function FromUnion(schema, references, path, value) {
+    for (const subschema of schema.anyOf) {
+        if (!(0, index_5.Check)(subschema, references, value))
+            continue;
+        // note: ensure interior is decoded first
+        const decoded = Visit(subschema, references, path, value);
+        return Default(schema, path, decoded);
+    }
+    return Default(schema, path, value);
+}
+// prettier-ignore
+function Visit(schema, references, path, value) {
+    const references_ = (0, index_4.Pushref)(schema, references);
+    const schema_ = schema;
+    switch (schema[index_1.Kind]) {
+        case 'Array':
+            return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
+        case 'Intersect':
+            return FromIntersect(schema_, references_, path, value);
+        case 'Not':
+            return FromNot(schema_, references_, path, value);
+        case 'Object':
+            return FromObject(schema_, references_, path, value);
+        case 'Record':
+            return FromRecord(schema_, references_, path, value);
+        case 'Ref':
+            return FromRef(schema_, references_, path, value);
+        case 'Symbol':
+            return Default(schema_, path, value);
+        case 'This':
+            return FromThis(schema_, references_, path, value);
+        case 'Tuple':
+            return FromTuple(schema_, references_, path, value);
+        case 'Union':
+            return FromUnion(schema_, references_, path, value);
+        default:
+            return Default(schema_, path, 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 TransformDecode(schema, references, value) {
+    return Visit(schema, references, '', value);
+}