tape-six 1.7.13 → 1.7.14

package/README.md

@@ -425,6 +425,7 @@ Test output can be controlled by flags. See [Supported flags](https://github.com
 
 The most recent releases:
 
+- 1.7.14 _Updated vendored `deep6` to 1.2.0: added `URL` support (unifier/walker/cloner + processors), named exports alongside default exports, fast path for naked objects, performance optimizations, improved TS typings, removed CommonJS build._
 - 1.7.13 _Replaced `process.exit()` / `Deno.exit()` with `process.exitCode` in test runners and `index.js` for graceful stdout flushing. Updated dependencies, GitHub Actions._
 - 1.7.12 _Added `--help`/`-h` and `--version`/`-v` options to all CLI utilities. Added flag documentation to help output._
 - 1.7.11 _Documentation consistency: added missing sequential test commands to AI docs, fixed test glob references._

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.7.13",
+  "version": "1.7.14",
   "description": "TAP-inspired unit test library for Node, Deno, Bun, and browsers. ES modules, TypeScript, zero dependencies.",
   "type": "module",
   "main": "index.js",

package/src/deep6/env.d.ts

@@ -0,0 +1,174 @@
+// Type definitions for deep6 environment
+// Generated from src/env.js
+
+/**
+ * Unification environment managing variable bindings and stack frames
+ *
+ * Maintains two parallel prototype-chain structures:
+ * - `variables`: maps variable names to their alias groups
+ * - `values`: maps variable names/aliases to their bound values
+ *
+ * Stack frames enable scoped bindings that can be reverted.
+ */
+export declare class Env {
+  /** Map of variable names to their alias groups */
+  variables: Record<string | symbol, unknown>;
+  /** Map of variable names/aliases to their bound values */
+  values: Record<string | symbol, unknown>;
+  /** Current stack frame depth */
+  depth: number;
+
+  constructor();
+
+  /** Pushes a new stack frame for nested scoping */
+  push(): void;
+
+  /**
+   * Pops the current stack frame, reverting bindings
+   * @throws {Error} If stack is empty
+   */
+  pop(): void;
+
+  /**
+   * Reverts to a specific stack frame depth
+   * @param depth - Target depth to revert to
+   * @throws {Error} If depth is higher than current depth
+   */
+  revert(depth: number): void;
+
+  /**
+   * Creates an alias between two variable names
+   * @param name1 - First variable name
+   * @param name2 - Second variable name
+   */
+  bindVar(name1: string | symbol, name2: string | symbol): void;
+
+  /**
+   * Binds a variable name (and its aliases) to a value
+   * @param name - Variable name to bind
+   * @param val - Value to bind
+   */
+  bindVal(name: string | symbol, val: unknown): void;
+
+  /**
+   * Checks if a variable is bound to a value
+   * @param name - Variable name to check
+   * @returns True if variable has a bound value
+   */
+  isBound(name: string | symbol): boolean;
+
+  /**
+   * Checks if two variable names are aliases
+   * @param name1 - First variable name
+   * @param name2 - Second variable name
+   * @returns True if variables are aliases
+   */
+  isAlias(name1: string | symbol, name2: string | symbol): boolean;
+
+  /**
+   * Gets the value bound to a variable
+   * @param name - Variable name
+   * @returns The bound value, or undefined if unbound
+   */
+  get(name: string | symbol): unknown;
+
+  /**
+   * Returns all variable bindings (for debugging)
+   * @returns Array of name/value pairs
+   */
+  getAllValues(): Array<{name: string | symbol; value: unknown}>;
+}
+
+/**
+ * Base class for custom unification behavior
+ *
+ * Subclasses must implement the `unify` method.
+ */
+export declare class Unifier {
+  /**
+   * Unifies this unifier with a value
+   * @param val - Value to unify with
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns True if unification succeeds
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Type guard for Unifier instances
+ * @param x - Value to check
+ * @returns True if x is a Unifier
+ */
+export declare const isUnifier: (x: unknown) => x is Unifier;
+
+/**
+ * Wildcard symbol that matches any value during unification
+ */
+export declare const any: unique symbol;
+
+/** Alias for `any` */
+export declare const _: typeof any;
+
+/**
+ * Logical variable for capturing values during unification
+ *
+ * Variables can be bound to values, aliased to other variables,
+ * and dereferenced through an Env.
+ */
+export declare class Variable extends Unifier {
+  /** Variable identifier */
+  name: string | symbol;
+
+  /**
+   * @param name - Optional identifier (defaults to a unique Symbol)
+   */
+  constructor(name?: string | symbol);
+
+  /**
+   * Checks if this variable is bound in the given environment
+   * @param env - Unification environment
+   * @returns True if bound
+   */
+  isBound(env: Env): boolean;
+
+  /**
+   * Checks if this variable is aliased to another
+   * @param name - Variable name, symbol, or Variable instance
+   * @param env - Unification environment
+   * @returns True if aliased
+   */
+  isAlias(name: Variable | string | symbol, env: Env): boolean;
+
+  /**
+   * Gets the bound value of this variable
+   * @param env - Unification environment
+   * @returns The bound value, or undefined if unbound
+   */
+  get(env: Env): unknown;
+
+  /**
+   * Unifies this variable with a value
+   * @param val - Value to unify with
+   * @param ls - Left argument stack
+   * @param rs - Right argument stack
+   * @param env - Unification environment
+   * @returns True if unification succeeds
+   */
+  unify(val: unknown, ls: unknown[], rs: unknown[], env: Env): boolean;
+}
+
+/**
+ * Type guard for Variable instances
+ * @param x - Value to check
+ * @returns True if x is a Variable
+ */
+export declare const isVariable: (x: unknown) => x is Variable;
+
+/**
+ * Creates a new Variable
+ * @param name - Optional identifier (defaults to a unique Symbol)
+ * @returns A new Variable instance
+ */
+export declare const variable: (name?: string | symbol) => Variable;

package/src/deep6/env.js

@@ -13,7 +13,7 @@ const collectSymbols = object => {
 };
 
 const ensure = (object, depth) => {
-  while (object[keyDepth] > depth) object = object.getPrototypeOf(object);
+  while (object[keyDepth] > depth) object = Object.getPrototypeOf(object);
   if (object[keyDepth] < depth) {
     object = Object.create(object);
     object[keyDepth] = depth;
@@ -90,14 +90,14 @@ class Env {
   }
   // helpers
   isBound(name) {
-    return name in env.values;
+    return name in this.values;
   }
   isAlias(name1, name2) {
-    const u = env.variables[name2];
+    const u = this.variables[name2];
     return u && u[name1] === 1;
   }
   get(name) {
-    return env.values[name];
+    return this.values[name];
   }
   // debugging
   getAllValues() {

package/src/deep6/index.d.ts

@@ -0,0 +1,86 @@
+// Type definitions for deep6
+// Generated from src/index.js
+
+/**
+ * Options for deep equality comparison
+ */
+export interface EqualOptions {
+  /** Handle circular references (default: true) */
+  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;
+}
+
+/**
+ * Options for pattern matching
+ */
+export interface MatchOptions {
+  /** Allow extra keys on target objects (default: true) */
+  openObjects?: boolean;
+  /** Allow extra entries in target Maps (default: true) */
+  openMaps?: boolean;
+  /** Allow extra entries in target Sets (default: true) */
+  openSets?: boolean;
+  /** Allow extra elements in target arrays (default: false) */
+  openArrays?: boolean;
+  /** Handle circular references (default: true) */
+  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;
+}
+
+/**
+ * Options for deep cloning via the main API
+ */
+export interface CloneOptions {
+  /** Handle circular references (default: true) */
+  circular?: boolean;
+  /** Clone symbol properties (default: false) */
+  symbols?: boolean;
+  /** Clone non-enumerable properties (default: false) */
+  allProps?: boolean;
+}
+
+/**
+ * Deep equality check using unification
+ * @param a - First value
+ * @param b - Second value
+ * @param options - Comparison options
+ * @returns True if values are deeply equal
+ */
+export declare const equal: (a: unknown, b: unknown, options?: EqualOptions) => boolean;
+
+/**
+ * Deep clone of a value
+ * @param a - Value to clone
+ * @param options - Cloning options
+ * @returns Deep copy of the value
+ */
+export declare const clone: <T>(a: T, options?: CloneOptions) => T;
+
+/**
+ * Pattern matching with wildcards
+ * @param object - Value to test
+ * @param pattern - Pattern to match against
+ * @param options - Matching options
+ * @returns True if object matches the pattern
+ */
+export declare const match: (object: unknown, pattern: unknown, options?: MatchOptions) => boolean;
+
+/** Alias for `match` */
+export declare const isShape: typeof match;
+
+export {any, _} from './env.js';
+
+/** Default export — deep equality function */
+export default equal;

package/src/deep6/index.js

@@ -7,13 +7,16 @@ const defaultOptions = {circular: true};
 const equal = (a, b, options = defaultOptions) => !!unify(a, b, null, options);
 
 const defaultMatchOptions = {openObjects: true, openMaps: true, openSets: true, circular: true};
-const match = (object, pattern, options = defaultMatchOptions) =>
-  !!unify(object, preprocess(pattern, options), null, {
-    circular: options.circular,
-    symbols: options.symbols,
-    loose: options.loose,
-    ignoreFunctions: options.ignoreFunctions
-  });
+const match = (object, pattern, options = defaultMatchOptions) => {
+  const processedPattern = preprocess(pattern, options),
+    unifyOptions = {
+      circular: options.circular,
+      symbols: options.symbols,
+      loose: options.loose,
+      ignoreFunctions: options.ignoreFunctions
+    };
+  return !!unify(object, processedPattern, null, unifyOptions);
+};
 
 const clone = (a, options = defaultOptions) => originalClone(a, null, options);
 

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

@@ -0,0 +1,59 @@
+// Type definitions for deep6 assemble
+// Generated from src/traverse/assemble.js
+
+import type {Env} from '../env.js';
+import type {WalkContext} from './walk.js';
+
+/**
+ * Options for assembly
+ */
+export interface AssembleOptions {
+  /** Handle circular references (default: false) */
+  circular?: boolean;
+  /** Include symbol properties (default: false) */
+  symbols?: boolean;
+  /** Include non-enumerable properties (default: false) */
+  allProps?: boolean;
+  /** Custom context object */
+  context?: Record<string, unknown>;
+  /** 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;
+  /** Custom type handler registry (flat array of [Constructor, handler] pairs) */
+  registry?: unknown[];
+  /** Custom filter functions */
+  filters?: Array<(val: unknown, context: WalkContext) => boolean>;
+}
+
+/**
+ * Flat array of type-specific assembler pairs: [Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom assembler.
+ */
+export declare const registry: unknown[];
+
+/**
+ * Filter functions for custom assembly processing
+ */
+export declare const filters: Array<(val: unknown, context: WalkContext) => boolean>;
+
+/**
+ * Replaces variables with their bound values from an environment
+ *
+ * Creates a new structure only when values differ from the source.
+ * Unbound variables are kept as-is.
+ *
+ * @param source - Value containing variables to resolve
+ * @param env - Env with bindings, or options object
+ * @param options - Assembly options (when env is provided separately)
+ * @returns New value with variables replaced, or original if unchanged
+ */
+export declare const assemble: ((source: unknown, env?: Env | AssembleOptions | null, options?: AssembleOptions) => unknown) & {
+  registry: unknown[];
+  filters: Array<(val: unknown, context: WalkContext) => boolean>;
+};
+
+export default assemble;

package/src/deep6/traverse/assemble.js

@@ -52,7 +52,7 @@ function postProcessSeen(context) {
   }
 }
 
-const postProcessMap = context => {
+function postProcessMap(context) {
   const stackOut = context.stackOut,
     s = this.s;
   let j = stackOut.length - 1;
@@ -65,7 +65,7 @@ const postProcessMap = context => {
   } else {
     replaceObject(j, s, stackOut);
   }
-};
+}
 
 function postProcessMapSeen(context) {
   const stackOut = context.stackOut,
@@ -108,6 +108,7 @@ const registry = [
 
 const addType = (Type, process) => registry.push(Type, process || processOther);
 
+typeof URL == 'function' && addType(URL);
 typeof Int8Array == 'function' && addType(Int8Array);
 typeof Uint8Array == 'function' && addType(Uint8Array);
 typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
@@ -154,5 +155,5 @@ const assemble = (source, env, options) => {
 assemble.registry = registry;
 assemble.filters = filters;
 
-export {registry, filters};
+export {registry, filters, assemble};
 export default assemble;

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

@@ -0,0 +1,57 @@
+// Type definitions for deep6 clone
+// Generated from src/traverse/clone.js
+
+import type {Env} from '../env.js';
+import type {WalkContext} from './walk.js';
+
+/**
+ * Options for deep cloning
+ */
+export interface CloneOptions {
+  /** Handle circular references (default: true in main API) */
+  circular?: boolean;
+  /** Clone symbol properties (default: false) */
+  symbols?: boolean;
+  /** Clone non-enumerable properties (default: false) */
+  allProps?: boolean;
+  /** Custom context object */
+  context?: Record<string, unknown>;
+  /** 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;
+  /** Custom type handler registry (flat array of [Constructor, handler] pairs) */
+  registry?: unknown[];
+  /** Custom filter functions — return true to indicate value was handled */
+  filters?: Array<(val: unknown, context: WalkContext) => boolean>;
+}
+
+/**
+ * Flat array of type-specific cloner pairs: [Constructor, handler, Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom type cloner.
+ * Handler signature: `(val, context) => void` (push result to context.stackOut)
+ */
+export declare const registry: unknown[];
+
+/**
+ * Filter functions for custom clone processing — return true to indicate value was handled
+ */
+export declare const filters: Array<(val: unknown, context: WalkContext) => boolean>;
+
+/**
+ * Deep clones a value with circular reference handling
+ *
+ * @param source - Value to clone
+ * @param env - Optional Env for variable resolution, or options object
+ * @param options - Cloning options (when env is provided separately)
+ * @returns Deep copy of the value
+ */
+export declare const clone: (<T>(source: T, env?: Env | CloneOptions | null, options?: CloneOptions) => T) & {
+  registry: unknown[];
+  filters: Array<(val: unknown, context: WalkContext) => boolean>;
+};
+
+export default clone;

package/src/deep6/traverse/clone.js

@@ -45,7 +45,7 @@ const registry = [
     Date,
     (val, context) => context.stackOut.push(new Date(val.getTime())),
     RegExp,
-    (val, context) => context.stackOut.push(new RegExp(val.source, (val.global ? 'g' : '') + (val.multiline ? 'm' : '') + (val.ignoreCase ? 'i' : ''))),
+    (val, context) => context.stackOut.push(new RegExp(val.source, val.flags)),
     Map,
     processMap(postProcessMap, postProcessMapSeen),
     Promise,
@@ -53,6 +53,8 @@ const registry = [
   ],
   filters = [];
 
+typeof URL == 'function' && registry.push(URL, (val, context) => context.stackOut.push(new URL(val.href)));
+
 // add more types
 
 const addType = (Type, process) => registry.push(Type, process || ((val, context) => context.stackOut.push(new Type(val))));
@@ -105,5 +107,5 @@ const clone = (source, env, options) => {
 clone.registry = registry;
 clone.filters = filters;
 
-export {registry, filters};
+export {registry, filters, clone};
 export default clone;

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

@@ -0,0 +1,59 @@
+// Type definitions for deep6 deref
+// Generated from src/traverse/deref.js
+
+import type {Env} from '../env.js';
+import type {WalkContext} from './walk.js';
+
+/**
+ * Options for dereferencing
+ */
+export interface DerefOptions {
+  /** Handle circular references (default: false) */
+  circular?: boolean;
+  /** Include symbol properties (default: false) */
+  symbols?: boolean;
+  /** Include non-enumerable properties (default: false) */
+  allProps?: boolean;
+  /** Custom context object */
+  context?: Record<string, unknown>;
+  /** 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;
+  /** Custom type handler registry (flat array of [Constructor, handler] pairs) */
+  registry?: unknown[];
+  /** Custom filter functions */
+  filters?: Array<(val: unknown, context: WalkContext) => boolean>;
+}
+
+/**
+ * Flat array of type-specific deref pairs: [Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom handler.
+ */
+export declare const registry: unknown[];
+
+/**
+ * Filter functions for custom deref processing
+ */
+export declare const filters: Array<(val: unknown, context: WalkContext) => boolean>;
+
+/**
+ * Replaces variables with bound values in-place
+ *
+ * Unlike assemble(), modifies the existing structure directly
+ * rather than creating a new one.
+ *
+ * @param source - Value to dereference (modified in-place)
+ * @param env - Env with bindings, or options object
+ * @param options - Deref options (when env is provided separately)
+ * @returns The same source value with variables replaced
+ */
+export declare const deref: ((source: unknown, env?: Env | DerefOptions | null, options?: DerefOptions) => unknown) & {
+  registry: unknown[];
+  filters: Array<(val: unknown, context: WalkContext) => boolean>;
+};
+
+export default deref;

package/src/deep6/traverse/deref.js

@@ -22,7 +22,7 @@ function postProcessMap(context) {
   const stackOut = context.stackOut,
     s = this.s;
   let j = stackOut.length - 1;
-  for (const key of s) {
+  for (const key of s.keys()) {
     s.set(key, stackOut[j--]);
   }
   replaceObject(j, s, stackOut);
@@ -54,6 +54,7 @@ const registry = [
 
 const addType = (Type, process) => registry.push(Type, process || processOther);
 
+typeof URL == 'function' && addType(URL);
 typeof Int8Array == 'function' && addType(Int8Array);
 typeof Uint8Array == 'function' && addType(Uint8Array);
 typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
@@ -100,5 +101,5 @@ const deref = (source, env, options) => {
 deref.registry = registry;
 deref.filters = filters;
 
-export {registry, filters};
+export {registry, filters, deref};
 export default deref;

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

@@ -0,0 +1,65 @@
+// Type definitions for deep6 preprocess
+// Generated from src/traverse/preprocess.js
+
+import type {WalkContext} from './walk.js';
+
+/**
+ * Options for pattern preprocessing
+ */
+export interface PreprocessOptions {
+  /** Wrap plain objects with open() (default: false) */
+  openObjects?: boolean;
+  /** Wrap arrays with open() (default: false) */
+  openArrays?: boolean;
+  /** Wrap Maps with open() (default: false) */
+  openMaps?: boolean;
+  /** Wrap Sets with open() (default: false) */
+  openSets?: boolean;
+  /** Handle circular references */
+  circular?: boolean;
+  /** Include symbol properties */
+  symbols?: boolean;
+  /** Include non-enumerable properties */
+  allProps?: boolean;
+  /** Custom context object */
+  context?: Record<string, unknown>;
+  /** 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;
+  /** Custom type handler registry (flat array of [Constructor, handler] pairs) */
+  registry?: unknown[];
+  /** Custom filter functions */
+  filters?: Array<(val: unknown, context: WalkContext) => boolean>;
+}
+
+/**
+ * Flat array of type-specific preprocessor pairs: [Constructor, handler, ...]
+ *
+ * Use `registry.push(Type, handler)` to register a custom preprocessor.
+ */
+export declare const registry: unknown[];
+
+/**
+ * Filter functions for custom preprocessing
+ */
+export declare const filters: Array<(val: unknown, context: WalkContext) => boolean>;
+
+/**
+ * Preprocesses a pattern for unification
+ *
+ * Wraps objects, arrays, Maps, and Sets with open/soft markers
+ * based on options. Used internally by match().
+ *
+ * @param source - Pattern to preprocess
+ * @param options - Preprocessing options
+ * @returns Preprocessed pattern ready for unification
+ */
+export declare const preprocess: ((source: unknown, options?: PreprocessOptions) => unknown) & {
+  registry: unknown[];
+  filters: Array<(val: unknown, context: WalkContext) => boolean>;
+};
+
+export default preprocess;

package/src/deep6/traverse/preprocess.js

@@ -63,6 +63,7 @@ const registry = [
 
 const addType = (Type, process) => registry.push(Type, process || processOther);
 
+typeof URL == 'function' && addType(URL);
 typeof Int8Array == 'function' && addType(Int8Array);
 typeof Uint8Array == 'function' && addType(Uint8Array);
 typeof Uint8ClampedArray == 'function' && addType(Uint8ClampedArray);
@@ -108,5 +109,5 @@ const preprocess = (source, options) => {
 preprocess.registry = registry;
 preprocess.filters = filters;
 
-export {registry, filters};
+export {registry, filters, preprocess};
 export default preprocess;