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

package/build/import/value/convert/convert.mjs

@@ -5,6 +5,9 @@ import { Deref } from '../deref/index.mjs';
 import { TObject as IsObjectType } from '../../type/guard/type.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
 import { Composite } from '../../type/composite/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValueConvertUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -12,6 +15,9 @@ export class ValueConvertUnknownTypeError extends Error {
         this.schema = schema;
     }
 }
+// ------------------------------------------------------------------
+// Conversions
+// ------------------------------------------------------------------
 function IsStringNumeric(value) {
     return IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
 }
@@ -39,6 +45,9 @@ function IsDateTimeStringWithoutTimeZone(value) {
 function IsDateString(value) {
     return IsString(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
 }
+// ------------------------------------------------------------------
+// Convert
+// ------------------------------------------------------------------
 function TryConvertLiteralString(value, target) {
     const conversion = TryConvertString(value);
     return conversion === target ? conversion : value;
@@ -51,6 +60,7 @@ function TryConvertLiteralBoolean(value, target) {
     const conversion = TryConvertBoolean(value);
     return conversion === target ? conversion : value;
 }
+// prettier-ignore
 function TryConvertLiteral(schema, value) {
     return (IsString(schema.const) ? TryConvertLiteralString(value, schema.const) :
         IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) :
@@ -78,6 +88,14 @@ function TryConvertNull(value) {
 function TryConvertUndefined(value) {
     return IsString(value) && value === 'undefined' ? undefined : value;
 }
+// ------------------------------------------------------------------
+// note: this function may return an invalid dates for the regex
+// tests above. Invalid dates will however be checked during the
+// casting function and will return a epoch date if invalid.
+// Consider better string parsing for the iso dates in future
+// revisions.
+// ------------------------------------------------------------------
+// prettier-ignore
 function TryConvertDate(value) {
     return (IsDate(value) ? value :
         IsNumber(value) ? new Date(value) :
@@ -91,9 +109,15 @@ function TryConvertDate(value) {
                                         IsDateString(value) ? new Date(`${value}T00:00:00.000Z`) :
                                             value);
 }
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 function Default(value) {
     return value;
 }
+// ------------------------------------------------------------------
+// Convert
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
     if (IsArray(value)) {
         return value.map((value) => Visit(schema.items, references, value));
@@ -112,11 +136,12 @@ function TDate(schema, references, value) {
 function TInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     const allObjects = schema.allOf.every(schema => IsObjectType(schema));
     if (allObjects)
         return Visit(Composite(schema.allOf), references, value);
-    return Visit(schema.allOf[0], references, value);
+    return Visit(schema.allOf[0], references, value); // todo: fix this
 }
 function TLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
@@ -127,6 +152,7 @@ function TNull(schema, references, value) {
 function TNumber(schema, references, value) {
     return TryConvertNumber(value);
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     const isConvertable = IsObject(value);
     if (!isConvertable)
@@ -158,6 +184,7 @@ function TSymbol(schema, references, value) {
 function TThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     const isConvertable = IsArray(value) && !IsUndefined(schema.items);
     if (!isConvertable)
@@ -224,6 +251,8 @@ function Visit(schema, references, value) {
             return Default(value);
     }
 }
+/** Converts any type mismatched values to their target type if a reasonable conversion is possible. */
+// prettier-ignore
 export function Convert(...args) {
     return args.length === 3
         ? Visit(args[0], args[1], args[2])

package/build/import/value/create/create.d.mts

@@ -25,5 +25,7 @@ export declare class ValueCreateRecursiveInstantiationError extends Error {
     readonly recursiveMaxDepth: number;
     constructor(schema: TSchema, recursiveMaxDepth: number);
 }
+/** Creates a value from the given schema and references */
 export declare function Create<T extends TSchema>(schema: T, references: TSchema[]): Static<T>;
+/** Creates a value from the given schema */
 export declare function Create<T extends TSchema>(schema: T): Static<T>;

package/build/import/value/create/create.mjs

@@ -5,6 +5,9 @@ import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGene
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index.mjs';
 import { TypeRegistry } from '../../type/registry/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValueCreateUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -49,6 +52,9 @@ export class ValueCreateRecursiveInstantiationError extends Error {
         this.recursiveMaxDepth = recursiveMaxDepth;
     }
 }
+// ------------------------------------------------------------------
+// Create
+// ------------------------------------------------------------------
 function TAny(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
@@ -157,6 +163,13 @@ function TIntersect(schema, references) {
         return schema.default;
     }
     else {
+        // --------------------------------------------------------------
+        // Note: The best we can do here is attempt to instance each
+        // sub type and apply through object assign. For non-object
+        // sub types, we just escape the assignment and just return
+        // the value. In the latter case, this is typically going to
+        // be a consequence of an illogical intersection.
+        // --------------------------------------------------------------
         const value = schema.allOf.reduce((acc, schema) => {
             const next = Visit(schema, references);
             return typeof next === 'object' ? { ...acc, ...next } : next;
@@ -452,8 +465,12 @@ function Visit(schema, references) {
             return TKind(schema_, references_);
     }
 }
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
 const recursiveMaxDepth = 512;
 let recursiveDepth = 0;
+/** Creates a value from the given schema */
 export function Create(...args) {
     recursiveDepth = 0;
     return args.length === 2 ? Visit(args[0], args[1]) : Visit(args[0], []);

package/build/import/value/default/default.d.mts

@@ -1,3 +1,5 @@
 import type { TSchema } from '../../type/schema/index.mjs';
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, references: TSchema[], value: unknown): unknown;
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export declare function Default<T extends TSchema>(schema: T, value: unknown): unknown;

package/build/import/value/default/default.mjs

@@ -3,15 +3,27 @@ import { TSchema as IsSchemaType } from '../../type/guard/type.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
+// ------------------------------------------------------------------
+// ValueOrDefault
+// ------------------------------------------------------------------
 function ValueOrDefault(schema, value) {
     return !(value === undefined) || !('default' in schema) ? value : schema.default;
 }
+// ------------------------------------------------------------------
+// IsCheckable
+// ------------------------------------------------------------------
 function IsCheckable(schema) {
     return IsSchemaType(schema) && schema[Kind] !== 'Unsafe';
 }
+// ------------------------------------------------------------------
+// IsDefaultSchema
+// ------------------------------------------------------------------
 function IsDefaultSchema(value) {
     return IsSchemaType(value) && 'default' in value;
 }
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
 function TArray(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsArray(defaulted))
@@ -34,13 +46,16 @@ function TObject(schema, references, value) {
         return defaulted;
     const additionalPropertiesSchema = schema.additionalProperties;
     const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+    // properties
     for (const key of knownPropertyKeys) {
         if (!IsDefaultSchema(schema.properties[key]))
             continue;
         defaulted[key] = Visit(schema.properties[key], references, defaulted[key]);
     }
+    // return if not additional properties
     if (!IsDefaultSchema(additionalPropertiesSchema))
         return defaulted;
+    // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKeys.includes(key))
             continue;
@@ -55,13 +70,16 @@ function TRecord(schema, references, value) {
     const additionalPropertiesSchema = schema.additionalProperties;
     const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0];
     const knownPropertyKey = new RegExp(propertyKeyPattern);
+    // properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (!(knownPropertyKey.test(key) && IsDefaultSchema(propertySchema)))
             continue;
         defaulted[key] = Visit(propertySchema, references, defaulted[key]);
     }
+    // return if not additional properties
     if (!IsDefaultSchema(additionalPropertiesSchema))
         return defaulted;
+    // additional properties
     for (const key of Object.getOwnPropertyNames(defaulted)) {
         if (knownPropertyKey.test(key))
             continue;
@@ -120,6 +138,7 @@ function Visit(schema, references, value) {
             return ValueOrDefault(schema_, value);
     }
 }
+/** `[Mutable]` Generates missing properties on a value using default schema annotations if available. This function does not check the value and returns an unknown type. You should Check the result before use. Default is a mutable operation. To avoid mutation, Clone the value first. */
 export function Default(...args) {
     return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
 }

package/build/import/value/delta/delta.mjs

@@ -21,6 +21,9 @@ export const Delete = CreateObject({
     path: CreateString(),
 });
 export const Edit = CreateUnion([Insert, Update, Delete]);
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValueDeltaObjectWithSymbolKeyError extends Error {
     key;
     constructor(key) {
@@ -35,6 +38,9 @@ export class ValueDeltaUnableToDiffUnknownValue extends Error {
         this.value = value;
     }
 }
+// ------------------------------------------------------------------
+// Command Factory
+// ------------------------------------------------------------------
 function CreateUpdate(path, value) {
     return { type: 'update', path, value };
 }
@@ -44,6 +50,9 @@ function CreateInsert(path, value) {
 function CreateDelete(path) {
     return { type: 'delete', path };
 }
+// ------------------------------------------------------------------
+// Diffing Generators
+// ------------------------------------------------------------------
 function* ObjectType(path, current, next) {
     if (!IsPlainObject(next))
         return yield CreateUpdate(path, next);
@@ -115,9 +124,15 @@ function* Visit(path, current, next) {
         return yield* ValueType(path, current, next);
     throw new ValueDeltaUnableToDiffUnknownValue(current);
 }
+// ------------------------------------------------------------------
+// Diff
+// ------------------------------------------------------------------
 export function Diff(current, next) {
     return [...Visit('', current, next)];
 }
+// ------------------------------------------------------------------
+// Patch
+// ------------------------------------------------------------------
 function IsRootUpdate(edits) {
     return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
 }

package/build/import/value/deref/deref.d.mts

@@ -5,4 +5,5 @@ export declare class TypeDereferenceError extends Error {
     readonly schema: TRef | TThis;
     constructor(schema: TRef | TThis);
 }
+/** Dereferences a schema from the references array or throws if not found */
 export declare function Deref(schema: TRef | TThis, references: TSchema[]): TSchema;

package/build/import/value/deref/deref.mjs

@@ -5,6 +5,7 @@ export class TypeDereferenceError extends Error {
         this.schema = schema;
     }
 }
+/** Dereferences a schema from the references array or throws if not found */
 export function Deref(schema, references) {
     const index = references.findIndex((target) => target.$id === schema.$ref);
     if (index === -1)

package/build/import/value/equal/equal.d.mts

@@ -1 +1,2 @@
+/** Returns true if the left value deep-equals the right */
 export declare function Equal<T>(left: T, right: unknown): right is T;

package/build/import/value/equal/equal.mjs

@@ -1,4 +1,7 @@
 import { IsPlainObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Equality Checks
+// ------------------------------------------------------------------
 function ObjectType(left, right) {
     if (!IsPlainObject(right))
         return false;
@@ -24,6 +27,10 @@ function TypedArrayType(left, right) {
 function ValueType(left, right) {
     return left === right;
 }
+// ------------------------------------------------------------------
+// Equal
+// ------------------------------------------------------------------
+/** Returns true if the left value deep-equals the right */
 export function Equal(left, right) {
     if (IsPlainObject(left))
         return ObjectType(left, right);

package/build/import/value/guard/guard.d.mts

@@ -2,23 +2,43 @@ export type ObjectType = Record<PropertyKey, unknown>;
 export type ArrayType = unknown[];
 export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
 export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/** Returns true if this value is an async iterator */
 export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
+/** Returns true if this value is an iterator */
 export declare function IsIterator(value: unknown): value is IterableIterator<any>;
+/** Returns true if this value is a typed array */
 export declare function IsTypedArray(value: unknown): value is TypedArrayType;
+/** Returns true if this value is a Promise */
 export declare function IsPromise(value: unknown): value is Promise<unknown>;
+/** Returns true if the value is a Uint8Array */
 export declare function IsUint8Array(value: unknown): value is Uint8Array;
+/** Returns true if this value is a Date */
 export declare function IsDate(value: unknown): value is Date;
+/** Returns true if this value has this property key */
 export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is ObjectType & Record<K, unknown>;
+/** Returns true if this object is not an instance of any other type */
 export declare function IsPlainObject(value: unknown): value is ObjectType;
+/** Returns true of this value is an object type */
 export declare function IsObject(value: unknown): value is ObjectType;
+/** Returns true if this value is an array, but not a typed array */
 export declare function IsArray(value: unknown): value is ArrayType;
+/** Returns true if this value is an undefined */
 export declare function IsUndefined(value: unknown): value is undefined;
+/** Returns true if this value is an null */
 export declare function IsNull(value: unknown): value is null;
+/** Returns true if this value is an boolean */
 export declare function IsBoolean(value: unknown): value is boolean;
+/** Returns true if this value is an number */
 export declare function IsNumber(value: unknown): value is number;
+/** Returns true if this value is an integer */
 export declare function IsInteger(value: unknown): value is number;
+/** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
+/** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
+/** Returns true if this value is a function */
 export declare function IsFunction(value: unknown): value is Function;
+/** Returns true if this value is a symbol */
 export declare function IsSymbol(value: unknown): value is symbol;
+/** Returns true if this value is a value type such as number, string, boolean */
 export declare function IsValueType(value: unknown): value is ValueType;

package/build/import/value/guard/guard.mjs

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

package/build/import/value/hash/hash.d.mts

@@ -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/import/value/hash/hash.mjs

@@ -1,4 +1,7 @@
 import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsPlainObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValueHashError extends Error {
     value;
     constructor(value) {
@@ -6,6 +9,9 @@ export class ValueHashError extends Error {
         this.value = value;
     }
 }
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
 var ByteMarker;
 (function (ByteMarker) {
     ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
@@ -20,18 +26,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) {
@@ -120,6 +135,10 @@ function FNV1A64(byte) {
     Accumulator = Accumulator ^ Bytes[byte];
     Accumulator = (Accumulator * Prime) % Size;
 }
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value) {
     Accumulator = BigInt('14695981039346656037');
     Visit(value);

package/build/import/value/index.mjs

@@ -1,4 +1,10 @@
+// ------------------------------------------------------------------
+// Value Errors (re-export)
+// ------------------------------------------------------------------
 export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
+// ------------------------------------------------------------------
+// Value Operators
+// ------------------------------------------------------------------
 export { Cast, ValueCastArrayUniqueItemsTypeError, ValueCastNeverTypeError, ValueCastRecursiveTypeError, ValueCastUnknownTypeError } from './cast/index.mjs';
 export { Check } from './check/index.mjs';
 export { Clean } from './clean/index.mjs';
@@ -12,5 +18,11 @@ export { Hash, ValueHashError } from './hash/index.mjs';
 export { Mutate, ValueMutateInvalidRootMutationError, ValueMutateTypeMismatchError } from './mutate/index.mjs';
 export { ValuePointer } from './pointer/index.mjs';
 export { TransformDecode as DecodeTransform, TransformEncode as EncodeTransform, HasTransform, TransformDecodeCheckError, TransformDecodeError, TransformEncodeCheckError, TransformEncodeError } from './transform/index.mjs';
+// ------------------------------------------------------------------
+// Value Guards
+// ------------------------------------------------------------------
 export { HasPropertyKey, IsArray, IsAsyncIterator, IsBigInt, IsBoolean, IsDate, IsFunction, IsInteger, IsIterator, IsNull, IsNumber, IsObject, IsPlainObject, IsPromise, IsString, IsSymbol, IsTypedArray, IsUint8Array, IsUndefined, IsValueType, } from './guard/index.mjs';
+// ------------------------------------------------------------------
+// Value Namespace
+// ------------------------------------------------------------------
 export { Value } from './value/index.mjs';

package/build/import/value/mutate/mutate.d.mts

@@ -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/import/value/mutate/mutate.mjs

@@ -1,6 +1,9 @@
 import { IsPlainObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
 import { ValuePointer } from '../pointer/index.mjs';
 import { Clone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValueMutateTypeMismatchError extends Error {
     constructor() {
         super('Cannot assign due type mismatch of assignable values');
@@ -69,13 +72,21 @@ function Visit(root, path, current, next) {
     if (IsValueType(next))
         return ValueType(root, path, current, next);
 }
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
 function IsNonMutableValue(value) {
     return IsTypedArray(value) || IsValueType(value);
 }
 function IsMismatchedValue(current, next) {
+    // prettier-ignore
     return ((IsPlainObject(current) && IsArray(next)) ||
         (IsArray(current) && IsPlainObject(next)));
 }
+// ------------------------------------------------------------------
+// Mutate
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 export function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
         throw new ValueMutateInvalidRootMutationError();

package/build/import/value/pointer/pointer.d.mts

@@ -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/import/value/pointer/pointer.mjs

@@ -1,3 +1,6 @@
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 export class ValuePointerRootSetError extends Error {
     value;
     path;
@@ -18,9 +21,16 @@ export class ValuePointerRootDeleteError extends Error {
         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;
@@ -43,6 +53,8 @@ export function* Format(pointer) {
     }
     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);
@@ -56,6 +68,8 @@ export function Set(value, pointer, update) {
     }
     owner[key] = update;
 }
+/** Deletes a value at the given pointer */
+// prettier-ignore
 export function Delete(value, pointer) {
     if (pointer === '')
         throw new ValuePointerRootDeleteError(value, pointer);
@@ -75,6 +89,8 @@ export function Delete(value, pointer) {
         delete owner[key];
     }
 }
+/** Returns true if a value exists at the given pointer */
+// prettier-ignore
 export function Has(value, pointer) {
     if (pointer === '')
         return true;
@@ -88,6 +104,8 @@ export function Has(value, pointer) {
     }
     return Object.getOwnPropertyNames(owner).includes(key);
 }
+/** Gets the value at the given pointer */
+// prettier-ignore
 export function Get(value, pointer) {
     if (pointer === '')
         return value;