tape-six 1.7.13 → 1.7.14

package/src/deep6/traverse/walk.d.ts

@@ -0,0 +1,219 @@
+// Type definitions for deep6 walk
+// Generated from src/traverse/walk.js
+
+/**
+ * Context object available during walk traversal
+ */
+export interface WalkContext {
+  /** Stack of values to process */
+  stack: unknown[];
+  /** Output stack for processed values */
+  stackOut: unknown[];
+  /** Map tracking circular references (present when circular: true) */
+  seen: Map<unknown, {value?: unknown; actions?: Array<[unknown, unknown]>}> | null;
+  /** Include symbol properties */
+  symbols?: boolean;
+  /** Include non-enumerable properties */
+  allProps?: boolean;
+  /** Optional environment for variable handling */
+  env?: unknown;
+  /** Wrapper for Maps (set by preprocess) */
+  wrapMap?: (map: Map<unknown, unknown>) => unknown;
+  /** Wrapper for Arrays (set by preprocess) */
+  wrapArray?: (array: unknown[]) => unknown;
+  /** Wrapper for Objects (set by preprocess) */
+  wrapObject?: (object: unknown) => unknown;
+  /** Wrapper for Sets (set by preprocess) */
+  wrapSet?: (set: Set<unknown>) => unknown;
+  /** Additional context properties */
+  [key: string]: unknown;
+}
+
+/**
+ * Options for walk traversal
+ */
+export interface WalkOptions {
+  /** Custom object processor */
+  processObject?: (object: unknown, context: WalkContext) => void;
+  /** Custom non-object value processor */
+  processOther?: (value: unknown, context: WalkContext) => void;
+  /** Custom circular reference processor */
+  processCircular?: (value: unknown, context: WalkContext) => void;
+  /**
+   * Flat array of type handler pairs: [Constructor, handler, Constructor, handler, ...]
+   *
+   * Each pair maps a constructor to a processing function.
+   */
+  registry?: unknown[];
+  /** Array of filter functions — return true to indicate value was handled */
+  filters?: Array<(val: unknown, context: WalkContext) => boolean>;
+  /** Enable circular reference detection */
+  circular?: boolean;
+  /** Include symbol properties */
+  symbols?: boolean;
+  /** Include non-enumerable properties */
+  allProps?: boolean;
+  /** Custom context object (properties are merged into WalkContext) */
+  context?: Record<string, unknown>;
+}
+
+/**
+ * Marker for values that were already seen (circular references)
+ */
+export declare class Circular {
+  /** The already-seen value */
+  value: unknown;
+  constructor(value: unknown);
+}
+
+/**
+ * Deferred processing command pushed onto the walk stack
+ */
+export declare class Command {
+  /** Function to execute during post-processing */
+  f: (context: WalkContext) => void;
+  /** Source object being processed */
+  s: unknown;
+  constructor(f: (context: WalkContext) => void, s: unknown);
+}
+
+/**
+ * Non-recursive stack-based object tree walker
+ *
+ * Traverses values using an explicit stack with support for
+ * circular references, type registries, and filters.
+ *
+ * @param o - Value to traverse
+ * @param options - Walk options and processors
+ */
+export declare const walk: ((o: unknown, options?: WalkOptions) => void) & {
+  Command: typeof Command;
+};
+
+/**
+ * Default type handler registry (flat array of [Constructor, handler] pairs)
+ */
+export declare const registry: unknown[];
+
+/**
+ * Default filter functions
+ */
+export declare const filters: Array<(val: unknown, context: WalkContext) => boolean>;
+
+// Utility processors
+
+/** Pushes value to stackOut unchanged */
+export declare const processOther: (value: unknown, context: WalkContext) => void;
+
+/** Pushes a Circular marker to stackOut */
+export declare const processCircular: (value: unknown, context: WalkContext) => void;
+
+/**
+ * Creates a Map processor with optional post-processing
+ * @param postProcess - Post-processor for normal flow
+ * @param postProcessSeen - Post-processor when circular refs are tracked
+ * @returns Map processing function
+ */
+export declare const processMap: (
+  postProcess?: (context: WalkContext) => void,
+  postProcessSeen?: (context: WalkContext) => void
+) => (object: Map<unknown, unknown>, context: WalkContext) => void;
+
+/**
+ * Post-processes a Map with circular reference resolution
+ * @param source - Original Map
+ * @param context - Walk context
+ */
+export declare const postMapCircular: (source: Map<unknown, unknown>, context: WalkContext) => void;
+
+/**
+ * Builds a new Map from processed values on stackOut
+ * @param keys - Keys for the new Map
+ * @param stackOut - Output stack with values
+ * @param wrap - Optional wrapper function
+ */
+export declare const buildNewMap: (keys: Iterable<unknown>, stackOut: unknown[], wrap?: (map: Map<unknown, unknown>) => unknown) => void;
+
+/**
+ * Replaces stackOut entries from upTo to end with a single object
+ * @param upTo - Index offset from end
+ * @param object - Object to push
+ * @param stackOut - Output stack
+ */
+export declare const replaceObject: (upTo: number, object: unknown, stackOut: unknown[]) => void;
+
+/**
+ * Creates an Object processor with optional post-processing
+ * @param postProcess - Post-processor for normal flow
+ * @param postProcessSeen - Post-processor when circular refs are tracked
+ * @returns Object processing function
+ */
+export declare const processObject: (
+  postProcess?: (context: WalkContext) => void,
+  postProcessSeen?: (context: WalkContext) => void
+) => (object: unknown, context: WalkContext) => void;
+
+/**
+ * Post-processes an Object with circular reference resolution
+ * @param source - Original object
+ * @param descriptors - Property descriptors
+ * @param keys - Property keys
+ * @param context - Walk context
+ */
+export declare const postObjectCircular: (
+  source: unknown,
+  descriptors: Record<string | symbol, PropertyDescriptor>,
+  keys: Array<string | symbol>,
+  context: WalkContext
+) => void;
+
+/**
+ * Extracts property descriptors and keys from an object
+ * @param object - Object to analyze
+ * @param context - Walk context (uses symbols and allProps flags)
+ * @returns Descriptors and keys
+ */
+export declare const getObjectData: (
+  object: unknown,
+  context: WalkContext
+) => {descriptors: Record<string | symbol, PropertyDescriptor>; keys: Array<string | symbol>};
+
+/**
+ * Builds a new object from processed values on stackOut
+ * @param source - Original object (used for prototype and array detection)
+ * @param descriptors - Property descriptors
+ * @param keys - Property keys
+ * @param stackOut - Output stack with values
+ * @param wrap - Optional wrapper function
+ */
+export declare const buildNewObject: (
+  source: unknown,
+  descriptors: Record<string | symbol, PropertyDescriptor>,
+  keys: Array<string | symbol>,
+  stackOut: unknown[],
+  wrap?: (object: unknown) => unknown
+) => void;
+
+/**
+ * Resolves a Variable to its bound value and pushes to the stack
+ * @param val - Variable instance
+ * @param context - Walk context (uses context.env)
+ */
+export declare const processVariable: (val: unknown, context: WalkContext) => void;
+
+/**
+ * Executes a Command's function
+ * @param val - Command instance
+ * @param context - Walk context
+ */
+export declare const processCommand: (val: unknown, context: WalkContext) => void;
+
+/**
+ * Resolves circular reference actions for a seen object
+ * @param seen - Map of seen objects
+ * @param source - Source object
+ * @param value - Resolved value
+ */
+export declare const setObject: (seen: Map<unknown, {value?: unknown; actions?: Array<[unknown, unknown]>}>, source: unknown, value: unknown) => void;
+
+export default walk;

package/src/deep6/traverse/walk.js

@@ -34,7 +34,10 @@ const processCircular = (value, context) => context.stackOut.push(new Circular(v
 
 const processMap = (postProcess, postProcessSeen) => (object, context) => {
   const stack = context.stack;
-  postProcess && stack.push(new Command(postProcessSeen ? (context.seen ? postProcessSeen : postProcess) : postProcess, object));
+  if (postProcess) {
+    const processor = context.seen && postProcessSeen ? postProcessSeen : postProcess;
+    stack.push(new Command(processor, object));
+  }
   for (const value of object.values()) {
     stack.push(value);
   }
@@ -170,8 +173,9 @@ class Command {
 
 const processCommand = (val, context) => val.f(context);
 
-const defaultRegistry = [Command, processCommand, Array, processObject(), Date, nop, RegExp, nop, Map, processMap(), Set, nop, Promise, nop],
-  defaultFilters = [];
+const defaultRegistry = [Command, processCommand, Array, processObject(), Date, nop, RegExp, nop, Map, processMap(), Set, nop, Promise, nop];
+typeof URL == 'function' && defaultRegistry.push(URL, nop);
+const defaultFilters = [];
 
 // add more types
 
@@ -257,6 +261,7 @@ export {
   getObjectData,
   buildNewObject,
   processVariable,
-  processCommand
+  processCommand,
+  walk
 };
 export default walk;

package/src/deep6/unifiers/matchCondition.d.ts

@@ -0,0 +1,45 @@
+// Type definitions for deep6 matchCondition unifier
+// Generated from src/unifiers/matchCondition.js
+
+import type {Unifier, Env} from '../env.js';
+
+/**
+ * Predicate-based matching unifier
+ *
+ * Delegates matching to a user-supplied function that receives
+ * the full unification context (value, stacks, environment).
+ */
+export declare class MatchCondition extends Unifier {
+  /** Predicate function */
+  f: (val: unknown, ls: unknown[], rs: unknown[], env: Env) => boolean;
+
+  /**
+   * @param f - Predicate that returns true if the value matches
+   */
+  constructor(f: (val: unknown, ls: unknown[], rs: unknown[], env: Env) => boolean);
+
+  /**
+   * Delegates to the predicate function
+   * @param val - Value to test
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns Result of the predicate
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Creates a predicate matcher
+ *
+ * @param f - Predicate function `(val, ls, rs, env) => boolean`
+ * @returns A new MatchCondition instance
+ *
+ * @example
+ * ```ts
+ * const isPositive = matchCondition(val => typeof val === 'number' && val > 0);
+ * match({n: 5}, {n: isPositive}); // true
+ * ```
+ */
+export declare const matchCondition: (f: (val: unknown, ls: unknown[], rs: unknown[], env: Env) => boolean) => MatchCondition;
+export default matchCondition;

package/src/deep6/unifiers/matchCondition.js

@@ -13,4 +13,5 @@ class MatchCondition extends Unifier {
 
 const matchCondition = f => new MatchCondition(f);
 
+export {matchCondition};
 export default matchCondition;

package/src/deep6/unifiers/matchInstanceOf.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for deep6 matchInstanceOf unifier
+// Generated from src/unifiers/matchInstanceOf.js
+
+import type {Unifier} from '../env.js';
+
+/**
+ * Instanceof-based matching unifier
+ *
+ * Matches values by their prototype chain. Rejects falsy values and unbound Variables.
+ */
+export declare class MatchInstanceOf extends Unifier {
+  /** Array of constructors to match against */
+  types: (new (...args: any[]) => unknown)[];
+
+  /**
+   * @param types - Constructor or array of constructors
+   */
+  constructor(types: (new (...args: any[]) => unknown) | (new (...args: any[]) => unknown)[]);
+
+  /**
+   * Tests if the value is an instance of one of the configured constructors
+   * @param val - Value to check
+   * @param ls - Left argument stack (unused)
+   * @param rs - Right argument stack (unused)
+   * @returns True if val is an instance of any configured type
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[]): boolean;
+}
+
+/**
+ * Creates an instanceof matcher
+ *
+ * @param types - Constructor(s) to match against
+ * @returns A new MatchInstanceOf instance
+ */
+export declare const matchInstanceOf: (types: (new (...args: any[]) => unknown) | (new (...args: any[]) => unknown)[]) => MatchInstanceOf;
+export default matchInstanceOf;

package/src/deep6/unifiers/matchInstanceOf.js

@@ -13,4 +13,5 @@ class MatchInstanceOf extends Unifier {
 
 const matchInstanceOf = types => new MatchInstanceOf(types);
 
+export {matchInstanceOf};
 export default matchInstanceOf;

package/src/deep6/unifiers/matchString.d.ts

@@ -0,0 +1,56 @@
+// Type definitions for deep6 matchString unifier
+// Generated from src/unifiers/matchString.js
+
+import type {Unifier} from '../env.js';
+
+/**
+ * RegExp-based string matching unifier
+ *
+ * Matches values against a regular expression. Optionally captures
+ * the match array and match properties (index, input) for variable binding.
+ */
+export declare class MatchString extends Unifier {
+  /** Regular expression to match against */
+  regexp: RegExp;
+  /** Pattern to unify with the match result array (optional) */
+  matches?: unknown;
+  /** Pattern to unify with match properties {index, input} (optional) */
+  props?: unknown;
+
+  /**
+   * @param regexp - Regular expression to match
+   * @param matches - Pattern to unify with match array (optional)
+   * @param props - Pattern to unify with {index, input} (optional)
+   */
+  constructor(regexp: RegExp, matches?: unknown, props?: unknown);
+
+  /**
+   * Tests a value against the regex and pushes capture bindings
+   * @param val - Value to match (coerced to string)
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @returns Truthy if the regex matches
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[]): boolean;
+}
+
+/**
+ * Creates a regex string matcher
+ *
+ * @param regexp - Regular expression to match against
+ * @param matches - Pattern to unify with the full match array (optional)
+ * @param props - Pattern to unify with {index, input} (optional)
+ * @returns A new MatchString instance
+ *
+ * @example
+ * ```ts
+ * // Simple matching
+ * matchString(/^hello/i);
+ *
+ * // With captures bound to a variable array
+ * const names = [any, variable('first'), variable('last')];
+ * matchString(/^(\w+)\s+(\w+)$/, names);
+ * ```
+ */
+export declare const matchString: (regexp: RegExp, matches?: unknown, props?: unknown) => MatchString;
+export default matchString;

package/src/deep6/unifiers/matchString.js

@@ -30,4 +30,5 @@ class MatchString extends Unifier {
 
 const matchString = (regexp, matches, props) => new MatchString(regexp, matches, props);
 
+export {matchString};
 export default matchString;

package/src/deep6/unifiers/matchTypeOf.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for deep6 matchTypeOf unifier
+// Generated from src/unifiers/matchTypeOf.js
+
+import type {Unifier} from '../env.js';
+
+/**
+ * Type-based matching unifier
+ *
+ * Matches values by their `typeof` result. Rejects unbound Variables.
+ */
+export declare class MatchTypeOf extends Unifier {
+  /** Array of type names to match against */
+  types: string[];
+
+  /**
+   * @param types - Type name or array of type names
+   */
+  constructor(types: string | string[]);
+
+  /**
+   * Tests if the value's typeof matches one of the configured types
+   * @param val - Value to check
+   * @param ls - Left argument stack (unused)
+   * @param rs - Right argument stack (unused)
+   * @returns True if typeof val matches
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[]): boolean;
+}
+
+/**
+ * Creates a typeof matcher
+ *
+ * @param types - Type name(s) to match against (e.g. 'string', ['number', 'bigint'])
+ * @returns A new MatchTypeOf instance
+ */
+export declare const matchTypeOf: (types: string | string[]) => MatchTypeOf;
+export default matchTypeOf;

package/src/deep6/unifiers/matchTypeOf.js

@@ -13,4 +13,5 @@ class MatchTypeOf extends Unifier {
 
 const matchTypeOf = types => new MatchTypeOf(types);
 
+export {matchTypeOf};
 export default matchTypeOf;

package/src/deep6/unifiers/ref.d.ts

@@ -0,0 +1,52 @@
+// Type definitions for deep6 ref unifier
+// Generated from src/unifiers/ref.js
+
+import type {Variable, Env} from '../env.js';
+
+/**
+ * Reference unifier for cross-pattern variable binding
+ *
+ * Binds both a variable and a value to the same input during unification.
+ * Pushes `(this.value, val)` and `(this.variable, val)` onto the stacks.
+ */
+export declare class Ref extends Variable {
+  /** The variable being referenced */
+  variable: Variable;
+  /** The value pattern to unify against */
+  value: unknown;
+
+  /**
+   * @param variable - Variable name (string) or Variable instance
+   * @param value - Value pattern to bind alongside the variable
+   */
+  constructor(variable: string | Variable, value: unknown);
+
+  /**
+   * Pushes value and variable bindings onto the stacks
+   * @param val - Input value
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns Always true
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Creates a reference unifier
+ *
+ * @param variable - Variable name or Variable instance
+ * @param value - Value pattern to bind alongside the variable
+ * @returns A new Ref instance
+ *
+ * @example
+ * ```ts
+ * const r = ref('x', variable('y'));
+ * // During unification, both 'x' and 'y' get bound to the matched value
+ * ```
+ */
+export declare const ref: ((variable: string | Variable, value: unknown) => Ref) & {
+  Ref: typeof Ref;
+};
+
+export default ref;

package/src/deep6/unifiers/ref.js

@@ -18,4 +18,5 @@ class Ref extends Variable {
 const ref = (variable, value) => new Ref(variable, value);
 ref.Ref = Ref;
 
+export {ref};
 export default ref;

package/src/deep6/unify.d.ts

@@ -0,0 +1,95 @@
+// Type definitions for deep6 unification
+// Generated from src/unify.js
+
+import {Env, Unifier, Variable} from './env.js';
+
+/**
+ * Options for unification
+ */
+export interface UnifyOptions {
+  /** Handle circular references (default: false) */
+  circular?: boolean;
+  /** Include symbol properties (default: false) */
+  symbols?: boolean;
+  /** Use loose equality for primitives (default: false) */
+  loose?: boolean;
+  /** Ignore function properties (default: false) */
+  ignoreFunctions?: boolean;
+  /** Distinguish +0 from -0 (default: false) */
+  signedZero?: boolean;
+  /** Allow extra keys on target objects (default: false) */
+  openObjects?: boolean;
+  /** Allow extra elements in target arrays (default: false) */
+  openArrays?: boolean;
+  /** Allow extra entries in target Maps (default: false) */
+  openMaps?: boolean;
+  /** Allow extra entries in target Sets (default: false) */
+  openSets?: boolean;
+}
+
+/**
+ * Core unification algorithm
+ *
+ * Attempts to unify two values, optionally binding variables.
+ * Returns an Env with bindings on success, or null on failure.
+ *
+ * @param l - Left value
+ * @param r - Right value
+ * @param env - Existing environment, options object, or null
+ * @param options - Unification options (when env is provided separately)
+ * @returns Environment with bindings, or null on failure
+ */
+export declare const unify: (l: unknown, r: unknown, env?: Env | UnifyOptions | null, options?: UnifyOptions) => Env | null;
+
+/**
+ * Flat array of type-specific unifier pairs: [Constructor, handler, Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom type handler.
+ * Handler signature: `(l, r, ls, rs, env) => boolean`
+ */
+export declare const registry: unknown[];
+
+/**
+ * Flat array of filter pairs: [predicate, handler, predicate, handler, ...]
+ *
+ * Use `filters.push(predicate, handler)` to register a custom filter.
+ */
+export declare const filters: unknown[];
+
+/**
+ * Wraps a value for open matching (target may have extra properties)
+ * @param o - Value to wrap
+ * @returns Open-wrapped value
+ */
+export declare const open: <T>(o: T) => T;
+
+/**
+ * Wraps a value for soft matching (bidirectional open, updates both sides)
+ * @param o - Value to wrap
+ * @returns Soft-wrapped value
+ */
+export declare const soft: <T>(o: T) => T;
+
+/**
+ * Checks if a value is open-wrapped
+ * @param o - Value to check
+ */
+export declare const isOpen: (o: unknown) => boolean;
+
+/**
+ * Checks if a value is soft-wrapped
+ * @param o - Value to check
+ */
+export declare const isSoft: (o: unknown) => boolean;
+
+/**
+ * Checks if a value is wrapped (open or soft)
+ * @param o - Value to check
+ */
+export declare const isWrapped: (o: unknown) => boolean;
+
+// Re-exports from env.js (value exports, usable as constructors)
+export {Env, Unifier, Variable} from './env.js';
+export {_, any, isUnifier, isVariable, variable} from './env.js';
+
+export default unify;