@thi.ng/zipper 2.1.68 → 2.1.70

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-18T13:41:20Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -69,7 +69,7 @@ For Node.js REPL:
 const zipper = await import("@thi.ng/zipper");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.01 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.02 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/zipper",
-  "version": "2.1.68",
+  "version": "2.1.70",
   "description": "Functional tree editing, manipulation & navigation",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,13 +35,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/arrays": "^2.7.7",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/errors": "^2.4.5"
+    "@thi.ng/api": "^8.9.13",
+    "@thi.ng/arrays": "^2.7.9",
+    "@thi.ng/checks": "^3.4.13",
+    "@thi.ng/errors": "^2.4.7"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -63,7 +66,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=12.7"
+    "node": ">=18"
   },
   "files": [
     "./*.js",
@@ -92,5 +95,5 @@
     ],
     "year": 2015
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "25a42a81fac8603a1e440a7aa8bc343276211ff4\n"
 }

package/zipper.js

@@ -2,193 +2,287 @@ import { peek } from "@thi.ng/arrays/peek";
 import { isArray } from "@thi.ng/checks/is-array";
 import { assert } from "@thi.ng/errors/assert";
 const newPath = (l, r, path, nodes, changed = false) => ({
-    l,
-    r,
-    path,
-    nodes,
-    changed,
+  l,
+  r,
+  path,
+  nodes,
+  changed
 });
-const changedPath = (path) => path ? { ...path, changed: true } : undefined;
-export class Location {
-    _node;
-    _ops;
-    _path;
-    constructor(node, ops, path) {
-        this._node = node;
-        this._ops = ops;
-        this._path = path;
+const changedPath = (path) => path ? { ...path, changed: true } : void 0;
+class Location {
+  _node;
+  _ops;
+  _path;
+  constructor(node, ops, path) {
+    this._node = node;
+    this._ops = ops;
+    this._path = path;
+  }
+  get isBranch() {
+    return this._ops.branch(this._node);
+  }
+  get isFirst() {
+    return !this.lefts;
+  }
+  get isLast() {
+    return !this.rights;
+  }
+  get depth() {
+    let d = 0;
+    let path = this._path;
+    while (path) {
+      d++;
+      path = path.path;
     }
-    get isBranch() {
-        return this._ops.branch(this._node);
+    return d;
+  }
+  get node() {
+    return this._node;
+  }
+  get children() {
+    return this._ops.children(this._node);
+  }
+  get path() {
+    return this._path ? this._path.nodes : void 0;
+  }
+  get lefts() {
+    return this._path ? this._path.l : void 0;
+  }
+  get rights() {
+    return this._path ? this._path.r : void 0;
+  }
+  get left() {
+    const path = this._path;
+    const lefts = path && path.l;
+    return lefts && lefts.length ? new Location(
+      peek(lefts),
+      this._ops,
+      newPath(
+        lefts.slice(0, lefts.length - 1),
+        [this._node].concat(path.r || []),
+        path.path,
+        path.nodes,
+        path.changed
+      )
+    ) : void 0;
+  }
+  get right() {
+    const path = this._path;
+    const rights = path && path.r;
+    if (!rights)
+      return;
+    const r = rights.slice(1);
+    return new Location(
+      rights[0],
+      this._ops,
+      newPath(
+        (path.l || []).concat([this._node]),
+        r.length ? r : void 0,
+        path.path,
+        path.nodes,
+        path.changed
+      )
+    );
+  }
+  get leftmost() {
+    const path = this._path;
+    const lefts = path && path.l;
+    return lefts && lefts.length ? new Location(
+      lefts[0],
+      this._ops,
+      newPath(
+        void 0,
+        lefts.slice(1).concat([this._node], path.r || []),
+        path.path,
+        path.nodes,
+        path.changed
+      )
+    ) : this;
+  }
+  get rightmost() {
+    const path = this._path;
+    const rights = path && path.r;
+    return rights ? new Location(
+      peek(rights),
+      this._ops,
+      newPath(
+        (path.l || []).concat(
+          [this._node],
+          rights.slice(0, rights.length - 1)
+        ),
+        void 0,
+        path.path,
+        path.nodes,
+        path.changed
+      )
+    ) : this;
+  }
+  get down() {
+    if (!this.isBranch)
+      return;
+    const children = this.children;
+    if (!children)
+      return;
+    const path = this._path;
+    const r = children.slice(1);
+    return new Location(
+      children[0],
+      this._ops,
+      newPath(
+        void 0,
+        r.length ? r : void 0,
+        path,
+        path ? path.nodes.concat([this._node]) : [this._node]
+      )
+    );
+  }
+  get up() {
+    let path = this._path;
+    const pnodes = path && path.nodes;
+    if (!pnodes)
+      return;
+    const pnode = peek(pnodes);
+    if (path.changed) {
+      return new Location(
+        this.newNode(
+          pnode,
+          (path.l || []).concat([this._node], path.r || [])
+        ),
+        this._ops,
+        changedPath(path.path)
+      );
+    } else {
+      return new Location(pnode, this._ops, path.path);
     }
-    get isFirst() {
-        return !this.lefts;
+  }
+  get root() {
+    const parent = this.up;
+    return parent ? parent.root : this._node;
+  }
+  get prev() {
+    let node = this.left;
+    if (!node)
+      return this.up;
+    while (true) {
+      const child = node.isBranch ? node.down : void 0;
+      if (!child)
+        return node;
+      node = child.rightmost;
     }
-    get isLast() {
-        return !this.rights;
+  }
+  get next() {
+    if (this.isBranch)
+      return this.down;
+    let right = this.right;
+    if (right)
+      return right;
+    let loc = this;
+    while (true) {
+      const up = loc.up;
+      if (!up)
+        return;
+      right = up.right;
+      if (right)
+        return right;
+      loc = up;
     }
-    get depth() {
-        let d = 0;
-        let path = this._path;
-        while (path) {
-            d++;
-            path = path.path;
-        }
-        return d;
-    }
-    get node() {
-        return this._node;
-    }
-    get children() {
-        return this._ops.children(this._node);
-    }
-    get path() {
-        return this._path ? this._path.nodes : undefined;
-    }
-    get lefts() {
-        return this._path ? this._path.l : undefined;
-    }
-    get rights() {
-        return this._path ? this._path.r : undefined;
-    }
-    get left() {
-        const path = this._path;
-        const lefts = path && path.l;
-        return lefts && lefts.length
-            ? new Location(peek(lefts), this._ops, newPath(lefts.slice(0, lefts.length - 1), [this._node].concat(path.r || []), path.path, path.nodes, path.changed))
-            : undefined;
-    }
-    get right() {
-        const path = this._path;
-        const rights = path && path.r;
-        if (!rights)
-            return;
-        const r = rights.slice(1);
-        return new Location(rights[0], this._ops, newPath((path.l || []).concat([this._node]), r.length ? r : undefined, path.path, path.nodes, path.changed));
-    }
-    get leftmost() {
-        const path = this._path;
-        const lefts = path && path.l;
-        return lefts && lefts.length
-            ? new Location(lefts[0], this._ops, newPath(undefined, lefts.slice(1).concat([this._node], path.r || []), path.path, path.nodes, path.changed))
-            : this;
-    }
-    get rightmost() {
-        const path = this._path;
-        const rights = path && path.r;
-        return rights
-            ? new Location(peek(rights), this._ops, newPath((path.l || []).concat([this._node], rights.slice(0, rights.length - 1)), undefined, path.path, path.nodes, path.changed))
-            : this;
-    }
-    get down() {
-        if (!this.isBranch)
-            return;
-        const children = this.children;
-        if (!children)
-            return;
-        const path = this._path;
-        const r = children.slice(1);
-        return new Location(children[0], this._ops, newPath(undefined, r.length ? r : undefined, path, path ? path.nodes.concat([this._node]) : [this._node]));
-    }
-    get up() {
-        let path = this._path;
-        const pnodes = path && path.nodes;
-        if (!pnodes)
-            return;
-        const pnode = peek(pnodes);
-        if (path.changed) {
-            return new Location(this.newNode(pnode, (path.l || []).concat([this._node], path.r || [])), this._ops, changedPath(path.path));
-        }
-        else {
-            return new Location(pnode, this._ops, path.path);
-        }
-    }
-    get root() {
-        const parent = this.up;
-        return parent ? parent.root : this._node;
-    }
-    get prev() {
-        let node = this.left;
-        if (!node)
-            return this.up;
-        while (true) {
-            const child = node.isBranch
-                ? node.down
-                : undefined;
-            if (!child)
-                return node;
-            node = child.rightmost;
-        }
-    }
-    get next() {
-        if (this.isBranch)
-            return this.down;
-        let right = this.right;
-        if (right)
-            return right;
-        let loc = this;
-        while (true) {
-            const up = loc.up;
-            if (!up)
-                return;
-            right = up.right;
-            if (right)
-                return right;
-            loc = up;
-        }
-    }
-    replace(x) {
-        return new Location(x, this._ops, changedPath(this._path));
-    }
-    update(fn, ...xs) {
-        return this.replace(fn(this._node, ...xs));
-    }
-    insertLeft(x) {
-        this.ensureNotRoot();
-        const path = this._path;
-        return new Location(this._node, this._ops, newPath(path.l ? path.l.concat([x]) : [x], path.r, path.path, path.nodes, true));
-    }
-    insertRight(x) {
-        this.ensureNotRoot();
-        const path = this._path;
-        return new Location(this._node, this._ops, newPath(path.l, [x].concat(path.r || []), path.path, path.nodes, true));
-    }
-    insertChild(x) {
-        this.ensureBranch();
-        return this.replace(this.newNode(this._node, [x, ...this.children]));
-    }
-    appendChild(x) {
-        this.ensureBranch();
-        return this.replace(this.newNode(this._node, this.children.concat([x])));
-    }
-    remove() {
-        this.ensureNotRoot();
-        const path = this._path;
-        const lefts = path.l;
-        if (lefts ? lefts.length : 0) {
-            let loc = new Location(peek(lefts), this._ops, newPath(lefts.slice(0, lefts.length - 1), path.r, path.path, path.nodes, true));
-            while (true) {
-                const child = loc.isBranch ? loc.down : undefined;
-                if (!child)
-                    return loc;
-                loc = child.rightmost;
-            }
-        }
-        return new Location(this.newNode(peek(path.nodes), path.r || []), this._ops, changedPath(path.path));
-    }
-    newNode(node, children) {
-        return this._ops.factory(node, children);
-    }
-    ensureNotRoot() {
-        assert(!!this._path, "can't insert at root level");
-    }
-    ensureBranch() {
-        assert(this.isBranch, "can only insert in branches");
+  }
+  replace(x) {
+    return new Location(x, this._ops, changedPath(this._path));
+  }
+  update(fn, ...xs) {
+    return this.replace(fn(this._node, ...xs));
+  }
+  insertLeft(x) {
+    this.ensureNotRoot();
+    const path = this._path;
+    return new Location(
+      this._node,
+      this._ops,
+      newPath(
+        path.l ? path.l.concat([x]) : [x],
+        path.r,
+        path.path,
+        path.nodes,
+        true
+      )
+    );
+  }
+  insertRight(x) {
+    this.ensureNotRoot();
+    const path = this._path;
+    return new Location(
+      this._node,
+      this._ops,
+      newPath(
+        path.l,
+        [x].concat(path.r || []),
+        path.path,
+        path.nodes,
+        true
+      )
+    );
+  }
+  insertChild(x) {
+    this.ensureBranch();
+    return this.replace(this.newNode(this._node, [x, ...this.children]));
+  }
+  appendChild(x) {
+    this.ensureBranch();
+    return this.replace(
+      this.newNode(this._node, this.children.concat([x]))
+    );
+  }
+  remove() {
+    this.ensureNotRoot();
+    const path = this._path;
+    const lefts = path.l;
+    if (lefts ? lefts.length : 0) {
+      let loc = new Location(
+        peek(lefts),
+        this._ops,
+        newPath(
+          lefts.slice(0, lefts.length - 1),
+          path.r,
+          path.path,
+          path.nodes,
+          true
+        )
+      );
+      while (true) {
+        const child = loc.isBranch ? loc.down : void 0;
+        if (!child)
+          return loc;
+        loc = child.rightmost;
+      }
     }
+    return new Location(
+      this.newNode(peek(path.nodes), path.r || []),
+      this._ops,
+      changedPath(path.path)
+    );
+  }
+  newNode(node, children) {
+    return this._ops.factory(node, children);
+  }
+  ensureNotRoot() {
+    assert(!!this._path, "can't insert at root level");
+  }
+  ensureBranch() {
+    assert(this.isBranch, "can only insert in branches");
+  }
 }
-export const zipper = (ops, node) => new Location(node, ops);
-export const arrayZipper = (root) => zipper({
+const zipper = (ops, node) => new Location(node, ops);
+const arrayZipper = (root) => zipper(
+  {
     branch: isArray,
     children: (x) => x,
-    factory: (_, xs) => xs,
-}, root);
+    factory: (_, xs) => xs
+  },
+  root
+);
+export {
+  Location,
+  arrayZipper,
+  zipper
+};