tape-six 1.7.13 → 1.8.0

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;