pi-proactive 0.2.0-beta.5 → 0.2.0-beta.6

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;

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

@@ -1,42 +0,0 @@
-// 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/typebox/build/value/equal/equal.d.mts

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

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

@@ -1,6 +0,0 @@
-// 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/typebox/build/value/equal/index.d.mts

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

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

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

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

@@ -1,6 +0,0 @@
-import type { TProperties, TSchema } from '../../type/index.mjs';
-import type { TLocalizedValidationError } from '../../error/index.mjs';
-/** Returns an array of validation errors for the given value. */
-export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
-/** Returns an array of validation errors for the given value. */
-export declare function Errors<Context extends TProperties, Type extends TSchema>(context: Context, type: Type, value: unknown): TLocalizedValidationError[];

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

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
-import { Errors as SchemaErrors } from '../../schema/index.mjs';
-/** Returns an array of validation errors for the given value. */
-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/typebox/build/value/errors/index.d.mts

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

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

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

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

@@ -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/node_modules/typebox/build/value/hash/hash.mjs

@@ -1,10 +0,0 @@
-// 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/typebox/build/value/hash/index.d.mts

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

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

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

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

@@ -1,20 +0,0 @@
-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/typebox/build/value/index.mjs

@@ -1,29 +0,0 @@
-// ------------------------------------------------------------------
-// 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/typebox/build/value/parse/index.d.mts

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

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

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

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

@@ -1,11 +0,0 @@
-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/typebox/build/value/parse/parse.mjs

@@ -1,47 +0,0 @@
-// 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/typebox/build/value/pipeline/index.d.mts

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

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

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

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

@@ -1,10 +0,0 @@
-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/typebox/build/value/pipeline/pipeline.mjs

@@ -1,15 +0,0 @@
-// 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/typebox/build/value/pointer/index.d.mts

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

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

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

package/node_modules/typebox/build/value/repair/error.d.mts

@@ -1,7 +0,0 @@
-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/typebox/build/value/repair/error.mjs

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

package/node_modules/typebox/build/value/repair/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/repair/from_array.mjs

@@ -1,39 +0,0 @@
-// 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/typebox/build/value/repair/from_enum.d.mts

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

package/node_modules/typebox/build/value/repair/from_enum.mjs

@@ -1,6 +0,0 @@
-// 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/typebox/build/value/repair/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/repair/from_intersect.mjs

@@ -1,8 +0,0 @@
-// 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/typebox/build/value/repair/from_object.d.mts

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

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

@@ -1,33 +0,0 @@
-// 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/typebox/build/value/repair/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/repair/from_record.mjs

@@ -1,33 +0,0 @@
-// deno-fmt-ignore-file
-import { IsAdditionalProperties } from '../../schema/types/index.mjs';
-import { RecordValue, RecordPattern } from '../../type/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { Create } from '../create/index.mjs';
-import { Check } from '../check/index.mjs';
-import { FromType } from './from_type.mjs';
-export function FromRecord(context, type, value) {
-    if (Check(context, type, value))
-        return value;
-    if (Guard.IsNull(value) || !Guard.IsObject(value) || Guard.IsArray(value))
-        return Create(context, type);
-    const recordKey = new RegExp(RecordPattern(type));
-    const recordValue = RecordValue(type);
-    const evaluatedKeys = new Set();
-    // PatternProperties
-    const result = {};
-    for (const [key, value_] of Guard.Entries(value)) {
-        if (!recordKey.test(key))
-            continue;
-        result[key] = FromType(context, recordValue, value_);
-        evaluatedKeys.add(key);
-    }
-    // AdditionalProperties
-    if (IsAdditionalProperties(type)) {
-        for (const key of Guard.Keys(value)) {
-            if (evaluatedKeys.has(key))
-                continue;
-            result[key] = FromType(context, type.additionalProperties, value[key]);
-        }
-    }
-    return result;
-}