tape-six 1.7.13 → 1.8.0

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;

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;