deep6 1.1.3 → 1.2.0

package/package.json

@@ -1,100 +1,22 @@
 {
   "name": "deep6",
-  "version": "1.1.3",
-  "description": "No dependency mini-library: unification, deep equivalence, deep cloning.",
+  "version": "1.2.0",
+  "description": "deep6 is a no-dependency ES6 mini-library for advanced deep equivalence, unification, and cloning of JavaScript structures. Supports extensible pattern matching, circular reference handling, Map, Set, URL, typed arrays, symbols, and property descriptors.",
   "type": "module",
-  "module": "src/index.js",
-  "main": "cjs/index.js",
+  "main": "src/index.js",
   "exports": {
-    ".": {
-      "require": "./cjs/index.js",
-      "default": "./src/index.js"
-    },
-    "./*": {
-      "require": "./cjs/*",
-      "default": "./src/*"
-    },
-    "./env.js": {
-      "require": "./cjs/env.js",
-      "default": "./src/env.js"
-    },
-    "./index.js": {
-      "require": "./cjs/index.js",
-      "default": "./src/index.js"
-    },
-    "./unify.js": {
-      "require": "./cjs/unify.js",
-      "default": "./src/unify.js"
-    },
-    "./unifiers/matchConditions.js": {
-      "require": "./cjs/unifiers/matchConditions.js",
-      "default": "./src/unifiers/matchConditions.js"
-    },
-    "./unifiers/matchInstanceOf.js": {
-      "require": "./cjs/unifiers/matchInstanceOf.js",
-      "default": "./src/unifiers/matchInstanceOf.js"
-    },
-    "./unifiers/matchString.js": {
-      "require": "./cjs/unifiers/matchString.js",
-      "default": "./src/unifiers/matchString.js"
-    },
-    "./unifiers/matchTypeOf.js": {
-      "require": "./cjs/unifiers/matchTypeOf.js",
-      "default": "./src/unifiers/matchTypeOf.js"
-    },
-    "./unifiers/ref.js": {
-      "require": "./cjs/unifiers/ref.js",
-      "default": "./src/unifiers/ref.js"
-    },
-    "./traverse/assemble.js": {
-      "require": "./cjs/traverse/assemble.js",
-      "default": "./src/traverse/assemble.js"
-    },
-    "./traverse/clone.js": {
-      "require": "./cjs/traverse/clone.js",
-      "default": "./src/traverse/clone.js"
-    },
-    "./traverse/deref.js": {
-      "require": "./cjs/traverse/deref.js",
-      "default": "./src/traverse/deref.js"
-    },
-    "./traverse/preprocess.js": {
-      "require": "./cjs/traverse/preprocess.js",
-      "default": "./src/traverse/preprocess.js"
-    },
-    "./traverse/walk.js": {
-      "require": "./cjs/traverse/walk.js",
-      "default": "./src/traverse/walk.js"
-    },
-    "./utils/replaceVars.js": {
-      "require": "./cjs/utils/replaceVars.js",
-      "default": "./src/utils/replaceVars.js"
-    },
-    "./cjs": "./cjs/index.js",
-    "./cjs/*": "./cjs/*",
-    "./cjs/env.js": "./cjs/env.js",
-    "./cjs/index.js": "./cjs/index.js",
-    "./cjs/unify.js": "./cjs/unify.js",
-    "./cjs/unifiers/matchConditions.js": "./cjs/unifiers/matchConditions.js",
-    "./cjs/unifiers/matchInstanceOf.js": "./cjs/unifiers/matchInstanceOf.js",
-    "./cjs/unifiers/matchString.js": "./cjs/unifiers/matchString.js",
-    "./cjs/unifiers/matchTypeOf.js": "./cjs/unifiers/matchTypeOf.js",
-    "./cjs/unifiers/ref.js": "./cjs/unifiers/ref.js",
-    "./cjs/traverse/assemble.js": "./cjs/traverse/assemble.js",
-    "./cjs/traverse/clone.js": "./cjs/traverse/clone.js",
-    "./cjs/traverse/deref.js": "./cjs/traverse/deref.js",
-    "./cjs/traverse/preprocess.js": "./cjs/traverse/preprocess.js",
-    "./cjs/traverse/walk.js": "./cjs/traverse/walk.js",
-    "./cjs/utils/replaceVars.js": "./cjs/utils/replaceVars.js"
+    ".": "./src/index.js",
+    "./*": "./src/*"
   },
   "scripts": {
     "start": "node tests/server.js --trace",
     "test": "node tests/tests.js",
+    "test:bun": "bun run tests/tests.js",
+    "test:deno": "deno run --allow-read tests/tests.js",
     "debug": "node --inspect-brk tests/tests.js",
-    "prepareDist": "node scripts/prepareDist.js",
-    "babel": "babel src --out-dir cjs",
-    "build": "npm run prepareDist && npm run babel",
-    "prepublishOnly": "npm run build"
+    "ts-check": "tsc --noEmit",
+    "lint": "prettier --check .",
+    "lint:fix": "prettier --write ."
   },
   "repository": {
     "type": "git",
@@ -102,36 +24,36 @@
   },
   "keywords": [
     "deep",
-    "unification",
-    "equivalence",
-    "comparison",
     "deep equivalence",
+    "deep equality",
+    "deep compare",
+    "unification",
+    "unify",
+    "pattern matching",
+    "pattern match",
+    "wildcard",
     "clone",
     "deep clone",
     "deep cloning",
-    "traversing"
+    "copy",
+    "deep copy",
+    "traversing",
+    "traverse",
+    "walk",
+    "logical variables",
+    "es6",
+    "no dependencies"
   ],
   "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (https://www.lazutkin.com/)",
+  "funding": "https://github.com/sponsors/uhop",
   "license": "BSD-3-Clause",
-  "devDependencies": {
-    "@babel/cli": "^7.14.5",
-    "@babel/core": "^7.14.6",
-    "@babel/preset-env": "^7.14.7"
-  },
   "files": [
     "/src",
-    "/cjs"
+    "llms.txt",
+    "llms-full.txt"
   ],
-  "babel": {
-    "presets": [
-      [
-        "@babel/preset-env",
-        {
-          "targets": {
-            "node": "current"
-          }
-        }
-      ]
-    ]
+  "devDependencies": {
+    "prettier": "^3.8.1",
+    "typescript": "^6.0.2"
   }
 }

package/src/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/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/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/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/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/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/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/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;