@astrofoundry/pi-astro 0.17.1 → 0.18.2

package/node_modules/typebox/build/value/create/from_template_literal.d.mts

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

package/node_modules/typebox/build/value/create/from_template_literal.mjs

@@ -1,11 +0,0 @@
-// deno-fmt-ignore-file
-import { IsString } from '../../type/index.mjs';
-import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
-import { FromType } from './from_type.mjs';
-import { CreateError } from './error.mjs';
-export function FromTemplateLiteral(context, type) {
-    const decoded = TemplateLiteralDecode(type.pattern);
-    if (IsString(decoded))
-        throw new CreateError(type, 'Unable to create TemplateLiteral due to infinite type expansion');
-    return FromType(context, decoded);
-}

package/node_modules/typebox/build/value/create/from_tuple.d.mts

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

package/node_modules/typebox/build/value/create/from_tuple.mjs

@@ -1,5 +0,0 @@
-// deno-fmt-ignore-file
-import { FromType } from './from_type.mjs';
-export function FromTuple(context, type) {
-    return Array.from({ length: type.minItems }, (_, i) => FromType(context, type.items[i]));
-}

package/node_modules/typebox/build/value/create/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): unknown;

package/node_modules/typebox/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/node_modules/typebox/build/value/create/from_undefined.d.mts

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

package/node_modules/typebox/build/value/create/from_undefined.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromUndefined(_context, _type) {
-    return undefined;
-}

package/node_modules/typebox/build/value/create/from_union.d.mts

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

package/node_modules/typebox/build/value/create/from_union.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromUnion(context, type) {
-    if (Guard.IsEqual(type.anyOf.length, 0)) {
-        throw Error('Unable to create Union with no variants');
-    }
-    return FromType(context, type.anyOf[0]);
-}

package/node_modules/typebox/build/value/create/from_void.d.mts

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

package/node_modules/typebox/build/value/create/from_void.mjs

@@ -1,4 +0,0 @@
-// deno-fmt-ignore-file
-export function FromVoid(_context, _type) {
-    return void 0;
-}

package/node_modules/typebox/build/value/create/index.d.mts

@@ -1,2 +0,0 @@
-export * from './error.mjs';
-export * from './create.mjs';

package/node_modules/typebox/build/value/create/index.mjs

@@ -1,2 +0,0 @@
-export * from './error.mjs';
-export * from './create.mjs';

package/node_modules/typebox/build/value/default/default.d.mts

@@ -1,13 +0,0 @@
-import type { TProperties, TSchema } from '../../type/index.mjs';
-/**
- * Patches missing properties on the value using default annotations specified on the provided type. This
- * function returns unknown so callers should Check the return value before use. This function mutates the
- * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
- */
-export declare function Default(type: TSchema, value: unknown): unknown;
-/**
- * Patches missing properties on the value using default annotations specified on the provided type. This
- * function returns unknown so callers should Check the return value before use. This function mutates the
- * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
- */
-export declare function Default(context: TProperties, type: TSchema, value: unknown): unknown;

package/node_modules/typebox/build/value/default/default.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
-import { FromType } from './from_type.mjs';
-/**
- * Patches missing properties on the value using default annotations specified on the provided type. This
- * function returns unknown so callers should Check the return value before use. This function mutates the
- * provided value. If mutation is not wanted, you should Clone the value before passing to this function.
- */
-export function Default(...args) {
-    const [context, type, value] = Arguments.Match(args, {
-        3: (context, type, value) => [context, type, value],
-        2: (type, value) => [{}, type, value],
-    });
-    return FromType(context, type, value);
-}

package/node_modules/typebox/build/value/default/from_array.d.mts

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

package/node_modules/typebox/build/value/default/from_array.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromArray(context, type, value) {
-    if (!Guard.IsArray(value))
-        return value;
-    for (let i = 0; i < value.length; i++) {
-        value[i] = FromType(context, type.items, value[i]);
-    }
-    return value;
-}

package/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/build/value/default/from_cyclic.d.mts

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

package/node_modules/typebox/build/value/default/from_cyclic.mjs

@@ -1,7 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Ref } from '../../type/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromCyclic(context, type, value) {
-    return FromType({ ...context, ...type.$defs }, Ref(type.$ref), value);
-}

package/node_modules/typebox/build/value/default/from_default.d.mts

@@ -1,3 +0,0 @@
-import { type XDefault } from '../../schema/index.mjs';
-import type { TSchema } from '../../type/index.mjs';
-export declare function FromDefault(type: TSchema & XDefault, value: unknown): unknown;

package/node_modules/typebox/build/value/default/from_default.mjs

@@ -1,13 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Clone } from '../clone/index.mjs';
-// ------------------------------------------------------------------
-// FromDefault
-// ------------------------------------------------------------------
-export function FromDefault(type, value) {
-    // we only use defaults when values are undefined, exit early
-    if (!Guard.IsUndefined(value))
-        return value;
-    return Guard.IsFunction(type.default) ? type.default() : Clone(type.default);
-}

package/node_modules/typebox/build/value/default/from_intersect.d.mts

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

package/node_modules/typebox/build/value/default/from_intersect.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Evaluate, Instantiate } from '../../type/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromIntersect(context, type, value) {
-    const instantiated = Instantiate(context, type);
-    const evaluated = Evaluate(instantiated);
-    return FromType(context, evaluated, value);
-}

package/node_modules/typebox/build/value/default/from_object.d.mts

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

package/node_modules/typebox/build/value/default/from_object.mjs

@@ -1,32 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { IsOptional } from '../../type/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-import { IsAdditionalProperties } from '../../schema/types/index.mjs';
-export function FromObject(context, type, value) {
-    if (!Guard.IsObject(value))
-        return value;
-    const knownPropertyKeys = Guard.Keys(type.properties);
-    // Properties
-    for (const key of knownPropertyKeys) {
-        // Resolve Value for Property
-        const propertyValue = FromType(context, type.properties[key], value[key]);
-        // Ambiguious Undefined: If the value is undefined, the type is optional there's no default. ignore.
-        const isUnassignableUndefined = Guard.IsUndefined(propertyValue) && (IsOptional(type.properties[key]) || !Guard.HasPropertyKey(type.properties[key], 'default'));
-        if (isUnassignableUndefined)
-            continue;
-        // Assign
-        value[key] = FromType(context, type.properties[key], value[key]);
-    }
-    // return if not additional properties
-    if (!IsAdditionalProperties(type) || Guard.IsBoolean(type.additionalProperties))
-        return value;
-    // AdditionalProperties
-    for (const key of Guard.Keys(value)) {
-        if (knownPropertyKeys.includes(key))
-            continue;
-        value[key] = FromType(context, type.additionalProperties, value[key]);
-    }
-    return value;
-}

package/node_modules/typebox/build/value/default/from_record.d.mts

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

package/node_modules/typebox/build/value/default/from_record.mjs

@@ -1,26 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { RecordPattern, RecordValue } from '../../type/index.mjs';
-import { IsAdditionalProperties, IsDefault } from '../../schema/types/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromRecord(context, type, value) {
-    if (!Guard.IsObject(value))
-        return value;
-    // PatternProperties
-    const [recordKey, recordValue] = [new RegExp(RecordPattern(type)), RecordValue(type)];
-    for (const key of Guard.Keys(value)) {
-        if (!(recordKey.test(key) && IsDefault(recordValue)))
-            continue;
-        value[key] = FromType(context, recordValue, value[key]);
-    }
-    // AdditionalProperties
-    if (!IsAdditionalProperties(type))
-        return value;
-    for (const key of Guard.Keys(value)) {
-        if (recordKey.test(key))
-            continue;
-        value[key] = FromType(context, type.additionalProperties, value[key]);
-    }
-    return value;
-}

package/node_modules/typebox/build/value/default/from_ref.d.mts

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

package/node_modules/typebox/build/value/default/from_ref.mjs

@@ -1,9 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromRef(context, type, value) {
-    return Guard.HasPropertyKey(context, type.$ref)
-        ? FromType(context, context[type.$ref], value)
-        : value;
-}

package/node_modules/typebox/build/value/default/from_tuple.d.mts

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

package/node_modules/typebox/build/value/default/from_tuple.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromTuple(context, schema, value) {
-    if (!Guard.IsArray(value))
-        return value;
-    const [items, max] = [schema.items, Math.max(schema.items.length, value.length)];
-    for (let i = 0; i < max; i++) {
-        if (i < items.length)
-            value[i] = FromType(context, items[i], value[i]);
-    }
-    return value;
-}

package/node_modules/typebox/build/value/default/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/node_modules/typebox/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/node_modules/typebox/build/value/default/from_union.d.mts

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

package/node_modules/typebox/build/value/default/from_union.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Check } from '../check/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromUnion(context, schema, value) {
-    for (const inner of schema.anyOf) {
-        const result = FromType(context, inner, Clone(value));
-        if (Check(context, inner, result)) {
-            return result;
-        }
-    }
-    return value;
-}

package/node_modules/typebox/build/value/default/index.d.mts

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

package/node_modules/typebox/build/value/default/index.mjs

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

package/node_modules/typebox/build/value/delta/diff.d.mts

@@ -1,10 +0,0 @@
-import { type TEdit } from './edit.mjs';
-/**
- * Generates a sequence of Edit commands to transform the current value into the next value.
- * These commands can be serialized and sent over a network to synchronize a remote
- * value, applied with Patch, or tested with Hash. Edit commands should be treated as
- * opaque data structures; TypeBox may enhance this functionality in the future to
- * support full operational transformation and may change the commands. Do not apply
- * any logic directly to the command structures.
- */
-export declare function Diff(current: unknown, next: unknown): TEdit[];

package/node_modules/typebox/build/value/delta/diff.mjs

@@ -1,135 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
-import { Equal } from '../equal/index.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-function CreateUpdate(path, value) {
-    return { type: 'update', path, value };
-}
-function CreateInsert(path, value) {
-    return { type: 'insert', path, value };
-}
-function CreateDelete(path) {
-    return { type: 'delete', path };
-}
-// ------------------------------------------------------------------
-// Assert
-// ------------------------------------------------------------------
-function AssertCanDiffObject(value) {
-    if (Guard.IsObject(value) && Guard.IsEqual(Guard.Symbols(value).length, 0))
-        return;
-    throw new Error('Cannot create diffs for objects with symbols keys');
-}
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function* FromObject(path, left, right) {
-    if (!Guard.IsObject(right) || Guard.IsArray(right))
-        return yield CreateUpdate(path, right);
-    AssertCanDiffObject(left);
-    AssertCanDiffObject(right);
-    const leftKeys = Guard.Keys(left);
-    const rightKeys = Guard.Keys(right);
-    // ----------------------------------------------------------------
-    // Insert
-    // ----------------------------------------------------------------
-    for (const key of rightKeys) {
-        if (Guard.HasPropertyKey(left, key))
-            continue;
-        if (Guard.IsUnsafePropertyKey(key))
-            continue;
-        yield CreateInsert(`${path}/${key}`, right[key]);
-    }
-    // ----------------------------------------------------------------
-    // Update
-    // ----------------------------------------------------------------
-    for (const key of leftKeys) {
-        if (!Guard.HasPropertyKey(right, key))
-            continue;
-        if (Guard.IsUnsafePropertyKey(key))
-            continue;
-        if (Equal(left, right))
-            continue;
-        yield* FromValue(`${path}/${key}`, left[key], right[key]);
-    }
-    // ----------------------------------------------------------------
-    // Delete
-    // ----------------------------------------------------------------
-    for (const key of leftKeys) {
-        if (Guard.HasPropertyKey(right, key))
-            continue;
-        if (Guard.IsUnsafePropertyKey(key))
-            continue;
-        yield CreateDelete(`${path}/${key}`);
-    }
-}
-// ------------------------------------------------------------------
-// Array
-// ------------------------------------------------------------------
-function* FromArray(path, left, right) {
-    if (!Guard.IsArray(right))
-        return yield CreateUpdate(path, right);
-    for (let i = 0; i < Math.min(left.length, right.length); i++) {
-        yield* FromValue(`${path}/${i}`, left[i], right[i]);
-    }
-    for (let i = 0; i < right.length; i++) {
-        if (i < left.length)
-            continue;
-        yield CreateInsert(`${path}/${i}`, right[i]);
-    }
-    for (let i = left.length - 1; i >= 0; i--) {
-        if (i < right.length)
-            continue;
-        yield CreateDelete(`${path}/${i}`);
-    }
-}
-// ------------------------------------------------------------------
-// TypedArray
-// ------------------------------------------------------------------
-function* FromTypedArray(path, left, right) {
-    const typeLeft = globalThis.Object.getPrototypeOf(left).constructor.name;
-    const typeRight = globalThis.Object.getPrototypeOf(right).constructor.name;
-    const predicate = GlobalsGuard.IsTypeArray(right)
-        && Guard.IsEqual(left.length, right.length)
-        && Guard.IsEqual(typeLeft, typeRight);
-    if (predicate) {
-        for (let index = 0; index < Math.min(left.length, right.length); index++) {
-            yield* FromValue(`${path}/${index}`, left[index], right[index]);
-        }
-    }
-    else {
-        return yield CreateUpdate(path, right);
-    }
-}
-// ------------------------------------------------------------------
-// Unknown
-// ------------------------------------------------------------------
-function* FromUnknown(path, left, right) {
-    if (left === right)
-        return;
-    yield CreateUpdate(path, right);
-}
-// ------------------------------------------------------------------
-// Value
-// ------------------------------------------------------------------
-function* FromValue(path, left, right) {
-    return (GlobalsGuard.IsTypeArray(left) ? yield* FromTypedArray(path, left, right) :
-        Guard.IsArray(left) ? yield* FromArray(path, left, right) :
-            Guard.IsObject(left) ? yield* FromObject(path, left, right) :
-                yield* FromUnknown(path, left, right));
-}
-// ------------------------------------------------------------------
-// Diff
-// ------------------------------------------------------------------
-/**
- * Generates a sequence of Edit commands to transform the current value into the next value.
- * These commands can be serialized and sent over a network to synchronize a remote
- * value, applied with Patch, or tested with Hash. Edit commands should be treated as
- * opaque data structures; TypeBox may enhance this functionality in the future to
- * support full operational transformation and may change the commands. Do not apply
- * any logic directly to the command structures.
- */
-export function Diff(current, next) {
-    return [...FromValue('', current, next)];
-}

package/node_modules/typebox/build/value/delta/edit.d.mts

@@ -1,24 +0,0 @@
-import * as T from '../../type/index.mjs';
-export type TInsert = T.Static<typeof Insert>;
-export declare const Insert: T.TObject<{
-    type: T.TLiteral<'insert'>;
-    path: T.TString;
-    value: T.TUnknown;
-}>;
-export type TUpdate = T.Static<typeof Update>;
-export declare const Update: T.TObject<{
-    type: T.TLiteral<'update'>;
-    path: T.TString;
-    value: T.TUnknown;
-}>;
-export type TDelete = T.Static<typeof Delete>;
-export declare const Delete: T.TObject<{
-    type: T.TLiteral<'delete'>;
-    path: T.TString;
-}>;
-export type TEdit = T.Static<typeof Edit>;
-export declare const Edit: T.TUnion<[
-    typeof Insert,
-    typeof Update,
-    typeof Delete
-]>;

package/node_modules/typebox/build/value/delta/edit.mjs

@@ -1,17 +0,0 @@
-// deno-fmt-ignore-file
-import * as T from '../../type/index.mjs';
-export const Insert = T.Object({
-    type: T.Literal('insert'),
-    path: T.String(),
-    value: T.Unknown(),
-});
-export const Update = Object({
-    type: T.Literal('update'),
-    path: T.String(),
-    value: T.Unknown(),
-});
-export const Delete = T.Object({
-    type: T.Literal('delete'),
-    path: T.String(),
-});
-export const Edit = T.Union([Insert, Update, Delete]);

package/node_modules/typebox/build/value/delta/index.d.mts

@@ -1,3 +0,0 @@
-export * from './diff.mjs';
-export * from './edit.mjs';
-export * from './patch.mjs';

package/node_modules/typebox/build/value/delta/index.mjs

@@ -1,3 +0,0 @@
-export * from './diff.mjs';
-export * from './edit.mjs';
-export * from './patch.mjs';

package/node_modules/typebox/build/value/delta/patch.d.mts

@@ -1,8 +0,0 @@
-import { type TEdit } from './edit.mjs';
-/**
- * Applies a sequence of Edit commands to a current value, producing a new value that incorporates
- * all edits. This function returns unknown so callers should Check the return value before use.
- * This function mutates the provided value. If mutation is not wanted, you should Clone the value
- * before passing to this function.
- */
-export declare function Patch(current: unknown, edits: TEdit[]): unknown;