@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/require/value/guard/guard.js

@@ -1,83 +1,114 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.IsPlainObject = exports.HasPropertyKey = exports.IsDate = exports.IsUint8Array = exports.IsPromise = exports.IsTypedArray = exports.IsIterator = exports.IsAsyncIterator = void 0;
+// --------------------------------------------------------------------------
+// Iterators
+// --------------------------------------------------------------------------
+/** Returns true if this value is an async iterator */
 function IsAsyncIterator(value) {
     return IsObject(value) && Symbol.asyncIterator in value;
 }
 exports.IsAsyncIterator = IsAsyncIterator;
+/** Returns true if this value is an iterator */
 function IsIterator(value) {
     return IsObject(value) && Symbol.iterator in value;
 }
 exports.IsIterator = IsIterator;
+// --------------------------------------------------------------------------
+// Nominal
+// --------------------------------------------------------------------------
+/** Returns true if this value is a typed array */
 function IsTypedArray(value) {
     return ArrayBuffer.isView(value);
 }
 exports.IsTypedArray = IsTypedArray;
+/** Returns true if this value is a Promise */
 function IsPromise(value) {
     return value instanceof Promise;
 }
 exports.IsPromise = IsPromise;
+/** Returns true if the value is a Uint8Array */
 function IsUint8Array(value) {
     return value instanceof Uint8Array;
 }
 exports.IsUint8Array = IsUint8Array;
+/** Returns true if this value is a Date */
 function IsDate(value) {
     return value instanceof Date && Number.isFinite(value.getTime());
 }
 exports.IsDate = IsDate;
+// --------------------------------------------------------------------------
+// Standard
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
 function HasPropertyKey(value, key) {
     return key in value;
 }
 exports.HasPropertyKey = HasPropertyKey;
+/** Returns true if this object is not an instance of any other type */
 function IsPlainObject(value) {
     return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === 'Object';
 }
 exports.IsPlainObject = IsPlainObject;
+/** Returns true of this value is an object type */
 function IsObject(value) {
     return value !== null && typeof value === 'object';
 }
 exports.IsObject = IsObject;
+/** Returns true if this value is an array, but not a typed array */
 function IsArray(value) {
     return Array.isArray(value) && !ArrayBuffer.isView(value);
 }
 exports.IsArray = IsArray;
+/** Returns true if this value is an undefined */
 function IsUndefined(value) {
     return value === undefined;
 }
 exports.IsUndefined = IsUndefined;
+/** Returns true if this value is an null */
 function IsNull(value) {
     return value === null;
 }
 exports.IsNull = IsNull;
+/** Returns true if this value is an boolean */
 function IsBoolean(value) {
     return typeof value === 'boolean';
 }
 exports.IsBoolean = IsBoolean;
+/** Returns true if this value is an number */
 function IsNumber(value) {
     return typeof value === 'number';
 }
 exports.IsNumber = IsNumber;
+/** Returns true if this value is an integer */
 function IsInteger(value) {
     return IsNumber(value) && Number.isInteger(value);
 }
 exports.IsInteger = IsInteger;
+/** Returns true if this value is bigint */
 function IsBigInt(value) {
     return typeof value === 'bigint';
 }
 exports.IsBigInt = IsBigInt;
+/** Returns true if this value is string */
 function IsString(value) {
     return typeof value === 'string';
 }
 exports.IsString = IsString;
+/** Returns true if this value is a function */
 function IsFunction(value) {
     return typeof value === 'function';
 }
 exports.IsFunction = IsFunction;
+/** Returns true if this value is a symbol */
 function IsSymbol(value) {
     return typeof value === 'symbol';
 }
 exports.IsSymbol = IsSymbol;
+/** Returns true if this value is a value type such as number, string, boolean */
 function IsValueType(value) {
+    // prettier-ignore
     return (IsBigInt(value) ||
         IsBoolean(value) ||
         IsNull(value) ||

package/build/require/value/guard/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/value/hash/hash.d.ts

@@ -2,4 +2,5 @@ export declare class ValueHashError extends Error {
     readonly value: unknown;
     constructor(value: unknown);
 }
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
 export declare function Hash(value: unknown): bigint;

package/build/require/value/hash/hash.js

@@ -1,7 +1,11 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hash = exports.ValueHashError = void 0;
 const index_1 = require("../guard/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValueHashError extends Error {
     constructor(value) {
         super(`Unable to hash value`);
@@ -9,6 +13,9 @@ class ValueHashError extends Error {
     }
 }
 exports.ValueHashError = ValueHashError;
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
 var ByteMarker;
 (function (ByteMarker) {
     ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
@@ -23,18 +30,27 @@ var ByteMarker;
     ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
     ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
 })(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
 let Accumulator = BigInt('14695981039346656037');
 const [Prime, Size] = [BigInt('1099511628211'), BigInt('2') ** BigInt('64')];
 const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
 const F64 = new Float64Array(1);
 const F64In = new DataView(F64.buffer);
 const F64Out = new Uint8Array(F64.buffer);
+// ------------------------------------------------------------------
+// NumberToBytes
+// ------------------------------------------------------------------
 function* NumberToBytes(value) {
     const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
     for (let i = 0; i < byteCount; i++) {
         yield (value >> (8 * (byteCount - 1 - i))) & 0xff;
     }
 }
+// ------------------------------------------------------------------
+// Hashing Functions
+// ------------------------------------------------------------------
 function ArrayType(value) {
     FNV1A64(ByteMarker.Array);
     for (const item of value) {
@@ -123,6 +139,10 @@ function FNV1A64(byte) {
     Accumulator = Accumulator ^ Bytes[byte];
     Accumulator = (Accumulator * Prime) % Size;
 }
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
 function Hash(value) {
     Accumulator = BigInt('14695981039346656037');
     Visit(value);

package/build/require/value/hash/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/value/index.js

@@ -1,10 +1,17 @@
 "use strict";
+
 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.EncodeTransform = exports.DecodeTransform = 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; } });
@@ -58,6 +65,9 @@ Object.defineProperty(exports, "TransformDecodeCheckError", { enumerable: true,
 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; } });
@@ -79,5 +89,8 @@ Object.defineProperty(exports, "IsTypedArray", { enumerable: true, get: function
 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
+// ------------------------------------------------------------------
 var index_16 = require("./value/index");
 Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_16.Value; } });

package/build/require/value/mutate/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/value/mutate/mutate.d.ts

@@ -7,4 +7,5 @@ export declare class ValueMutateInvalidRootMutationError extends Error {
 export type Mutable = {
     [key: string]: unknown;
 } | unknown[];
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export declare function Mutate(current: Mutable, next: Mutable): void;

package/build/require/value/mutate/mutate.js

@@ -1,9 +1,13 @@
 "use strict";
+
 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');
@@ -74,13 +78,21 @@ function Visit(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();

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

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValuePointer = void 0;
 exports.ValuePointer = require("./pointer");

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

@@ -9,8 +9,13 @@ export declare class ValuePointerRootDeleteError extends Error {
     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/require/value/pointer/pointer.js

@@ -1,6 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Get = exports.Has = exports.Delete = exports.Set = exports.Format = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValuePointerRootSetError extends Error {
     constructor(value, path, update) {
         super('Cannot set root value');
@@ -18,9 +22,16 @@ class ValuePointerRootDeleteError extends Error {
     }
 }
 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;
@@ -44,6 +55,8 @@ function* Format(pointer) {
     yield Escape(pointer.slice(start));
 }
 exports.Format = Format;
+/** 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);
@@ -58,6 +71,8 @@ function Set(value, pointer, update) {
     owner[key] = update;
 }
 exports.Set = Set;
+/** Deletes a value at the given pointer */
+// prettier-ignore
 function Delete(value, pointer) {
     if (pointer === '')
         throw new ValuePointerRootDeleteError(value, pointer);
@@ -78,6 +93,8 @@ function Delete(value, pointer) {
     }
 }
 exports.Delete = Delete;
+/** Returns true if a value exists at the given pointer */
+// prettier-ignore
 function Has(value, pointer) {
     if (pointer === '')
         return true;
@@ -92,6 +109,8 @@ function Has(value, pointer) {
     return Object.getOwnPropertyNames(owner).includes(key);
 }
 exports.Has = Has;
+/** Gets the value at the given pointer */
+// prettier-ignore
 function Get(value, pointer) {
     if (pointer === '')
         return value;

package/build/require/value/transform/decode.d.ts

@@ -11,4 +11,9 @@ export declare class TransformDecodeError extends Error {
     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 TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;

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

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecode = exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +9,10 @@ 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`);
@@ -25,6 +30,10 @@ class TransformDecodeError extends Error {
     }
 }
 exports.TransformDecodeError = TransformDecodeError;
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
@@ -33,11 +42,13 @@ function Default(schema, value) {
         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);
@@ -62,6 +73,7 @@ function TIntersect(schema, references, value) {
 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);
@@ -83,6 +95,7 @@ function TObject(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
@@ -105,28 +118,34 @@ function TRecord(schema, references, 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;
@@ -155,6 +174,11 @@ function Visit(schema, references, value) {
             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 TransformDecode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/encode.d.ts

@@ -11,4 +11,10 @@ export declare class TransformEncodeError extends Error {
     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 TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/require/value/transform/encode.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncode = exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +9,9 @@ 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
+// ------------------------------------------------------------------
 class TransformEncodeCheckError extends Error {
     constructor(schema, value, error) {
         super(`Unable to encode due to invalid value`);
@@ -25,6 +29,10 @@ class TransformEncodeError extends Error {
     }
 }
 exports.TransformEncodeError = TransformEncodeError;
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
@@ -33,12 +41,14 @@ function Default(schema, value) {
         throw new TransformEncodeError(schema, value, error);
     }
 }
+// prettier-ignore
 function TArray(schema, references, value) {
     const defaulted = Default(schema, value);
     return (0, index_2.IsArray)(defaulted)
         ? defaulted.map((value) => Visit(schema.items, references, value))
         : defaulted;
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
@@ -60,9 +70,11 @@ function TIntersect(schema, references, value) {
             : 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 (!(0, index_2.IsPlainObject)(value))
@@ -84,6 +96,7 @@ function TObject(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
@@ -106,27 +119,33 @@ function TRecord(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRef(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
+// prettier-ignore
 function TThis(schema, references, value) {
     const target = (0, index_5.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 (0, index_2.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 (!(0, index_6.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 (!(0, index_6.Check)(schema, references, value1))
@@ -135,6 +154,7 @@ function TUnion(schema, references, value) {
     }
     return Default(schema, value);
 }
+// prettier-ignore
 function Visit(schema, references, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
@@ -161,6 +181,12 @@ function Visit(schema, references, value) {
             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.
+ */
 function TransformEncode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/has.d.ts

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