@jbrowse/plugin-wiggle 4.1.3 → 4.1.4

package/esm/d3-hierarchy2/array.js

@@ -0,0 +1,15 @@
+export default function (x) {
+    return typeof x === "object" && "length" in x
+        ? x
+        : Array.from(x);
+}
+export function shuffle(array, random) {
+    let m = array.length, t, i;
+    while (m) {
+        i = random() * m-- | 0;
+        t = array[m];
+        array[m] = array[i];
+        array[i] = t;
+    }
+    return array;
+}

package/esm/d3-hierarchy2/cluster.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/cluster.js

@@ -0,0 +1,63 @@
+function defaultSeparation(a, b) {
+    return a.parent === b.parent ? 1 : 2;
+}
+function meanX(children) {
+    return children.reduce(meanXReduce, 0) / children.length;
+}
+function meanXReduce(x, c) {
+    return x + c.x;
+}
+function maxY(children) {
+    return 1 + children.reduce(maxYReduce, 0);
+}
+function maxYReduce(y, c) {
+    return Math.max(y, c.y);
+}
+function leafLeft(node) {
+    var children;
+    while (children = node.children)
+        node = children[0];
+    return node;
+}
+function leafRight(node) {
+    var children;
+    while (children = node.children)
+        node = children[children.length - 1];
+    return node;
+}
+export default function () {
+    var separation = defaultSeparation, dx = 1, dy = 1, nodeSize = false;
+    function cluster(root) {
+        var previousNode, x = 0;
+        root.eachAfter(function (node) {
+            var children = node.children;
+            if (children) {
+                node.x = meanX(children);
+                node.y = maxY(children);
+            }
+            else {
+                node.x = previousNode ? x += separation(node, previousNode) : 0;
+                node.y = 0;
+                previousNode = node;
+            }
+        });
+        var left = leafLeft(root), right = leafRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+        return root.eachAfter(nodeSize ? function (node) {
+            node.x = (node.x - root.x) * dx;
+            node.y = (root.y - node.y) * dy;
+        } : function (node) {
+            node.x = (node.x - x0) / (x1 - x0) * dx;
+            node.y = (1 - (root.y ? node.y / root.y : 1)) * dy;
+        });
+    }
+    cluster.separation = function (x) {
+        return arguments.length ? (separation = x, cluster) : separation;
+    };
+    cluster.size = function (x) {
+        return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]);
+    };
+    cluster.nodeSize = function (x) {
+        return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null);
+    };
+    return cluster;
+}

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

@@ -0,0 +1,2 @@
+export declare function constantZero(): number;
+export default function (x: any): () => any;

package/esm/d3-hierarchy2/constant.js

@@ -0,0 +1,8 @@
+export function constantZero() {
+    return 0;
+}
+export default function (x) {
+    return function () {
+        return x;
+    };
+}

package/esm/d3-hierarchy2/hierarchy/ancestors.d.ts

@@ -0,0 +1 @@
+export default function (): any[];

package/esm/d3-hierarchy2/hierarchy/ancestors.js

@@ -0,0 +1,7 @@
+export default function () {
+    var node = this, nodes = [node];
+    while (node = node.parent) {
+        nodes.push(node);
+    }
+    return nodes;
+}

package/esm/d3-hierarchy2/hierarchy/count.d.ts

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

package/esm/d3-hierarchy2/hierarchy/count.js

@@ -0,0 +1,12 @@
+function count(node) {
+    var sum = 0, children = node.children, i = children && children.length;
+    if (!i)
+        sum = 1;
+    else
+        while (--i >= 0)
+            sum += children[i].value;
+    node.value = sum;
+}
+export default function () {
+    return this.eachAfter(count);
+}

package/esm/d3-hierarchy2/hierarchy/descendants.d.ts

@@ -0,0 +1 @@
+export default function (): unknown[];

package/esm/d3-hierarchy2/hierarchy/descendants.js

@@ -0,0 +1,3 @@
+export default function () {
+    return Array.from(this);
+}

package/esm/d3-hierarchy2/hierarchy/each.d.ts

@@ -0,0 +1 @@
+export default function (callback: any, that: any): any;

package/esm/d3-hierarchy2/hierarchy/each.js

@@ -0,0 +1,7 @@
+export default function (callback, that) {
+    let index = -1;
+    for (const node of this) {
+        callback.call(that, node, ++index, this);
+    }
+    return this;
+}

package/esm/d3-hierarchy2/hierarchy/eachAfter.d.ts

@@ -0,0 +1 @@
+export default function (callback: any, that: any): any;

package/esm/d3-hierarchy2/hierarchy/eachAfter.js

@@ -0,0 +1,15 @@
+export default function (callback, that) {
+    var node = this, nodes = [node], next = [], children, i, n, index = -1;
+    while (node = nodes.pop()) {
+        next.push(node);
+        if (children = node.children) {
+            for (i = 0, n = children.length; i < n; ++i) {
+                nodes.push(children[i]);
+            }
+        }
+    }
+    while (node = next.pop()) {
+        callback.call(that, node, ++index, this);
+    }
+    return this;
+}

package/esm/d3-hierarchy2/hierarchy/eachBefore.d.ts

@@ -0,0 +1 @@
+export default function (callback: any, that: any): any;

package/esm/d3-hierarchy2/hierarchy/eachBefore.js

@@ -0,0 +1,12 @@
+export default function (callback, that) {
+    var node = this, nodes = [node], children, i, index = -1;
+    while (node = nodes.pop()) {
+        callback.call(that, node, ++index, this);
+        if (children = node.children) {
+            for (i = children.length - 1; i >= 0; --i) {
+                nodes.push(children[i]);
+            }
+        }
+    }
+    return this;
+}

package/esm/d3-hierarchy2/hierarchy/find.d.ts

@@ -0,0 +1 @@
+export default function (callback: any, that: any): any;

package/esm/d3-hierarchy2/hierarchy/find.js

@@ -0,0 +1,8 @@
+export default function (callback, that) {
+    let index = -1;
+    for (const node of this) {
+        if (callback.call(that, node, ++index, this)) {
+            return node;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export default function hierarchy(data: any, children: any): any;
+export declare function computeHeight(node: any): void;
+export declare function Node(data: any): void;

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

@@ -0,0 +1,78 @@
+import node_count from "./count.js";
+import node_each from "./each.js";
+import node_eachBefore from "./eachBefore.js";
+import node_eachAfter from "./eachAfter.js";
+import node_find from "./find.js";
+import node_sum from "./sum.js";
+import node_sort from "./sort.js";
+import node_path from "./path.js";
+import node_ancestors from "./ancestors.js";
+import node_descendants from "./descendants.js";
+import node_leaves from "./leaves.js";
+import node_links from "./links.js";
+import node_iterator from "./iterator.js";
+export default function hierarchy(data, children) {
+    if (data instanceof Map) {
+        data = [undefined, data];
+        if (children === undefined)
+            children = mapChildren;
+    }
+    else if (children === undefined) {
+        children = objectChildren;
+    }
+    var root = new Node(data), node, nodes = [root], child, childs, i, n;
+    while (node = nodes.pop()) {
+        if ((childs = children(node.data)) && (n = (childs = Array.from(childs)).length)) {
+            node.children = childs;
+            for (i = n - 1; i >= 0; --i) {
+                nodes.push(child = childs[i] = new Node(childs[i]));
+                child.parent = node;
+                child.depth = node.depth + 1;
+            }
+        }
+    }
+    return root.eachBefore(computeHeight);
+}
+function node_copy() {
+    return hierarchy(this).eachBefore(copyData);
+}
+function objectChildren(d) {
+    return d.children;
+}
+function mapChildren(d) {
+    return Array.isArray(d) ? d[1] : null;
+}
+function copyData(node) {
+    if (node.data.value !== undefined)
+        node.value = node.data.value;
+    node.data = node.data.data;
+}
+export function computeHeight(node) {
+    var height = 0;
+    do
+        node.height = height;
+    while ((node = node.parent) && (node.height < ++height));
+}
+export function Node(data) {
+    this.data = data;
+    this.depth =
+        this.height = 0;
+    this.parent = null;
+}
+Node.prototype = hierarchy.prototype = {
+    constructor: Node,
+    count: node_count,
+    each: node_each,
+    eachAfter: node_eachAfter,
+    eachBefore: node_eachBefore,
+    find: node_find,
+    sum: node_sum,
+    sort: node_sort,
+    path: node_path,
+    ancestors: node_ancestors,
+    descendants: node_descendants,
+    leaves: node_leaves,
+    links: node_links,
+    copy: node_copy,
+    [Symbol.iterator]: node_iterator
+};

package/esm/d3-hierarchy2/hierarchy/iterator.d.ts

@@ -0,0 +1 @@
+export default function (): Generator<any, void, unknown>;

package/esm/d3-hierarchy2/hierarchy/iterator.js

@@ -0,0 +1,14 @@
+export default function* () {
+    var node = this, current, next = [node], children, i, n;
+    do {
+        current = next.reverse(), next = [];
+        while (node = current.pop()) {
+            yield node;
+            if (children = node.children) {
+                for (i = 0, n = children.length; i < n; ++i) {
+                    next.push(children[i]);
+                }
+            }
+        }
+    } while (next.length);
+}

package/esm/d3-hierarchy2/hierarchy/leaves.d.ts

@@ -0,0 +1 @@
+export default function (): any[];

package/esm/d3-hierarchy2/hierarchy/leaves.js

@@ -0,0 +1,9 @@
+export default function () {
+    var leaves = [];
+    this.eachBefore(function (node) {
+        if (!node.children) {
+            leaves.push(node);
+        }
+    });
+    return leaves;
+}

package/esm/d3-hierarchy2/hierarchy/links.d.ts

@@ -0,0 +1 @@
+export default function (): any[];

package/esm/d3-hierarchy2/hierarchy/links.js

@@ -0,0 +1,9 @@
+export default function () {
+    var root = this, links = [];
+    root.each(function (node) {
+        if (node !== root) {
+            links.push({ source: node.parent, target: node });
+        }
+    });
+    return links;
+}

package/esm/d3-hierarchy2/hierarchy/path.d.ts

@@ -0,0 +1 @@
+export default function (end: any): any[];

package/esm/d3-hierarchy2/hierarchy/path.js

@@ -0,0 +1,26 @@
+export default function (end) {
+    var start = this, ancestor = leastCommonAncestor(start, end), nodes = [start];
+    while (start !== ancestor) {
+        start = start.parent;
+        nodes.push(start);
+    }
+    var k = nodes.length;
+    while (end !== ancestor) {
+        nodes.splice(k, 0, end);
+        end = end.parent;
+    }
+    return nodes;
+}
+function leastCommonAncestor(a, b) {
+    if (a === b)
+        return a;
+    var aNodes = a.ancestors(), bNodes = b.ancestors(), c = null;
+    a = aNodes.pop();
+    b = bNodes.pop();
+    while (a === b) {
+        c = a;
+        a = aNodes.pop();
+        b = bNodes.pop();
+    }
+    return c;
+}

package/esm/d3-hierarchy2/hierarchy/sort.d.ts

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

package/esm/d3-hierarchy2/hierarchy/sort.js

@@ -0,0 +1,7 @@
+export default function (compare) {
+    return this.eachBefore(function (node) {
+        if (node.children) {
+            node.children.sort(compare);
+        }
+    });
+}

package/esm/d3-hierarchy2/hierarchy/sum.d.ts

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

package/esm/d3-hierarchy2/hierarchy/sum.js

@@ -0,0 +1,8 @@
+export default function (value) {
+    return this.eachAfter(function (node) {
+        var sum = +value(node.data) || 0, children = node.children, i = children && children.length;
+        while (--i >= 0)
+            sum += children[i].value;
+        node.value = sum;
+    });
+}

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

@@ -0,0 +1,15 @@
+export { default as cluster } from "./cluster.ts";
+export { default as hierarchy, Node } from "./hierarchy/index.ts";
+export { default as pack } from "./pack/index.ts";
+export { default as packSiblings } from "./pack/siblings.ts";
+export { default as packEnclose } from "./pack/enclose.ts";
+export { default as partition } from "./partition.ts";
+export { default as stratify } from "./stratify.ts";
+export { default as tree } from "./tree.ts";
+export { default as treemap } from "./treemap/index.ts";
+export { default as treemapBinary } from "./treemap/binary.ts";
+export { default as treemapDice } from "./treemap/dice.ts";
+export { default as treemapSlice } from "./treemap/slice.ts";
+export { default as treemapSliceDice } from "./treemap/sliceDice.ts";
+export { default as treemapSquarify } from "./treemap/squarify.ts";
+export { default as treemapResquarify } from "./treemap/resquarify.ts";

package/esm/d3-hierarchy2/index.js

@@ -0,0 +1,15 @@
+export { default as cluster } from "./cluster.js";
+export { default as hierarchy, Node } from "./hierarchy/index.js";
+export { default as pack } from "./pack/index.js";
+export { default as packSiblings } from "./pack/siblings.js";
+export { default as packEnclose } from "./pack/enclose.js";
+export { default as partition } from "./partition.js";
+export { default as stratify } from "./stratify.js";
+export { default as tree } from "./tree.js";
+export { default as treemap } from "./treemap/index.js";
+export { default as treemapBinary } from "./treemap/binary.js";
+export { default as treemapDice } from "./treemap/dice.js";
+export { default as treemapSlice } from "./treemap/slice.js";
+export { default as treemapSliceDice } from "./treemap/sliceDice.js";
+export { default as treemapSquarify } from "./treemap/squarify.js";
+export { default as treemapResquarify } from "./treemap/resquarify.js";

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

@@ -0,0 +1 @@
+export default function (): () => number;

package/esm/d3-hierarchy2/lcg.js

@@ -0,0 +1,7 @@
+const a = 1664525;
+const c = 1013904223;
+const m = 4294967296;
+export default function () {
+    let s = 1;
+    return () => (s = (a * s + c) % m) / m;
+}

package/esm/d3-hierarchy2/pack/enclose.d.ts

@@ -0,0 +1,10 @@
+export default function (circles: any): {
+    x: any;
+    y: any;
+    r: any;
+} | undefined;
+export declare function packEncloseRandom(circles: any, random: any): {
+    x: any;
+    y: any;
+    r: any;
+} | undefined;

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

@@ -0,0 +1,84 @@
+import { shuffle } from "../array.js";
+import lcg from "../lcg.js";
+export default function (circles) {
+    return packEncloseRandom(circles, lcg());
+}
+export function packEncloseRandom(circles, random) {
+    var i = 0, n = (circles = shuffle(Array.from(circles), random)).length, B = [], p, e;
+    while (i < n) {
+        p = circles[i];
+        if (e && enclosesWeak(e, p))
+            ++i;
+        else
+            e = encloseBasis(B = extendBasis(B, p)), i = 0;
+    }
+    return e;
+}
+function extendBasis(B, p) {
+    var i, j;
+    if (enclosesWeakAll(p, B))
+        return [p];
+    for (i = 0; i < B.length; ++i) {
+        if (enclosesNot(p, B[i])
+            && enclosesWeakAll(encloseBasis2(B[i], p), B)) {
+            return [B[i], p];
+        }
+    }
+    for (i = 0; i < B.length - 1; ++i) {
+        for (j = i + 1; j < B.length; ++j) {
+            if (enclosesNot(encloseBasis2(B[i], B[j]), p)
+                && enclosesNot(encloseBasis2(B[i], p), B[j])
+                && enclosesNot(encloseBasis2(B[j], p), B[i])
+                && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) {
+                return [B[i], B[j], p];
+            }
+        }
+    }
+    throw new Error;
+}
+function enclosesNot(a, b) {
+    var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y;
+    return dr < 0 || dr * dr < dx * dx + dy * dy;
+}
+function enclosesWeak(a, b) {
+    var dr = a.r - b.r + Math.max(a.r, b.r, 1) * 1e-9, dx = b.x - a.x, dy = b.y - a.y;
+    return dr > 0 && dr * dr > dx * dx + dy * dy;
+}
+function enclosesWeakAll(a, B) {
+    for (var i = 0; i < B.length; ++i) {
+        if (!enclosesWeak(a, B[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function encloseBasis(B) {
+    switch (B.length) {
+        case 1: return encloseBasis1(B[0]);
+        case 2: return encloseBasis2(B[0], B[1]);
+        case 3: return encloseBasis3(B[0], B[1], B[2]);
+    }
+}
+function encloseBasis1(a) {
+    return {
+        x: a.x,
+        y: a.y,
+        r: a.r
+    };
+}
+function encloseBasis2(a, b) {
+    var x1 = a.x, y1 = a.y, r1 = a.r, x2 = b.x, y2 = b.y, r2 = b.r, x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, l = Math.sqrt(x21 * x21 + y21 * y21);
+    return {
+        x: (x1 + x2 + x21 / l * r21) / 2,
+        y: (y1 + y2 + y21 / l * r21) / 2,
+        r: (l + r1 + r2) / 2
+    };
+}
+function encloseBasis3(a, b, c) {
+    var x1 = a.x, y1 = a.y, r1 = a.r, x2 = b.x, y2 = b.y, r2 = b.r, x3 = c.x, y3 = c.y, r3 = c.r, a2 = x1 - x2, a3 = x1 - x3, b2 = y1 - y2, b3 = y1 - y3, c2 = r2 - r1, c3 = r3 - r1, d1 = x1 * x1 + y1 * y1 - r1 * r1, d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, ab = a3 * b2 - a2 * b3, xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1, xb = (b3 * c2 - b2 * c3) / ab, ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1, yb = (a2 * c3 - a3 * c2) / ab, A = xb * xb + yb * yb - 1, B = 2 * (r1 + xa * xb + ya * yb), C = xa * xa + ya * ya - r1 * r1, r = -(Math.abs(A) > 1e-6 ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B);
+    return {
+        x: x1 + xa + xb * r,
+        y: y1 + ya + yb * r,
+        r: r
+    };
+}

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

@@ -0,0 +1,7 @@
+import { constantZero } from "../constant.ts";
+export default function (): {
+    (root: any): any;
+    radius(x: any): any;
+    size(x: any): number[] | any;
+    padding(x: any): any | typeof constantZero;
+};

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

@@ -0,0 +1,68 @@
+import { optional } from "../accessors.js";
+import constant, { constantZero } from "../constant.js";
+import lcg from "../lcg.js";
+import { packSiblingsRandom } from "./siblings.js";
+function defaultRadius(d) {
+    return Math.sqrt(d.value);
+}
+export default function () {
+    var radius = null, dx = 1, dy = 1, padding = constantZero;
+    function pack(root) {
+        const random = lcg();
+        root.x = dx / 2, root.y = dy / 2;
+        if (radius) {
+            root.eachBefore(radiusLeaf(radius))
+                .eachAfter(packChildrenRandom(padding, 0.5, random))
+                .eachBefore(translateChild(1));
+        }
+        else {
+            root.eachBefore(radiusLeaf(defaultRadius))
+                .eachAfter(packChildrenRandom(constantZero, 1, random))
+                .eachAfter(packChildrenRandom(padding, root.r / Math.min(dx, dy), random))
+                .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r)));
+        }
+        return root;
+    }
+    pack.radius = function (x) {
+        return arguments.length ? (radius = optional(x), pack) : radius;
+    };
+    pack.size = function (x) {
+        return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy];
+    };
+    pack.padding = function (x) {
+        return arguments.length ? (padding = typeof x === "function" ? x : constant(+x), pack) : padding;
+    };
+    return pack;
+}
+function radiusLeaf(radius) {
+    return function (node) {
+        if (!node.children) {
+            node.r = Math.max(0, +radius(node) || 0);
+        }
+    };
+}
+function packChildrenRandom(padding, k, random) {
+    return function (node) {
+        if (children = node.children) {
+            var children, i, n = children.length, r = padding(node) * k || 0, e;
+            if (r)
+                for (i = 0; i < n; ++i)
+                    children[i].r += r;
+            e = packSiblingsRandom(children, random);
+            if (r)
+                for (i = 0; i < n; ++i)
+                    children[i].r -= r;
+            node.r = e + r;
+        }
+    };
+}
+function translateChild(k) {
+    return function (node) {
+        var parent = node.parent;
+        node.r *= k;
+        if (parent) {
+            node.x = parent.x + k * node.x;
+            node.y = parent.y + k * node.y;
+        }
+    };
+}

package/esm/d3-hierarchy2/pack/siblings.d.ts

@@ -0,0 +1,2 @@
+export declare function packSiblingsRandom(circles: any, random: any): any;
+export default function (circles: any): any;