tape-six 1.7.12 → 1.7.14

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2005-2022 Eugene Lazutkin
+Copyright 2005-2026 Eugene Lazutkin
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 

package/README.md

@@ -425,6 +425,8 @@ 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._
 - 1.7.10 _Switched from workflows to Agent Skills (agentskills.io) for consumer integration. Improved CJS import docs._

package/bin/tape6-bun.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 
+import process from 'node:process';
 import {fileURLToPath} from 'node:url';
 
 import {
@@ -68,12 +69,16 @@ const main = async () => {
 
   if (currentOptions.optionFlags['--info'] === '') {
     showInfo(currentOptions, files);
-    process.exit(0);
+    await new Promise(r => process.stdout.write('', r));
+    process.exitCode = 0;
+    return;
   }
 
   if (!files.length) {
     console.log('No files found.');
-    process.exit(1);
+    await new Promise(r => process.stdout.write('', r));
+    process.exitCode = 1;
+    return;
   }
 
   const reporter = getReporter(),
@@ -94,7 +99,8 @@ const main = async () => {
     fail: hasFailed
   });
 
-  process.exit(hasFailed ? 1 : 0);
+  await new Promise(r => process.stdout.write('', r));
+  process.exitCode = hasFailed ? 1 : 0;
 };
 
 main().catch(error => console.error('ERROR:', error));

package/bin/tape6-deno.js

@@ -70,13 +70,15 @@ const main = async () => {
   if (currentOptions.optionFlags['--info'] === '') {
     showInfo(currentOptions, files);
     await new Promise(r => process.stdout.write('', r));
-    Deno.exit(0);
+    process.exitCode = 0;
+    return;
   }
 
   if (!files.length) {
     console.log('No files found.');
     await new Promise(r => process.stdout.write('', r));
-    Deno.exit(1);
+    process.exitCode = 1;
+    return;
   }
 
   const reporter = getReporter(),
@@ -98,7 +100,7 @@ const main = async () => {
   });
 
   await new Promise(r => process.stdout.write('', r));
-  Deno.exit(hasFailed ? 1 : 0);
+  process.exitCode = hasFailed ? 1 : 0;
 };
 
 main().catch(error => console.error('ERROR:', error));

package/bin/tape6-node.js

@@ -69,12 +69,16 @@ const main = async () => {
 
   if (currentOptions.optionFlags['--info'] === '') {
     showInfo(currentOptions, files);
-    process.exit(0);
+    await new Promise(r => process.stdout.write('', r));
+    process.exitCode = 0;
+    return;
   }
 
   if (!files.length) {
     console.log('No files found.');
-    process.exit(1);
+    await new Promise(r => process.stdout.write('', r));
+    process.exitCode = 1;
+    return;
   }
 
   const reporter = getReporter(),
@@ -95,7 +99,8 @@ const main = async () => {
     fail: hasFailed
   });
 
-  process.exit(hasFailed ? 1 : 0);
+  await new Promise(r => process.stdout.write('', r));
+  process.exitCode = hasFailed ? 1 : 0;
 };
 
 main().catch(error => console.error('ERROR:', error));

package/bin/tape6-seq.js

@@ -79,13 +79,15 @@ const main = async () => {
   if (currentOptions.optionFlags['--info'] === '') {
     showInfo(currentOptions, files);
     await new Promise(r => process.stdout.write('', r));
-    process.exit(0);
+    process.exitCode = 0;
+    return;
   }
 
   if (!files.length) {
     console.log('No files found.');
     await new Promise(r => process.stdout.write('', r));
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
 
   const reporter = getReporter(),
@@ -107,7 +109,7 @@ const main = async () => {
   });
 
   await new Promise(r => process.stdout.write('', r));
-  process.exit(hasFailed ? 1 : 0);
+  process.exitCode = hasFailed ? 1 : 0;
 };
 
 main().catch(error => console.error('ERROR:', error));

package/index.js

@@ -46,6 +46,7 @@ const init = async () => {
   const isNode = typeof process == 'object' && process.versions?.node,
     isDeno = typeof Deno == 'object',
     isBun = typeof Bun == 'object',
+    isCli = isNode || isBun || isDeno,
     isBrowser = typeof window == 'object' && !!window.location,
     options = {};
 
@@ -74,7 +75,7 @@ const init = async () => {
 
   let originalConsole = null,
     setCurrentReporter = null;
-  if (!options.noConsoleCapture && (isNode || isBun || isDeno)) {
+  if (!options.noConsoleCapture && isCli) {
     const {captureConsole, setCurrentReporter: setReporter} = await import(
       new URL('./src/utils/capture-console.js', import.meta.url)
     );
@@ -161,7 +162,7 @@ const init = async () => {
     setCurrentReporter?.(reporter);
   }
 
-  return {options, isBrowser, isBun, isDeno, isNode};
+  return {options, isBrowser, isBun, isDeno, isNode, isCli};
 };
 
 const getTestFileName = ({isBrowser, isBun, isDeno, isNode}) => {
@@ -193,7 +194,7 @@ const testRunner = async () => {
     settings = await init();
   }
 
-  const {isBrowser, isBun, isDeno, isNode} = settings,
+  const {isBrowser, isCli} = settings,
     reporter = getReporter(),
     testFileName = getTestFileName(settings);
 
@@ -235,13 +236,9 @@ const testRunner = async () => {
     fail: runHasFailed
   });
 
-  if (!getConfiguredFlag()) {
-    if (isDeno) {
-      runHasFailed && Deno.exit(1);
-    } else if (isBun) {
-      runHasFailed && process.exit(1);
-    } else if (isNode) {
-      runHasFailed && process.exit(1);
+  if (!getConfiguredFlag() && runHasFailed) {
+    if (isCli) {
+      process.exitCode = 1;
     }
   }
   if (isBrowser && typeof __tape6_reportResults == 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tape-six",
-  "version": "1.7.12",
+  "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",
@@ -104,6 +104,6 @@
     "@types/chai": "^5.2.3",
     "@types/node": "^25.5.0",
     "chai": "^6.2.2",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   }
 }

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;