pi-proactive 0.2.0-beta.2 → 0.2.0-beta.4

package/node_modules/typebox/build/schema/engine/_context.mjs

@@ -1,137 +0,0 @@
-// deno-fmt-ignore-file
-import { Settings } from '../../system/settings/index.mjs';
-import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// HasUnevaluated
-// ------------------------------------------------------------------
-function HasUnevaluatedFromObject(value) {
-    return (Schema.IsUnevaluatedItems(value)
-        || Schema.IsUnevaluatedProperties(value)
-        || G.Some(G.Keys(value), key => HasUnevaluatedFromUnknown(value[key])));
-}
-function HasUnevaluatedFromArray(value) {
-    return G.Some(value, value => HasUnevaluatedFromUnknown(value));
-}
-function HasUnevaluatedFromUnknown(value) {
-    return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
-        G.IsObject(value) ? HasUnevaluatedFromObject(value) :
-            false);
-}
-export function HasUnevaluated(context, schema) {
-    return HasUnevaluatedFromUnknown(schema) || G.Some(G.Keys(context), key => HasUnevaluatedFromUnknown(context[key]));
-}
-// ------------------------------------------------------------------
-// BuildContext
-// ------------------------------------------------------------------
-export class BuildContext {
-    constructor(hasUnevaluated) {
-        this.hasUnevaluated = hasUnevaluated;
-    }
-    UseUnevaluated() {
-        return this.hasUnevaluated;
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push() {
-        return E.Call(E.Member('context', 'Push'), []);
-    }
-    Pop() {
-        return E.Call(E.Member('context', 'Pop'), []);
-    }
-    // ----------------------------------------------------------------
-    // Top
-    // ----------------------------------------------------------------
-    AddIndex(index) {
-        return E.Call(E.Member('context', 'AddIndex'), [index]);
-    }
-    AddKey(key) {
-        return E.Call(E.Member('context', 'AddKey'), [key]);
-    }
-    Merge(results) {
-        return E.Call(E.Member('context', 'Merge'), [results]);
-    }
-}
-// ------------------------------------------------------------------
-// CheckContext
-// ------------------------------------------------------------------
-export class CheckContext {
-    constructor() {
-        const indices = new Set();
-        const keys = new Set();
-        this.stack = [{ indices, keys }];
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push() {
-        const indices = new Set();
-        const keys = new Set();
-        this.stack.push({ indices, keys });
-        return true;
-    }
-    Pop() {
-        this.stack.pop();
-        return true;
-    }
-    // ----------------------------------------------------------------
-    // Top
-    // ----------------------------------------------------------------
-    AddIndex(index) {
-        this.GetIndices().add(index);
-        return true;
-    }
-    AddKey(key) {
-        this.GetKeys().add(key);
-        return true;
-    }
-    GetIndices() {
-        const top = this.stack[this.stack.length - 1];
-        return top.indices;
-    }
-    GetKeys() {
-        const top = this.stack[this.stack.length - 1];
-        return top.keys;
-    }
-    Merge(results) {
-        for (const context of results) {
-            context.GetIndices().forEach(value => this.GetIndices().add(value));
-            context.GetKeys().forEach(value => this.GetKeys().add(value));
-        }
-        return true;
-    }
-}
-// ------------------------------------------------------------------
-// ErrorContext
-// ------------------------------------------------------------------
-export class ErrorContext extends CheckContext {
-    constructor() {
-        super();
-        this.errors = [];
-    }
-    // ----------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------
-    AtCapacity() {
-        return this.errors.length >= Settings.Get().maxErrors;
-    }
-    AddError(keyword, schemaPath, instancePath, params) {
-        return this.AddErrorObject({ keyword, schemaPath, instancePath, params });
-    }
-    AddErrors(error) {
-        error.forEach(error => this.AddErrorObject(error));
-        return false;
-    }
-    GetErrors() {
-        return this.errors;
-    }
-    // ----------------------------------------------------------------
-    // Private
-    // ----------------------------------------------------------------
-    AddErrorObject(error) {
-        if (!this.AtCapacity())
-            this.errors.push(error);
-        return false;
-    }
-}

package/node_modules/typebox/build/schema/engine/_exact_optional.d.mts

@@ -1,3 +0,0 @@
-export declare function IsExactOptional(required: string[], key: string): boolean;
-export declare function InexactOptionalBuild(value: string, key: string): string;
-export declare function InexactOptionalCheck(value: Record<PropertyKey, unknown>, key: string): boolean;

package/node_modules/typebox/build/schema/engine/_exact_optional.mjs

@@ -1,20 +0,0 @@
-import { Settings } from '../../system/settings/index.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// IsExactOptional
-// ------------------------------------------------------------------
-export function IsExactOptional(required, key) {
-    return required.includes(key) || Settings.Get().exactOptionalPropertyTypes;
-}
-// ------------------------------------------------------------------
-// ExactOptionalBuild
-// ------------------------------------------------------------------
-export function InexactOptionalBuild(value, key) {
-    return E.IsUndefined(E.Member(value, key));
-}
-// ------------------------------------------------------------------
-// ExactOptionalCheck
-// ------------------------------------------------------------------
-export function InexactOptionalCheck(value, key) {
-    return G.IsUndefined(value[key]);
-}

package/node_modules/typebox/build/schema/engine/_externals.d.mts

@@ -1,7 +0,0 @@
-export interface TExternal {
-    identifier: 'External';
-    variables: unknown[];
-}
-export declare function CreateVariable(value: unknown): string;
-export declare function ResetExternal(): void;
-export declare function GetExternal(): TExternal;

package/node_modules/typebox/build/schema/engine/_externals.mjs

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-const state = {
-    identifier: 'External',
-    variables: []
-};
-// ------------------------------------------------------------------
-// CreateVariable
-// ------------------------------------------------------------------
-export function CreateVariable(value) {
-    const call = `External[${state.variables.length}]`;
-    state.variables.push(value);
-    return call;
-}
-// ------------------------------------------------------------------
-// ResetExternal
-// ------------------------------------------------------------------
-export function ResetExternal() {
-    state.variables = [];
-}
-// ------------------------------------------------------------------
-// GetExternals
-// ------------------------------------------------------------------
-export function GetExternal() {
-    return { ...state };
-}

package/node_modules/typebox/build/schema/engine/_functions.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function ResetFunctions(): void;
-export declare function GetFunctions(): string[];
-export declare function CreateFunction(stack: Stack.XStack, context: BuildContext, schema: Schema.XSchema, value: string): string;

package/node_modules/typebox/build/schema/engine/_functions.mjs

@@ -1,65 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-const index = [0];
-const names = new Map;
-const funcs = new Map();
-// ------------------------------------------------------------------
-// CreateName
-// ------------------------------------------------------------------
-function NextName() {
-    return `${index[0]++}`;
-}
-function CreateName(schema, href) {
-    if (!names.has(schema))
-        names.set(schema, new Map());
-    const hrefs = names.get(schema);
-    if (hrefs.has(href))
-        return hrefs.get(href);
-    const name = NextName();
-    hrefs.set(href, name);
-    return name;
-}
-// ------------------------------------------------------------------
-// CreateCallExpression
-// ------------------------------------------------------------------
-function CreateCallExpression(context, _schema, name, value) {
-    return context.UseUnevaluated()
-        ? E.Call(`check_${name}`, ['context', value])
-        : E.Call(`check_${name}`, [value]);
-}
-// ------------------------------------------------------------------
-// CreateFunctionExpression
-// ------------------------------------------------------------------
-function CreateFunctionExpression(stack, context, schema, name) {
-    const expression = BuildSchema(stack, context, schema, 'value');
-    return context.UseUnevaluated()
-        ? E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['context', 'value'], expression))
-        : E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['value'], expression));
-}
-// ------------------------------------------------------------------
-// ResetFunctions
-// ------------------------------------------------------------------
-export function ResetFunctions() {
-    index[0] = 0;
-    names.clear();
-    funcs.clear();
-}
-// ------------------------------------------------------------------
-// GetFunctions
-// ------------------------------------------------------------------
-export function GetFunctions() {
-    return [...funcs.values()];
-}
-// ------------------------------------------------------------------
-// CreateFunction
-// ------------------------------------------------------------------
-export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.lexicalBase);
-    const call = CreateCallExpression(context, schema, name, value);
-    if (funcs.has(name))
-        return call;
-    funcs.set(name, '');
-    funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
-    return call;
-}

package/node_modules/typebox/build/schema/engine/_pathing.d.mts

@@ -1 +0,0 @@
-export declare function EncodeFragment(fragment: string): string;

package/node_modules/typebox/build/schema/engine/_pathing.mjs

@@ -1,11 +0,0 @@
-// ------------------------------------------------------------------
-// EncodeFragment
-//
-// We use this function to encode instancePath and schemaPath path
-// fragments for errors. We need this encoding such that callers
-// can use Pointer to deref error targets. We should consider adding
-// this to the Pointer module as Pointer.Encode(...) (review)
-// ------------------------------------------------------------------
-export function EncodeFragment(fragment) {
-    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
-}

package/node_modules/typebox/build/schema/engine/_reducer.d.mts

@@ -1,4 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function Reducer(stack: Stack.XStack, context: BuildContext, schemas: Schema.XSchema[], value: string, check: string): string;

package/node_modules/typebox/build/schema/engine/_reducer.mjs

@@ -1,45 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Reducer
-//
-// This function is used to generate an reducer evaluation context 
-// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
-// is required from 2019-09 onwards to gather evaluated keys and indices
-// for the unevaluatedItems and unevaluatedProperties keywords.
-//
-// ------------------------------------------------------------------
-//
-// const context = new Context() // exterior
-//
-// (() => {
-//   const results = []
-//
-//   const context_0 = context.Clone()
-//   const context_1 = context.Clone()
-//   const context_2 = context.Clone()
-//   const context_3 = context.Clone()
-//   
-//   const condition_0 = ((context) => <subschema>)(context_0)
-//   const condition_1 = ((context) => <subschema>)(context_1)
-//   const condition_2 = ((context) => <subschema>)(context_2)
-//   const condition_3 = ((context) => <subschema>)(context_3)
-// 
-//   if(condition_0) results.push(context_0)
-//   if(condition_1) results.push(context_1)
-//   if(condition_2) results.push(context_2)
-//   if(condition_3) results.push(context_3)
-//
-//   return <check> && context.Merge(results)
-// })()
-//
-// ------------------------------------------------------------------
-export function Reducer(stack, context, schemas, value, check) {
-    const results = E.ConstDeclaration('results', '[]');
-    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, E.New('CheckContext', [])));
-    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(stack, context, schema, value)), [`context_${index}`])));
-    const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])));
-    const returns = E.Return(E.And(check, context.Merge('results')));
-    return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
-}

package/node_modules/typebox/build/schema/engine/_refine.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRefine(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XRefine, value: string): string;
-export declare function CheckRefine(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XRefine, value: unknown): boolean;
-export declare function ErrorRefine(_stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRefine, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/_refine.mjs

@@ -1,34 +0,0 @@
-// deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildRefineMultiple(_stack, _context, schema, value) {
-    const external = Externals.CreateVariable(schema['~refine']);
-    return E.Every(external, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
-}
-function BuildRefineSingle(_stack, _context, schema, value) {
-    const external = Externals.CreateVariable(schema['~refine'][0]);
-    return E.Call(E.Member(external, 'check'), [value]);
-}
-export function BuildRefine(_stack, _context, schema, value) {
-    return G.IsEqual(schema['~refine'].length, 1)
-        ? BuildRefineSingle(_stack, _context, schema, value)
-        : BuildRefineMultiple(_stack, _context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRefine(_stack, _context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.check(value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) ||
-            context.AddError('~refine', schemaPath, instancePath, { index, message: refinement.error(value) });
-    });
-}

package/node_modules/typebox/build/schema/engine/_regexp.d.mts

@@ -1,2 +0,0 @@
-/** Standard RegExp with Unicode */
-export declare function UnicodeRegExp(pattern: string): RegExp;

package/node_modules/typebox/build/schema/engine/_regexp.mjs

@@ -1,4 +0,0 @@
-/** Standard RegExp with Unicode */
-export function UnicodeRegExp(pattern) {
-    return new RegExp(pattern, 'u');
-}

package/node_modules/typebox/build/schema/engine/_stack.d.mts

@@ -1,36 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare const DefaultUri = "urn:typebox:root";
-export interface XStack {
-    /** The schema context. */
-    readonly context: Record<string, Schema.XSchema>;
-    /** The entry schema. */
-    readonly schema: Schema.XSchema;
-    /** Visited $id schemas, kept only to detect resource re-entry (see resolve.ts FindResolvedResource). */
-    readonly ids: Schema.XId[];
-    /** Nearest enclosing $id schema, used as the root for local pointer resolution. */
-    readonly lexicalSchema: Schema.XSchema;
-    /** First $recursiveAnchor: true schema seen on the path. */
-    readonly recursiveAnchor: Schema.XRecursiveAnchor | undefined;
-    /** Dynamic anchors visible at this point in the traversal. */
-    readonly dynamicAnchors: Schema.XDynamicAnchor[];
-    /** Lexical base URL, used to resolve relative $id and $ref values within the current schema. */
-    readonly lexicalBase: string;
-    /** Base URL of the current resource, reset each time a new resource $id is entered. */
-    readonly resourceBase: string;
-    /** Base URL that $ref values resolve against. */
-    readonly referenceBase: string;
-    /** Resource entry point bookkeeping: schema -> the base/root to apply when that schema is next pushed. */
-    readonly resourceEntries: Map<Schema.XSchemaObject, {
-        base: string;
-        root: Schema.XSchemaObject;
-    }>;
-    /** True while referenceBase should track resourceBase rather than lexicalBase. */
-    readonly useResourceBaseForReference: boolean;
-    /** True until the next $id schema is entered, marking it as a fresh resource root. */
-    readonly pendingResource: boolean;
-    /** True once traversal has entered a retrieved or legacy resource. */
-    readonly enteredResource: boolean;
-}
-export declare function NextUri(ref: string, base: string): URL;
-export declare function Stack(context: Record<string, Schema.XSchema>, schema: Schema.XSchema): XStack;
-export declare function NextStack(stack: XStack, schema: Schema.XSchema): XStack;

package/node_modules/typebox/build/schema/engine/_stack.mjs

@@ -1,150 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-import * as Schema from '../types/index.mjs';
-// ------------------------------------------------------------------
-// DefaultUri
-// ------------------------------------------------------------------
-export const DefaultUri = 'urn:typebox:root';
-// ------------------------------------------------------------------
-// NextUri
-//
-// Resolves a relative or absolute ref against a base URI or URN.
-// Hierarchical bases (http, https, etc.) resolve using the normal
-// URL rules. URN bases have no path to resolve against, so the ref
-// is appended after the base's last ':' segment instead.
-// ------------------------------------------------------------------
-export function NextUri(ref, base) {
-    return (URL.canParse(ref, base)) ? new URL(ref, base) : Guard.IsEqual(base, DefaultUri) ? new URL(`${base}:${ref}`) : new URL(`${base.slice(0, base.lastIndexOf(':'))}:${ref}`);
-}
-// ------------------------------------------------------------------
-// Stack
-//
-// Creates the root frame a schema traversal starts from.
-// ------------------------------------------------------------------
-export function Stack(context, schema) {
-    const base = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? NextUri(schema.$id, DefaultUri).href : DefaultUri;
-    return {
-        context,
-        schema,
-        lexicalSchema: schema,
-        lexicalBase: base,
-        resourceBase: base,
-        referenceBase: base,
-        ids: [],
-        useResourceBaseForReference: true,
-        recursiveAnchor: undefined,
-        dynamicAnchors: [],
-        resourceEntries: new Map(),
-        pendingResource: true,
-        enteredResource: false
-    };
-}
-// ------------------------------------------------------------------
-// RegisterResourceAnchors
-//
-// Collects $dynamicAnchor schemas reachable from a resource root,
-// stopping at nested $id boundaries which own their own anchors.
-// ------------------------------------------------------------------
-function RegisterResourceAnchors(anchors, schema, isRoot = true) {
-    if (Schema.IsSchemaBoolean(schema))
-        return anchors;
-    if (Array.isArray(schema))
-        return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
-    if (!Schema.IsSchemaObject(schema))
-        return anchors;
-    if (!isRoot && Schema.IsId(schema))
-        return anchors;
-    const next = !isRoot && Schema.IsDynamicAnchor(schema) ? [...anchors, schema] : anchors;
-    return Object.keys(schema).reduce((result, key) => RegisterResourceAnchors(result, schema[key], false), next);
-}
-// ------------------------------------------------------------------
-// ResourceEntry
-//
-// A ref crossing (Resolve.Ref) may have marked `schema` as the entry
-// point of a retrieved/legacy resource. If so the frame resets to
-// that resource's base/root instead of chaining onto the parent.
-// ------------------------------------------------------------------
-function ResourceEntry(stack, schema) {
-    return stack.resourceEntries.get(schema);
-}
-function NextEnteredResource(stack, schema) {
-    return stack.enteredResource || ResourceEntry(stack, schema) !== undefined;
-}
-// ------------------------------------------------------------------
-// NextStack
-//
-// Each Next* helper below computes one XStack field in isolation from
-// the previous frame and the schema being pushed.
-// ------------------------------------------------------------------
-function IsRelativeId(schema) {
-    return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(schema.$id);
-}
-function NextIds(stack, schema) {
-    return Schema.IsId(schema) ? [...stack.ids, schema] : stack.ids;
-}
-function NextRecursiveAnchor(stack, schema) {
-    return stack.recursiveAnchor ?? (Schema.IsRecursiveAnchorTrue(schema) ? schema : undefined);
-}
-function NextDynamicAnchors(stack, schema) {
-    const registered = Schema.IsId(schema) ? RegisterResourceAnchors(stack.dynamicAnchors, schema) : stack.dynamicAnchors;
-    return Schema.IsDynamicAnchor(schema) ? [...registered, schema] : registered;
-}
-function NextPendingResource(stack, schema) {
-    return Schema.IsId(schema) ? false : stack.pendingResource;
-}
-function NextLexicalBase(stack, schema) {
-    const entry = ResourceEntry(stack, schema);
-    if (entry)
-        return entry.base;
-    return Schema.IsId(schema) ? NextUri(schema.$id, stack.lexicalBase).href : stack.lexicalBase;
-}
-function NextResourceBase(stack, schema) {
-    const entry = ResourceEntry(stack, schema);
-    if (entry)
-        return entry.base;
-    return (Schema.IsId(schema) && stack.pendingResource) ? NextUri(schema.$id, stack.resourceBase).href : stack.resourceBase;
-}
-function NextUseResourceBaseForReference(stack, schema) {
-    return Schema.IsId(schema) ? !IsRelativeId(schema) : stack.useResourceBaseForReference;
-}
-function NextReferenceBase(stack, schema) {
-    const isRetrieved = NextEnteredResource(stack, schema);
-    const useResourceBaseForReference = NextUseResourceBaseForReference(stack, schema);
-    return (isRetrieved || useResourceBaseForReference) ? NextResourceBase(stack, schema) : NextLexicalBase(stack, schema);
-}
-function NextLexicalSchema(stack, schema) {
-    const entry = ResourceEntry(stack, schema);
-    if (entry)
-        return entry.root;
-    return Schema.IsId(schema) ? schema : stack.lexicalSchema;
-}
-// ------------------------------------------------------------------
-// NextStack | HasStackKeywords (Optimization)
-//
-// HasStackKeywords narrows schema to an object and checks whether it
-// carries $id, $dynamicAnchor, a first-seen $recursiveAnchor, or a
-// resource-entry point. When none apply, NextStack skips the frame
-// rebuild and returns the parent stack as-is.
-// ------------------------------------------------------------------
-function HasStackKeywords(stack, schema) {
-    return Schema.IsSchemaObject(schema) && (Schema.IsId(schema) ||
-        Schema.IsDynamicAnchor(schema) ||
-        (Guard.IsUndefined(stack.recursiveAnchor) && Schema.IsRecursiveAnchorTrue(schema)) ||
-        !Guard.IsUndefined(ResourceEntry(stack, schema)));
-}
-export function NextStack(stack, schema) {
-    return HasStackKeywords(stack, schema)
-        ? {
-            ...stack,
-            ids: NextIds(stack, schema),
-            dynamicAnchors: NextDynamicAnchors(stack, schema),
-            recursiveAnchor: NextRecursiveAnchor(stack, schema),
-            pendingResource: NextPendingResource(stack, schema),
-            lexicalBase: NextLexicalBase(stack, schema),
-            resourceBase: NextResourceBase(stack, schema),
-            useResourceBaseForReference: NextUseResourceBaseForReference(stack, schema),
-            referenceBase: NextReferenceBase(stack, schema),
-            lexicalSchema: NextLexicalSchema(stack, schema),
-            enteredResource: NextEnteredResource(stack, schema)
-        }
-        : stack;
-}

package/node_modules/typebox/build/schema/engine/_unique.d.mts

@@ -1,4 +0,0 @@
-/** Creates a unique variable name */
-export declare function CreateUnique(): string;
-/** Resets the unique variable name counter */
-export declare function ResetUnique(): void;

package/node_modules/typebox/build/schema/engine/_unique.mjs

@@ -1,9 +0,0 @@
-let index = 0;
-/** Creates a unique variable name */
-export function CreateUnique() {
-    return `unique_${index++}`;
-}
-/** Resets the unique variable name counter */
-export function ResetUnique() {
-    index = 0;
-}

package/node_modules/typebox/build/schema/engine/additionalItems.d.mts

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAdditionalItems(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalItems, value: string): string;
-export declare function CheckAdditionalItems(stack: Stack.XStack, context: CheckContext, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
-export declare function ErrorAdditionalItems(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalItems, value: unknown[]): boolean;