@hkyhy/marsun-components-core 0.1.113 → 0.1.114

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

@@ -0,0 +1,38 @@
+import { scale as s, weightedSum as l, dot as h, norm2 as y } from "./blas1.js";
+import { wolfeLineSearch as d } from "./linesearch.js";
+function w(o, f, x) {
+  let e = { x: f.slice(), fx: 0, fxprime: f.slice() }, r = { x: f.slice(), fx: 0, fxprime: f.slice() };
+  const m = f.slice();
+  let c, i = 1;
+  x = x || {};
+  const n = x.maxIterations || f.length * 20;
+  e.fx = o(e.x, e.fxprime);
+  const t = e.fxprime.slice();
+  s(t, e.fxprime, -1);
+  for (let p = 0; p < n; ++p) {
+    if (i = d(o, t, e, r, i), x.history && x.history.push({
+      x: e.x.slice(),
+      fx: e.fx,
+      fxprime: e.fxprime.slice(),
+      alpha: i
+    }), !i)
+      s(t, e.fxprime, -1);
+    else {
+      l(m, 1, r.fxprime, -1, e.fxprime);
+      const u = h(e.fxprime, e.fxprime), k = Math.max(0, h(m, r.fxprime) / u);
+      l(t, k, t, -1, r.fxprime), c = e, e = r, r = c;
+    }
+    if (y(e.fxprime) <= 1e-5)
+      break;
+  }
+  return x.history && x.history.push({
+    x: e.x.slice(),
+    fx: e.fx,
+    fxprime: e.fxprime.slice(),
+    alpha: i
+  }), e;
+}
+export {
+  w as conjugateGradient
+};
+//# sourceMappingURL=conjugateGradient.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conjugateGradient.js","sources":["../../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/fmin/conjugateGradient.js"],"sourcesContent":["import { dot, gemv, norm2, scale, weightedSum } from './blas1';\nimport { wolfeLineSearch } from './linesearch';\nexport function conjugateGradient(f, initial, params) {\n    // allocate all memory up front here, keep out of the loop for perfomance\n    // reasons\n    let current = { x: initial.slice(), fx: 0, fxprime: initial.slice() };\n    let next = { x: initial.slice(), fx: 0, fxprime: initial.slice() };\n    const yk = initial.slice();\n    let temp;\n    let a = 1;\n    params = params || {};\n    const maxIterations = params.maxIterations || initial.length * 20;\n    current.fx = f(current.x, current.fxprime);\n    const pk = current.fxprime.slice();\n    scale(pk, current.fxprime, -1);\n    for (let i = 0; i < maxIterations; ++i) {\n        a = wolfeLineSearch(f, pk, current, next, a);\n        // todo: history in wrong spot?\n        if (params.history) {\n            params.history.push({\n                x: current.x.slice(),\n                fx: current.fx,\n                fxprime: current.fxprime.slice(),\n                alpha: a,\n            });\n        }\n        if (!a) {\n            // faiiled to find point that satifies wolfe conditions.\n            // reset direction for next iteration\n            scale(pk, current.fxprime, -1);\n        }\n        else {\n            // update direction using Polak–Ribiere CG method\n            weightedSum(yk, 1, next.fxprime, -1, current.fxprime);\n            const delta_k = dot(current.fxprime, current.fxprime);\n            const beta_k = Math.max(0, dot(yk, next.fxprime) / delta_k);\n            weightedSum(pk, beta_k, pk, -1, next.fxprime);\n            temp = current;\n            current = next;\n            next = temp;\n        }\n        if (norm2(current.fxprime) <= 1e-5) {\n            break;\n        }\n    }\n    if (params.history) {\n        params.history.push({\n            x: current.x.slice(),\n            fx: current.fx,\n            fxprime: current.fxprime.slice(),\n            alpha: a,\n        });\n    }\n    return current;\n}\n/// Solves a system of lienar equations Ax =b for x\n/// using the conjugate gradient method.\nexport function conjugateGradientSolve(A, b, x, history) {\n    const r = x.slice();\n    const Ap = x.slice();\n    let rsold;\n    let rsnew;\n    let alpha;\n    // r = b - A*x\n    gemv(Ap, A, x);\n    weightedSum(r, 1, b, -1, Ap);\n    const p = r.slice();\n    rsold = dot(r, r);\n    for (let i = 0; i < b.length; ++i) {\n        gemv(Ap, A, p);\n        alpha = rsold / dot(p, Ap);\n        if (history) {\n            history.push({ x: x.slice(), p: p.slice(), alpha: alpha });\n        }\n        //x=x+alpha*p;\n        weightedSum(x, 1, x, alpha, p);\n        // r=r-alpha*Ap;\n        weightedSum(r, 1, r, -alpha, Ap);\n        rsnew = dot(r, r);\n        if (Math.sqrt(rsnew) <= 1e-10)\n            break;\n        // p=r+(rsnew/rsold)*p;\n        weightedSum(p, 1, r, rsnew / rsold, p);\n        rsold = rsnew;\n    }\n    if (history) {\n        history.push({ x: x.slice(), p: p.slice(), alpha: alpha });\n    }\n    return x;\n}\n//# sourceMappingURL=conjugateGradient.js.map"],"names":["conjugateGradient","f","initial","params","current","next","yk","temp","a","maxIterations","pk","scale","i","wolfeLineSearch","weightedSum","delta_k","dot","beta_k","norm2"],"mappings":";;AAEO,SAASA,EAAkBC,GAAGC,GAASC,GAAQ;AAGlD,MAAIC,IAAU,EAAE,GAAGF,EAAQ,MAAK,GAAI,IAAI,GAAG,SAASA,EAAQ,MAAK,EAAE,GAC/DG,IAAO,EAAE,GAAGH,EAAQ,MAAK,GAAI,IAAI,GAAG,SAASA,EAAQ,MAAK,EAAE;AAChE,QAAMI,IAAKJ,EAAQ,MAAK;AACxB,MAAIK,GACAC,IAAI;AACR,EAAAL,IAASA,KAAU,CAAA;AACnB,QAAMM,IAAgBN,EAAO,iBAAiBD,EAAQ,SAAS;AAC/D,EAAAE,EAAQ,KAAKH,EAAEG,EAAQ,GAAGA,EAAQ,OAAO;AACzC,QAAMM,IAAKN,EAAQ,QAAQ,MAAK;AAChC,EAAAO,EAAMD,GAAIN,EAAQ,SAAS,EAAE;AAC7B,WAASQ,IAAI,GAAGA,IAAIH,GAAe,EAAEG,GAAG;AAWpC,QAVAJ,IAAIK,EAAgBZ,GAAGS,GAAIN,GAASC,GAAMG,CAAC,GAEvCL,EAAO,WACPA,EAAO,QAAQ,KAAK;AAAA,MAChB,GAAGC,EAAQ,EAAE,MAAK;AAAA,MAClB,IAAIA,EAAQ;AAAA,MACZ,SAASA,EAAQ,QAAQ,MAAK;AAAA,MAC9B,OAAOI;AAAA,IACvB,CAAa,GAED,CAACA;AAGD,MAAAG,EAAMD,GAAIN,EAAQ,SAAS,EAAE;AAAA,SAE5B;AAED,MAAAU,EAAYR,GAAI,GAAGD,EAAK,SAAS,IAAID,EAAQ,OAAO;AACpD,YAAMW,IAAUC,EAAIZ,EAAQ,SAASA,EAAQ,OAAO,GAC9Ca,IAAS,KAAK,IAAI,GAAGD,EAAIV,GAAID,EAAK,OAAO,IAAIU,CAAO;AAC1D,MAAAD,EAAYJ,GAAIO,GAAQP,GAAI,IAAIL,EAAK,OAAO,GAC5CE,IAAOH,GACPA,IAAUC,GACVA,IAAOE;AAAA,IACX;AACA,QAAIW,EAAMd,EAAQ,OAAO,KAAK;AAC1B;AAAA,EAER;AACA,SAAID,EAAO,WACPA,EAAO,QAAQ,KAAK;AAAA,IAChB,GAAGC,EAAQ,EAAE,MAAK;AAAA,IAClB,IAAIA,EAAQ;AAAA,IACZ,SAASA,EAAQ,QAAQ,MAAK;AAAA,IAC9B,OAAOI;AAAA,EACnB,CAAS,GAEEJ;AACX;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,31 @@
+import { dot as b, weightedSum as S } from "./blas1.js";
+function L(h, o, p, r, i, u, x) {
+  const l = p.fx, m = b(p.fxprime, o);
+  let f = l, d = l, t = m, n = 0;
+  i = i || 1, u = u || 1e-6, x = x || 0.1;
+  function w(e, s, M) {
+    for (let P = 0; P < 16; ++P)
+      if (i = (e + s) / 2, S(r.x, 1, p.x, i, o), f = r.fx = h(r.x, r.fxprime), t = b(r.fxprime, o), f > l + u * i * m || f >= M)
+        s = i;
+      else {
+        if (Math.abs(t) <= -x * m)
+          return i;
+        t * (s - e) >= 0 && (s = e), e = i, M = f;
+      }
+    return 0;
+  }
+  for (let e = 0; e < 10; ++e) {
+    if (S(r.x, 1, p.x, i, o), f = r.fx = h(r.x, r.fxprime), t = b(r.fxprime, o), f > l + u * i * m || e && f >= d)
+      return w(n, i, d);
+    if (Math.abs(t) <= -x * m)
+      return i;
+    if (t >= 0)
+      return w(i, n, f);
+    d = f, n = i, i *= 2;
+  }
+  return i;
+}
+export {
+  L as wolfeLineSearch
+};
+//# sourceMappingURL=linesearch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linesearch.js","sources":["../../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/fmin/linesearch.js"],"sourcesContent":["import { dot, weightedSum } from './blas1';\n/// searches along line 'pk' for a point that satifies the wolfe conditions\n/// See 'Numerical Optimization' by Nocedal and Wright p59-60\n/// f : objective function\n/// pk : search direction\n/// current: object containing current gradient/loss\n/// next: output: contains next gradient/loss\n/// returns a: step size taken\nexport function wolfeLineSearch(f, pk, current, next, a, c1, c2) {\n    const phi0 = current.fx;\n    const phiPrime0 = dot(current.fxprime, pk);\n    let phi = phi0;\n    let phi_old = phi0;\n    let phiPrime = phiPrime0;\n    let a0 = 0;\n    a = a || 1;\n    c1 = c1 || 1e-6;\n    c2 = c2 || 0.1;\n    function zoom(a_lo, a_high, phi_lo) {\n        for (let iteration = 0; iteration < 16; ++iteration) {\n            a = (a_lo + a_high) / 2;\n            weightedSum(next.x, 1.0, current.x, a, pk);\n            phi = next.fx = f(next.x, next.fxprime);\n            phiPrime = dot(next.fxprime, pk);\n            if (phi > phi0 + c1 * a * phiPrime0 || phi >= phi_lo) {\n                a_high = a;\n            }\n            else {\n                if (Math.abs(phiPrime) <= -c2 * phiPrime0) {\n                    return a;\n                }\n                if (phiPrime * (a_high - a_lo) >= 0) {\n                    a_high = a_lo;\n                }\n                a_lo = a;\n                phi_lo = phi;\n            }\n        }\n        return 0;\n    }\n    for (let iteration = 0; iteration < 10; ++iteration) {\n        weightedSum(next.x, 1.0, current.x, a, pk);\n        phi = next.fx = f(next.x, next.fxprime);\n        phiPrime = dot(next.fxprime, pk);\n        if (phi > phi0 + c1 * a * phiPrime0 || (iteration && phi >= phi_old)) {\n            return zoom(a0, a, phi_old);\n        }\n        if (Math.abs(phiPrime) <= -c2 * phiPrime0) {\n            return a;\n        }\n        if (phiPrime >= 0) {\n            return zoom(a, a0, phi);\n        }\n        phi_old = phi;\n        a0 = a;\n        a *= 2;\n    }\n    return a;\n}\n//# sourceMappingURL=linesearch.js.map"],"names":["wolfeLineSearch","f","pk","current","next","a","c1","c2","phi0","phiPrime0","dot","phi","phi_old","phiPrime","a0","zoom","a_lo","a_high","phi_lo","iteration","weightedSum"],"mappings":";AAQO,SAASA,EAAgBC,GAAGC,GAAIC,GAASC,GAAMC,GAAGC,GAAIC,GAAI;AAC7D,QAAMC,IAAOL,EAAQ,IACfM,IAAYC,EAAIP,EAAQ,SAASD,CAAE;AACzC,MAAIS,IAAMH,GACNI,IAAUJ,GACVK,IAAWJ,GACXK,IAAK;AACT,EAAAT,IAAIA,KAAK,GACTC,IAAKA,KAAM,MACXC,IAAKA,KAAM;AACX,WAASQ,EAAKC,GAAMC,GAAQC,GAAQ;AAChC,aAASC,IAAY,GAAGA,IAAY,IAAI,EAAEA;AAKtC,UAJAd,KAAKW,IAAOC,KAAU,GACtBG,EAAYhB,EAAK,GAAG,GAAKD,EAAQ,GAAGE,GAAGH,CAAE,GACzCS,IAAMP,EAAK,KAAKH,EAAEG,EAAK,GAAGA,EAAK,OAAO,GACtCS,IAAWH,EAAIN,EAAK,SAASF,CAAE,GAC3BS,IAAMH,IAAOF,IAAKD,IAAII,KAAaE,KAAOO;AAC1C,QAAAD,IAASZ;AAAA,WAER;AACD,YAAI,KAAK,IAAIQ,CAAQ,KAAK,CAACN,IAAKE;AAC5B,iBAAOJ;AAEX,QAAIQ,KAAYI,IAASD,MAAS,MAC9BC,IAASD,IAEbA,IAAOX,GACPa,IAASP;AAAA,MACb;AAEJ,WAAO;AAAA,EACX;AACA,WAASQ,IAAY,GAAGA,IAAY,IAAI,EAAEA,GAAW;AAIjD,QAHAC,EAAYhB,EAAK,GAAG,GAAKD,EAAQ,GAAGE,GAAGH,CAAE,GACzCS,IAAMP,EAAK,KAAKH,EAAEG,EAAK,GAAGA,EAAK,OAAO,GACtCS,IAAWH,EAAIN,EAAK,SAASF,CAAE,GAC3BS,IAAMH,IAAOF,IAAKD,IAAII,KAAcU,KAAaR,KAAOC;AACxD,aAAOG,EAAKD,GAAIT,GAAGO,CAAO;AAE9B,QAAI,KAAK,IAAIC,CAAQ,KAAK,CAACN,IAAKE;AAC5B,aAAOJ;AAEX,QAAIQ,KAAY;AACZ,aAAOE,EAAKV,GAAGS,GAAIH,CAAG;AAE1B,IAAAC,IAAUD,GACVG,IAAKT,GACLA,KAAK;AAAA,EACT;AACA,SAAOA;AACX;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,60 @@
+import { weightedSum as D } from "./blas1.js";
+function A(d, x, e) {
+  e = e || {};
+  const S = e.maxIterations || x.length * 200, k = e.nonZeroDelta || 1.05, z = e.zeroDelta || 1e-3, I = e.minErrorDelta || 1e-6, Z = e.minErrorDelta || 1e-5, b = e.rho !== void 0 ? e.rho : 1, y = e.chi !== void 0 ? e.chi : 2, M = e.psi !== void 0 ? e.psi : -0.5, w = e.sigma !== void 0 ? e.sigma : 0.5;
+  let m;
+  const s = x.length, i = new Array(s + 1);
+  i[0] = x, i[0].fx = d(x), i[0].id = 0;
+  for (let t = 0; t < s; ++t) {
+    const o = x.slice();
+    o[t] = o[t] ? o[t] * k : z, i[t + 1] = o, i[t + 1].fx = d(o), i[t + 1].id = t + 1;
+  }
+  function h(t) {
+    for (let o = 0; o < t.length; o++)
+      i[s][o] = t[o];
+    i[s].fx = t.fx;
+  }
+  const E = (t, o) => t.fx - o.fx, r = x.slice(), l = x.slice(), c = x.slice(), u = x.slice();
+  for (let t = 0; t < S; ++t) {
+    if (i.sort(E), e.history) {
+      const n = i.map((f) => {
+        const g = f.slice();
+        return g.fx = f.fx, g.id = f.id, g;
+      });
+      n.sort((f, g) => f.id - g.id), e.history.push({
+        x: i[0].slice(),
+        fx: i[0].fx,
+        simplex: n
+      });
+    }
+    m = 0;
+    for (let n = 0; n < s; ++n)
+      m = Math.max(m, Math.abs(i[0][n] - i[1][n]));
+    if (Math.abs(i[0].fx - i[s].fx) < I && m < Z)
+      break;
+    for (let n = 0; n < s; ++n) {
+      r[n] = 0;
+      for (let f = 0; f < s; ++f)
+        r[n] += i[f][n];
+      r[n] /= s;
+    }
+    const o = i[s];
+    if (D(l, 1 + b, r, -b, o), l.fx = d(l), l.fx < i[0].fx)
+      D(u, 1 + y, r, -y, o), u.fx = d(u), u.fx < l.fx ? h(u) : h(l);
+    else if (l.fx >= i[s - 1].fx) {
+      let n = !1;
+      if (l.fx > o.fx ? (D(c, 1 + M, r, -M, o), c.fx = d(c), c.fx < o.fx ? h(c) : n = !0) : (D(c, 1 - M * b, r, M * b, o), c.fx = d(c), c.fx < l.fx ? h(c) : n = !0), n) {
+        if (w >= 1)
+          break;
+        for (let f = 1; f < i.length; ++f)
+          D(i[f], 1 - w, i[0], w, i[f]), i[f].fx = d(i[f]);
+      }
+    } else
+      h(l);
+  }
+  return i.sort(E), { fx: i[0].fx, x: i[0] };
+}
+export {
+  A as nelderMead
+};
+//# sourceMappingURL=nelderMead.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nelderMead.js","sources":["../../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/fmin/nelderMead.js"],"sourcesContent":["import { weightedSum } from './blas1';\n/** minimizes a function using the downhill simplex method */\nexport function nelderMead(f, x0, parameters) {\n    parameters = parameters || {};\n    const maxIterations = parameters.maxIterations || x0.length * 200;\n    const nonZeroDelta = parameters.nonZeroDelta || 1.05;\n    const zeroDelta = parameters.zeroDelta || 0.001;\n    const minErrorDelta = parameters.minErrorDelta || 1e-6;\n    const minTolerance = parameters.minErrorDelta || 1e-5;\n    const rho = parameters.rho !== undefined ? parameters.rho : 1;\n    const chi = parameters.chi !== undefined ? parameters.chi : 2;\n    const psi = parameters.psi !== undefined ? parameters.psi : -0.5;\n    const sigma = parameters.sigma !== undefined ? parameters.sigma : 0.5;\n    let maxDiff;\n    // initialize simplex.\n    const N = x0.length;\n    const simplex = new Array(N + 1);\n    simplex[0] = x0;\n    simplex[0].fx = f(x0);\n    simplex[0].id = 0;\n    for (let i = 0; i < N; ++i) {\n        const point = x0.slice();\n        point[i] = point[i] ? point[i] * nonZeroDelta : zeroDelta;\n        simplex[i + 1] = point;\n        simplex[i + 1].fx = f(point);\n        simplex[i + 1].id = i + 1;\n    }\n    function updateSimplex(value) {\n        for (let i = 0; i < value.length; i++) {\n            simplex[N][i] = value[i];\n        }\n        simplex[N].fx = value.fx;\n    }\n    const sortOrder = (a, b) => a.fx - b.fx;\n    const centroid = x0.slice();\n    const reflected = x0.slice();\n    const contracted = x0.slice();\n    const expanded = x0.slice();\n    for (let iteration = 0; iteration < maxIterations; ++iteration) {\n        simplex.sort(sortOrder);\n        if (parameters.history) {\n            // copy the simplex (since later iterations will mutate) and\n            // sort it to have a consistent order between iterations\n            const sortedSimplex = simplex.map((x) => {\n                const state = x.slice();\n                state.fx = x.fx;\n                state.id = x.id;\n                return state;\n            });\n            sortedSimplex.sort((a, b) => a.id - b.id);\n            parameters.history.push({\n                x: simplex[0].slice(),\n                fx: simplex[0].fx,\n                simplex: sortedSimplex,\n            });\n        }\n        maxDiff = 0;\n        for (let i = 0; i < N; ++i) {\n            maxDiff = Math.max(maxDiff, Math.abs(simplex[0][i] - simplex[1][i]));\n        }\n        if (Math.abs(simplex[0].fx - simplex[N].fx) < minErrorDelta &&\n            maxDiff < minTolerance) {\n            break;\n        }\n        // compute the centroid of all but the worst point in the simplex\n        for (let i = 0; i < N; ++i) {\n            centroid[i] = 0;\n            for (let j = 0; j < N; ++j) {\n                centroid[i] += simplex[j][i];\n            }\n            centroid[i] /= N;\n        }\n        // reflect the worst point past the centroid  and compute loss at reflected\n        // point\n        const worst = simplex[N];\n        weightedSum(reflected, 1 + rho, centroid, -rho, worst);\n        reflected.fx = f(reflected);\n        // if the reflected point is the best seen, then possibly expand\n        if (reflected.fx < simplex[0].fx) {\n            weightedSum(expanded, 1 + chi, centroid, -chi, worst);\n            expanded.fx = f(expanded);\n            if (expanded.fx < reflected.fx) {\n                updateSimplex(expanded);\n            }\n            else {\n                updateSimplex(reflected);\n            }\n        }\n        // if the reflected point is worse than the second worst, we need to\n        // contract\n        else if (reflected.fx >= simplex[N - 1].fx) {\n            let shouldReduce = false;\n            if (reflected.fx > worst.fx) {\n                // do an inside contraction\n                weightedSum(contracted, 1 + psi, centroid, -psi, worst);\n                contracted.fx = f(contracted);\n                if (contracted.fx < worst.fx) {\n                    updateSimplex(contracted);\n                }\n                else {\n                    shouldReduce = true;\n                }\n            }\n            else {\n                // do an outside contraction\n                weightedSum(contracted, 1 - psi * rho, centroid, psi * rho, worst);\n                contracted.fx = f(contracted);\n                if (contracted.fx < reflected.fx) {\n                    updateSimplex(contracted);\n                }\n                else {\n                    shouldReduce = true;\n                }\n            }\n            if (shouldReduce) {\n                // if we don't contract here, we're done\n                if (sigma >= 1)\n                    break;\n                // do a reduction\n                for (let i = 1; i < simplex.length; ++i) {\n                    weightedSum(simplex[i], 1 - sigma, simplex[0], sigma, simplex[i]);\n                    simplex[i].fx = f(simplex[i]);\n                }\n            }\n        }\n        else {\n            updateSimplex(reflected);\n        }\n    }\n    simplex.sort(sortOrder);\n    return { fx: simplex[0].fx, x: simplex[0] };\n}\n//# sourceMappingURL=nelderMead.js.map"],"names":["nelderMead","f","x0","parameters","maxIterations","nonZeroDelta","zeroDelta","minErrorDelta","minTolerance","rho","chi","psi","sigma","maxDiff","N","simplex","i","point","updateSimplex","value","sortOrder","a","b","centroid","reflected","contracted","expanded","iteration","sortedSimplex","x","state","j","worst","weightedSum","shouldReduce"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,249 @@
+import { circleOverlap as R, distance as F, intersectionArea as v, circleCircleIntersection as A } from "./circleintersection.js";
+import { nelderMead as D } from "./fmin/nelderMead.js";
+import { norm2 as b, zeros as k, scale as B, zerosM as j } from "./fmin/blas1.js";
+import { conjugateGradient as C } from "./fmin/conjugateGradient.js";
+import { bisect as G } from "./fmin/bisect.js";
+function Z(s, n) {
+  n = n || {}, n.maxIterations = n.maxIterations || 500;
+  const h = n.initialLayout || K, e = n.lossFunction || I;
+  s = E(s);
+  const i = h(s, n), t = [], l = [];
+  let o;
+  for (o in i)
+    i.hasOwnProperty(o) && (t.push(i[o].x), t.push(i[o].y), l.push(o));
+  const d = D(function(y) {
+    const r = {};
+    for (let c = 0; c < l.length; ++c) {
+      const g = l[c];
+      r[g] = {
+        x: y[2 * c],
+        y: y[2 * c + 1],
+        radius: i[g].radius
+      };
+    }
+    return e(r, s);
+  }, t, n).x;
+  for (let y = 0; y < l.length; ++y)
+    o = l[y], i[o].x = d[2 * y], i[o].y = d[2 * y + 1];
+  return i;
+}
+const S = 1e-10;
+function P(s, n, h) {
+  return Math.min(s, n) * Math.min(s, n) * Math.PI <= h + S ? Math.abs(s - n) : G(function(e) {
+    return R(s, n, e) - h;
+  }, 0, s + n);
+}
+function E(s) {
+  s = s.slice();
+  const n = [], h = {};
+  let e, i, t, l;
+  for (e = 0; e < s.length; ++e) {
+    const o = s[e];
+    o.sets.length == 1 ? n.push(o.sets[0]) : o.sets.length == 2 && (t = o.sets[0], l = o.sets[1], h[[t, l]] = !0, h[[l, t]] = !0);
+  }
+  for (n.sort((o, f) => o > f ? 1 : -1), e = 0; e < n.length; ++e)
+    for (t = n[e], i = e + 1; i < n.length; ++i)
+      l = n[i], [t, l] in h || s.push({ sets: [t, l], size: 0 });
+  return s;
+}
+function H(s, n, h) {
+  const e = j(n.length, n.length), i = j(n.length, n.length);
+  return s.filter(function(t) {
+    return t.sets.length == 2;
+  }).map(function(t) {
+    const l = h[t.sets[0]], o = h[t.sets[1]], f = Math.sqrt(n[l].size / Math.PI), d = Math.sqrt(n[o].size / Math.PI), y = P(f, d, t.size);
+    e[l][o] = e[o][l] = y;
+    let r = 0;
+    t.size + 1e-10 >= Math.min(n[l].size, n[o].size) ? r = 1 : t.size <= 1e-10 && (r = -1), i[l][o] = i[o][l] = r;
+  }), { distances: e, constraints: i };
+}
+function J(s, n, h, e) {
+  let i = 0, t;
+  for (t = 0; t < n.length; ++t)
+    n[t] = 0;
+  for (t = 0; t < h.length; ++t) {
+    const l = s[2 * t], o = s[2 * t + 1];
+    for (let f = t + 1; f < h.length; ++f) {
+      const d = s[2 * f], y = s[2 * f + 1], r = h[t][f], c = e[t][f], g = (d - l) * (d - l) + (y - o) * (y - o), a = Math.sqrt(g), u = g - r * r;
+      c > 0 && a <= r || c < 0 && a >= r || (i += 2 * u * u, n[2 * t] += 4 * u * (l - d), n[2 * t + 1] += 4 * u * (o - y), n[2 * f] += 4 * u * (d - l), n[2 * f + 1] += 4 * u * (y - o));
+    }
+  }
+  return i;
+}
+function K(s, n) {
+  let h = Q(s, n);
+  const e = n.lossFunction || I;
+  if (s.length >= 8) {
+    const i = N(s, n), t = e(i, s), l = e(h, s);
+    t + 1e-8 < l && (h = i);
+  }
+  return h;
+}
+function N(s, n) {
+  n = n || {};
+  const h = n.restarts || 10, e = [], i = {};
+  let t;
+  for (t = 0; t < s.length; ++t) {
+    const u = s[t];
+    u.sets.length == 1 && (i[u.sets[0]] = e.length, e.push(u));
+  }
+  const l = H(s, e, i);
+  let o = l.distances;
+  const f = l.constraints, d = b(o.map(b)) / o.length;
+  o = o.map(function(u) {
+    return u.map(function(m) {
+      return m / d;
+    });
+  });
+  const y = function(u, m) {
+    return J(u, m, o, f);
+  };
+  let r, c;
+  for (t = 0; t < h; ++t) {
+    const u = k(o.length * 2).map(Math.random);
+    c = C(y, u, n), (!r || c.fx < r.fx) && (r = c);
+  }
+  const g = r.x, a = {};
+  for (t = 0; t < e.length; ++t) {
+    const u = e[t];
+    a[u.sets[0]] = {
+      x: g[2 * t] * d,
+      y: g[2 * t + 1] * d,
+      radius: Math.sqrt(u.size / Math.PI)
+    };
+  }
+  if (n.history)
+    for (t = 0; t < n.history.length; ++t)
+      B(n.history[t].x, d);
+  return a;
+}
+function Q(s, n) {
+  const h = n && n.lossFunction ? n.lossFunction : I, e = {}, i = {};
+  let t;
+  for (let r = 0; r < s.length; ++r) {
+    const c = s[r];
+    c.sets.length == 1 && (t = c.sets[0], e[t] = {
+      x: 1e10,
+      y: 1e10,
+      // rowid: circles.length, // fix to ->
+      rowid: Object.keys(e).length,
+      size: c.size,
+      radius: Math.sqrt(c.size / Math.PI)
+    }, i[t] = []);
+  }
+  s = s.filter(function(r) {
+    return r.sets.length == 2;
+  });
+  for (let r = 0; r < s.length; ++r) {
+    const c = s[r];
+    let g = c.hasOwnProperty("weight") ? c.weight : 1;
+    const a = c.sets[0], u = c.sets[1];
+    c.size + S >= Math.min(e[a].size, e[u].size) && (g = 0), i[a].push({ set: u, size: c.size, weight: g }), i[u].push({ set: a, size: c.size, weight: g });
+  }
+  const l = [];
+  for (t in i)
+    if (i.hasOwnProperty(t)) {
+      let r = 0;
+      for (let c = 0; c < i[t].length; ++c)
+        r += i[t][c].size * i[t][c].weight;
+      l.push({ set: t, size: r });
+    }
+  function o(r, c) {
+    return c.size - r.size;
+  }
+  l.sort(o);
+  const f = {};
+  function d(r) {
+    return r.set in f;
+  }
+  function y(r, c) {
+    e[c].x = r.x, e[c].y = r.y, f[c] = !0;
+  }
+  y({ x: 0, y: 0 }, l[0].set);
+  for (let r = 1; r < l.length; ++r) {
+    const c = l[r].set, g = i[c].filter(d);
+    if (t = e[c], g.sort(o), g.length === 0)
+      throw "ERROR: missing pairwise overlap information";
+    const a = [];
+    for (let z = 0; z < g.length; ++z) {
+      const x = e[g[z].set], p = P(t.radius, x.radius, g[z].size);
+      a.push({ x: x.x + p, y: x.y }), a.push({ x: x.x - p, y: x.y }), a.push({ y: x.y + p, x: x.x }), a.push({ y: x.y - p, x: x.x });
+      for (let M = z + 1; M < g.length; ++M) {
+        const w = e[g[M].set], q = P(t.radius, w.radius, g[M].size), L = A({ x: x.x, y: x.y, radius: p }, { x: w.x, y: w.y, radius: q });
+        for (let O = 0; O < L.length; ++O)
+          a.push(L[O]);
+      }
+    }
+    let u = 1e50, m = a[0];
+    for (let z = 0; z < a.length; ++z) {
+      e[c].x = a[z].x, e[c].y = a[z].y;
+      const x = h(e, s);
+      x < u && (u = x, m = a[z]);
+    }
+    y(m, c);
+  }
+  return e;
+}
+function I(s, n) {
+  let h = 0;
+  function e(i) {
+    return i.map(function(t) {
+      return s[t];
+    });
+  }
+  for (let i = 0; i < n.length; ++i) {
+    const t = n[i];
+    let l;
+    if (t.sets.length == 1)
+      continue;
+    if (t.sets.length == 2) {
+      const f = s[t.sets[0]], d = s[t.sets[1]];
+      l = R(f.radius, d.radius, F(f, d));
+    } else
+      l = v(e(t.sets));
+    const o = t.hasOwnProperty("weight") ? t.weight : 1;
+    h += o * (l - t.size) * (l - t.size);
+  }
+  return h;
+}
+function T(s) {
+  const n = function(h) {
+    const e = Math.max.apply(null, s.map(function(t) {
+      return t[h] + t.radius;
+    })), i = Math.min.apply(null, s.map(function(t) {
+      return t[h] - t.radius;
+    }));
+    return { max: e, min: i };
+  };
+  return { xRange: n("x"), yRange: n("y") };
+}
+function _(s, n, h, e) {
+  const i = [], t = [];
+  for (const u in s)
+    s.hasOwnProperty(u) && (t.push(u), i.push(s[u]));
+  n -= 2 * e, h -= 2 * e;
+  const l = T(i), o = l.xRange, f = l.yRange;
+  if (o.max == o.min || f.max == f.min)
+    return console.log("not scaling solution: zero size detected"), s;
+  const d = n / (o.max - o.min), y = h / (f.max - f.min), r = Math.min(y, d), c = (n - (o.max - o.min) * r) / 2, g = (h - (f.max - f.min) * r) / 2, a = {};
+  for (let u = 0; u < i.length; ++u) {
+    const m = i[u];
+    a[t[u]] = {
+      radius: r * m.radius,
+      x: e + c + (m.x - o.min) * r,
+      y: e + g + (m.y - f.min) * r
+    };
+  }
+  return a;
+}
+export {
+  K as bestInitialLayout,
+  N as constrainedMDSLayout,
+  P as distanceFromIntersectArea,
+  H as getDistanceMatrices,
+  Q as greedyLayout,
+  I as lossFunction,
+  _ as scaleSolution,
+  Z as venn
+};
+//# sourceMappingURL=layout.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layout.js","sources":["../../../../../../../../node_modules/@antv/g2/esm/data/utils/venn/layout.js"],"sourcesContent":["import { bisect, conjugateGradient, nelderMead, norm2, scale, zeros, zerosM, } from './fmin';\nimport { circleCircleIntersection, circleOverlap, distance, intersectionArea, } from './circleintersection';\n/** given a list of set objects, and their corresponding overlaps.\nupdates the (x, y, radius) attribute on each set such that their positions\nroughly correspond to the desired overlaps */\nexport function venn(areas, parameters) {\n    parameters = parameters || {};\n    parameters.maxIterations = parameters.maxIterations || 500;\n    const initialLayout = parameters.initialLayout || bestInitialLayout;\n    const loss = parameters.lossFunction || lossFunction;\n    // add in missing pairwise areas as having 0 size\n    areas = addMissingAreas(areas);\n    // initial layout is done greedily\n    const circles = initialLayout(areas, parameters);\n    // transform x/y coordinates to a vector to optimize\n    const initial = [], setids = [];\n    let setid;\n    for (setid in circles) {\n        // eslint-disable-next-line\n        if (circles.hasOwnProperty(setid)) {\n            initial.push(circles[setid].x);\n            initial.push(circles[setid].y);\n            setids.push(setid);\n        }\n    }\n    // optimize initial layout from our loss function\n    const solution = nelderMead(function (values) {\n        const current = {};\n        for (let i = 0; i < setids.length; ++i) {\n            const setid = setids[i];\n            current[setid] = {\n                x: values[2 * i],\n                y: values[2 * i + 1],\n                radius: circles[setid].radius,\n            };\n        }\n        return loss(current, areas);\n    }, initial, parameters);\n    // transform solution vector back to x/y points\n    const positions = solution.x;\n    for (let i = 0; i < setids.length; ++i) {\n        setid = setids[i];\n        circles[setid].x = positions[2 * i];\n        circles[setid].y = positions[2 * i + 1];\n    }\n    return circles;\n}\nconst SMALL = 1e-10;\n/** Returns the distance necessary for two circles of radius r1 + r2 to\nhave the overlap area 'overlap' */\nexport function distanceFromIntersectArea(r1, r2, overlap) {\n    // handle complete overlapped circles\n    if (Math.min(r1, r2) * Math.min(r1, r2) * Math.PI <= overlap + SMALL) {\n        return Math.abs(r1 - r2);\n    }\n    return bisect(function (distance) {\n        return circleOverlap(r1, r2, distance) - overlap;\n    }, 0, r1 + r2);\n}\n/** Missing pair-wise intersection area data can cause problems:\n treating as an unknown means that sets will be laid out overlapping,\n which isn't what people expect. To reflect that we want disjoint sets\n here, set the overlap to 0 for all missing pairwise set intersections */\nfunction addMissingAreas(areas) {\n    areas = areas.slice();\n    // two circle intersections that aren't defined\n    const ids = [], pairs = {};\n    let i, j, a, b;\n    for (i = 0; i < areas.length; ++i) {\n        const area = areas[i];\n        if (area.sets.length == 1) {\n            ids.push(area.sets[0]);\n        }\n        else if (area.sets.length == 2) {\n            a = area.sets[0];\n            b = area.sets[1];\n            // @ts-ignore\n            pairs[[a, b]] = true;\n            // @ts-ignore\n            pairs[[b, a]] = true;\n        }\n    }\n    ids.sort((a, b) => {\n        return a > b ? 1 : -1;\n    });\n    for (i = 0; i < ids.length; ++i) {\n        a = ids[i];\n        for (j = i + 1; j < ids.length; ++j) {\n            b = ids[j];\n            // @ts-ignore\n            if (!([a, b] in pairs)) {\n                areas.push({ sets: [a, b], size: 0 });\n            }\n        }\n    }\n    return areas;\n}\n/// Returns two matrices, one of the euclidean distances between the sets\n/// and the other indicating if there are subset or disjoint set relationships\nexport function getDistanceMatrices(areas, sets, setids) {\n    // initialize an empty distance matrix between all the points\n    const distances = zerosM(sets.length, sets.length), constraints = zerosM(sets.length, sets.length);\n    // compute required distances between all the sets such that\n    // the areas match\n    areas\n        .filter(function (x) {\n        return x.sets.length == 2;\n    })\n        .map(function (current) {\n        const left = setids[current.sets[0]], right = setids[current.sets[1]], r1 = Math.sqrt(sets[left].size / Math.PI), r2 = Math.sqrt(sets[right].size / Math.PI), distance = distanceFromIntersectArea(r1, r2, current.size);\n        distances[left][right] = distances[right][left] = distance;\n        // also update constraints to indicate if its a subset or disjoint\n        // relationship\n        let c = 0;\n        if (current.size + 1e-10 >= Math.min(sets[left].size, sets[right].size)) {\n            c = 1;\n        }\n        else if (current.size <= 1e-10) {\n            c = -1;\n        }\n        constraints[left][right] = constraints[right][left] = c;\n    });\n    return { distances: distances, constraints: constraints };\n}\n/// computes the gradient and loss simulatenously for our constrained MDS optimizer\nfunction constrainedMDSGradient(x, fxprime, distances, constraints) {\n    let loss = 0, i;\n    for (i = 0; i < fxprime.length; ++i) {\n        fxprime[i] = 0;\n    }\n    for (i = 0; i < distances.length; ++i) {\n        const xi = x[2 * i], yi = x[2 * i + 1];\n        for (let j = i + 1; j < distances.length; ++j) {\n            const xj = x[2 * j], yj = x[2 * j + 1], dij = distances[i][j], constraint = constraints[i][j];\n            const squaredDistance = (xj - xi) * (xj - xi) + (yj - yi) * (yj - yi), distance = Math.sqrt(squaredDistance), delta = squaredDistance - dij * dij;\n            if ((constraint > 0 && distance <= dij) ||\n                (constraint < 0 && distance >= dij)) {\n                continue;\n            }\n            loss += 2 * delta * delta;\n            fxprime[2 * i] += 4 * delta * (xi - xj);\n            fxprime[2 * i + 1] += 4 * delta * (yi - yj);\n            fxprime[2 * j] += 4 * delta * (xj - xi);\n            fxprime[2 * j + 1] += 4 * delta * (yj - yi);\n        }\n    }\n    return loss;\n}\n/// takes the best working variant of either constrained MDS or greedy\nexport function bestInitialLayout(areas, params) {\n    let initial = greedyLayout(areas, params);\n    const loss = params.lossFunction || lossFunction;\n    // greedylayout is sufficient for all 2/3 circle cases. try out\n    // constrained MDS for higher order problems, take its output\n    // if it outperforms. (greedy is aesthetically better on 2/3 circles\n    // since it axis aligns)\n    if (areas.length >= 8) {\n        const constrained = constrainedMDSLayout(areas, params), constrainedLoss = loss(constrained, areas), greedyLoss = loss(initial, areas);\n        if (constrainedLoss + 1e-8 < greedyLoss) {\n            initial = constrained;\n        }\n    }\n    return initial;\n}\n/// use the constrained MDS variant to generate an initial layout\nexport function constrainedMDSLayout(areas, params) {\n    params = params || {};\n    const restarts = params.restarts || 10;\n    // bidirectionally map sets to a rowid  (so we can create a matrix)\n    const sets = [], setids = {};\n    let i;\n    for (i = 0; i < areas.length; ++i) {\n        const area = areas[i];\n        if (area.sets.length == 1) {\n            setids[area.sets[0]] = sets.length;\n            sets.push(area);\n        }\n    }\n    const matrices = getDistanceMatrices(areas, sets, setids);\n    let distances = matrices.distances;\n    const constraints = matrices.constraints;\n    // keep distances bounded, things get messed up otherwise.\n    // TODO: proper preconditioner?\n    const norm = norm2(distances.map(norm2)) / distances.length;\n    distances = distances.map(function (row) {\n        return row.map(function (value) {\n            return value / norm;\n        });\n    });\n    const obj = function (x, fxprime) {\n        return constrainedMDSGradient(x, fxprime, distances, constraints);\n    };\n    let best, current;\n    for (i = 0; i < restarts; ++i) {\n        const initial = zeros(distances.length * 2).map(Math.random);\n        current = conjugateGradient(obj, initial, params);\n        if (!best || current.fx < best.fx) {\n            best = current;\n        }\n    }\n    const positions = best.x;\n    // translate rows back to (x,y,radius) coordinates\n    const circles = {};\n    for (i = 0; i < sets.length; ++i) {\n        const set = sets[i];\n        circles[set.sets[0]] = {\n            x: positions[2 * i] * norm,\n            y: positions[2 * i + 1] * norm,\n            radius: Math.sqrt(set.size / Math.PI),\n        };\n    }\n    if (params.history) {\n        for (i = 0; i < params.history.length; ++i) {\n            scale(params.history[i].x, norm);\n        }\n    }\n    return circles;\n}\n/** Lays out a Venn diagram greedily, going from most overlapped sets to\nleast overlapped, attempting to position each new set such that the\noverlapping areas to already positioned sets are basically right */\nexport function greedyLayout(areas, params) {\n    const loss = params && params.lossFunction ? params.lossFunction : lossFunction;\n    // define a circle for each set\n    const circles = {}, setOverlaps = {};\n    let set;\n    for (let i = 0; i < areas.length; ++i) {\n        const area = areas[i];\n        if (area.sets.length == 1) {\n            set = area.sets[0];\n            circles[set] = {\n                x: 1e10,\n                y: 1e10,\n                // rowid: circles.length, // fix to ->\n                rowid: Object.keys(circles).length,\n                size: area.size,\n                radius: Math.sqrt(area.size / Math.PI),\n            };\n            setOverlaps[set] = [];\n        }\n    }\n    areas = areas.filter(function (a) {\n        return a.sets.length == 2;\n    });\n    // map each set to a list of all the other sets that overlap it\n    for (let i = 0; i < areas.length; ++i) {\n        const current = areas[i];\n        // eslint-disable-next-line\n        let weight = current.hasOwnProperty('weight') ? current.weight : 1.0;\n        const left = current.sets[0], right = current.sets[1];\n        // completely overlapped circles shouldn't be positioned early here\n        if (current.size + SMALL >=\n            Math.min(circles[left].size, circles[right].size)) {\n            weight = 0;\n        }\n        setOverlaps[left].push({ set: right, size: current.size, weight: weight });\n        setOverlaps[right].push({ set: left, size: current.size, weight: weight });\n    }\n    // get list of most overlapped sets\n    const mostOverlapped = [];\n    for (set in setOverlaps) {\n        // eslint-disable-next-line\n        if (setOverlaps.hasOwnProperty(set)) {\n            let size = 0;\n            for (let i = 0; i < setOverlaps[set].length; ++i) {\n                size += setOverlaps[set][i].size * setOverlaps[set][i].weight;\n            }\n            mostOverlapped.push({ set: set, size: size });\n        }\n    }\n    // sort by size desc\n    function sortOrder(a, b) {\n        return b.size - a.size;\n    }\n    mostOverlapped.sort(sortOrder);\n    // keep track of what sets have been laid out\n    const positioned = {};\n    function isPositioned(element) {\n        return element.set in positioned;\n    }\n    // adds a point to the output\n    function positionSet(point, index) {\n        circles[index].x = point.x;\n        circles[index].y = point.y;\n        positioned[index] = true;\n    }\n    // add most overlapped set at (0,0)\n    positionSet({ x: 0, y: 0 }, mostOverlapped[0].set);\n    // get distances between all points. TODO, necessary?\n    // answer: probably not\n    // var distances = venn.getDistanceMatrices(circles, areas).distances;\n    for (let i = 1; i < mostOverlapped.length; ++i) {\n        const setIndex = mostOverlapped[i].set, overlap = setOverlaps[setIndex].filter(isPositioned);\n        set = circles[setIndex];\n        overlap.sort(sortOrder);\n        if (overlap.length === 0) {\n            // this shouldn't happen anymore with addMissingAreas\n            throw 'ERROR: missing pairwise overlap information';\n        }\n        const points = [];\n        for (let j = 0; j < overlap.length; ++j) {\n            // get appropriate distance from most overlapped already added set\n            const p1 = circles[overlap[j].set], d1 = distanceFromIntersectArea(set.radius, p1.radius, overlap[j].size);\n            // sample positions at 90 degrees for maximum aesthetics\n            points.push({ x: p1.x + d1, y: p1.y });\n            points.push({ x: p1.x - d1, y: p1.y });\n            points.push({ y: p1.y + d1, x: p1.x });\n            points.push({ y: p1.y - d1, x: p1.x });\n            // if we have at least 2 overlaps, then figure out where the\n            // set should be positioned analytically and try those too\n            for (let k = j + 1; k < overlap.length; ++k) {\n                const p2 = circles[overlap[k].set], d2 = distanceFromIntersectArea(set.radius, p2.radius, overlap[k].size);\n                const extraPoints = circleCircleIntersection({ x: p1.x, y: p1.y, radius: d1 }, { x: p2.x, y: p2.y, radius: d2 });\n                for (let l = 0; l < extraPoints.length; ++l) {\n                    points.push(extraPoints[l]);\n                }\n            }\n        }\n        // we have some candidate positions for the set, examine loss\n        // at each position to figure out where to put it at\n        let bestLoss = 1e50, bestPoint = points[0];\n        for (let j = 0; j < points.length; ++j) {\n            circles[setIndex].x = points[j].x;\n            circles[setIndex].y = points[j].y;\n            const localLoss = loss(circles, areas);\n            if (localLoss < bestLoss) {\n                bestLoss = localLoss;\n                bestPoint = points[j];\n            }\n        }\n        positionSet(bestPoint, setIndex);\n    }\n    return circles;\n}\n/** Given a bunch of sets, and the desired overlaps between these sets - computes\nthe distance from the actual overlaps to the desired overlaps. Note that\nthis method ignores overlaps of more than 2 circles */\nexport function lossFunction(sets, overlaps) {\n    let output = 0;\n    function getCircles(indices) {\n        return indices.map(function (i) {\n            return sets[i];\n        });\n    }\n    for (let i = 0; i < overlaps.length; ++i) {\n        const area = overlaps[i];\n        let overlap;\n        if (area.sets.length == 1) {\n            continue;\n        }\n        else if (area.sets.length == 2) {\n            const left = sets[area.sets[0]], right = sets[area.sets[1]];\n            overlap = circleOverlap(left.radius, right.radius, distance(left, right));\n        }\n        else {\n            overlap = intersectionArea(getCircles(area.sets));\n        }\n        // eslint-disable-next-line\n        const weight = area.hasOwnProperty('weight') ? area.weight : 1.0;\n        output += weight * (overlap - area.size) * (overlap - area.size);\n    }\n    return output;\n}\n// orientates a bunch of circles to point in orientation\nfunction orientateCircles(circles, orientation, orientationOrder) {\n    if (orientationOrder === null) {\n        circles.sort(function (a, b) {\n            return b.radius - a.radius;\n        });\n    }\n    else {\n        circles.sort(orientationOrder);\n    }\n    let i;\n    // shift circles so largest circle is at (0, 0)\n    if (circles.length > 0) {\n        const largestX = circles[0].x, largestY = circles[0].y;\n        for (i = 0; i < circles.length; ++i) {\n            circles[i].x -= largestX;\n            circles[i].y -= largestY;\n        }\n    }\n    if (circles.length == 2) {\n        // if the second circle is a subset of the first, arrange so that\n        // it is off to one side. hack for https://github.com/benfred/venn.js/issues/120\n        const dist = distance(circles[0], circles[1]);\n        if (dist < Math.abs(circles[1].radius - circles[0].radius)) {\n            circles[1].x =\n                circles[0].x + circles[0].radius - circles[1].radius - 1e-10;\n            circles[1].y = circles[0].y;\n        }\n    }\n    // rotate circles so that second largest is at an angle of 'orientation'\n    // from largest\n    if (circles.length > 1) {\n        const rotation = Math.atan2(circles[1].x, circles[1].y) - orientation;\n        let x, y;\n        const c = Math.cos(rotation), s = Math.sin(rotation);\n        for (i = 0; i < circles.length; ++i) {\n            x = circles[i].x;\n            y = circles[i].y;\n            circles[i].x = c * x - s * y;\n            circles[i].y = s * x + c * y;\n        }\n    }\n    // mirror solution if third solution is above plane specified by\n    // first two circles\n    if (circles.length > 2) {\n        let angle = Math.atan2(circles[2].x, circles[2].y) - orientation;\n        while (angle < 0) {\n            angle += 2 * Math.PI;\n        }\n        while (angle > 2 * Math.PI) {\n            angle -= 2 * Math.PI;\n        }\n        if (angle > Math.PI) {\n            const slope = circles[1].y / (1e-10 + circles[1].x);\n            for (i = 0; i < circles.length; ++i) {\n                const d = (circles[i].x + slope * circles[i].y) / (1 + slope * slope);\n                circles[i].x = 2 * d - circles[i].x;\n                circles[i].y = 2 * d * slope - circles[i].y;\n            }\n        }\n    }\n}\nexport function disjointCluster(circles) {\n    // union-find clustering to get disjoint sets\n    circles.map(function (circle) {\n        circle.parent = circle;\n    });\n    // path compression step in union find\n    function find(circle) {\n        if (circle.parent !== circle) {\n            circle.parent = find(circle.parent);\n        }\n        return circle.parent;\n    }\n    function union(x, y) {\n        const xRoot = find(x), yRoot = find(y);\n        xRoot.parent = yRoot;\n    }\n    // get the union of all overlapping sets\n    for (let i = 0; i < circles.length; ++i) {\n        for (let j = i + 1; j < circles.length; ++j) {\n            const maxDistance = circles[i].radius + circles[j].radius;\n            if (distance(circles[i], circles[j]) + 1e-10 < maxDistance) {\n                union(circles[j], circles[i]);\n            }\n        }\n    }\n    // find all the disjoint clusters and group them together\n    const disjointClusters = {};\n    let setid;\n    for (let i = 0; i < circles.length; ++i) {\n        setid = find(circles[i]).parent.setid;\n        if (!(setid in disjointClusters)) {\n            disjointClusters[setid] = [];\n        }\n        disjointClusters[setid].push(circles[i]);\n    }\n    // cleanup bookkeeping\n    circles.map(function (circle) {\n        delete circle.parent;\n    });\n    // return in more usable form\n    const ret = [];\n    for (setid in disjointClusters) {\n        // eslint-disable-next-line\n        if (disjointClusters.hasOwnProperty(setid)) {\n            ret.push(disjointClusters[setid]);\n        }\n    }\n    return ret;\n}\nfunction getBoundingBox(circles) {\n    const minMax = function (d) {\n        const hi = Math.max.apply(null, circles.map(function (c) {\n            return c[d] + c.radius;\n        })), lo = Math.min.apply(null, circles.map(function (c) {\n            return c[d] - c.radius;\n        }));\n        return { max: hi, min: lo };\n    };\n    return { xRange: minMax('x'), yRange: minMax('y') };\n}\nexport function normalizeSolution(solution, orientation, orientationOrder) {\n    if (orientation === null) {\n        orientation = Math.PI / 2;\n    }\n    // work with a list instead of a dictionary, and take a copy so we\n    // don't mutate input\n    let circles = [], i, setid;\n    for (setid in solution) {\n        // eslint-disable-next-line\n        if (solution.hasOwnProperty(setid)) {\n            const previous = solution[setid];\n            circles.push({\n                x: previous.x,\n                y: previous.y,\n                radius: previous.radius,\n                setid: setid,\n            });\n        }\n    }\n    // get all the disjoint clusters\n    const clusters = disjointCluster(circles);\n    // orientate all disjoint sets, get sizes\n    for (i = 0; i < clusters.length; ++i) {\n        orientateCircles(clusters[i], orientation, orientationOrder);\n        const bounds = getBoundingBox(clusters[i]);\n        clusters[i].size =\n            (bounds.xRange.max - bounds.xRange.min) *\n                (bounds.yRange.max - bounds.yRange.min);\n        clusters[i].bounds = bounds;\n    }\n    clusters.sort(function (a, b) {\n        return b.size - a.size;\n    });\n    // orientate the largest at 0,0, and get the bounds\n    circles = clusters[0];\n    // @ts-ignore fixme 从逻辑上看似乎是不对的，后续看看\n    let returnBounds = circles.bounds;\n    const spacing = (returnBounds.xRange.max - returnBounds.xRange.min) / 50;\n    function addCluster(cluster, right, bottom) {\n        if (!cluster)\n            return;\n        const bounds = cluster.bounds;\n        let xOffset, yOffset, centreing;\n        if (right) {\n            xOffset = returnBounds.xRange.max - bounds.xRange.min + spacing;\n        }\n        else {\n            xOffset = returnBounds.xRange.max - bounds.xRange.max;\n            centreing =\n                (bounds.xRange.max - bounds.xRange.min) / 2 -\n                    (returnBounds.xRange.max - returnBounds.xRange.min) / 2;\n            if (centreing < 0)\n                xOffset += centreing;\n        }\n        if (bottom) {\n            yOffset = returnBounds.yRange.max - bounds.yRange.min + spacing;\n        }\n        else {\n            yOffset = returnBounds.yRange.max - bounds.yRange.max;\n            centreing =\n                (bounds.yRange.max - bounds.yRange.min) / 2 -\n                    (returnBounds.yRange.max - returnBounds.yRange.min) / 2;\n            if (centreing < 0)\n                yOffset += centreing;\n        }\n        for (let j = 0; j < cluster.length; ++j) {\n            cluster[j].x += xOffset;\n            cluster[j].y += yOffset;\n            circles.push(cluster[j]);\n        }\n    }\n    let index = 1;\n    while (index < clusters.length) {\n        addCluster(clusters[index], true, false);\n        addCluster(clusters[index + 1], false, true);\n        addCluster(clusters[index + 2], true, true);\n        index += 3;\n        // have one cluster (in top left). lay out next three relative\n        // to it in a grid\n        returnBounds = getBoundingBox(circles);\n    }\n    // convert back to solution form\n    const ret = {};\n    for (i = 0; i < circles.length; ++i) {\n        ret[circles[i].setid] = circles[i];\n    }\n    return ret;\n}\n/** Scales a solution from venn.venn or venn.greedyLayout such that it fits in\na rectangle of width/height - with padding around the borders. also\ncenters the diagram in the available space at the same time */\nexport function scaleSolution(solution, width, height, padding) {\n    const circles = [], setids = [];\n    for (const setid in solution) {\n        // eslint-disable-next-line\n        if (solution.hasOwnProperty(setid)) {\n            setids.push(setid);\n            circles.push(solution[setid]);\n        }\n    }\n    width -= 2 * padding;\n    height -= 2 * padding;\n    const bounds = getBoundingBox(circles), xRange = bounds.xRange, yRange = bounds.yRange;\n    if (xRange.max == xRange.min || yRange.max == yRange.min) {\n        console.log('not scaling solution: zero size detected');\n        return solution;\n    }\n    const xScaling = width / (xRange.max - xRange.min), yScaling = height / (yRange.max - yRange.min), scaling = Math.min(yScaling, xScaling), \n    // while we're at it, center the diagram too\n    xOffset = (width - (xRange.max - xRange.min) * scaling) / 2, yOffset = (height - (yRange.max - yRange.min) * scaling) / 2;\n    const scaled = {};\n    for (let i = 0; i < circles.length; ++i) {\n        const circle = circles[i];\n        scaled[setids[i]] = {\n            radius: scaling * circle.radius,\n            x: padding + xOffset + (circle.x - xRange.min) * scaling,\n            y: padding + yOffset + (circle.y - yRange.min) * scaling,\n        };\n    }\n    return scaled;\n}\n//# sourceMappingURL=layout.js.map"],"names":["venn","areas","parameters","initialLayout","bestInitialLayout","loss","lossFunction","addMissingAreas","circles","initial","setids","setid","positions","nelderMead","values","current","i","SMALL","distanceFromIntersectArea","r1","r2","overlap","bisect","distance","circleOverlap","ids","pairs","j","a","b","area","getDistanceMatrices","sets","distances","zerosM","constraints","x","left","right","c","constrainedMDSGradient","fxprime","xi","yi","xj","yj","dij","constraint","squaredDistance","delta","params","greedyLayout","constrained","constrainedMDSLayout","constrainedLoss","greedyLoss","restarts","matrices","norm","norm2","row","value","obj","best","zeros","conjugateGradient","set","scale","setOverlaps","weight","mostOverlapped","size","sortOrder","positioned","isPositioned","element","positionSet","point","index","setIndex","points","p1","d1","k","p2","d2","extraPoints","circleCircleIntersection","l","bestLoss","bestPoint","localLoss","overlaps","output","getCircles","indices","intersectionArea","getBoundingBox","minMax","d","hi","lo","scaleSolution","solution","width","height","padding","bounds","xRange","yRange","xScaling","yScaling","scaling","xOffset","yOffset","scaled","circle"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,25 @@
+import { venn as f, scaleSolution as k } from "./utils/venn/layout.js";
+import { intersectionAreaPath as v } from "./utils/venn/diagram.js";
+const y = (c) => {
+  const { sets: r = "sets", size: i = "size", as: a = ["key", "path"], padding: p = 0 } = c, [l, g] = a;
+  return (u) => {
+    const e = u.map((s) => Object.assign(Object.assign({}, s), { sets: s[r], size: s[i], [l]: s.sets.join("&") }));
+    e.sort((s, n) => s.sets.length - n.sets.length);
+    const h = f(e);
+    let t;
+    return e.map((s) => {
+      const n = s[r], m = ({ width: j, height: b }) => {
+        t = t || k(h, j, b, p);
+        const z = n.map((O) => t[O]);
+        let o = v(z);
+        return /[zZ]$/.test(o) || (o += " Z"), o;
+      };
+      return Object.assign(Object.assign({}, s), { [g]: m });
+    });
+  };
+};
+y.props = {};
+export {
+  y as Venn
+};
+//# sourceMappingURL=venn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"venn.js","sources":["../../../../../../node_modules/@antv/g2/esm/data/venn.js"],"sourcesContent":["import { intersectionAreaPath, scaleSolution, venn } from './utils/venn';\n/**\n * Layout venn data, get the path string for each set.\n */\nexport const Venn = (options) => {\n    const { sets = 'sets', size = 'size', as = ['key', 'path'], padding = 0, } = options;\n    const [key, path] = as;\n    return (data) => {\n        // Transform the data, venn layout use `sets` and `size` field.\n        const vennData = data.map((d) => (Object.assign(Object.assign({}, d), { sets: d[sets], size: d[size], [key]: d.sets.join('&') })));\n        // Sort data, avoid data occlusion.\n        vennData.sort((a, b) => a.sets.length - b.sets.length);\n        // Layout venn data.\n        const solution = venn(vennData);\n        let circles;\n        return vennData.map((datum) => {\n            const setsValue = datum[sets];\n            const pathFunc = ({ width, height }) => {\n                circles = circles\n                    ? circles\n                    : scaleSolution(solution, width, height, padding);\n                const setCircles = setsValue.map((set) => circles[set]);\n                let p = intersectionAreaPath(setCircles);\n                // Close the path for event picker.\n                if (!/[zZ]$/.test(p))\n                    p += ' Z';\n                return p;\n            };\n            return Object.assign(Object.assign({}, datum), { [path]: pathFunc });\n        });\n    };\n};\nVenn.props = {};\n//# sourceMappingURL=venn.js.map"],"names":["Venn","options","sets","size","as","padding","key","path","data","vennData","d","a","b","solution","venn","circles","datum","setsValue","pathFunc","width","height","scaleSolution","setCircles","set","p","intersectionAreaPath"],"mappings":";;AAIY,MAACA,IAAO,CAACC,MAAY;AAC7B,QAAM,EAAE,MAAAC,IAAO,QAAQ,MAAAC,IAAO,QAAQ,IAAAC,IAAK,CAAC,OAAO,MAAM,GAAG,SAAAC,IAAU,EAAC,IAAMJ,GACvE,CAACK,GAAKC,CAAI,IAAIH;AACpB,SAAO,CAACI,MAAS;AAEb,UAAMC,IAAWD,EAAK,IAAI,CAACE,MAAO,OAAO,OAAO,OAAO,OAAO,CAAA,GAAIA,CAAC,GAAG,EAAE,MAAMA,EAAER,CAAI,GAAG,MAAMQ,EAAEP,CAAI,GAAG,CAACG,CAAG,GAAGI,EAAE,KAAK,KAAK,GAAG,EAAC,CAAE,CAAE;AAEjI,IAAAD,EAAS,KAAK,CAACE,GAAGC,MAAMD,EAAE,KAAK,SAASC,EAAE,KAAK,MAAM;AAErD,UAAMC,IAAWC,EAAKL,CAAQ;AAC9B,QAAIM;AACJ,WAAON,EAAS,IAAI,CAACO,MAAU;AAC3B,YAAMC,IAAYD,EAAMd,CAAI,GACtBgB,IAAW,CAAC,EAAE,OAAAC,GAAO,QAAAC,EAAM,MAAO;AACpC,QAAAL,IAAUA,KAEJM,EAAcR,GAAUM,GAAOC,GAAQf,CAAO;AACpD,cAAMiB,IAAaL,EAAU,IAAI,CAACM,MAAQR,EAAQQ,CAAG,CAAC;AACtD,YAAIC,IAAIC,EAAqBH,CAAU;AAEvC,eAAK,QAAQ,KAAKE,CAAC,MACfA,KAAK,OACFA;AAAA,MACX;AACA,aAAO,OAAO,OAAO,OAAO,OAAO,CAAA,GAAIR,CAAK,GAAG,EAAE,CAACT,CAAI,GAAGW,GAAU;AAAA,IACvE,CAAC;AAAA,EACL;AACJ;AACAlB,EAAK,QAAQ,CAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/data/wordCloud.js

@@ -0,0 +1,98 @@
+import { flow as j } from "./utils/flow.js";
+import { tagCloud as _ } from "./utils/d3-cloud/index.js";
+import I from "../../../../d3-array/src/min.js";
+import M from "../../../../d3-array/src/max.js";
+var A = function(n, r, e, t) {
+  function o(s) {
+    return s instanceof e ? s : new e(function(a) {
+      a(s);
+    });
+  }
+  return new (e || (e = Promise))(function(s, a) {
+    function f(i) {
+      try {
+        u(t.next(i));
+      } catch (c) {
+        a(c);
+      }
+    }
+    function y(i) {
+      try {
+        u(t.throw(i));
+      } catch (c) {
+        a(c);
+      }
+    }
+    function u(i) {
+      i.done ? s(i.value) : o(i.value).then(f, y);
+    }
+    u((t = t.apply(n, r || [])).next());
+  });
+}, S = function(n, r) {
+  var e = {};
+  for (var t in n) Object.prototype.hasOwnProperty.call(n, t) && r.indexOf(t) < 0 && (e[t] = n[t]);
+  if (n != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var o = 0, t = Object.getOwnPropertySymbols(n); o < t.length; o++)
+      r.indexOf(t[o]) < 0 && Object.prototype.propertyIsEnumerable.call(n, t[o]) && (e[t[o]] = n[t[o]]);
+  return e;
+};
+const T = {
+  fontSize: [20, 60],
+  font: "Impact",
+  padding: 2,
+  rotate: function() {
+    return (~~(Math.random() * 6) - 3) * 30;
+  }
+};
+function k(n) {
+  return new Promise((r, e) => {
+    if (n instanceof HTMLImageElement) {
+      r(n);
+      return;
+    }
+    if (typeof n == "string") {
+      const t = new Image();
+      t.crossOrigin = "anonymous", t.src = n, t.onload = () => r(t), t.onerror = () => {
+        console.error(`'image ${n} load failed !!!'`), e();
+      };
+      return;
+    }
+    e();
+  });
+}
+function z(n, r) {
+  if (typeof n == "function")
+    return n;
+  if (Array.isArray(n)) {
+    const [e, t] = n;
+    if (!r)
+      return () => (t + e) / 2;
+    const [o, s] = r;
+    return s === o ? () => (t + e) / 2 : ({ value: a }) => (t - e) / (s - o) * (a - o) + e;
+  }
+  return () => n;
+}
+const C = (n, r) => (e) => A(void 0, void 0, void 0, function* () {
+  const t = Object.assign({}, T, n, {
+    canvas: r.createCanvas
+  }), o = _();
+  yield j(o, t).set("fontSize", (d) => {
+    const l = e.map((p) => p.value);
+    return z(d, [I(l), M(l)]);
+  }).set("font").set("fontStyle").set("fontWeight").set("padding").set("rotate").set("size").set("spiral").set("timeInterval").set("random").set("text").set("on").set("canvas").setAsync("imageMask", k, o.createMask), o.words([...e]);
+  const s = o.start(), [a, f] = t.size, y = [
+    { x: 0, y: 0 },
+    { x: a, y: f }
+  ], { _bounds: u = y, _tags: i, hasImage: c } = s, m = i.map((d) => {
+    var { x: l, y: p, font: w } = d, h = S(d, ["x", "y", "font"]);
+    return Object.assign(Object.assign({}, h), { x: l + a / 2, y: p + f / 2, fontFamily: w });
+  }), [{ x: O, y: b }, { x: g, y: v }] = u, x = { text: "", value: 0, opacity: 0, fontSize: 0 };
+  return m.push(Object.assign(Object.assign({}, x), { x: c ? 0 : O, y: c ? 0 : b }), Object.assign(Object.assign({}, x), { x: c ? a : g, y: c ? f : v })), m;
+});
+C.props = {};
+export {
+  C as WordCloud,
+  z as normalizeFontSize,
+  k as processImageMask
+};
+//# sourceMappingURL=wordCloud.js.map