@jbrowse/plugin-wiggle 4.1.3 → 4.1.5

package/esm/d3-hierarchy2/pack/siblings.js

@@ -0,0 +1,94 @@
+import array from "../array.js";
+import lcg from "../lcg.js";
+import { packEncloseRandom } from "./enclose.js";
+function place(b, a, c) {
+    var dx = b.x - a.x, x, a2, dy = b.y - a.y, y, b2, d2 = dx * dx + dy * dy;
+    if (d2) {
+        a2 = a.r + c.r, a2 *= a2;
+        b2 = b.r + c.r, b2 *= b2;
+        if (a2 > b2) {
+            x = (d2 + b2 - a2) / (2 * d2);
+            y = Math.sqrt(Math.max(0, b2 / d2 - x * x));
+            c.x = b.x - x * dx - y * dy;
+            c.y = b.y - x * dy + y * dx;
+        }
+        else {
+            x = (d2 + a2 - b2) / (2 * d2);
+            y = Math.sqrt(Math.max(0, a2 / d2 - x * x));
+            c.x = a.x + x * dx - y * dy;
+            c.y = a.y + x * dy + y * dx;
+        }
+    }
+    else {
+        c.x = a.x + c.r;
+        c.y = a.y;
+    }
+}
+function intersects(a, b) {
+    var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y;
+    return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+function score(node) {
+    var a = node._, b = node.next._, ab = a.r + b.r, dx = (a.x * b.r + b.x * a.r) / ab, dy = (a.y * b.r + b.y * a.r) / ab;
+    return dx * dx + dy * dy;
+}
+function Node(circle) {
+    this._ = circle;
+    this.next = null;
+    this.previous = null;
+}
+export function packSiblingsRandom(circles, random) {
+    if (!(n = (circles = array(circles)).length))
+        return 0;
+    var a, b, c, n, aa, ca, i, j, k, sj, sk;
+    a = circles[0], a.x = 0, a.y = 0;
+    if (!(n > 1))
+        return a.r;
+    b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0;
+    if (!(n > 2))
+        return a.r + b.r;
+    place(b, a, c = circles[2]);
+    a = new Node(a), b = new Node(b), c = new Node(c);
+    a.next = c.previous = b;
+    b.next = a.previous = c;
+    c.next = b.previous = a;
+    pack: for (i = 3; i < n; ++i) {
+        place(a._, b._, c = circles[i]), c = new Node(c);
+        j = b.next, k = a.previous, sj = b._.r, sk = a._.r;
+        do {
+            if (sj <= sk) {
+                if (intersects(j._, c._)) {
+                    b = j, a.next = b, b.previous = a, --i;
+                    continue pack;
+                }
+                sj += j._.r, j = j.next;
+            }
+            else {
+                if (intersects(k._, c._)) {
+                    a = k, a.next = b, b.previous = a, --i;
+                    continue pack;
+                }
+                sk += k._.r, k = k.previous;
+            }
+        } while (j !== k.next);
+        c.previous = a, c.next = b, a.next = b.previous = b = c;
+        aa = score(a);
+        while ((c = c.next) !== b) {
+            if ((ca = score(c)) < aa) {
+                a = c, aa = ca;
+            }
+        }
+        b = a.next;
+    }
+    a = [b._], c = b;
+    while ((c = c.next) !== b)
+        a.push(c._);
+    c = packEncloseRandom(a, random);
+    for (i = 0; i < n; ++i)
+        a = circles[i], a.x -= c.x, a.y -= c.y;
+    return c.r;
+}
+export default function (circles) {
+    packSiblingsRandom(circles, lcg());
+    return circles;
+}

package/esm/d3-hierarchy2/partition.d.ts

@@ -0,0 +1,6 @@
+export default function (): {
+    (root: any): any;
+    round(x: any): boolean | any;
+    size(x: any): number[] | any;
+    padding(x: any): number | any;
+};

package/esm/d3-hierarchy2/partition.js

@@ -0,0 +1,42 @@
+import roundNode from "./treemap/round.js";
+import treemapDice from "./treemap/dice.js";
+export default function () {
+    var dx = 1, dy = 1, padding = 0, round = false;
+    function partition(root) {
+        var n = root.height + 1;
+        root.x0 =
+            root.y0 = padding;
+        root.x1 = dx;
+        root.y1 = dy / n;
+        root.eachBefore(positionNode(dy, n));
+        if (round)
+            root.eachBefore(roundNode);
+        return root;
+    }
+    function positionNode(dy, n) {
+        return function (node) {
+            if (node.children) {
+                treemapDice(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n);
+            }
+            var x0 = node.x0, y0 = node.y0, x1 = node.x1 - padding, y1 = node.y1 - padding;
+            if (x1 < x0)
+                x0 = x1 = (x0 + x1) / 2;
+            if (y1 < y0)
+                y0 = y1 = (y0 + y1) / 2;
+            node.x0 = x0;
+            node.y0 = y0;
+            node.x1 = x1;
+            node.y1 = y1;
+        };
+    }
+    partition.round = function (x) {
+        return arguments.length ? (round = !!x, partition) : round;
+    };
+    partition.size = function (x) {
+        return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy];
+    };
+    partition.padding = function (x) {
+        return arguments.length ? (padding = +x, partition) : padding;
+    };
+    return partition;
+}

package/esm/d3-hierarchy2/stratify.d.ts

@@ -0,0 +1,9 @@
+declare function defaultId(d: any): any;
+declare function defaultParentId(d: any): any;
+export default function (): {
+    (data: any): any;
+    id(x: any): typeof defaultId;
+    parentId(x: any): typeof defaultParentId;
+    path(x: any): any;
+};
+export {};

package/esm/d3-hierarchy2/stratify.js

@@ -0,0 +1,115 @@
+import { optional } from "./accessors.js";
+import { Node, computeHeight } from "./hierarchy/index.js";
+var preroot = { depth: -1 }, ambiguous = {}, imputed = {};
+function defaultId(d) {
+    return d.id;
+}
+function defaultParentId(d) {
+    return d.parentId;
+}
+export default function () {
+    var id = defaultId, parentId = defaultParentId, path;
+    function stratify(data) {
+        var nodes = Array.from(data), currentId = id, currentParentId = parentId, n, d, i, root, parent, node, nodeId, nodeKey, nodeByKey = new Map;
+        if (path != null) {
+            const I = nodes.map((d, i) => normalize(path(d, i, data)));
+            const P = I.map(parentof);
+            const S = new Set(I).add("");
+            for (const i of P) {
+                if (!S.has(i)) {
+                    S.add(i);
+                    I.push(i);
+                    P.push(parentof(i));
+                    nodes.push(imputed);
+                }
+            }
+            currentId = (_, i) => I[i];
+            currentParentId = (_, i) => P[i];
+        }
+        for (i = 0, n = nodes.length; i < n; ++i) {
+            d = nodes[i], node = nodes[i] = new Node(d);
+            if ((nodeId = currentId(d, i, data)) != null && (nodeId += "")) {
+                nodeKey = node.id = nodeId;
+                nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node);
+            }
+            if ((nodeId = currentParentId(d, i, data)) != null && (nodeId += "")) {
+                node.parent = nodeId;
+            }
+        }
+        for (i = 0; i < n; ++i) {
+            node = nodes[i];
+            if (nodeId = node.parent) {
+                parent = nodeByKey.get(nodeId);
+                if (!parent)
+                    throw new Error("missing: " + nodeId);
+                if (parent === ambiguous)
+                    throw new Error("ambiguous: " + nodeId);
+                if (parent.children)
+                    parent.children.push(node);
+                else
+                    parent.children = [node];
+                node.parent = parent;
+            }
+            else {
+                if (root)
+                    throw new Error("multiple roots");
+                root = node;
+            }
+        }
+        if (!root)
+            throw new Error("no root");
+        if (path != null) {
+            while (root.data === imputed && root.children.length === 1) {
+                root = root.children[0], --n;
+            }
+            for (let i = nodes.length - 1; i >= 0; --i) {
+                node = nodes[i];
+                if (node.data !== imputed)
+                    break;
+                node.data = null;
+            }
+        }
+        root.parent = preroot;
+        root.eachBefore(function (node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(computeHeight);
+        root.parent = null;
+        if (n > 0)
+            throw new Error("cycle");
+        return root;
+    }
+    stratify.id = function (x) {
+        return arguments.length ? (id = optional(x), stratify) : id;
+    };
+    stratify.parentId = function (x) {
+        return arguments.length ? (parentId = optional(x), stratify) : parentId;
+    };
+    stratify.path = function (x) {
+        return arguments.length ? (path = optional(x), stratify) : path;
+    };
+    return stratify;
+}
+function normalize(path) {
+    path = `${path}`;
+    let i = path.length;
+    if (slash(path, i - 1) && !slash(path, i - 2))
+        path = path.slice(0, -1);
+    return path[0] === "/" ? path : `/${path}`;
+}
+function parentof(path) {
+    let i = path.length;
+    if (i < 2)
+        return "";
+    while (--i > 1)
+        if (slash(path, i))
+            break;
+    return path.slice(0, i);
+}
+function slash(path, i) {
+    if (path[i] === "/") {
+        let k = 0;
+        while (i > 0 && path[--i] === "\\")
+            ++k;
+        if ((k & 1) === 0)
+            return true;
+    }
+    return false;
+}

package/esm/d3-hierarchy2/tree.d.ts

@@ -0,0 +1,8 @@
+declare function defaultSeparation(a: any, b: any): 1 | 2;
+export default function (): {
+    (root: any): any;
+    separation(x: any): any | typeof defaultSeparation;
+    size(x: any): number[] | any | null;
+    nodeSize(x: any): number[] | any | null;
+};
+export {};

package/esm/d3-hierarchy2/tree.js

@@ -0,0 +1,153 @@
+import { Node } from "./hierarchy/index.js";
+function defaultSeparation(a, b) {
+    return a.parent === b.parent ? 1 : 2;
+}
+function nextLeft(v) {
+    var children = v.children;
+    return children ? children[0] : v.t;
+}
+function nextRight(v) {
+    var children = v.children;
+    return children ? children[children.length - 1] : v.t;
+}
+function moveSubtree(wm, wp, shift) {
+    var change = shift / (wp.i - wm.i);
+    wp.c -= change;
+    wp.s += shift;
+    wm.c += change;
+    wp.z += shift;
+    wp.m += shift;
+}
+function executeShifts(v) {
+    var shift = 0, change = 0, children = v.children, i = children.length, w;
+    while (--i >= 0) {
+        w = children[i];
+        w.z += shift;
+        w.m += shift;
+        shift += w.s + (change += w.c);
+    }
+}
+function nextAncestor(vim, v, ancestor) {
+    return vim.a.parent === v.parent ? vim.a : ancestor;
+}
+function TreeNode(node, i) {
+    this._ = node;
+    this.parent = null;
+    this.children = null;
+    this.A = null;
+    this.a = this;
+    this.z = 0;
+    this.m = 0;
+    this.c = 0;
+    this.s = 0;
+    this.t = null;
+    this.i = i;
+}
+TreeNode.prototype = Object.create(Node.prototype);
+function treeRoot(root) {
+    var tree = new TreeNode(root, 0), node, nodes = [tree], child, children, i, n;
+    while (node = nodes.pop()) {
+        if (children = node._.children) {
+            node.children = new Array(n = children.length);
+            for (i = n - 1; i >= 0; --i) {
+                nodes.push(child = node.children[i] = new TreeNode(children[i], i));
+                child.parent = node;
+            }
+        }
+    }
+    (tree.parent = new TreeNode(null, 0)).children = [tree];
+    return tree;
+}
+export default function () {
+    var separation = defaultSeparation, dx = 1, dy = 1, nodeSize = null;
+    function tree(root) {
+        var t = treeRoot(root);
+        t.eachAfter(firstWalk), t.parent.m = -t.z;
+        t.eachBefore(secondWalk);
+        if (nodeSize)
+            root.eachBefore(sizeNode);
+        else {
+            var left = root, right = root, bottom = root;
+            root.eachBefore(function (node) {
+                if (node.x < left.x)
+                    left = node;
+                if (node.x > right.x)
+                    right = node;
+                if (node.depth > bottom.depth)
+                    bottom = node;
+            });
+            var s = left === right ? 1 : separation(left, right) / 2, tx = s - left.x, kx = dx / (right.x + s + tx), ky = dy / (bottom.depth || 1);
+            root.eachBefore(function (node) {
+                node.x = (node.x + tx) * kx;
+                node.y = node.depth * ky;
+            });
+        }
+        return root;
+    }
+    function firstWalk(v) {
+        var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
+        if (children) {
+            executeShifts(v);
+            var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+            if (w) {
+                v.z = w.z + separation(v._, w._);
+                v.m = v.z - midpoint;
+            }
+            else {
+                v.z = midpoint;
+            }
+        }
+        else if (w) {
+            v.z = w.z + separation(v._, w._);
+        }
+        v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+    }
+    function secondWalk(v) {
+        v._.x = v.z + v.parent.m;
+        v.m += v.parent.m;
+    }
+    function apportion(v, w, ancestor) {
+        if (w) {
+            var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+            while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) {
+                vom = nextLeft(vom);
+                vop = nextRight(vop);
+                vop.a = v;
+                shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+                if (shift > 0) {
+                    moveSubtree(nextAncestor(vim, v, ancestor), v, shift);
+                    sip += shift;
+                    sop += shift;
+                }
+                sim += vim.m;
+                sip += vip.m;
+                som += vom.m;
+                sop += vop.m;
+            }
+            if (vim && !nextRight(vop)) {
+                vop.t = vim;
+                vop.m += sim - sop;
+            }
+            if (vip && !nextLeft(vom)) {
+                vom.t = vip;
+                vom.m += sip - som;
+                ancestor = v;
+            }
+        }
+        return ancestor;
+    }
+    function sizeNode(node) {
+        node.x *= dx;
+        node.y = node.depth * dy;
+    }
+    tree.separation = function (x) {
+        return arguments.length ? (separation = x, tree) : separation;
+    };
+    tree.size = function (x) {
+        return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]);
+    };
+    tree.nodeSize = function (x) {
+        return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null);
+    };
+    return tree;
+}

package/esm/d3-hierarchy2/treemap/binary.d.ts

@@ -0,0 +1 @@
+export default function (parent: any, x0: any, y0: any, x1: any, y1: any): void;

package/esm/d3-hierarchy2/treemap/binary.js

@@ -0,0 +1,36 @@
+export default function (parent, x0, y0, x1, y1) {
+    var nodes = parent.children, i, n = nodes.length, sum, sums = new Array(n + 1);
+    for (sums[0] = sum = i = 0; i < n; ++i) {
+        sums[i + 1] = sum += nodes[i].value;
+    }
+    partition(0, n, parent.value, x0, y0, x1, y1);
+    function partition(i, j, value, x0, y0, x1, y1) {
+        if (i >= j - 1) {
+            var node = nodes[i];
+            node.x0 = x0, node.y0 = y0;
+            node.x1 = x1, node.y1 = y1;
+            return;
+        }
+        var valueOffset = sums[i], valueTarget = (value / 2) + valueOffset, k = i + 1, hi = j - 1;
+        while (k < hi) {
+            var mid = k + hi >>> 1;
+            if (sums[mid] < valueTarget)
+                k = mid + 1;
+            else
+                hi = mid;
+        }
+        if ((valueTarget - sums[k - 1]) < (sums[k] - valueTarget) && i + 1 < k)
+            --k;
+        var valueLeft = sums[k] - valueOffset, valueRight = value - valueLeft;
+        if ((x1 - x0) > (y1 - y0)) {
+            var xk = value ? (x0 * valueRight + x1 * valueLeft) / value : x1;
+            partition(i, k, valueLeft, x0, y0, xk, y1);
+            partition(k, j, valueRight, xk, y0, x1, y1);
+        }
+        else {
+            var yk = value ? (y0 * valueRight + y1 * valueLeft) / value : y1;
+            partition(i, k, valueLeft, x0, y0, x1, yk);
+            partition(k, j, valueRight, x0, yk, x1, y1);
+        }
+    }
+}

package/esm/d3-hierarchy2/treemap/dice.d.ts

@@ -0,0 +1 @@
+export default function (parent: any, x0: any, y0: any, x1: any, y1: any): void;

package/esm/d3-hierarchy2/treemap/dice.js

@@ -0,0 +1,7 @@
+export default function (parent, x0, y0, x1, y1) {
+    var nodes = parent.children, node, i = -1, n = nodes.length, k = parent.value && (x1 - x0) / parent.value;
+    while (++i < n) {
+        node = nodes[i], node.y0 = y0, node.y1 = y1;
+        node.x0 = x0, node.x1 = x0 += node.value * k;
+    }
+}

package/esm/d3-hierarchy2/treemap/index.d.ts

@@ -0,0 +1,17 @@
+import { constantZero } from "../constant.ts";
+export default function (): {
+    (root: any): any;
+    round(x: any): boolean | any;
+    size(x: any): number[] | any;
+    tile(x: any): {
+        (parent: any, x0: any, y0: any, x1: any, y1: any): void;
+        ratio(x: any): any;
+    } | any;
+    padding(x: any): any;
+    paddingInner(x: any): typeof constantZero | any;
+    paddingOuter(x: any): any;
+    paddingTop(x: any): typeof constantZero | any;
+    paddingRight(x: any): typeof constantZero | any;
+    paddingBottom(x: any): typeof constantZero | any;
+    paddingLeft(x: any): typeof constantZero | any;
+};

package/esm/d3-hierarchy2/treemap/index.js

@@ -0,0 +1,72 @@
+import roundNode from "./round.js";
+import squarify from "./squarify.js";
+import { required } from "../accessors.js";
+import constant, { constantZero } from "../constant.js";
+export default function () {
+    var tile = squarify, round = false, dx = 1, dy = 1, paddingStack = [0], paddingInner = constantZero, paddingTop = constantZero, paddingRight = constantZero, paddingBottom = constantZero, paddingLeft = constantZero;
+    function treemap(root) {
+        root.x0 =
+            root.y0 = 0;
+        root.x1 = dx;
+        root.y1 = dy;
+        root.eachBefore(positionNode);
+        paddingStack = [0];
+        if (round)
+            root.eachBefore(roundNode);
+        return root;
+    }
+    function positionNode(node) {
+        var p = paddingStack[node.depth], x0 = node.x0 + p, y0 = node.y0 + p, x1 = node.x1 - p, y1 = node.y1 - p;
+        if (x1 < x0)
+            x0 = x1 = (x0 + x1) / 2;
+        if (y1 < y0)
+            y0 = y1 = (y0 + y1) / 2;
+        node.x0 = x0;
+        node.y0 = y0;
+        node.x1 = x1;
+        node.y1 = y1;
+        if (node.children) {
+            p = paddingStack[node.depth + 1] = paddingInner(node) / 2;
+            x0 += paddingLeft(node) - p;
+            y0 += paddingTop(node) - p;
+            x1 -= paddingRight(node) - p;
+            y1 -= paddingBottom(node) - p;
+            if (x1 < x0)
+                x0 = x1 = (x0 + x1) / 2;
+            if (y1 < y0)
+                y0 = y1 = (y0 + y1) / 2;
+            tile(node, x0, y0, x1, y1);
+        }
+    }
+    treemap.round = function (x) {
+        return arguments.length ? (round = !!x, treemap) : round;
+    };
+    treemap.size = function (x) {
+        return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy];
+    };
+    treemap.tile = function (x) {
+        return arguments.length ? (tile = required(x), treemap) : tile;
+    };
+    treemap.padding = function (x) {
+        return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner();
+    };
+    treemap.paddingInner = function (x) {
+        return arguments.length ? (paddingInner = typeof x === "function" ? x : constant(+x), treemap) : paddingInner;
+    };
+    treemap.paddingOuter = function (x) {
+        return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop();
+    };
+    treemap.paddingTop = function (x) {
+        return arguments.length ? (paddingTop = typeof x === "function" ? x : constant(+x), treemap) : paddingTop;
+    };
+    treemap.paddingRight = function (x) {
+        return arguments.length ? (paddingRight = typeof x === "function" ? x : constant(+x), treemap) : paddingRight;
+    };
+    treemap.paddingBottom = function (x) {
+        return arguments.length ? (paddingBottom = typeof x === "function" ? x : constant(+x), treemap) : paddingBottom;
+    };
+    treemap.paddingLeft = function (x) {
+        return arguments.length ? (paddingLeft = typeof x === "function" ? x : constant(+x), treemap) : paddingLeft;
+    };
+    return treemap;
+}

package/esm/d3-hierarchy2/treemap/resquarify.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    (parent: any, x0: any, y0: any, x1: any, y1: any): void;
+    ratio(x: any): any;
+};
+export default _default;

package/esm/d3-hierarchy2/treemap/resquarify.js

@@ -0,0 +1,28 @@
+import treemapDice from "./dice.js";
+import treemapSlice from "./slice.js";
+import { phi, squarifyRatio } from "./squarify.js";
+export default (function custom(ratio) {
+    function resquarify(parent, x0, y0, x1, y1) {
+        if ((rows = parent._squarify) && (rows.ratio === ratio)) {
+            var rows, row, nodes, i, j = -1, n, m = rows.length, value = parent.value;
+            while (++j < m) {
+                row = rows[j], nodes = row.children;
+                for (i = row.value = 0, n = nodes.length; i < n; ++i)
+                    row.value += nodes[i].value;
+                if (row.dice)
+                    treemapDice(row, x0, y0, x1, value ? y0 += (y1 - y0) * row.value / value : y1);
+                else
+                    treemapSlice(row, x0, y0, value ? x0 += (x1 - x0) * row.value / value : x1, y1);
+                value -= row.value;
+            }
+        }
+        else {
+            parent._squarify = rows = squarifyRatio(ratio, parent, x0, y0, x1, y1);
+            rows.ratio = ratio;
+        }
+    }
+    resquarify.ratio = function (x) {
+        return custom((x = +x) > 1 ? x : 1);
+    };
+    return resquarify;
+})(phi);

package/esm/d3-hierarchy2/treemap/round.d.ts

@@ -0,0 +1 @@
+export default function (node: any): void;

package/esm/d3-hierarchy2/treemap/round.js

@@ -0,0 +1,6 @@
+export default function (node) {
+    node.x0 = Math.round(node.x0);
+    node.y0 = Math.round(node.y0);
+    node.x1 = Math.round(node.x1);
+    node.y1 = Math.round(node.y1);
+}

package/esm/d3-hierarchy2/treemap/slice.d.ts

@@ -0,0 +1 @@
+export default function (parent: any, x0: any, y0: any, x1: any, y1: any): void;

package/esm/d3-hierarchy2/treemap/slice.js

@@ -0,0 +1,7 @@
+export default function (parent, x0, y0, x1, y1) {
+    var nodes = parent.children, node, i = -1, n = nodes.length, k = parent.value && (y1 - y0) / parent.value;
+    while (++i < n) {
+        node = nodes[i], node.x0 = x0, node.x1 = x1;
+        node.y0 = y0, node.y1 = y0 += node.value * k;
+    }
+}

package/esm/d3-hierarchy2/treemap/sliceDice.d.ts

@@ -0,0 +1 @@
+export default function (parent: any, x0: any, y0: any, x1: any, y1: any): void;

package/esm/d3-hierarchy2/treemap/sliceDice.js

@@ -0,0 +1,5 @@
+import dice from "./dice.js";
+import slice from "./slice.js";
+export default function (parent, x0, y0, x1, y1) {
+    (parent.depth & 1 ? slice : dice)(parent, x0, y0, x1, y1);
+}

package/esm/d3-hierarchy2/treemap/squarify.d.ts

@@ -0,0 +1,11 @@
+export declare var phi: number;
+export declare function squarifyRatio(ratio: any, parent: any, x0: any, y0: any, x1: any, y1: any): {
+    value: any;
+    dice: boolean;
+    children: any;
+}[];
+declare const _default: {
+    (parent: any, x0: any, y0: any, x1: any, y1: any): void;
+    ratio(x: any): any;
+};
+export default _default;