@depup/typebox 1.1.21-depup.0 → 1.3.8-depup.0

package/build/value/convert/from-array.mjs

@@ -1,8 +0,0 @@
-// deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
-import { Guard } from '../../guard/index.mjs';
-export function FromArray(context, type, value) {
-    return Guard.IsArray(value)
-        ? value.map(value => FromType(context, type.items, value))
-        : value;
-}

package/build/value/convert/from-base.d.mts

@@ -1,2 +0,0 @@
-import type { Base, TProperties } from '../../type/index.mjs';
-export declare function FromBase(_context: TProperties, type: Base, value: unknown): unknown;

package/build/value/convert/from-base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type, value) {
-    return type.Convert(value);
-}

package/build/value/convert/from-enum.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
-import { FromUnion } from './from-union.mjs';
-export function FromEnum(context, type, value) {
-    const union = EnumToUnion(type);
-    return FromUnion(context, union, value);
-}

package/build/value/convert/from-type.mjs

@@ -1,45 +0,0 @@
-// deno-fmt-ignore-file
-import * as T from '../../type/index.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromBase } from './from-base.mjs';
-import { FromBigInt } from './from-bigint.mjs';
-import { FromBoolean } from './from-boolean.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromEnum } from './from-enum.mjs';
-import { FromInteger } from './from-integer.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromLiteral } from './from-literal.mjs';
-import { FromNull } from './from-null.mjs';
-import { FromNumber } from './from-number.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromRef } from './from-ref.mjs';
-import { FromString } from './from-string.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUndefined } from './from-undefined.mjs';
-import { FromUnion } from './from-union.mjs';
-import { FromVoid } from './from-void.mjs';
-export function FromType(context, type, value) {
-    return (T.IsArray(type) ? FromArray(context, type, value) :
-        T.IsBase(type) ? FromBase(context, type, value) :
-            T.IsBigInt(type) ? FromBigInt(context, type, value) :
-                T.IsBoolean(type) ? FromBoolean(context, type, value) :
-                    T.IsCyclic(type) ? FromCyclic(context, type, value) :
-                        T.IsEnum(type) ? FromEnum(context, type, value) :
-                            T.IsInteger(type) ? FromInteger(context, type, value) :
-                                T.IsIntersect(type) ? FromIntersect(context, type, value) :
-                                    T.IsLiteral(type) ? FromLiteral(context, type, value) :
-                                        T.IsNull(type) ? FromNull(context, type, value) :
-                                            T.IsNumber(type) ? FromNumber(context, type, value) :
-                                                T.IsObject(type) ? FromObject(context, type, value) :
-                                                    T.IsRecord(type) ? FromRecord(context, type, value) :
-                                                        T.IsRef(type) ? FromRef(context, type, value) :
-                                                            T.IsString(type) ? FromString(context, type, value) :
-                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
-                                                                    T.IsTuple(type) ? FromTuple(context, type, value) :
-                                                                        T.IsUndefined(type) ? FromUndefined(context, type, value) :
-                                                                            T.IsUnion(type) ? FromUnion(context, type, value) :
-                                                                                T.IsVoid(type) ? FromVoid(context, type, value) :
-                                                                                    value);
-}

package/build/value/convert/try/try-number.mjs

@@ -1,76 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail, IsOk } from './try-result.mjs';
-// ------------------------------------------------------------------
-// Two-Phase
-// ------------------------------------------------------------------
-import { TryBigInt } from './try-bigint.mjs';
-// ------------------------------------------------------------------
-// BigInt
-// ------------------------------------------------------------------
-const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
-const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
-function CanBigIntDowncast(value) {
-    return (value <= maxBigInt && value >= minBigInt);
-}
-function FromBigInt(value) {
-    return CanBigIntDowncast(value) ? Ok(Number(value)) : Fail();
-}
-// ------------------------------------------------------------------
-// Boolean
-// ------------------------------------------------------------------
-function FromBoolean(value) {
-    return value ? Ok(1) : Ok(0);
-}
-// ------------------------------------------------------------------
-// Number
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromNumber(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok(0);
-}
-// ------------------------------------------------------------------
-// String
-// ------------------------------------------------------------------
-function FromString(value) {
-    const coerced = +value;
-    if (Guard.IsNumber(coerced))
-        return Ok(coerced);
-    const lowercase = value.toLowerCase();
-    if (Guard.IsEqual(lowercase, 'false'))
-        return Ok(0);
-    if (Guard.IsEqual(lowercase, 'true'))
-        return Ok(1);
-    const result = TryBigInt(value);
-    if (IsOk(result))
-        return FromBigInt(result.value);
-    return Fail();
-}
-// ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok(0);
-}
-// ------------------------------------------------------------------
-// Try
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-export function TryNumber(value) {
-    return (Guard.IsBigInt(value) ? FromBigInt(value) :
-        Guard.IsBoolean(value) ? FromBoolean(value) :
-            Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
-                    Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
-                            Fail());
-}
-// deno-coverage-ignore-stop

package/build/value/convert/try/try-string.mjs

@@ -1,56 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../../guard/index.mjs';
-import { Ok, Fail } from './try-result.mjs';
-// ------------------------------------------------------------------
-// BigInt
-// ------------------------------------------------------------------
-function FromBigInt(value) {
-    return Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Boolean
-// ------------------------------------------------------------------
-function FromBoolean(value) {
-    return Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Number
-// ------------------------------------------------------------------
-function FromNumber(value) {
-    return Ok(value.toString());
-}
-// ------------------------------------------------------------------
-// Null
-// ------------------------------------------------------------------
-function FromNull(value) {
-    return Ok('null');
-}
-// ------------------------------------------------------------------
-// String
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-function FromString(value) {
-    return Ok(value);
-}
-// deno-coverage-ignore-stop
-// ------------------------------------------------------------------
-// Undefined
-// ------------------------------------------------------------------
-function FromUndefined(value) {
-    return Ok('');
-}
-// ------------------------------------------------------------------
-// Try
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - unreachable | guarded
-export function TryString(value) {
-    return (Guard.IsBigInt(value) ? FromBigInt(value) :
-        Guard.IsBoolean(value) ? FromBoolean(value) :
-            Guard.IsNumber(value) ? FromNumber(value) :
-                Guard.IsNull(value) ? FromNull(value) :
-                    Guard.IsString(value) ? FromString(value) :
-                        Guard.IsUndefined(value) ? FromUndefined(value) :
-                            Fail());
-}
-// deno-coverage-ignore-stop

package/build/value/create/from-async-iterator.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TAsyncIterator } from '../../type/index.mjs';
-export declare function FromAsyncIterator(_context: TProperties, _type: TAsyncIterator): unknown;

package/build/value/create/from-async-iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-async function* CreateAsyncIterator() { }
-export function FromAsyncIterator(_context, _type) {
-    return CreateAsyncIterator();
-}

package/build/value/create/from-base.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, Base } from '../../type/index.mjs';
-export declare function FromBase(_context: TProperties, type: Base): unknown;

package/build/value/create/from-base.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromBase(_context, type) {
-    return type.Create();
-}

package/build/value/create/from-enum.mjs

@@ -1,6 +0,0 @@
-// deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
-import { FromType } from './from-type.mjs';
-export function FromEnum(context, type) {
-    return FromType(context, EnumToUnion(type));
-}

package/build/value/create/from-iterator.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TIterator } from '../../type/index.mjs';
-export declare function FromIterator(_context: TProperties, _type: TIterator): unknown;

package/build/value/create/from-iterator.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-function* CreateIterator() { }
-export function FromIterator(_context, _type) {
-    return CreateIterator();
-}

package/build/value/create/from-promise.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, TPromise } from '../../type/index.mjs';
-export declare function FromPromise(context: TProperties, type: TPromise): unknown;

package/build/value/create/from-promise.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-import { FromType } from './from-type.mjs';
-export function FromPromise(context, type) {
-    return Promise.resolve(FromType(context, type.item));
-}

package/build/value/create/from-type.mjs

@@ -1,69 +0,0 @@
-// deno-fmt-ignore-file
-import * as T from '../../type/index.mjs';
-import * as S from '../../schema/types/index.mjs';
-import { FromDefault } from './from-default.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromAsyncIterator } from './from-async-iterator.mjs';
-import { FromBase } from './from-base.mjs';
-import { FromBigInt } from './from-bigint.mjs';
-import { FromBoolean } from './from-boolean.mjs';
-import { FromConstructor } from './from-constructor.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromEnum } from './from-enum.mjs';
-import { FromFunction } from './from-function.mjs';
-import { FromInteger } from './from-integer.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromIterator } from './from-iterator.mjs';
-import { FromLiteral } from './from-literal.mjs';
-import { FromNever } from './from-never.mjs';
-import { FromNull } from './from-null.mjs';
-import { FromNumber } from './from-number.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromPromise } from './from-promise.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromRef } from './from-ref.mjs';
-import { FromString } from './from-string.mjs';
-import { FromSymbol } from './from-symbol.mjs';
-import { FromTemplateLiteral } from './from-template-literal.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUndefined } from './from-undefined.mjs';
-import { FromUnion } from './from-union.mjs';
-import { FromVoid } from './from-void.mjs';
-export function FromType(context, type) {
-    return (
-    // -----------------------------------------------------
-    // Default
-    // -----------------------------------------------------
-    S.IsDefault(type) ? FromDefault(context, type) :
-        // -----------------------------------------------------
-        // Types
-        // -----------------------------------------------------
-        T.IsArray(type) ? FromArray(context, type) :
-            T.IsAsyncIterator(type) ? FromAsyncIterator(context, type) :
-                T.IsBase(type) ? FromBase(context, type) :
-                    T.IsBigInt(type) ? FromBigInt(context, type) :
-                        T.IsBoolean(type) ? FromBoolean(context, type) :
-                            T.IsConstructor(type) ? FromConstructor(context, type) :
-                                T.IsCyclic(type) ? FromCyclic(context, type) :
-                                    T.IsEnum(type) ? FromEnum(context, type) :
-                                        T.IsFunction(type) ? FromFunction(context, type) :
-                                            T.IsInteger(type) ? FromInteger(context, type) :
-                                                T.IsIntersect(type) ? FromIntersect(context, type) :
-                                                    T.IsIterator(type) ? FromIterator(context, type) :
-                                                        T.IsLiteral(type) ? FromLiteral(context, type) :
-                                                            T.IsNever(type) ? FromNever(context, type) :
-                                                                T.IsNull(type) ? FromNull(context, type) :
-                                                                    T.IsNumber(type) ? FromNumber(context, type) :
-                                                                        T.IsObject(type) ? FromObject(context, type) :
-                                                                            T.IsPromise(type) ? FromPromise(context, type) :
-                                                                                T.IsRecord(type) ? FromRecord(context, type) :
-                                                                                    T.IsRef(type) ? FromRef(context, type) :
-                                                                                        T.IsString(type) ? FromString(context, type) :
-                                                                                            T.IsSymbol(type) ? FromSymbol(context, type) :
-                                                                                                T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type) :
-                                                                                                    T.IsTuple(type) ? FromTuple(context, type) :
-                                                                                                        T.IsUndefined(type) ? FromUndefined(context, type) :
-                                                                                                            T.IsUnion(type) ? FromUnion(context, type) :
-                                                                                                                T.IsVoid(type) ? FromVoid(context, type) :
-                                                                                                                    undefined);
-}

package/build/value/default/from-base.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, Base } from '../../type/index.mjs';
-export declare function FromBase(context: TProperties, type: Base, value: unknown): unknown;

package/build/value/default/from-base.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file 
-export function FromBase(context, type, value) {
-    return type.Default(value);
-}

package/build/value/default/from-intersect.d.mts

@@ -1,2 +0,0 @@
-import { TProperties, TIntersect } from '../../type/index.mjs';
-export declare function FromIntersect(context: TProperties, type: TIntersect, value: unknown): unknown;

package/build/value/default/from-type.mjs

@@ -1,27 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { IsDefault } from '../../schema/index.mjs';
-import * as T from '../../type/index.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromBase } from './from-base.mjs';
-import { FromCyclic } from './from-cyclic.mjs';
-import { FromDefault } from './from-default.mjs';
-import { FromIntersect } from './from-intersect.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromRecord } from './from-record.mjs';
-import { FromRef } from './from-ref.mjs';
-import { FromTuple } from './from-tuple.mjs';
-import { FromUnion } from './from-union.mjs';
-export function FromType(context, type, value) {
-    const defaulted = IsDefault(type) ? FromDefault(type, value) : value;
-    return (T.IsArray(type) ? FromArray(context, type, defaulted) :
-        T.IsBase(type) ? FromBase(context, type, defaulted) :
-            T.IsCyclic(type) ? FromCyclic(context, type, defaulted) :
-                T.IsIntersect(type) ? FromIntersect(context, type, defaulted) :
-                    T.IsObject(type) ? FromObject(context, type, defaulted) :
-                        T.IsRecord(type) ? FromRecord(context, type, defaulted) :
-                            T.IsRef(type) ? FromRef(context, type, defaulted) :
-                                T.IsTuple(type) ? FromTuple(context, type, defaulted) :
-                                    T.IsUnion(type) ? FromUnion(context, type, defaulted) :
-                                        defaulted);
-}

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

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

package/build/value/mutate/error.mjs

@@ -1,6 +0,0 @@
-// deno-fmt-ignore-file
-export class MutateError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}

package/build/value/mutate/from-array.d.mts

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

package/build/value/mutate/from-array.mjs

@@ -1,16 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { FromValue } from './from-value.mjs';
-export function FromArray(root, path, current, next) {
-    if (!Guard.IsArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            FromValue(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}

package/build/value/mutate/from-object.d.mts

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

package/build/value/mutate/from-object.mjs

@@ -1,27 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { FromValue } from './from-value.mjs';
-export function FromObject(root, path, current, next) {
-    if (!Guard.IsObjectNotArray(current)) {
-        Pointer.Set(root, path, Clone(next));
-    }
-    else {
-        const currentKeys = Guard.Keys(current);
-        const nextKeys = 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) {
-            FromValue(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}

package/build/value/mutate/from-unknown.d.mts

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

package/build/value/mutate/from-unknown.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { Pointer } from '../pointer/index.mjs';
-export function FromUnknown(root, path, current, next) {
-    if (current === next)
-        return;
-    Pointer.Set(root, path, next);
-}

package/build/value/mutate/from-value.d.mts

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

package/build/value/mutate/from-value.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromArray } from './from-array.mjs';
-import { FromObject } from './from-object.mjs';
-import { FromUnknown } from './from-unknown.mjs';
-export function FromValue(root, path, current, next) {
-    if (Guard.IsArray(next))
-        return FromArray(root, path, current, next);
-    if (Guard.IsObject(next))
-        return FromObject(root, path, current, next);
-    return FromUnknown(root, path, current, next);
-}

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

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

package/build/value/mutate/index.mjs

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

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

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

@@ -1,39 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-import { MutateError } from './error.mjs';
-import { FromValue } from './from-value.mjs';
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return GlobalsGuard.IsTypeArray(value)
-        || GlobalsGuard.IsDate(value)
-        || GlobalsGuard.IsMap(value)
-        || GlobalsGuard.IsSet(value)
-        || Guard.IsNumber(value)
-        || Guard.IsString(value)
-        || Guard.IsBoolean(value)
-        || Guard.IsSymbol(value);
-}
-// ------------------------------------------------------------------
-// IsTrueObject
-// ------------------------------------------------------------------
-function IsMismatchedValue(left, right) {
-    return ((Guard.IsObjectNotArray(left) && Guard.IsArray(right)) ||
-        (Guard.IsArray(left) && 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.
- */
-export function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new MutateError('Only object and array types can be mutated at the root level');
-    if (IsMismatchedValue(current, next))
-        throw new MutateError('Cannot assign due type mismatch of assignable values');
-    FromValue(current, '', current, next);
-}

package/build/value/repair/from-base.d.mts

@@ -1,2 +0,0 @@
-import type { TProperties, Base } from '../../type/index.mjs';
-export declare function FromBase(context: TProperties, type: Base, value: unknown): unknown;

package/build/value/repair/from-base.mjs

@@ -1,8 +0,0 @@
-// deno-fmt-ignore-file
-import { FromUnknown } from './from-unknown.mjs';
-// ------------------------------------------------------------------
-// FromBase
-// ------------------------------------------------------------------
-export function FromBase(context, type, value) {
-    return FromUnknown(context, type, value);
-}

package/build/value/repair/from-enum.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { EnumToUnion } from '../../type/engine/enum/index.mjs';
-import { FromType } from './from-type.mjs';
-export function FromEnum(context, type, value) {
-    const union = EnumToUnion(type);
-    return FromType(context, union, value);
-}

package/build/value/repair/from-template-literal.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-import { TemplateLiteralDecode } from '../../type/engine/template-literal/index.mjs';
-import { FromType } from './from-type.mjs';
-export function FromTemplateLiteral(context, type, value) {
-    const decoded = TemplateLiteralDecode(type.pattern);
-    return FromType(context, decoded, value);
-}

package/build/value/repair/from-type.d.mts

@@ -1,2 +0,0 @@
-import * as T from '../../type/index.mjs';
-export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

package/build/value/shared/union-priority-sort.d.mts

@@ -1,3 +0,0 @@
-import { type TSchema } from '../../type/index.mjs';
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];

package/build/value/shared/union-priority-sort.mjs

@@ -1,36 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Compare } from '../../type/index.mjs';
-// ------------------------------------------------------------------
-// DeterministicCompare
-//
-// Provides a deterministic tie-break for schemas. This is used when
-// schemas are structurally disjoint or mutually inclusive. While
-// JSON serialization incurs a performance overhead, it serves as a
-// reliable mechanism to ensure stable ordering and preserves the
-// alphabetical alignment of named constants.
-//
-// ------------------------------------------------------------------
-function DeterministicCompare(left, right) {
-    return JSON.stringify(left).localeCompare(JSON.stringify(right));
-}
-// ------------------------------------------------------------------
-// UnionPrioritySort
-//
-// Performs a deterministic sort on Union members. By default, this
-// function ensures that narrow (more specific) types precede broader
-// types in the resulting array. The order can be reversed by setting
-// the order property to -1 which will reverse unions from broader
-// to more narrow.
-//
-// ------------------------------------------------------------------
-/** Deterministically sorts schemas by structural relationship (narrow to broad) */
-export function UnionPrioritySort(types, order = 1) {
-    return types.sort((left, right) => {
-        const result = Compare(left, right);
-        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
-            Guard.IsEqual(result, 'right-inside') ? 1 :
-                Guard.IsEqual(result, 'left-inside') ? -1 :
-                    DeterministicCompare(left, right)) * order;
-    });
-}