typebox 1.0.33 → 1.0.34

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

@@ -1,17 +0,0 @@
-"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("./errors"), exports);

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

@@ -1,6 +0,0 @@
-/**
- * Computes a unique 64-bit hash of the specified value and returns the hex string representation. This
- * function internally uses a non-cryptographic FNV1A64 algorithm for hashing. Hashing is implemented
- * via structural traversal of the value.
- */
-export declare function Hash(value: unknown): string;

package/build/cjs/value/hash/hash.js

@@ -1,13 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hash = Hash;
-const index_1 = require("../../system/hashing/index");
-/**
- * Computes a unique 64-bit hash of the specified value and returns the hex string representation. This
- * function internally uses a non-cryptographic FNV1A64 algorithm for hashing. Hashing is implemented
- * via structural traversal of the value.
- */
-function Hash(value) {
-    return index_1.Hashing.Hash(value);
-}

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

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

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

@@ -1,17 +0,0 @@
-"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("./hash"), exports);

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

@@ -1,20 +0,0 @@
-export * from './assert/index';
-export * from './check/index';
-export * from './clean/index';
-export * from './clone/index';
-export * from './codec/index';
-export * from './convert/index';
-export * from './create/index';
-export * from './errors/index';
-export * from './default/index';
-export * from './equal/index';
-export * from './hash/index';
-export * from './mutate/index';
-export * from './parse/index';
-export * from './delta/index';
-export * from './pipeline/index';
-export * from './pointer/index';
-export * from './repair/index';
-import * as Value from './value';
-export * as Value from './value';
-export default Value;

package/build/cjs/value/index.js

@@ -1,43 +0,0 @@
-"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 });
-exports.Value = void 0;
-// ------------------------------------------------------------------
-// Functions
-// ------------------------------------------------------------------
-__exportStar(require("./assert/index"), exports);
-__exportStar(require("./check/index"), exports);
-__exportStar(require("./clean/index"), exports);
-__exportStar(require("./clone/index"), exports);
-__exportStar(require("./codec/index"), exports);
-__exportStar(require("./convert/index"), exports);
-__exportStar(require("./create/index"), exports);
-__exportStar(require("./errors/index"), exports);
-__exportStar(require("./default/index"), exports);
-__exportStar(require("./equal/index"), exports);
-__exportStar(require("./hash/index"), exports);
-__exportStar(require("./mutate/index"), exports);
-__exportStar(require("./parse/index"), exports);
-__exportStar(require("./delta/index"), exports);
-__exportStar(require("./pipeline/index"), exports);
-__exportStar(require("./pointer/index"), exports);
-__exportStar(require("./repair/index"), exports);
-// ------------------------------------------------------------------
-// Default
-// ------------------------------------------------------------------
-const Value = require("./value");
-exports.Value = require("./value");
-exports.default = Value;

package/build/cjs/value/mutate/error.d.ts

@@ -1,3 +0,0 @@
-export declare class MutateError extends Error {
-    constructor(message: string);
-}

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

@@ -1,10 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MutateError = void 0;
-class MutateError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-exports.MutateError = MutateError;

package/build/cjs/value/mutate/from-array.d.ts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate';
-export declare function FromArray(root: TMutable, path: string, current: unknown, next: unknown[]): void;

package/build/cjs/value/mutate/from-array.js

@@ -1,19 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromArray = FromArray;
-const index_1 = require("../../guard/index");
-const index_2 = require("../clone/index");
-const index_3 = require("../pointer/index");
-const from_value_1 = require("./from-value");
-function FromArray(root, path, current, next) {
-    if (!index_1.Guard.IsArray(current)) {
-        index_3.Pointer.Set(root, path, (0, index_2.Clone)(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            (0, from_value_1.FromValue)(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}

package/build/cjs/value/mutate/from-object.d.ts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate';
-export declare function FromObject(root: TMutable, path: string, current: unknown, next: Record<string, unknown>): void;

package/build/cjs/value/mutate/from-object.js

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromObject = FromObject;
-const index_1 = require("../../guard/index");
-const index_2 = require("../pointer/index");
-const index_3 = require("../clone/index");
-const from_value_1 = require("./from-value");
-function FromObject(root, path, current, next) {
-    if (!index_1.Guard.IsObjectNotArray(current)) {
-        index_2.Pointer.Set(root, path, (0, index_3.Clone)(next));
-    }
-    else {
-        const currentKeys = index_1.Guard.Keys(current);
-        const nextKeys = index_1.Guard.Keys(next);
-        for (const currentKey of currentKeys) {
-            if (!nextKeys.includes(currentKey)) {
-                delete current[currentKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            if (!currentKeys.includes(nextKey)) {
-                current[nextKey] = next[nextKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            (0, from_value_1.FromValue)(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}

package/build/cjs/value/mutate/from-unknown.d.ts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate';
-export declare function FromUnknown(root: TMutable, path: string, current: unknown, next: unknown): void;

package/build/cjs/value/mutate/from-unknown.js

@@ -1,10 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromUnknown = FromUnknown;
-const index_1 = require("../pointer/index");
-function FromUnknown(root, path, current, next) {
-    if (current === next)
-        return;
-    index_1.Pointer.Set(root, path, next);
-}

package/build/cjs/value/mutate/from-value.d.ts

@@ -1,2 +0,0 @@
-import { type TMutable } from './mutate';
-export declare function FromValue(root: TMutable, path: string, current: unknown, next: unknown): void;

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

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromValue = FromValue;
-const index_1 = require("../../guard/index");
-const from_array_1 = require("./from-array");
-const from_object_1 = require("./from-object");
-const from_unknown_1 = require("./from-unknown");
-function FromValue(root, path, current, next) {
-    if (index_1.Guard.IsArray(next))
-        return (0, from_array_1.FromArray)(root, path, current, next);
-    if (index_1.Guard.IsObject(next))
-        return (0, from_object_1.FromObject)(root, path, current, next);
-    return (0, from_unknown_1.FromUnknown)(root, path, current, next);
-}

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

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

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

@@ -1,17 +0,0 @@
-"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("./mutate"), exports);

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

@@ -1,9 +0,0 @@
-export type TMutable = {
-    [key: string]: unknown;
-} | unknown[];
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- */
-export declare function Mutate(current: TMutable, next: TMutable): void;

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

@@ -1,42 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mutate = Mutate;
-const index_1 = require("../../guard/index");
-const error_1 = require("./error");
-const from_value_1 = require("./from-value");
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return index_1.GlobalsGuard.IsTypeArray(value)
-        || index_1.GlobalsGuard.IsDate(value)
-        || index_1.GlobalsGuard.IsMap(value)
-        || index_1.GlobalsGuard.IsSet(value)
-        || index_1.Guard.IsNumber(value)
-        || index_1.Guard.IsString(value)
-        || index_1.Guard.IsBoolean(value)
-        || index_1.Guard.IsSymbol(value);
-}
-// ------------------------------------------------------------------
-// IsTrueObject
-// ------------------------------------------------------------------
-function IsMismatchedValue(left, right) {
-    return ((index_1.Guard.IsObjectNotArray(left) && index_1.Guard.IsArray(right)) ||
-        (index_1.Guard.IsArray(left) && index_1.Guard.IsObjectNotArray(right)));
-}
-// ------------------------------------------------------------------
-// Mutate
-// ------------------------------------------------------------------
-/**
- * Performs a deep structural assignment, applying values from next to current while retaining internal references. This function
- * is written for use in infrastructure that interprets reference changes as a signal to perform some action (i.e. React redraw), this
- * function can mitigate this by applying mutable updates deep within a value, ensuring parent references are retained.
- */
-function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new error_1.MutateError('Only object and array types can be mutated at the root level');
-    if (IsMismatchedValue(current, next))
-        throw new error_1.MutateError('Cannot assign due type mismatch of assignable values');
-    (0, from_value_1.FromValue)(current, '', current, next);
-}

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

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

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

@@ -1,17 +0,0 @@
-"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

@@ -1,21 +0,0 @@
-import { type TLocalizedValidationError } from '../../error/errors';
-import { type TProperties, type TSchema, type StaticParse } from '../../type/index';
-import { AssertError } from '../assert/index';
-export declare class ParseError extends AssertError {
-    constructor(value: unknown, errors: TLocalizedValidationError[]);
-}
-export declare const Parser: import("../pipeline/pipeline").PipelineInterface;
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
-export declare function Parse<const Type extends TSchema, Result extends unknown = StaticParse<Type>>(type: Type, value: unknown): Result;
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
-export declare function Parse<Context extends TProperties, const Type extends TSchema, Result extends unknown = StaticParse<Type, Context>>(context: Context, type: Type, value: unknown): Result;

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

@@ -1,52 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = exports.ParseError = void 0;
-exports.Parse = Parse;
-const index_1 = require("../../system/arguments/index");
-const index_2 = require("../assert/index");
-const index_3 = require("../check/index");
-const index_4 = require("../errors/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");
-const index_9 = require("../pipeline/index");
-// ------------------------------------------------------------------
-// Assert
-// ------------------------------------------------------------------
-class ParseError extends index_2.AssertError {
-    constructor(value, errors) {
-        super('Parse', value, errors);
-    }
-}
-exports.ParseError = ParseError;
-function Assert(context, type, value) {
-    if (!(0, index_3.Check)(context, type, value))
-        throw new ParseError(value, (0, index_4.Errors)(context, type, value));
-    return value;
-}
-// ------------------------------------------------------------------
-// Parser
-// ------------------------------------------------------------------
-exports.Parser = (0, index_9.Pipeline)([
-    (_context, _type, value) => (0, index_6.Clone)(value),
-    (context, type, value) => (0, index_8.Default)(context, type, value),
-    (context, type, value) => (0, index_7.Convert)(context, type, value),
-    (context, type, value) => (0, index_5.Clean)(context, type, value),
-    (context, type, value) => Assert(context, type, value)
-]);
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
-function Parse(...args) {
-    const [context, type, value] = index_1.Arguments.Match(args, {
-        3: (context, type, value) => [context, type, value],
-        2: (type, value) => [{}, type, value],
-    });
-    const result = (0, index_3.Check)(context, type, value) ? value : (0, exports.Parser)(context, type, value);
-    return result;
-}

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

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

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

@@ -1,17 +0,0 @@
-"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("./pipeline"), exports);

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

@@ -1,10 +0,0 @@
-import { type TProperties, type TSchema } from '../../type/index';
-export interface PipelineFunction {
-    (context: TProperties, schema: TSchema, value: unknown): unknown;
-}
-export interface PipelineInterface {
-    (schema: TSchema, value: unknown): unknown;
-    (context: TProperties, schema: TSchema, value: unknown): unknown;
-}
-/** Creates a value processing pipeline. */
-export declare function Pipeline(pipeline: PipelineFunction[]): PipelineInterface;

package/build/cjs/value/pipeline/pipeline.js

@@ -1,18 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pipeline = Pipeline;
-const index_1 = require("../../system/arguments/index");
-// ------------------------------------------------------------------
-// Pipeline
-// ------------------------------------------------------------------
-/** Creates a value processing pipeline. */
-function Pipeline(pipeline) {
-    return (...args) => {
-        const [context, type, value] = index_1.Arguments.Match(args, {
-            3: (context, type, value) => [context, type, value],
-            2: (type, value) => [{}, type, value],
-        });
-        return pipeline.reduce((result, func) => func(context, type, result), value);
-    };
-}

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

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

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

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

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

@@ -1,17 +0,0 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Transforms a pointer into navigable key components */
-export declare function Format(pointer: string): IterableIterator<string>;
-/**
- * Sets the value at the given pointer and returns the updated value. If the pointer
- * path does not exist, the path will be created.
- */
-export declare function Set(value: ObjectLike, pointer: string, update: unknown): ObjectLike;
-/**
- * Deletes a value at the given pointer and returns the updated value.
- */
-export declare function Delete(value: ObjectLike, pointer: string): ObjectLike;
-/** Returns true if a property or element exists at the given pointer */
-export declare function Has(value: ObjectLike, pointer: string): boolean;
-/** Gets the value at the given pointer or undefined if not exists. */
-export declare function Get(value: ObjectLike, pointer: string): unknown | undefined;
-export {};

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

@@ -1,144 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Format = Format;
-exports.Set = Set;
-exports.Delete = Delete;
-exports.Has = Has;
-exports.Get = Get;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValuePointerRootSetError extends Error {
-    constructor(value, path, update) {
-        super('Cannot set root value');
-        this.value = value;
-        this.path = path;
-        this.update = update;
-    }
-}
-class ValuePointerRootDeleteError extends Error {
-    constructor(value, path) {
-        super('Cannot delete root value');
-        this.value = value;
-        this.path = path;
-    }
-}
-// ------------------------------------------------------------------
-// ValuePointer
-// ------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-function Escape(component) {
-    const decoded = decodeURIComponent(component);
-    return decoded.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-// ------------------------------------------------------------------
-// Format
-// ------------------------------------------------------------------
-/** Transforms a pointer into navigable key components */
-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));
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-/**
- * Sets the value at the given pointer and returns the updated value. If the pointer
- * path does not exist, the path will be created.
- */
-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 (index_1.Guard.IsUndefined(next[component]))
-            next[component] = {};
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (index_1.Guard.IsObject(owner)) {
-        owner[key] = update;
-    }
-    return value;
-}
-// ------------------------------------------------------------------
-// Delete
-// ------------------------------------------------------------------
-/**
- * Deletes a value at the given pointer and returns the updated value.
- */
-function Delete(value, pointer) {
-    if (pointer === '')
-        throw new ValuePointerRootDeleteError(value, pointer);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (index_1.Guard.IsUndefined(next[component]) || index_1.Guard.IsNull(next[component])) {
-            return value;
-        }
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (index_1.Guard.IsArray(owner)) {
-        const index = parseInt(key);
-        owner.splice(index, 1);
-    }
-    else if (index_1.Guard.IsObject(owner)) {
-        delete owner[key];
-    }
-    return value;
-}
-// ------------------------------------------------------------------
-// Has
-// ------------------------------------------------------------------
-/** Returns true if a property or element exists at the given pointer */
-function Has(value, pointer) {
-    if (pointer === '')
-        return true;
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (index_1.Guard.IsUndefined(next[component]) || index_1.Guard.IsNull(next[component])) {
-            return false;
-        }
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    return Object.getOwnPropertyNames(owner).includes(key);
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-/** Gets the value at the given pointer or undefined if not exists. */
-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/repair/error.d.ts

@@ -1,7 +0,0 @@
-import type { TProperties, TSchema } from '../../type/index';
-export declare class RepairError extends Error {
-    readonly context: TProperties;
-    readonly type: TSchema;
-    readonly value: unknown;
-    constructor(context: TProperties, type: TSchema, value: unknown, message: string);
-}