@luan.sh/pi-tool-search 0.3.7

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/default/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/diff.d.mts

@@ -0,0 +1,10 @@
+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/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/diff.mjs

@@ -0,0 +1,135 @@
+// 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/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/edit.d.mts

@@ -0,0 +1,24 @@
+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/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/edit.mjs

@@ -0,0 +1,17 @@
+// 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/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/patch.d.mts

@@ -0,0 +1,8 @@
+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;

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/delta/patch.mjs

@@ -0,0 +1,42 @@
+// deno-fmt-ignore-file
+import { Clone } from '../clone/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+function IsRoot(edits) {
+    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
+}
+function IsEmpty(edits) {
+    return edits.length === 0;
+}
+// ------------------------------------------------------------------
+// Patch
+// ------------------------------------------------------------------
+/**
+ * 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 function Patch(current, edits) {
+    if (IsRoot(edits))
+        return Clone(edits[0].value);
+    if (IsEmpty(edits))
+        return Clone(current);
+    const clone = Clone(current);
+    for (const edit of edits) {
+        switch (edit.type) {
+            case 'insert': {
+                Pointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'update': {
+                Pointer.Set(clone, edit.path, edit.value);
+                break;
+            }
+            case 'delete': {
+                Pointer.Delete(clone, edit.path);
+                break;
+            }
+        }
+    }
+    return clone;
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/equal/equal.d.mts

@@ -0,0 +1,2 @@
+/** Returns true if left and right values are structurally equal */
+export declare function Equal(left: unknown, right: unknown): boolean;

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/equal/equal.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+/** Returns true if left and right values are structurally equal */
+export function Equal(left, right) {
+    return Guard.IsDeepEqual(left, right);
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/equal/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/equal/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/errors/errors.d.mts

@@ -0,0 +1,16 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+import type { TLocalizedValidationError } from '../../error/index.mjs';
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurrence of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurrence of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export declare function Errors<Context extends TProperties, Type extends TSchema>(context: Context, type: Type, value: unknown): TLocalizedValidationError[];

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/errors/errors.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Errors as SchemaErrors, } from '../../schema/index.mjs';
+/**
+ * Performs an exhaustive Check on the specified value and reports any errors found.
+ * If no errors are found, an empty array is returned. Unlike Check, this function
+ * does not terminate at the first occurrence of an error. For best performance, call
+ * Check first and call Errors only if Check returns false.
+ */
+export function Errors(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const [_, errors] = SchemaErrors(context, type, value);
+    return errors;
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/errors/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/errors/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/hash/hash.d.mts

@@ -0,0 +1,6 @@
+/**
+ * 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/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/hash/hash.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { Hashing } from '../../system/hashing/index.mjs';
+/**
+ * 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 function Hash(value) {
+    return Hashing.Hash(value);
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/hash/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/hash/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/parse/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/parse/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/parse/parse.d.mts

@@ -0,0 +1,11 @@
+import { type TLocalizedValidationError } from '../../error/errors.mjs';
+import { type TProperties, type TSchema, type StaticParse } from '../../type/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+export declare class ParseError extends AssertError {
+    constructor(value: unknown, errors: TLocalizedValidationError[]);
+}
+export declare const Parser: import("../pipeline/pipeline.mjs").PipelineInterface;
+/**  Parses a value with the given type. */
+export declare function Parse<const Type extends TSchema>(type: Type, value: unknown): StaticParse<Type>;
+/**  Parses a value with the given type. */
+export declare function Parse<Context extends TProperties, const Type extends TSchema>(context: Context, type: Type, value: unknown): StaticParse<Type, Context>;

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/parse/parse.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import { Settings } from '../../system/system.mjs';
+import { Arguments } from '../../system/arguments/index.mjs';
+import { AssertError } from '../assert/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Errors } from '../errors/index.mjs';
+import { Clean } from '../clean/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Pipeline } from '../pipeline/index.mjs';
+// ------------------------------------------------------------------
+// Assert
+// ------------------------------------------------------------------
+export class ParseError extends AssertError {
+    constructor(value, errors) {
+        super('Parse', value, errors);
+    }
+}
+function Assert(context, type, value) {
+    if (!Check(context, type, value))
+        throw new ParseError(value, Errors(context, type, value));
+    return value;
+}
+// ------------------------------------------------------------------
+// Parser
+// ------------------------------------------------------------------
+export const Parser = Pipeline([
+    (_context, _type, value) => Clone(value),
+    (context, type, value) => Default(context, type, value),
+    (context, type, value) => Convert(context, type, value),
+    (context, type, value) => Clean(context, type, value),
+    (context, type, value) => Assert(context, type, value)
+]);
+/**  Parses a value with the given type. */
+export function Parse(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const checked = Check(context, type, value);
+    if (checked)
+        return value;
+    if (Settings.Get().correctiveParse)
+        return Parser(context, type, value);
+    throw new ParseError(value, Errors(context, type, value));
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pipeline/index.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pipeline/index.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pipeline/pipeline.d.mts

@@ -0,0 +1,10 @@
+import { type TProperties, type TSchema } from '../../type/index.mjs';
+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/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pipeline/pipeline.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+// ------------------------------------------------------------------
+// Pipeline
+// ------------------------------------------------------------------
+/** Creates a value processing pipeline. */
+export function Pipeline(pipeline) {
+    return (...args) => {
+        const [context, type, value] = 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/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pointer/index.d.mts

@@ -0,0 +1 @@
+export * from '../../schema/pointer/index.mjs';

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/pointer/index.mjs

@@ -0,0 +1 @@
+export * from '../../schema/pointer/index.mjs';

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/error.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/error.mjs

@@ -0,0 +1,8 @@
+export class RepairError extends Error {
+    constructor(context, type, value, message) {
+        super(message);
+        this.context = context;
+        this.type = type;
+        this.value = value;
+    }
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_array.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_array.mjs

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import { IsMaxItems, IsMinItems, IsUniqueItems } from '../../schema/types/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Hash } from '../hash/index.mjs';
+import { FromType } from './from_type.mjs';
+import { RepairError } from './error.mjs';
+// ------------------------------------------------------------------
+// MakeUnique
+// ------------------------------------------------------------------
+function MakeUnique(values) {
+    const [hashes, result] = [new Set(), []];
+    for (const value of values) {
+        const hash = Hash(value);
+        if (hashes.has(hash))
+            continue;
+        hashes.add(hash);
+        result.push(value);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+export function FromArray(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    const created = Guard.IsArray(value) ? value : Create(context, type);
+    const minimum = IsMinItems(type) && created.length < type.minItems ? [...created, ...Array.from({ length: type.minItems - created.length }, () => Create(context, type))] : created;
+    const maximum = IsMaxItems(type) && minimum.length > type.maxItems ? minimum.slice(0, type.maxItems) : minimum;
+    const repaired = maximum.map((value) => FromType(context, type.items, value));
+    if (!IsUniqueItems(type) || (IsUniqueItems(type) && !Guard.IsEqual(type.uniqueItems, true)))
+        return repaired;
+    const unique = MakeUnique(repaired);
+    if (!Check(context, type, unique))
+        throw new RepairError(context, type, value, 'Failed to repair Array due to uniqueItems constraint');
+    return unique;
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_enum.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_enum.mjs

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_intersect.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_intersect.mjs

@@ -0,0 +1,8 @@
+// deno-fmt-ignore-file
+import { Instantiate, Evaluate } 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/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_object.d.mts

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

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_object.mjs

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { IsAdditionalProperties } from '../../schema/types/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromObject(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    if (!Guard.IsObjectNotArray(value))
+        return Create(context, type);
+    // Dependencies
+    const required = new Set(Guard.IsUndefined(type.required) ? [] : type.required);
+    // Properties
+    const result = {};
+    for (const [key, schema] of Guard.Entries(type.properties)) {
+        if (!required.has(key) && Guard.IsUndefined(value[key]))
+            continue;
+        result[key] = key in value
+            ? FromType(context, schema, value[key])
+            : Create(context, schema);
+    }
+    // AdditionalProperties
+    const evaluatedKeys = Guard.Keys(type.properties);
+    if (IsAdditionalProperties(type) && Guard.IsObject(type.additionalProperties)) {
+        for (const key of Guard.Keys(value)) {
+            if (evaluatedKeys.includes(key))
+                continue;
+            result[key] = FromType(context, type.additionalProperties, value[key]);
+        }
+    }
+    return result;
+}

package/node_modules/@luan.sh/pi-xsettings/node_modules/typebox/build/value/repair/from_record.d.mts

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