@hkyhy/marsun-components-core 0.1.113 → 0.1.114

package/dist/node_modules/@antv/g2/esm/data/utils/d3-sankey/sankey.js

@@ -0,0 +1,262 @@
+import { justify as tt } from "./align.js";
+import { constant as S } from "./constant.js";
+import z from "../../../../../../d3-array/src/sum.js";
+import C from "../../../../../../d3-array/src/max.js";
+import nt from "../../../../../../d3-array/src/min.js";
+function H(s, c) {
+  return M(s.source, c.source) || s.index - c.index;
+}
+function P(s, c) {
+  return M(s.target, c.target) || s.index - c.index;
+}
+function M(s, c) {
+  return s.y0 - c.y0;
+}
+function D(s) {
+  return s.value;
+}
+function et(s) {
+  return s.index;
+}
+function ot(s) {
+  return s.nodes;
+}
+function rt(s) {
+  return s.links;
+}
+function W(s, c) {
+  const a = s.get(c);
+  if (!a)
+    throw new Error("missing: " + c);
+  return a;
+}
+function q({ nodes: s }) {
+  for (const c of s) {
+    let a = c.y0, h = a;
+    for (const d of c.sourceLinks)
+      d.y0 = a + d.width / 2, a += d.width;
+    for (const d of c.targetLinks)
+      d.y1 = h + d.width / 2, h += d.width;
+  }
+}
+function lt() {
+  let s = 0, c = 0, a = 1, h = 1, d = 24, B = 8, l, N = et, T = tt, w, k, y, E = ot, b = rt, v = 6;
+  function u(t) {
+    const o = {
+      nodes: E(t),
+      links: b(t)
+    };
+    return F(o), G(o), J(o), K(o), U(o), q(o), o;
+  }
+  u.update = function(t) {
+    return q(t), t;
+  }, u.nodeId = function(t) {
+    return arguments.length ? (N = typeof t == "function" ? t : S(t), u) : N;
+  }, u.nodeAlign = function(t) {
+    return arguments.length ? (T = typeof t == "function" ? t : S(t), u) : T;
+  }, u.nodeDepth = function(t) {
+    return arguments.length ? (w = t, u) : w;
+  }, u.nodeSort = function(t) {
+    return arguments.length ? (k = t, u) : k;
+  }, u.nodeWidth = function(t) {
+    return arguments.length ? (d = +t, u) : d;
+  }, u.nodePadding = function(t) {
+    return arguments.length ? (B = l = +t, u) : B;
+  }, u.nodes = function(t) {
+    return arguments.length ? (E = typeof t == "function" ? t : S(t), u) : E;
+  }, u.links = function(t) {
+    return arguments.length ? (b = typeof t == "function" ? t : S(t), u) : b;
+  }, u.linkSort = function(t) {
+    return arguments.length ? (y = t, u) : y;
+  }, u.size = function(t) {
+    return arguments.length ? (s = c = 0, a = +t[0], h = +t[1], u) : [a - s, h - c];
+  }, u.extent = function(t) {
+    return arguments.length ? (s = +t[0][0], a = +t[1][0], c = +t[0][1], h = +t[1][1], u) : [
+      [s, c],
+      [a, h]
+    ];
+  }, u.iterations = function(t) {
+    return arguments.length ? (v = +t, u) : v;
+  };
+  function F({ nodes: t, links: o }) {
+    t.forEach((n, e) => {
+      n.index = e, n.sourceLinks = [], n.targetLinks = [];
+    });
+    const r = new Map(t.map((n) => [N(n), n]));
+    if (o.forEach((n, e) => {
+      n.index = e;
+      let { source: i, target: f } = n;
+      typeof i != "object" && (i = n.source = W(r, i)), typeof f != "object" && (f = n.target = W(r, f)), i.sourceLinks.push(n), f.targetLinks.push(n);
+    }), y != null)
+      for (const { sourceLinks: n, targetLinks: e } of t)
+        n.sort(y), e.sort(y);
+  }
+  function G({ nodes: t }) {
+    for (const o of t)
+      o.value = o.fixedValue === void 0 ? Math.max(z(o.sourceLinks, D), z(o.targetLinks, D)) : o.fixedValue;
+  }
+  function J({ nodes: t }) {
+    const o = t.length;
+    let r = new Set(t), n = /* @__PURE__ */ new Set(), e = 0;
+    for (; r.size; ) {
+      if (r.forEach((i) => {
+        i.depth = e;
+        for (const { target: f } of i.sourceLinks)
+          n.add(f);
+      }), ++e > o)
+        throw new Error("circular link");
+      r = n, n = /* @__PURE__ */ new Set();
+    }
+    if (w) {
+      const i = Math.max(C(t, (g) => g.depth) + 1, 0);
+      let f;
+      for (let g = 0; g < t.length; g++)
+        f = t[g], f.depth = w.call(null, f, i);
+    }
+  }
+  function K({ nodes: t }) {
+    const o = t.length;
+    let r = new Set(t), n = /* @__PURE__ */ new Set(), e = 0;
+    for (; r.size; ) {
+      if (r.forEach((i) => {
+        i.height = e;
+        for (const { source: f } of i.targetLinks)
+          n.add(f);
+      }), ++e > o)
+        throw new Error("circular link");
+      r = n, n = /* @__PURE__ */ new Set();
+    }
+  }
+  function O({ nodes: t }) {
+    const o = Math.max(C(t, (e) => e.depth) + 1, 0), r = (a - s - d) / (o - 1), n = new Array(o).fill(0).map(() => []);
+    for (const e of t) {
+      const i = Math.max(0, Math.min(o - 1, Math.floor(T.call(null, e, o))));
+      e.layer = i, e.x0 = s + i * r, e.x1 = e.x0 + d, n[i] ? n[i].push(e) : n[i] = [e];
+    }
+    if (k)
+      for (const e of n)
+        e.sort(k);
+    return n;
+  }
+  function Q(t) {
+    const o = nt(t, (r) => (h - c - (r.length - 1) * l) / z(r, D));
+    for (const r of t) {
+      let n = c;
+      for (const e of r) {
+        e.y0 = n, e.y1 = n + e.value * o, n = e.y1 + l;
+        for (const i of e.sourceLinks)
+          i.width = i.value * o;
+      }
+      n = (h - n + l) / (r.length + 1);
+      for (let e = 0; e < r.length; ++e) {
+        const i = r[e];
+        i.y0 += n * (e + 1), i.y1 += n * (e + 1);
+      }
+      Z(r);
+    }
+  }
+  function U(t) {
+    const o = O(t);
+    l = Math.min(B, (h - c) / (C(o, (r) => r.length) - 1)), Q(o);
+    for (let r = 0; r < v; ++r) {
+      const n = Math.pow(0.99, r), e = Math.max(1 - n, (r + 1) / v);
+      Y(o, n, e), X(o, n, e);
+    }
+  }
+  function X(t, o, r) {
+    for (let n = 1, e = t.length; n < e; ++n) {
+      const i = t[n];
+      for (const f of i) {
+        let g = 0, m = 0;
+        for (const { source: L, value: j } of f.targetLinks) {
+          const x = j * (f.layer - L.layer);
+          g += $(L, f) * x, m += x;
+        }
+        if (!(m > 0))
+          continue;
+        const p = (g / m - f.y0) * o;
+        f.y0 += p, f.y1 += p, R(f);
+      }
+      k === void 0 && i.sort(M), i.length && I(i, r);
+    }
+  }
+  function Y(t, o, r) {
+    for (let n = t.length, e = n - 2; e >= 0; --e) {
+      const i = t[e];
+      for (const f of i) {
+        let g = 0, m = 0;
+        for (const { target: L, value: j } of f.sourceLinks) {
+          const x = j * (L.layer - f.layer);
+          g += _(f, L) * x, m += x;
+        }
+        if (!(m > 0))
+          continue;
+        const p = (g / m - f.y0) * o;
+        f.y0 += p, f.y1 += p, R(f);
+      }
+      k === void 0 && i.sort(M), i.length && I(i, r);
+    }
+  }
+  function I(t, o) {
+    const r = t.length >> 1, n = t[r];
+    A(t, n.y0 - l, r - 1, o), V(t, n.y1 + l, r + 1, o), A(t, h, t.length - 1, o), V(t, c, 0, o);
+  }
+  function V(t, o, r, n) {
+    for (; r < t.length; ++r) {
+      const e = t[r], i = (o - e.y0) * n;
+      i > 1e-6 && (e.y0 += i, e.y1 += i), o = e.y1 + l;
+    }
+  }
+  function A(t, o, r, n) {
+    for (; r >= 0; --r) {
+      const e = t[r], i = (e.y1 - o) * n;
+      i > 1e-6 && (e.y0 -= i, e.y1 -= i), o = e.y0 - l;
+    }
+  }
+  function R({ sourceLinks: t, targetLinks: o }) {
+    if (y === void 0) {
+      for (const { source: { sourceLinks: r } } of o)
+        r.sort(P);
+      for (const { target: { targetLinks: r } } of t)
+        r.sort(H);
+    }
+  }
+  function Z(t) {
+    if (y === void 0)
+      for (const { sourceLinks: o, targetLinks: r } of t)
+        o.sort(P), r.sort(H);
+  }
+  function $(t, o) {
+    let r = t.y0 - (t.sourceLinks.length - 1) * l / 2;
+    for (const { target: n, width: e } of t.sourceLinks) {
+      if (n === o)
+        break;
+      r += e + l;
+    }
+    for (const { source: n, width: e } of o.targetLinks) {
+      if (n === t)
+        break;
+      r -= e;
+    }
+    return r;
+  }
+  function _(t, o) {
+    let r = o.y0 - (o.targetLinks.length - 1) * l / 2;
+    for (const { source: n, width: e } of o.targetLinks) {
+      if (n === t)
+        break;
+      r += e + l;
+    }
+    for (const { target: n, width: e } of t.sourceLinks) {
+      if (n === o)
+        break;
+      r -= e;
+    }
+    return r;
+  }
+  return u;
+}
+export {
+  lt as Sankey
+};
+//# sourceMappingURL=sankey.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/d3-sankey/sankey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sankey.js","sources":["../../../../../../../../node_modules/@antv/g2/esm/data/utils/d3-sankey/sankey.js"],"sourcesContent":["import { sum, max, min } from '@antv/vendor/d3-array';\nimport { justify } from './align';\nimport { constant } from './constant';\nfunction ascendingSourceBreadth(a, b) {\n    return ascendingBreadth(a.source, b.source) || a.index - b.index;\n}\nfunction ascendingTargetBreadth(a, b) {\n    return ascendingBreadth(a.target, b.target) || a.index - b.index;\n}\nfunction ascendingBreadth(a, b) {\n    return a.y0 - b.y0;\n}\nfunction value(d) {\n    return d.value;\n}\nfunction defaultId(d) {\n    return d.index;\n}\nfunction defaultNodes(graph) {\n    return graph.nodes;\n}\nfunction defaultLinks(graph) {\n    return graph.links;\n}\nfunction find(nodeById, id) {\n    const node = nodeById.get(id);\n    if (!node)\n        throw new Error('missing: ' + id);\n    return node;\n}\nfunction computeLinkBreadths({ nodes }) {\n    for (const node of nodes) {\n        let y0 = node.y0;\n        let y1 = y0;\n        for (const link of node.sourceLinks) {\n            link.y0 = y0 + link.width / 2;\n            y0 += link.width;\n        }\n        for (const link of node.targetLinks) {\n            link.y1 = y1 + link.width / 2;\n            y1 += link.width;\n        }\n    }\n}\nexport function Sankey() {\n    let x0 = 0, y0 = 0, x1 = 1, y1 = 1; // extent\n    let dx = 24; // nodeWidth\n    let dy = 8, py; // nodePadding\n    let id = defaultId;\n    let align = justify;\n    let depth;\n    let sort;\n    let linkSort;\n    let nodes = defaultNodes;\n    let links = defaultLinks;\n    let iterations = 6;\n    function sankey(arg) {\n        const graph = {\n            nodes: nodes(arg),\n            links: links(arg),\n        };\n        computeNodeLinks(graph);\n        computeNodeValues(graph);\n        computeNodeDepths(graph);\n        computeNodeHeights(graph);\n        computeNodeBreadths(graph);\n        computeLinkBreadths(graph);\n        return graph;\n    }\n    sankey.update = function (graph) {\n        computeLinkBreadths(graph);\n        return graph;\n    };\n    sankey.nodeId = function (_) {\n        return arguments.length\n            ? ((id = typeof _ === 'function' ? _ : constant(_)), sankey)\n            : id;\n    };\n    sankey.nodeAlign = function (_) {\n        return arguments.length\n            ? ((align = typeof _ === 'function' ? _ : constant(_)), sankey)\n            : align;\n    };\n    sankey.nodeDepth = function (_) {\n        return arguments.length\n            ? ((depth = typeof _ === 'function' ? _ : _), sankey)\n            : depth;\n    };\n    sankey.nodeSort = function (_) {\n        return arguments.length ? ((sort = _), sankey) : sort;\n    };\n    sankey.nodeWidth = function (_) {\n        return arguments.length ? ((dx = +_), sankey) : dx;\n    };\n    sankey.nodePadding = function (_) {\n        return arguments.length ? ((dy = py = +_), sankey) : dy;\n    };\n    sankey.nodes = function (_) {\n        return arguments.length\n            ? ((nodes = typeof _ === 'function' ? _ : constant(_)), sankey)\n            : nodes;\n    };\n    sankey.links = function (_) {\n        return arguments.length\n            ? ((links = typeof _ === 'function' ? _ : constant(_)), sankey)\n            : links;\n    };\n    sankey.linkSort = function (_) {\n        return arguments.length ? ((linkSort = _), sankey) : linkSort;\n    };\n    sankey.size = function (_) {\n        return arguments.length\n            ? ((x0 = y0 = 0), (x1 = +_[0]), (y1 = +_[1]), sankey)\n            : [x1 - x0, y1 - y0];\n    };\n    sankey.extent = function (_) {\n        return arguments.length\n            ? ((x0 = +_[0][0]),\n                (x1 = +_[1][0]),\n                (y0 = +_[0][1]),\n                (y1 = +_[1][1]),\n                sankey)\n            : [\n                [x0, y0],\n                [x1, y1],\n            ];\n    };\n    sankey.iterations = function (_) {\n        return arguments.length ? ((iterations = +_), sankey) : iterations;\n    };\n    function computeNodeLinks({ nodes, links }) {\n        nodes.forEach((node, idx) => {\n            node.index = idx;\n            node.sourceLinks = [];\n            node.targetLinks = [];\n        });\n        const nodeById = new Map(nodes.map((d) => [id(d), d]));\n        links.forEach((link, idx) => {\n            link.index = idx;\n            let { source, target } = link;\n            if (typeof source !== 'object')\n                source = link.source = find(nodeById, source);\n            if (typeof target !== 'object')\n                target = link.target = find(nodeById, target);\n            source.sourceLinks.push(link);\n            target.targetLinks.push(link);\n        });\n        if (linkSort != null) {\n            for (const { sourceLinks, targetLinks } of nodes) {\n                sourceLinks.sort(linkSort);\n                targetLinks.sort(linkSort);\n            }\n        }\n    }\n    function computeNodeValues({ nodes }) {\n        for (const node of nodes) {\n            node.value =\n                node.fixedValue === undefined\n                    ? Math.max(sum(node.sourceLinks, value), sum(node.targetLinks, value))\n                    : node.fixedValue;\n        }\n    }\n    function computeNodeDepths({ nodes }) {\n        const n = nodes.length;\n        let current = new Set(nodes);\n        let next = new Set();\n        let x = 0;\n        while (current.size) {\n            current.forEach((node) => {\n                node.depth = x;\n                for (const { target } of node.sourceLinks) {\n                    next.add(target);\n                }\n            });\n            if (++x > n)\n                throw new Error('circular link');\n            current = next;\n            next = new Set();\n        }\n        // 如果配置了 depth，则设置自定义 depth\n        if (depth) {\n            const maxDepth = Math.max(max(nodes, (d) => d.depth) + 1, 0);\n            let node;\n            for (let i = 0; i < nodes.length; i++) {\n                node = nodes[i];\n                node.depth = depth.call(null, node, maxDepth);\n            }\n        }\n    }\n    function computeNodeHeights({ nodes }) {\n        const n = nodes.length;\n        let current = new Set(nodes);\n        let next = new Set();\n        let x = 0;\n        while (current.size) {\n            current.forEach((node) => {\n                node.height = x;\n                for (const { source } of node.targetLinks) {\n                    next.add(source);\n                }\n            });\n            if (++x > n)\n                throw new Error('circular link');\n            current = next;\n            next = new Set();\n        }\n    }\n    function computeNodeLayers({ nodes }) {\n        const x = Math.max(max(nodes, (d) => d.depth) + 1, 0);\n        const kx = (x1 - x0 - dx) / (x - 1);\n        const columns = new Array(x).fill(0).map(() => []);\n        for (const node of nodes) {\n            const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));\n            node.layer = i;\n            node.x0 = x0 + i * kx;\n            node.x1 = node.x0 + dx;\n            if (columns[i])\n                columns[i].push(node);\n            else\n                columns[i] = [node];\n        }\n        if (sort)\n            for (const column of columns) {\n                column.sort(sort);\n            }\n        return columns;\n    }\n    function initializeNodeBreadths(columns) {\n        const ky = min(columns, (c) => (y1 - y0 - (c.length - 1) * py) / sum(c, value));\n        for (const nodes of columns) {\n            let y = y0;\n            for (const node of nodes) {\n                node.y0 = y;\n                node.y1 = y + node.value * ky;\n                y = node.y1 + py;\n                for (const link of node.sourceLinks) {\n                    link.width = link.value * ky;\n                }\n            }\n            y = (y1 - y + py) / (nodes.length + 1);\n            for (let i = 0; i < nodes.length; ++i) {\n                const node = nodes[i];\n                node.y0 += y * (i + 1);\n                node.y1 += y * (i + 1);\n            }\n            reorderLinks(nodes);\n        }\n    }\n    function computeNodeBreadths(graph) {\n        const columns = computeNodeLayers(graph);\n        py = Math.min(dy, (y1 - y0) / (max(columns, (c) => c.length) - 1));\n        initializeNodeBreadths(columns);\n        for (let i = 0; i < iterations; ++i) {\n            const alpha = Math.pow(0.99, i);\n            const beta = Math.max(1 - alpha, (i + 1) / iterations);\n            relaxRightToLeft(columns, alpha, beta);\n            relaxLeftToRight(columns, alpha, beta);\n        }\n    }\n    // Reposition each node based on its incoming (target) links.\n    function relaxLeftToRight(columns, alpha, beta) {\n        for (let i = 1, n = columns.length; i < n; ++i) {\n            const column = columns[i];\n            for (const target of column) {\n                let y = 0;\n                let w = 0;\n                for (const { source, value } of target.targetLinks) {\n                    const v = value * (target.layer - source.layer);\n                    y += targetTop(source, target) * v;\n                    w += v;\n                }\n                if (!(w > 0))\n                    continue;\n                const dy = (y / w - target.y0) * alpha;\n                target.y0 += dy;\n                target.y1 += dy;\n                reorderNodeLinks(target);\n            }\n            if (sort === undefined)\n                column.sort(ascendingBreadth);\n            if (column.length)\n                resolveCollisions(column, beta);\n        }\n    }\n    // Reposition each node based on its outgoing (source) links.\n    function relaxRightToLeft(columns, alpha, beta) {\n        for (let n = columns.length, i = n - 2; i >= 0; --i) {\n            const column = columns[i];\n            for (const source of column) {\n                let y = 0;\n                let w = 0;\n                for (const { target, value } of source.sourceLinks) {\n                    const v = value * (target.layer - source.layer);\n                    y += sourceTop(source, target) * v;\n                    w += v;\n                }\n                if (!(w > 0))\n                    continue;\n                const dy = (y / w - source.y0) * alpha;\n                source.y0 += dy;\n                source.y1 += dy;\n                reorderNodeLinks(source);\n            }\n            if (sort === undefined)\n                column.sort(ascendingBreadth);\n            if (column.length)\n                resolveCollisions(column, beta);\n        }\n    }\n    function resolveCollisions(nodes, alpha) {\n        const i = nodes.length >> 1;\n        const subject = nodes[i];\n        resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);\n        resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);\n        resolveCollisionsBottomToTop(nodes, y1, nodes.length - 1, alpha);\n        resolveCollisionsTopToBottom(nodes, y0, 0, alpha);\n    }\n    // Push any overlapping nodes down.\n    function resolveCollisionsTopToBottom(nodes, y, i, alpha) {\n        for (; i < nodes.length; ++i) {\n            const node = nodes[i];\n            const dy = (y - node.y0) * alpha;\n            if (dy > 1e-6)\n                (node.y0 += dy), (node.y1 += dy);\n            y = node.y1 + py;\n        }\n    }\n    // Push any overlapping nodes up.\n    function resolveCollisionsBottomToTop(nodes, y, i, alpha) {\n        for (; i >= 0; --i) {\n            const node = nodes[i];\n            const dy = (node.y1 - y) * alpha;\n            if (dy > 1e-6)\n                (node.y0 -= dy), (node.y1 -= dy);\n            y = node.y0 - py;\n        }\n    }\n    function reorderNodeLinks({ sourceLinks, targetLinks }) {\n        if (linkSort === undefined) {\n            for (const { source: { sourceLinks }, } of targetLinks) {\n                sourceLinks.sort(ascendingTargetBreadth);\n            }\n            for (const { target: { targetLinks }, } of sourceLinks) {\n                targetLinks.sort(ascendingSourceBreadth);\n            }\n        }\n    }\n    function reorderLinks(nodes) {\n        if (linkSort === undefined) {\n            for (const { sourceLinks, targetLinks } of nodes) {\n                sourceLinks.sort(ascendingTargetBreadth);\n                targetLinks.sort(ascendingSourceBreadth);\n            }\n        }\n    }\n    // Returns the target.y0 that would produce an ideal link from source to target.\n    function targetTop(source, target) {\n        let y = source.y0 - ((source.sourceLinks.length - 1) * py) / 2;\n        for (const { target: node, width } of source.sourceLinks) {\n            if (node === target)\n                break;\n            y += width + py;\n        }\n        for (const { source: node, width } of target.targetLinks) {\n            if (node === source)\n                break;\n            y -= width;\n        }\n        return y;\n    }\n    // Returns the source.y0 that would produce an ideal link from source to target.\n    function sourceTop(source, target) {\n        let y = target.y0 - ((target.targetLinks.length - 1) * py) / 2;\n        for (const { source: node, width } of target.targetLinks) {\n            if (node === source)\n                break;\n            y += width + py;\n        }\n        for (const { target: node, width } of source.sourceLinks) {\n            if (node === target)\n                break;\n            y -= width;\n        }\n        return y;\n    }\n    return sankey;\n}\n//# sourceMappingURL=sankey.js.map"],"names":["ascendingSourceBreadth","a","b","ascendingBreadth","ascendingTargetBreadth","value","d","defaultId","defaultNodes","graph","defaultLinks","find","nodeById","id","node","computeLinkBreadths","nodes","y0","y1","link","Sankey","x0","x1","dx","dy","py","align","justify","depth","sort","linkSort","links","iterations","sankey","arg","computeNodeLinks","computeNodeValues","computeNodeDepths","computeNodeHeights","computeNodeBreadths","_","constant","idx","source","target","sourceLinks","targetLinks","sum","n","current","next","x","maxDepth","max","i","computeNodeLayers","kx","columns","column","initializeNodeBreadths","ky","min","c","y","reorderLinks","alpha","beta","relaxRightToLeft","relaxLeftToRight","w","v","targetTop","reorderNodeLinks","resolveCollisions","sourceTop","subject","resolveCollisionsBottomToTop","resolveCollisionsTopToBottom","width"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/fields.js

@@ -0,0 +1,13 @@
+function o(e, n) {
+  return e.map((r) => {
+    if (Array.isArray(r)) {
+      const [i, t = n] = r;
+      return [i, t];
+    }
+    return [r, n];
+  });
+}
+export {
+  o as normalizeFields
+};
+//# sourceMappingURL=fields.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sources":["../../../../../../../node_modules/@antv/g2/esm/data/utils/fields.js"],"sourcesContent":["/**\n *\n * @description Converts a random format array into a regular two-dimensional array\n * @example ['a', 'b', ['c', value]] => [['a', defaultValue], ['b', defaultValue], ['c', value]]\n */\nexport function normalizeFields(fields, defaultValue) {\n    return fields.map((d) => {\n        if (Array.isArray(d)) {\n            const [field, value = defaultValue] = d;\n            return [field, value];\n        }\n        return [d, defaultValue];\n    });\n}\n//# sourceMappingURL=fields.js.map"],"names":["normalizeFields","fields","defaultValue","d","field","value"],"mappings":"AAKO,SAASA,EAAgBC,GAAQC,GAAc;AAClD,SAAOD,EAAO,IAAI,CAACE,MAAM;AACrB,QAAI,MAAM,QAAQA,CAAC,GAAG;AAClB,YAAM,CAACC,GAAOC,IAAQH,CAAY,IAAIC;AACtC,aAAO,CAACC,GAAOC,CAAK;AAAA,IACxB;AACA,WAAO,CAACF,GAAGD,CAAY;AAAA,EAC3B,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/flow.js

@@ -0,0 +1,49 @@
+var p = function(f, u, n, t) {
+  function l(i) {
+    return i instanceof n ? i : new n(function(d) {
+      d(i);
+    });
+  }
+  return new (n || (n = Promise))(function(i, d) {
+    function s(e) {
+      try {
+        c(t.next(e));
+      } catch (o) {
+        d(o);
+      }
+    }
+    function h(e) {
+      try {
+        c(t.throw(e));
+      } catch (o) {
+        d(o);
+      }
+    }
+    function c(e) {
+      e.done ? i(e.value) : l(e.value).then(s, h);
+    }
+    c((t = t.apply(f, u || [])).next());
+  });
+};
+function w(f, u) {
+  return {
+    set(n, t, l) {
+      if (u[n] === void 0)
+        return this;
+      const i = t ? t.call(null, u[n]) : u[n];
+      return l ? l.call(null, i) : typeof f[n] == "function" ? f[n](i) : f[n] = i, this;
+    },
+    setAsync(n, t, l) {
+      return p(this, void 0, void 0, function* () {
+        if (u[n] === void 0)
+          return this;
+        const i = t ? yield t.call(null, u[n]) : u[n];
+        return l ? l.call(null, i) : typeof f[n] == "function" ? f[n](i) : f[n] = i, this;
+      });
+    }
+  };
+}
+export {
+  w as flow
+};
+//# sourceMappingURL=flow.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sources":["../../../../../../../node_modules/@antv/g2/esm/data/utils/flow.js"],"sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\n/**\n * @todo Combine with the `Container` util\n */\nexport function flow(target, source) {\n    return {\n        set(key, normalize, callback) {\n            if (source[key] === undefined)\n                return this;\n            const value = normalize ? normalize.call(null, source[key]) : source[key];\n            if (callback)\n                callback.call(null, value);\n            else if (typeof target[key] === 'function')\n                target[key](value);\n            else\n                target[key] = value;\n            return this;\n        },\n        setAsync(key, normalize, callback) {\n            return __awaiter(this, void 0, void 0, function* () {\n                if (source[key] === undefined)\n                    return this;\n                const value = normalize\n                    ? yield normalize.call(null, source[key])\n                    : source[key];\n                if (callback)\n                    callback.call(null, value);\n                else if (typeof target[key] === 'function')\n                    target[key](value);\n                else\n                    target[key] = value;\n                return this;\n            });\n        },\n    };\n}\n//# sourceMappingURL=flow.js.map"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","reject","fulfilled","step","e","rejected","result","flow","target","source","key","normalize","callback"],"mappings":"AAAA,IAAIA,IAAwC,SAAUC,GAASC,GAAYC,GAAGC,GAAW;AACrF,WAASC,EAAMC,GAAO;AAAE,WAAOA,aAAiBH,IAAIG,IAAQ,IAAIH,EAAE,SAAUI,GAAS;AAAE,MAAAA,EAAQD,CAAK;AAAA,IAAG,CAAC;AAAA,EAAG;AAC3G,SAAO,KAAKH,MAAMA,IAAI,UAAU,SAAUI,GAASC,GAAQ;AACvD,aAASC,EAAUH,GAAO;AAAE,UAAI;AAAE,QAAAI,EAAKN,EAAU,KAAKE,CAAK,CAAC;AAAA,MAAG,SAASK,GAAG;AAAE,QAAAH,EAAOG,CAAC;AAAA,MAAG;AAAA,IAAE;AAC1F,aAASC,EAASN,GAAO;AAAE,UAAI;AAAE,QAAAI,EAAKN,EAAU,MAASE,CAAK,CAAC;AAAA,MAAG,SAASK,GAAG;AAAE,QAAAH,EAAOG,CAAC;AAAA,MAAG;AAAA,IAAE;AAC7F,aAASD,EAAKG,GAAQ;AAAE,MAAAA,EAAO,OAAON,EAAQM,EAAO,KAAK,IAAIR,EAAMQ,EAAO,KAAK,EAAE,KAAKJ,GAAWG,CAAQ;AAAA,IAAG;AAC7G,IAAAF,GAAMN,IAAYA,EAAU,MAAMH,GAASC,KAAc,CAAA,CAAE,GAAG,MAAM;AAAA,EACxE,CAAC;AACL;AAIO,SAASY,EAAKC,GAAQC,GAAQ;AACjC,SAAO;AAAA,IACH,IAAIC,GAAKC,GAAWC,GAAU;AAC1B,UAAIH,EAAOC,CAAG,MAAM;AAChB,eAAO;AACX,YAAMX,IAAQY,IAAYA,EAAU,KAAK,MAAMF,EAAOC,CAAG,CAAC,IAAID,EAAOC,CAAG;AACxE,aAAIE,IACAA,EAAS,KAAK,MAAMb,CAAK,IACpB,OAAOS,EAAOE,CAAG,KAAM,aAC5BF,EAAOE,CAAG,EAAEX,CAAK,IAEjBS,EAAOE,CAAG,IAAIX,GACX;AAAA,IACX;AAAA,IACA,SAASW,GAAKC,GAAWC,GAAU;AAC/B,aAAOnB,EAAU,MAAM,QAAQ,QAAQ,aAAa;AAChD,YAAIgB,EAAOC,CAAG,MAAM;AAChB,iBAAO;AACX,cAAMX,IAAQY,IACR,MAAMA,EAAU,KAAK,MAAMF,EAAOC,CAAG,CAAC,IACtCD,EAAOC,CAAG;AAChB,eAAIE,IACAA,EAAS,KAAK,MAAMb,CAAK,IACpB,OAAOS,EAAOE,CAAG,KAAM,aAC5BF,EAAOE,CAAG,EAAEX,CAAK,IAEjBS,EAAOE,CAAG,IAAIX,GACX;AAAA,MACX,CAAC;AAAA,IACL;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/venn/circleintersection.js

@@ -0,0 +1,112 @@
+function q(n, t) {
+  const e = m(n), a = e.filter(function(i) {
+    return b(i, n);
+  });
+  let u = 0, l = 0, r;
+  const h = [];
+  if (a.length > 1) {
+    const i = j(a);
+    for (r = 0; r < a.length; ++r) {
+      const o = a[r];
+      o.angle = Math.atan2(o.x - i.x, o.y - i.y);
+    }
+    a.sort(function(o, g) {
+      return g.angle - o.angle;
+    });
+    let x = a[a.length - 1];
+    for (r = 0; r < a.length; ++r) {
+      const o = a[r];
+      l += (x.x + o.x) * (o.y - x.y);
+      const g = { x: (o.x + x.x) / 2, y: (o.y + x.y) / 2 };
+      let s = null;
+      for (let y = 0; y < o.parentIndex.length; ++y)
+        if (x.parentIndex.indexOf(o.parentIndex[y]) > -1) {
+          const f = n[o.parentIndex[y]], L = Math.atan2(o.x - f.x, o.y - f.y), A = Math.atan2(x.x - f.x, x.y - f.y);
+          let M = A - L;
+          M < 0 && (M += 2 * Math.PI);
+          const P = A - M / 2;
+          let c = d(g, {
+            x: f.x + f.radius * Math.sin(P),
+            y: f.y + f.radius * Math.cos(P)
+          });
+          c > f.radius * 2 && (c = f.radius * 2), (s === null || s.width > c) && (s = { circle: f, width: c, p1: o, p2: x });
+        }
+      s !== null && (h.push(s), u += I(s.circle.radius, s.width), x = o);
+    }
+  } else {
+    let i = n[0];
+    for (r = 1; r < n.length; ++r)
+      n[r].radius < i.radius && (i = n[r]);
+    let x = !1;
+    for (r = 0; r < n.length; ++r)
+      if (d(n[r], i) > Math.abs(i.radius - n[r].radius)) {
+        x = !0;
+        break;
+      }
+    x ? u = l = 0 : (u = i.radius * i.radius * Math.PI, h.push({
+      circle: i,
+      p1: { x: i.x, y: i.y + i.radius },
+      p2: { x: i.x - 1e-10, y: i.y + i.radius },
+      width: i.radius * 2
+    }));
+  }
+  return l /= 2, t && (t.area = u + l, t.arcArea = u, t.polygonArea = l, t.arcs = h, t.innerPoints = a, t.intersectionPoints = e), u + l;
+}
+function b(n, t) {
+  for (let e = 0; e < t.length; ++e)
+    if (d(n, t[e]) > t[e].radius + 1e-10)
+      return !1;
+  return !0;
+}
+function m(n) {
+  const t = [];
+  for (let e = 0; e < n.length; ++e)
+    for (let a = e + 1; a < n.length; ++a) {
+      const u = w(n[e], n[a]);
+      for (let l = 0; l < u.length; ++l) {
+        const r = u[l];
+        r.parentIndex = [e, a], t.push(r);
+      }
+    }
+  return t;
+}
+function I(n, t) {
+  return n * n * Math.acos(1 - t / n) - (n - t) * Math.sqrt(t * (2 * n - t));
+}
+function d(n, t) {
+  return Math.sqrt((n.x - t.x) * (n.x - t.x) + (n.y - t.y) * (n.y - t.y));
+}
+function C(n, t, e) {
+  if (e >= n + t)
+    return 0;
+  if (e <= Math.abs(n - t))
+    return Math.PI * Math.min(n, t) * Math.min(n, t);
+  const a = n - (e * e - t * t + n * n) / (2 * e), u = t - (e * e - n * n + t * t) / (2 * e);
+  return I(n, a) + I(t, u);
+}
+function w(n, t) {
+  const e = d(n, t), a = n.radius, u = t.radius;
+  if (e >= a + u || e <= Math.abs(a - u))
+    return [];
+  const l = (a * a - u * u + e * e) / (2 * e), r = Math.sqrt(a * a - l * l), h = n.x + l * (t.x - n.x) / e, i = n.y + l * (t.y - n.y) / e, x = -(t.y - n.y) * (r / e), o = -(t.x - n.x) * (r / e);
+  return [
+    { x: h + x, y: i - o },
+    { x: h - x, y: i + o }
+  ];
+}
+function j(n) {
+  const t = { x: 0, y: 0 };
+  for (let e = 0; e < n.length; ++e)
+    t.x += n[e].x, t.y += n[e].y;
+  return t.x /= n.length, t.y /= n.length, t;
+}
+export {
+  I as circleArea,
+  w as circleCircleIntersection,
+  C as circleOverlap,
+  b as containedInCircles,
+  d as distance,
+  j as getCenter,
+  q as intersectionArea
+};
+//# sourceMappingURL=circleintersection.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/venn/circleintersection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleintersection.js","sources":["../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/circleintersection.js"],"sourcesContent":["const SMALL = 1e-10;\n/**\n * Returns the intersection area of a bunch of circles (where each circle\n * is an object having an x,y and radius property)\n */\nexport function intersectionArea(circles, stats) {\n    // Get all the intersection points of the circles\n    const intersectionPoints = getIntersectionPoints(circles);\n    // Filter out points that aren't included in all the circles\n    const innerPoints = intersectionPoints.filter(function (p) {\n        return containedInCircles(p, circles);\n    });\n    let arcArea = 0, polygonArea = 0, i;\n    const arcs = [];\n    // If we have intersection points that are within all the circles,\n    // then figure out the area contained by them\n    if (innerPoints.length > 1) {\n        // Sort the points by angle from the center of the polygon, which lets\n        // us just iterate over points to get the edges\n        const center = getCenter(innerPoints);\n        for (i = 0; i < innerPoints.length; ++i) {\n            const p = innerPoints[i];\n            p.angle = Math.atan2(p.x - center.x, p.y - center.y);\n        }\n        innerPoints.sort(function (a, b) {\n            return b.angle - a.angle;\n        });\n        // Iterate over all points, get arc between the points\n        // and update the areas\n        let p2 = innerPoints[innerPoints.length - 1];\n        for (i = 0; i < innerPoints.length; ++i) {\n            const p1 = innerPoints[i];\n            // Polygon area updates easily ...\n            polygonArea += (p2.x + p1.x) * (p1.y - p2.y);\n            // Updating the arc area is a little more involved\n            const midPoint = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };\n            let arc = null;\n            for (let j = 0; j < p1.parentIndex.length; ++j) {\n                if (p2.parentIndex.indexOf(p1.parentIndex[j]) > -1) {\n                    // Figure out the angle halfway between the two points\n                    // on the current circle\n                    const circle = circles[p1.parentIndex[j]], a1 = Math.atan2(p1.x - circle.x, p1.y - circle.y), a2 = Math.atan2(p2.x - circle.x, p2.y - circle.y);\n                    let angleDiff = a2 - a1;\n                    if (angleDiff < 0) {\n                        angleDiff += 2 * Math.PI;\n                    }\n                    // and use that angle to figure out the width of the\n                    // arc\n                    const a = a2 - angleDiff / 2;\n                    let width = distance(midPoint, {\n                        x: circle.x + circle.radius * Math.sin(a),\n                        y: circle.y + circle.radius * Math.cos(a),\n                    });\n                    // Clamp the width to the largest is can actually be\n                    // (sometimes slightly overflows because of FP errors)\n                    if (width > circle.radius * 2) {\n                        width = circle.radius * 2;\n                    }\n                    // Pick the circle whose arc has the smallest width\n                    if (arc === null || arc.width > width) {\n                        arc = { circle: circle, width: width, p1: p1, p2: p2 };\n                    }\n                }\n            }\n            if (arc !== null) {\n                arcs.push(arc);\n                arcArea += circleArea(arc.circle.radius, arc.width);\n                p2 = p1;\n            }\n        }\n    }\n    else {\n        // No intersection points, is either disjoint - or is completely\n        // overlapped. figure out which by examining the smallest circle\n        let smallest = circles[0];\n        for (i = 1; i < circles.length; ++i) {\n            if (circles[i].radius < smallest.radius) {\n                smallest = circles[i];\n            }\n        }\n        // Make sure the smallest circle is completely contained in all\n        // the other circles\n        let disjoint = false;\n        for (i = 0; i < circles.length; ++i) {\n            if (distance(circles[i], smallest) >\n                Math.abs(smallest.radius - circles[i].radius)) {\n                disjoint = true;\n                break;\n            }\n        }\n        if (disjoint) {\n            arcArea = polygonArea = 0;\n        }\n        else {\n            arcArea = smallest.radius * smallest.radius * Math.PI;\n            arcs.push({\n                circle: smallest,\n                p1: { x: smallest.x, y: smallest.y + smallest.radius },\n                p2: { x: smallest.x - SMALL, y: smallest.y + smallest.radius },\n                width: smallest.radius * 2,\n            });\n        }\n    }\n    polygonArea /= 2;\n    if (stats) {\n        stats.area = arcArea + polygonArea;\n        stats.arcArea = arcArea;\n        stats.polygonArea = polygonArea;\n        stats.arcs = arcs;\n        stats.innerPoints = innerPoints;\n        stats.intersectionPoints = intersectionPoints;\n    }\n    return arcArea + polygonArea;\n}\n/**\n * Returns whether a point is contained by all of a list of circles\n */\nexport function containedInCircles(point, circles) {\n    for (let i = 0; i < circles.length; ++i) {\n        if (distance(point, circles[i]) > circles[i].radius + SMALL) {\n            return false;\n        }\n    }\n    return true;\n}\n/** Gets all intersection points between a bunch of circles */\nfunction getIntersectionPoints(circles) {\n    const ret = [];\n    for (let i = 0; i < circles.length; ++i) {\n        for (let j = i + 1; j < circles.length; ++j) {\n            const intersect = circleCircleIntersection(circles[i], circles[j]);\n            for (let k = 0; k < intersect.length; ++k) {\n                const p = intersect[k];\n                p.parentIndex = [i, j];\n                ret.push(p);\n            }\n        }\n    }\n    return ret;\n}\n/** Circular segment area calculation. See http://mathworld.wolfram.com/CircularSegment.html */\nexport function circleArea(r, width) {\n    return (r * r * Math.acos(1 - width / r) -\n        (r - width) * Math.sqrt(width * (2 * r - width)));\n}\n/** Euclidean distance between two points */\nexport function distance(p1, p2) {\n    return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));\n}\n/** Returns the overlap area of two circles of radius r1 and r2 - that\nhave their centers separated by distance d. Simpler faster\ncircle intersection for only two circles */\nexport function circleOverlap(r1, r2, d) {\n    // no overlap\n    if (d >= r1 + r2) {\n        return 0;\n    }\n    // Completely overlapped\n    if (d <= Math.abs(r1 - r2)) {\n        return Math.PI * Math.min(r1, r2) * Math.min(r1, r2);\n    }\n    const w1 = r1 - (d * d - r2 * r2 + r1 * r1) / (2 * d), w2 = r2 - (d * d - r1 * r1 + r2 * r2) / (2 * d);\n    return circleArea(r1, w1) + circleArea(r2, w2);\n}\n/** Given two circles (containing a x/y/radius attributes),\nreturns the intersecting points if possible.\nnote: doesn't handle cases where there are infinitely many\nintersection points (circles are equivalent):, or only one intersection point*/\nexport function circleCircleIntersection(p1, p2) {\n    const d = distance(p1, p2), r1 = p1.radius, r2 = p2.radius;\n    // If to far away, or self contained - can't be done\n    if (d >= r1 + r2 || d <= Math.abs(r1 - r2)) {\n        return [];\n    }\n    const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d), h = Math.sqrt(r1 * r1 - a * a), x0 = p1.x + (a * (p2.x - p1.x)) / d, y0 = p1.y + (a * (p2.y - p1.y)) / d, rx = -(p2.y - p1.y) * (h / d), ry = -(p2.x - p1.x) * (h / d);\n    return [\n        { x: x0 + rx, y: y0 - ry },\n        { x: x0 - rx, y: y0 + ry },\n    ];\n}\n/** Returns the center of a bunch of points */\nexport function getCenter(points) {\n    const center = { x: 0, y: 0 };\n    for (let i = 0; i < points.length; ++i) {\n        center.x += points[i].x;\n        center.y += points[i].y;\n    }\n    center.x /= points.length;\n    center.y /= points.length;\n    return center;\n}\n//# sourceMappingURL=circleintersection.js.map"],"names":["intersectionArea","circles","stats","intersectionPoints","getIntersectionPoints","innerPoints","p","containedInCircles","arcArea","polygonArea","i","arcs","center","getCenter","a","b","p2","p1","midPoint","arc","j","circle","a1","a2","angleDiff","width","distance","circleArea","smallest","disjoint","point","ret","intersect","circleCircleIntersection","k","r","circleOverlap","r1","r2","d","w1","w2","h","x0","y0","rx","ry","points"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/venn/diagram.js

@@ -0,0 +1,29 @@
+import { intersectionArea as u } from "./circleintersection.js";
+function a(s, r, t) {
+  const n = [], c = s - t, e = r;
+  return n.push("M", c, e), n.push("A", t, t, 0, 1, 0, c + 2 * t, e), n.push("A", t, t, 0, 1, 0, c, e), n.join(" ");
+}
+function l(s) {
+  const r = {};
+  u(s, r);
+  const t = r.arcs;
+  if (t.length === 0)
+    return "M 0 0";
+  if (t.length == 1) {
+    const n = t[0].circle;
+    return a(n.x, n.y, n.radius);
+  } else {
+    const n = [`
+M`, t[0].p2.x, t[0].p2.y];
+    for (let c = 0; c < t.length; ++c) {
+      const e = t[c], i = e.circle.radius, o = e.width > i;
+      n.push(`
+A`, i, i, 0, o ? 1 : 0, 1, e.p1.x, e.p1.y);
+    }
+    return n.join(" ");
+  }
+}
+export {
+  l as intersectionAreaPath
+};
+//# sourceMappingURL=diagram.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/venn/diagram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram.js","sources":["../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/diagram.js"],"sourcesContent":["import { intersectionArea } from './circleintersection';\n/**\n * 根据圆心(x, y) 半径 r 返回圆的绘制 path\n * @param x 圆心点 x\n * @param y 圆心点 y\n * @param r 圆的半径\n * @returns 圆的 path\n */\nfunction circlePath(x, y, r) {\n    const ret = [];\n    // ret.push('\\nM', x, y);\n    // ret.push('\\nm', -r, 0);\n    // ret.push('\\na', r, r, 0, 1, 0, r * 2, 0);\n    // ret.push('\\na', r, r, 0, 1, 0, -r * 2, 0);\n    const x0 = x - r;\n    const y0 = y;\n    ret.push('M', x0, y0);\n    ret.push('A', r, r, 0, 1, 0, x0 + 2 * r, y0);\n    ret.push('A', r, r, 0, 1, 0, x0, y0);\n    return ret.join(' ');\n}\n/** returns a svg path of the intersection area of a bunch of circles */\nexport function intersectionAreaPath(circles) {\n    const stats = {};\n    intersectionArea(circles, stats);\n    const arcs = stats.arcs;\n    if (arcs.length === 0) {\n        return 'M 0 0';\n    }\n    else if (arcs.length == 1) {\n        const circle = arcs[0].circle;\n        return circlePath(circle.x, circle.y, circle.radius);\n    }\n    else {\n        // draw path around arcs\n        const ret = ['\\nM', arcs[0].p2.x, arcs[0].p2.y];\n        for (let i = 0; i < arcs.length; ++i) {\n            const arc = arcs[i], r = arc.circle.radius, wide = arc.width > r;\n            ret.push('\\nA', r, r, 0, wide ? 1 : 0, 1, arc.p1.x, arc.p1.y);\n        }\n        return ret.join(' ');\n    }\n}\n//# sourceMappingURL=diagram.js.map"],"names":["circlePath","x","y","r","ret","x0","y0","intersectionAreaPath","circles","stats","intersectionArea","arcs","circle","i","arc","wide"],"mappings":";AAQA,SAASA,EAAWC,GAAGC,GAAGC,GAAG;AACzB,QAAMC,IAAM,CAAA,GAKNC,IAAKJ,IAAIE,GACTG,IAAKJ;AACX,SAAAE,EAAI,KAAK,KAAKC,GAAIC,CAAE,GACpBF,EAAI,KAAK,KAAKD,GAAGA,GAAG,GAAG,GAAG,GAAGE,IAAK,IAAIF,GAAGG,CAAE,GAC3CF,EAAI,KAAK,KAAKD,GAAGA,GAAG,GAAG,GAAG,GAAGE,GAAIC,CAAE,GAC5BF,EAAI,KAAK,GAAG;AACvB;AAEO,SAASG,EAAqBC,GAAS;AAC1C,QAAMC,IAAQ,CAAA;AACd,EAAAC,EAAiBF,GAASC,CAAK;AAC/B,QAAME,IAAOF,EAAM;AACnB,MAAIE,EAAK,WAAW;AAChB,WAAO;AAEN,MAAIA,EAAK,UAAU,GAAG;AACvB,UAAMC,IAASD,EAAK,CAAC,EAAE;AACvB,WAAOX,EAAWY,EAAO,GAAGA,EAAO,GAAGA,EAAO,MAAM;AAAA,EACvD,OACK;AAED,UAAMR,IAAM,CAAC;AAAA,IAAOO,EAAK,CAAC,EAAE,GAAG,GAAGA,EAAK,CAAC,EAAE,GAAG,CAAC;AAC9C,aAASE,IAAI,GAAGA,IAAIF,EAAK,QAAQ,EAAEE,GAAG;AAClC,YAAMC,IAAMH,EAAKE,CAAC,GAAGV,IAAIW,EAAI,OAAO,QAAQC,IAAOD,EAAI,QAAQX;AAC/D,MAAAC,EAAI,KAAK;AAAA,IAAOD,GAAGA,GAAG,GAAGY,IAAO,IAAI,GAAG,GAAGD,EAAI,GAAG,GAAGA,EAAI,GAAG,CAAC;AAAA,IAChE;AACA,WAAOV,EAAI,KAAK,GAAG;AAAA,EACvB;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/venn/fmin/bisect.js

@@ -0,0 +1,22 @@
+function h(o, t, e, n) {
+  n = n || {};
+  const u = n.maxIterations || 100, d = n.tolerance || 1e-10, s = o(t), r = o(e);
+  let i = e - t;
+  if (s * r > 0)
+    throw "Initial bisect points must have opposite signs";
+  if (s === 0)
+    return t;
+  if (r === 0)
+    return e;
+  for (let f = 0; f < u; ++f) {
+    i /= 2;
+    const c = t + i, l = o(c);
+    if (l * s >= 0 && (t = c), Math.abs(i) < d || l === 0)
+      return c;
+  }
+  return t + i;
+}
+export {
+  h as bisect
+};
+//# sourceMappingURL=bisect.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/venn/fmin/bisect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bisect.js","sources":["../../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/fmin/bisect.js"],"sourcesContent":["/** finds the zeros of a function, given two starting points (which must\n * have opposite signs */\nexport function bisect(f, a, b, parameters) {\n    parameters = parameters || {};\n    const maxIterations = parameters.maxIterations || 100;\n    const tolerance = parameters.tolerance || 1e-10;\n    const fA = f(a);\n    const fB = f(b);\n    let delta = b - a;\n    if (fA * fB > 0) {\n        throw 'Initial bisect points must have opposite signs';\n    }\n    if (fA === 0)\n        return a;\n    if (fB === 0)\n        return b;\n    for (let i = 0; i < maxIterations; ++i) {\n        delta /= 2;\n        const mid = a + delta;\n        const fMid = f(mid);\n        if (fMid * fA >= 0) {\n            a = mid;\n        }\n        if (Math.abs(delta) < tolerance || fMid === 0) {\n            return mid;\n        }\n    }\n    return a + delta;\n}\n//# sourceMappingURL=bisect.js.map"],"names":["bisect","f","a","b","parameters","maxIterations","tolerance","fA","fB","delta","i","mid","fMid"],"mappings":"AAEO,SAASA,EAAOC,GAAGC,GAAGC,GAAGC,GAAY;AACxC,EAAAA,IAAaA,KAAc,CAAA;AAC3B,QAAMC,IAAgBD,EAAW,iBAAiB,KAC5CE,IAAYF,EAAW,aAAa,OACpCG,IAAKN,EAAEC,CAAC,GACRM,IAAKP,EAAEE,CAAC;AACd,MAAIM,IAAQN,IAAID;AAChB,MAAIK,IAAKC,IAAK;AACV,UAAM;AAEV,MAAID,MAAO;AACP,WAAOL;AACX,MAAIM,MAAO;AACP,WAAOL;AACX,WAASO,IAAI,GAAGA,IAAIL,GAAe,EAAEK,GAAG;AACpC,IAAAD,KAAS;AACT,UAAME,IAAMT,IAAIO,GACVG,IAAOX,EAAEU,CAAG;AAIlB,QAHIC,IAAOL,KAAM,MACbL,IAAIS,IAEJ,KAAK,IAAIF,CAAK,IAAIH,KAAaM,MAAS;AACxC,aAAOD;AAAA,EAEf;AACA,SAAOT,IAAIO;AACf;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/utils/venn/fmin/blas1.js

@@ -0,0 +1,35 @@
+function f(t) {
+  const n = new Array(t);
+  for (let e = 0; e < t; ++e)
+    n[e] = 0;
+  return n;
+}
+function c(t, n) {
+  return f(t).map(() => f(n));
+}
+function u(t, n) {
+  let e = 0;
+  for (let r = 0; r < t.length; ++r)
+    e += t[r] * n[r];
+  return e;
+}
+function l(t) {
+  return Math.sqrt(u(t, t));
+}
+function h(t, n, e) {
+  for (let r = 0; r < n.length; ++r)
+    t[r] = n[r] * e;
+}
+function s(t, n, e, r, i) {
+  for (let o = 0; o < t.length; ++o)
+    t[o] = n * e[o] + r * i[o];
+}
+export {
+  u as dot,
+  l as norm2,
+  h as scale,
+  s as weightedSum,
+  f as zeros,
+  c as zerosM
+};
+//# sourceMappingURL=blas1.js.map

package/dist/node_modules/@antv/g2/esm/data/utils/venn/fmin/blas1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blas1.js","sources":["../../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/fmin/blas1.js"],"sourcesContent":["// need some basic operations on vectors, rather than adding a dependency,\n// just define here\nexport function zeros(x) {\n    const r = new Array(x);\n    for (let i = 0; i < x; ++i) {\n        r[i] = 0;\n    }\n    return r;\n}\nexport function zerosM(x, y) {\n    return zeros(x).map(() => zeros(y));\n}\nexport function dot(a, b) {\n    let ret = 0;\n    for (let i = 0; i < a.length; ++i) {\n        ret += a[i] * b[i];\n    }\n    return ret;\n}\nexport function norm2(a) {\n    return Math.sqrt(dot(a, a));\n}\nexport function scale(ret, value, c) {\n    for (let i = 0; i < value.length; ++i) {\n        ret[i] = value[i] * c;\n    }\n}\nexport function weightedSum(ret, w1, v1, w2, v2) {\n    for (let j = 0; j < ret.length; ++j) {\n        ret[j] = w1 * v1[j] + w2 * v2[j];\n    }\n}\nexport function gemv(output, A, x) {\n    for (let i = 0; i < output.length; ++i) {\n        output[i] = dot(A[i], x);\n    }\n}\n//# sourceMappingURL=blas1.js.map"],"names":["zeros","x","r","i","zerosM","y","dot","a","b","ret","norm2","scale","value","c","weightedSum","w1","v1","w2","v2","j"],"mappings":"AAEO,SAASA,EAAMC,GAAG;AACrB,QAAMC,IAAI,IAAI,MAAMD,CAAC;AACrB,WAASE,IAAI,GAAGA,IAAIF,GAAG,EAAEE;AACrB,IAAAD,EAAEC,CAAC,IAAI;AAEX,SAAOD;AACX;AACO,SAASE,EAAOH,GAAGI,GAAG;AACzB,SAAOL,EAAMC,CAAC,EAAE,IAAI,MAAMD,EAAMK,CAAC,CAAC;AACtC;AACO,SAASC,EAAIC,GAAGC,GAAG;AACtB,MAAIC,IAAM;AACV,WAASN,IAAI,GAAGA,IAAII,EAAE,QAAQ,EAAEJ;AAC5B,IAAAM,KAAOF,EAAEJ,CAAC,IAAIK,EAAEL,CAAC;AAErB,SAAOM;AACX;AACO,SAASC,EAAMH,GAAG;AACrB,SAAO,KAAK,KAAKD,EAAIC,GAAGA,CAAC,CAAC;AAC9B;AACO,SAASI,EAAMF,GAAKG,GAAOC,GAAG;AACjC,WAASV,IAAI,GAAGA,IAAIS,EAAM,QAAQ,EAAET;AAChC,IAAAM,EAAIN,CAAC,IAAIS,EAAMT,CAAC,IAAIU;AAE5B;AACO,SAASC,EAAYL,GAAKM,GAAIC,GAAIC,GAAIC,GAAI;AAC7C,WAASC,IAAI,GAAGA,IAAIV,EAAI,QAAQ,EAAEU;AAC9B,IAAAV,EAAIU,CAAC,IAAIJ,IAAKC,EAAGG,CAAC,IAAIF,IAAKC,EAAGC,CAAC;AAEvC;","x_google_ignoreList":[0]}