npm - gs-maplibre-draw - Versions diffs - 0.0.1 - Mend

gs-maplibre-draw 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1076 @@
+const { abs: R, cos: N, sin: U, acos: et, atan2: J, sqrt: F, pow: L } = Math;
+function $(o) {
+  return o < 0 ? -L(-o, 1 / 3) : L(o, 1 / 3);
+}
+const tt = Math.PI, X = 2 * tt, P = tt / 2, nt = 1e-6, Q = Number.MAX_SAFE_INTEGER || 9007199254740991, H = Number.MIN_SAFE_INTEGER || -9007199254740991, it = { x: 0, y: 0, z: 0 }, y = {
+  // Legendre-Gauss abscissae with n=24 (x_i values, defined at i=n as the roots of the nth order Legendre polynomial Pn(x))
+  Tvalues: [
+    -0.06405689286260563,
+    0.06405689286260563,
+    -0.1911188674736163,
+    0.1911188674736163,
+    -0.3150426796961634,
+    0.3150426796961634,
+    -0.4337935076260451,
+    0.4337935076260451,
+    -0.5454214713888396,
+    0.5454214713888396,
+    -0.6480936519369755,
+    0.6480936519369755,
+    -0.7401241915785544,
+    0.7401241915785544,
+    -0.820001985973903,
+    0.820001985973903,
+    -0.8864155270044011,
+    0.8864155270044011,
+    -0.9382745520027328,
+    0.9382745520027328,
+    -0.9747285559713095,
+    0.9747285559713095,
+    -0.9951872199970213,
+    0.9951872199970213
+  ],
+  // Legendre-Gauss weights with n=24 (w_i values, defined by a function linked to in the Bezier primer article)
+  Cvalues: [
+    0.12793819534675216,
+    0.12793819534675216,
+    0.1258374563468283,
+    0.1258374563468283,
+    0.12167047292780339,
+    0.12167047292780339,
+    0.1155056680537256,
+    0.1155056680537256,
+    0.10744427011596563,
+    0.10744427011596563,
+    0.09761865210411388,
+    0.09761865210411388,
+    0.08619016153195327,
+    0.08619016153195327,
+    0.0733464814110803,
+    0.0733464814110803,
+    0.05929858491543678,
+    0.05929858491543678,
+    0.04427743881741981,
+    0.04427743881741981,
+    0.028531388628933663,
+    0.028531388628933663,
+    0.0123412297999872,
+    0.0123412297999872
+  ],
+  arcfn: function(o, e) {
+    const n = e(o);
+    let i = n.x * n.x + n.y * n.y;
+    return typeof n.z < "u" && (i += n.z * n.z), F(i);
+  },
+  compute: function(o, e, n) {
+    if (o === 0)
+      return e[0].t = 0, e[0];
+    const i = e.length - 1;
+    if (o === 1)
+      return e[i].t = 1, e[i];
+    const s = 1 - o;
+    let c = e;
+    if (i === 0)
+      return e[0].t = o, e[0];
+    if (i === 1) {
+      const l = {
+        x: s * c[0].x + o * c[1].x,
+        y: s * c[0].y + o * c[1].y,
+        t: o
+      };
+      return n && (l.z = s * c[0].z + o * c[1].z), l;
+    }
+    if (i < 4) {
+      let l = s * s, u = o * o, f, h, a, p = 0;
+      i === 2 ? (c = [c[0], c[1], c[2], it], f = l, h = s * o * 2, a = u) : i === 3 && (f = l * s, h = l * o * 3, a = s * u * 3, p = o * u);
+      const g = {
+        x: f * c[0].x + h * c[1].x + a * c[2].x + p * c[3].x,
+        y: f * c[0].y + h * c[1].y + a * c[2].y + p * c[3].y,
+        t: o
+      };
+      return n && (g.z = f * c[0].z + h * c[1].z + a * c[2].z + p * c[3].z), g;
+    }
+    const r = JSON.parse(JSON.stringify(e));
+    for (; r.length > 1; ) {
+      for (let l = 0; l < r.length - 1; l++)
+        r[l] = {
+          x: r[l].x + (r[l + 1].x - r[l].x) * o,
+          y: r[l].y + (r[l + 1].y - r[l].y) * o
+        }, typeof r[l].z < "u" && (r[l].z = r[l].z + (r[l + 1].z - r[l].z) * o);
+      r.splice(r.length - 1, 1);
+    }
+    return r[0].t = o, r[0];
+  },
+  computeWithRatios: function(o, e, n, i) {
+    const s = 1 - o, c = n, r = e;
+    let l = c[0], u = c[1], f = c[2], h = c[3], a;
+    if (l *= s, u *= o, r.length === 2)
+      return a = l + u, {
+        x: (l * r[0].x + u * r[1].x) / a,
+        y: (l * r[0].y + u * r[1].y) / a,
+        z: i ? (l * r[0].z + u * r[1].z) / a : !1,
+        t: o
+      };
+    if (l *= s, u *= 2 * s, f *= o * o, r.length === 3)
+      return a = l + u + f, {
+        x: (l * r[0].x + u * r[1].x + f * r[2].x) / a,
+        y: (l * r[0].y + u * r[1].y + f * r[2].y) / a,
+        z: i ? (l * r[0].z + u * r[1].z + f * r[2].z) / a : !1,
+        t: o
+      };
+    if (l *= s, u *= 1.5 * s, f *= 3 * s, h *= o * o * o, r.length === 4)
+      return a = l + u + f + h, {
+        x: (l * r[0].x + u * r[1].x + f * r[2].x + h * r[3].x) / a,
+        y: (l * r[0].y + u * r[1].y + f * r[2].y + h * r[3].y) / a,
+        z: i ? (l * r[0].z + u * r[1].z + f * r[2].z + h * r[3].z) / a : !1,
+        t: o
+      };
+  },
+  derive: function(o, e) {
+    const n = [];
+    for (let i = o, s = i.length, c = s - 1; s > 1; s--, c--) {
+      const r = [];
+      for (let l = 0, u; l < c; l++)
+        u = {
+          x: c * (i[l + 1].x - i[l].x),
+          y: c * (i[l + 1].y - i[l].y)
+        }, e && (u.z = c * (i[l + 1].z - i[l].z)), r.push(u);
+      n.push(r), i = r;
+    }
+    return n;
+  },
+  between: function(o, e, n) {
+    return e <= o && o <= n || y.approximately(o, e) || y.approximately(o, n);
+  },
+  approximately: function(o, e, n) {
+    return R(o - e) <= (n || nt);
+  },
+  length: function(o) {
+    const n = y.Tvalues.length;
+    let i = 0;
+    for (let s = 0, c; s < n; s++)
+      c = 0.5 * y.Tvalues[s] + 0.5, i += y.Cvalues[s] * y.arcfn(c, o);
+    return 0.5 * i;
+  },
+  map: function(o, e, n, i, s) {
+    const c = n - e, r = s - i, l = o - e, u = l / c;
+    return i + r * u;
+  },
+  lerp: function(o, e, n) {
+    const i = {
+      x: e.x + o * (n.x - e.x),
+      y: e.y + o * (n.y - e.y)
+    };
+    return e.z !== void 0 && n.z !== void 0 && (i.z = e.z + o * (n.z - e.z)), i;
+  },
+  pointToString: function(o) {
+    let e = o.x + "/" + o.y;
+    return typeof o.z < "u" && (e += "/" + o.z), e;
+  },
+  pointsToString: function(o) {
+    return "[" + o.map(y.pointToString).join(", ") + "]";
+  },
+  copy: function(o) {
+    return JSON.parse(JSON.stringify(o));
+  },
+  angle: function(o, e, n) {
+    const i = e.x - o.x, s = e.y - o.y, c = n.x - o.x, r = n.y - o.y, l = i * r - s * c, u = i * c + s * r;
+    return J(l, u);
+  },
+  // round as string, to avoid rounding errors
+  round: function(o, e) {
+    const n = "" + o, i = n.indexOf(".");
+    return parseFloat(n.substring(0, i + 1 + e));
+  },
+  dist: function(o, e) {
+    const n = o.x - e.x, i = o.y - e.y;
+    return F(n * n + i * i);
+  },
+  closest: function(o, e) {
+    let n = L(2, 63), i, s;
+    return o.forEach(function(c, r) {
+      s = y.dist(e, c), s < n && (n = s, i = r);
+    }), { mdist: n, mpos: i };
+  },
+  abcratio: function(o, e) {
+    if (e !== 2 && e !== 3)
+      return !1;
+    if (typeof o > "u")
+      o = 0.5;
+    else if (o === 0 || o === 1)
+      return o;
+    const n = L(o, e) + L(1 - o, e), i = n - 1;
+    return R(i / n);
+  },
+  projectionratio: function(o, e) {
+    if (e !== 2 && e !== 3)
+      return !1;
+    if (typeof o > "u")
+      o = 0.5;
+    else if (o === 0 || o === 1)
+      return o;
+    const n = L(1 - o, e), i = L(o, e) + n;
+    return n / i;
+  },
+  lli8: function(o, e, n, i, s, c, r, l) {
+    const u = (o * i - e * n) * (s - r) - (o - n) * (s * l - c * r), f = (o * i - e * n) * (c - l) - (e - i) * (s * l - c * r), h = (o - n) * (c - l) - (e - i) * (s - r);
+    return h == 0 ? !1 : { x: u / h, y: f / h };
+  },
+  lli4: function(o, e, n, i) {
+    const s = o.x, c = o.y, r = e.x, l = e.y, u = n.x, f = n.y, h = i.x, a = i.y;
+    return y.lli8(s, c, r, l, u, f, h, a);
+  },
+  lli: function(o, e) {
+    return y.lli4(o, o.c, e, e.c);
+  },
+  makeline: function(o, e) {
+    return new E(
+      o.x,
+      o.y,
+      (o.x + e.x) / 2,
+      (o.y + e.y) / 2,
+      e.x,
+      e.y
+    );
+  },
+  findbbox: function(o) {
+    let e = Q, n = Q, i = H, s = H;
+    return o.forEach(function(c) {
+      const r = c.bbox();
+      e > r.x.min && (e = r.x.min), n > r.y.min && (n = r.y.min), i < r.x.max && (i = r.x.max), s < r.y.max && (s = r.y.max);
+    }), {
+      x: { min: e, mid: (e + i) / 2, max: i, size: i - e },
+      y: { min: n, mid: (n + s) / 2, max: s, size: s - n }
+    };
+  },
+  shapeintersections: function(o, e, n, i, s) {
+    if (!y.bboxoverlap(e, i))
+      return [];
+    const c = [], r = [o.startcap, o.forward, o.back, o.endcap], l = [n.startcap, n.forward, n.back, n.endcap];
+    return r.forEach(function(u) {
+      u.virtual || l.forEach(function(f) {
+        if (f.virtual)
+          return;
+        const h = u.intersects(f, s);
+        h.length > 0 && (h.c1 = u, h.c2 = f, h.s1 = o, h.s2 = n, c.push(h));
+      });
+    }), c;
+  },
+  makeshape: function(o, e, n) {
+    const i = e.points.length, s = o.points.length, c = y.makeline(e.points[i - 1], o.points[0]), r = y.makeline(o.points[s - 1], e.points[0]), l = {
+      startcap: c,
+      forward: o,
+      back: e,
+      endcap: r,
+      bbox: y.findbbox([c, o, e, r])
+    };
+    return l.intersections = function(u) {
+      return y.shapeintersections(
+        l,
+        l.bbox,
+        u,
+        u.bbox,
+        n
+      );
+    }, l;
+  },
+  getminmax: function(o, e, n) {
+    if (!n)
+      return { min: 0, max: 0 };
+    let i = Q, s = H, c, r;
+    n.indexOf(0) === -1 && (n = [0].concat(n)), n.indexOf(1) === -1 && n.push(1);
+    for (let l = 0, u = n.length; l < u; l++)
+      c = n[l], r = o.get(c), r[e] < i && (i = r[e]), r[e] > s && (s = r[e]);
+    return { min: i, mid: (i + s) / 2, max: s, size: s - i };
+  },
+  align: function(o, e) {
+    const n = e.p1.x, i = e.p1.y, s = -J(e.p2.y - i, e.p2.x - n), c = function(r) {
+      return {
+        x: (r.x - n) * N(s) - (r.y - i) * U(s),
+        y: (r.x - n) * U(s) + (r.y - i) * N(s)
+      };
+    };
+    return o.map(c);
+  },
+  roots: function(o, e) {
+    e = e || { p1: { x: 0, y: 0 }, p2: { x: 1, y: 0 } };
+    const n = o.length - 1, i = y.align(o, e), s = function(x) {
+      return 0 <= x && x <= 1;
+    };
+    if (n === 2) {
+      const x = i[0].y, m = i[1].y, v = i[2].y, w = x - 2 * m + v;
+      if (w !== 0) {
+        const b = -F(m * m - x * v), k = -x + m, q = -(b + k) / w, M = -(-b + k) / w;
+        return [q, M].filter(s);
+      } else if (m !== v && w === 0)
+        return [(2 * m - v) / (2 * m - 2 * v)].filter(s);
+      return [];
+    }
+    const c = i[0].y, r = i[1].y, l = i[2].y, u = i[3].y;
+    let f = -c + 3 * r - 3 * l + u, h = 3 * c - 6 * r + 3 * l, a = -3 * c + 3 * r, p = c;
+    if (y.approximately(f, 0)) {
+      if (y.approximately(h, 0))
+        return y.approximately(a, 0) ? [] : [-p / a].filter(s);
+      const x = F(a * a - 4 * h * p), m = 2 * h;
+      return [(x - a) / m, (-a - x) / m].filter(s);
+    }
+    h /= f, a /= f, p /= f;
+    const g = (3 * a - h * h) / 3, _ = g / 3, C = (2 * h * h * h - 9 * h * a + 27 * p) / 27, A = C / 2, S = A * A + _ * _ * _;
+    let j, O, T, z, d;
+    if (S < 0) {
+      const x = -g / 3, m = x * x * x, v = F(m), w = -C / (2 * v), b = w < -1 ? -1 : w > 1 ? 1 : w, k = et(b), q = $(v), M = 2 * q;
+      return T = M * N(k / 3) - h / 3, z = M * N((k + X) / 3) - h / 3, d = M * N((k + 2 * X) / 3) - h / 3, [T, z, d].filter(s);
+    } else {
+      if (S === 0)
+        return j = A < 0 ? $(-A) : -$(A), T = 2 * j - h / 3, z = -j - h / 3, [T, z].filter(s);
+      {
+        const x = F(S);
+        return j = $(-A + x), O = $(A + x), [j - O - h / 3].filter(s);
+      }
+    }
+  },
+  droots: function(o) {
+    if (o.length === 3) {
+      const e = o[0], n = o[1], i = o[2], s = e - 2 * n + i;
+      if (s !== 0) {
+        const c = -F(n * n - e * i), r = -e + n, l = -(c + r) / s, u = -(-c + r) / s;
+        return [l, u];
+      } else if (n !== i && s === 0)
+        return [(2 * n - i) / (2 * (n - i))];
+      return [];
+    }
+    if (o.length === 2) {
+      const e = o[0], n = o[1];
+      return e !== n ? [e / (e - n)] : [];
+    }
+    return [];
+  },
+  curvature: function(o, e, n, i, s) {
+    let c, r, l, u, f = 0, h = 0;
+    const a = y.compute(o, e), p = y.compute(o, n), g = a.x * a.x + a.y * a.y;
+    if (i ? (c = F(
+      L(a.y * p.z - p.y * a.z, 2) + L(a.z * p.x - p.z * a.x, 2) + L(a.x * p.y - p.x * a.y, 2)
+    ), r = L(g + a.z * a.z, 3 / 2)) : (c = a.x * p.y - a.y * p.x, r = L(g, 3 / 2)), c === 0 || r === 0)
+      return { k: 0, r: 0 };
+    if (f = c / r, h = r / c, !s) {
+      const _ = y.curvature(o - 1e-3, e, n, i, !0).k, C = y.curvature(o + 1e-3, e, n, i, !0).k;
+      u = (C - f + (f - _)) / 2, l = (R(C - f) + R(f - _)) / 2;
+    }
+    return { k: f, r: h, dk: u, adk: l };
+  },
+  inflections: function(o) {
+    if (o.length < 4)
+      return [];
+    const e = y.align(o, { p1: o[0], p2: o.slice(-1)[0] }), n = e[2].x * e[1].y, i = e[3].x * e[1].y, s = e[1].x * e[2].y, c = e[3].x * e[2].y, r = 18 * (-3 * n + 2 * i + 3 * s - c), l = 18 * (3 * n - i - 3 * s), u = 18 * (s - n);
+    if (y.approximately(r, 0)) {
+      if (!y.approximately(l, 0)) {
+        let p = -u / l;
+        if (0 <= p && p <= 1)
+          return [p];
+      }
+      return [];
+    }
+    const f = 2 * r;
+    if (y.approximately(f, 0))
+      return [];
+    const h = l * l - 4 * r * u;
+    if (h < 0)
+      return [];
+    const a = Math.sqrt(h);
+    return [(a - l) / f, -(l + a) / f].filter(function(p) {
+      return 0 <= p && p <= 1;
+    });
+  },
+  bboxoverlap: function(o, e) {
+    const n = ["x", "y"], i = n.length;
+    for (let s = 0, c, r, l, u; s < i; s++)
+      if (c = n[s], r = o[c].mid, l = e[c].mid, u = (o[c].size + e[c].size) / 2, R(r - l) >= u)
+        return !1;
+    return !0;
+  },
+  expandbox: function(o, e) {
+    e.x.min < o.x.min && (o.x.min = e.x.min), e.y.min < o.y.min && (o.y.min = e.y.min), e.z && e.z.min < o.z.min && (o.z.min = e.z.min), e.x.max > o.x.max && (o.x.max = e.x.max), e.y.max > o.y.max && (o.y.max = e.y.max), e.z && e.z.max > o.z.max && (o.z.max = e.z.max), o.x.mid = (o.x.min + o.x.max) / 2, o.y.mid = (o.y.min + o.y.max) / 2, o.z && (o.z.mid = (o.z.min + o.z.max) / 2), o.x.size = o.x.max - o.x.min, o.y.size = o.y.max - o.y.min, o.z && (o.z.size = o.z.max - o.z.min);
+  },
+  pairiteration: function(o, e, n) {
+    const i = o.bbox(), s = e.bbox(), c = 1e5, r = n || 0.5;
+    if (i.x.size + i.y.size < r && s.x.size + s.y.size < r)
+      return [
+        (c * (o._t1 + o._t2) / 2 | 0) / c + "/" + (c * (e._t1 + e._t2) / 2 | 0) / c
+      ];
+    let l = o.split(0.5), u = e.split(0.5), f = [
+      { left: l.left, right: u.left },
+      { left: l.left, right: u.right },
+      { left: l.right, right: u.right },
+      { left: l.right, right: u.left }
+    ];
+    f = f.filter(function(a) {
+      return y.bboxoverlap(a.left.bbox(), a.right.bbox());
+    });
+    let h = [];
+    return f.length === 0 || (f.forEach(function(a) {
+      h = h.concat(
+        y.pairiteration(a.left, a.right, r)
+      );
+    }), h = h.filter(function(a, p) {
+      return h.indexOf(a) === p;
+    })), h;
+  },
+  getccenter: function(o, e, n) {
+    const i = e.x - o.x, s = e.y - o.y, c = n.x - e.x, r = n.y - e.y, l = i * N(P) - s * U(P), u = i * U(P) + s * N(P), f = c * N(P) - r * U(P), h = c * U(P) + r * N(P), a = (o.x + e.x) / 2, p = (o.y + e.y) / 2, g = (e.x + n.x) / 2, _ = (e.y + n.y) / 2, C = a + l, A = p + u, S = g + f, j = _ + h, O = y.lli8(a, p, C, A, g, _, S, j), T = y.dist(O, o);
+    let z = J(o.y - O.y, o.x - O.x), d = J(e.y - O.y, e.x - O.x), x = J(n.y - O.y, n.x - O.x), m;
+    return z < x ? ((z > d || d > x) && (z += X), z > x && (m = x, x = z, z = m)) : x < d && d < z ? (m = x, x = z, z = m) : x += X, O.s = z, O.e = x, O.r = T, O;
+  },
+  numberSort: function(o, e) {
+    return o - e;
+  }
+};
+class V {
+  constructor(e) {
+    this.curves = [], this._3d = !1, e && (this.curves = e, this._3d = this.curves[0]._3d);
+  }
+  valueOf() {
+    return this.toString();
+  }
+  toString() {
+    return "[" + this.curves.map(function(e) {
+      return y.pointsToString(e.points);
+    }).join(", ") + "]";
+  }
+  addCurve(e) {
+    this.curves.push(e), this._3d = this._3d || e._3d;
+  }
+  length() {
+    return this.curves.map(function(e) {
+      return e.length();
+    }).reduce(function(e, n) {
+      return e + n;
+    });
+  }
+  curve(e) {
+    return this.curves[e];
+  }
+  bbox() {
+    const e = this.curves;
+    for (var n = e[0].bbox(), i = 1; i < e.length; i++)
+      y.expandbox(n, e[i].bbox());
+    return n;
+  }
+  offset(e) {
+    const n = [];
+    return this.curves.forEach(function(i) {
+      n.push(...i.offset(e));
+    }), new V(n);
+  }
+}
+const { abs: G, min: K, max: B, cos: rt, sin: st, acos: ot, sqrt: Z } = Math, ct = Math.PI;
+class E {
+  constructor(e) {
+    let n = e && e.forEach ? e : Array.from(arguments).slice(), i = !1;
+    if (typeof n[0] == "object") {
+      i = n.length;
+      const g = [];
+      n.forEach(function(_) {
+        ["x", "y", "z"].forEach(function(C) {
+          typeof _[C] < "u" && g.push(_[C]);
+        });
+      }), n = g;
+    }
+    let s = !1;
+    const c = n.length;
+    if (i) {
+      if (i > 4) {
+        if (arguments.length !== 1)
+          throw new Error(
+            "Only new Bezier(point[]) is accepted for 4th and higher order curves"
+          );
+        s = !0;
+      }
+    } else if (c !== 6 && c !== 8 && c !== 9 && c !== 12 && arguments.length !== 1)
+      throw new Error(
+        "Only new Bezier(point[]) is accepted for 4th and higher order curves"
+      );
+    const r = this._3d = !s && (c === 9 || c === 12) || e && e[0] && typeof e[0].z < "u", l = this.points = [];
+    for (let g = 0, _ = r ? 3 : 2; g < c; g += _) {
+      var u = {
+        x: n[g],
+        y: n[g + 1]
+      };
+      r && (u.z = n[g + 2]), l.push(u);
+    }
+    const f = this.order = l.length - 1, h = this.dims = ["x", "y"];
+    r && h.push("z"), this.dimlen = h.length;
+    const a = y.align(l, { p1: l[0], p2: l[f] }), p = y.dist(l[0], l[f]);
+    this._linear = a.reduce((g, _) => g + G(_.y), 0) < p / 50, this._lut = [], this._t1 = 0, this._t2 = 1, this.update();
+  }
+  static quadraticFromPoints(e, n, i, s) {
+    if (typeof s > "u" && (s = 0.5), s === 0)
+      return new E(n, n, i);
+    if (s === 1)
+      return new E(e, n, n);
+    const c = E.getABC(2, e, n, i, s);
+    return new E(e, c.A, i);
+  }
+  static cubicFromPoints(e, n, i, s, c) {
+    typeof s > "u" && (s = 0.5);
+    const r = E.getABC(3, e, n, i, s);
+    typeof c > "u" && (c = y.dist(n, r.C));
+    const l = c * (1 - s) / s, u = y.dist(e, i), f = (i.x - e.x) / u, h = (i.y - e.y) / u, a = c * f, p = c * h, g = l * f, _ = l * h, C = { x: n.x - a, y: n.y - p }, A = { x: n.x + g, y: n.y + _ }, S = r.A, j = { x: S.x + (C.x - S.x) / (1 - s), y: S.y + (C.y - S.y) / (1 - s) }, O = { x: S.x + (A.x - S.x) / s, y: S.y + (A.y - S.y) / s }, T = { x: e.x + (j.x - e.x) / s, y: e.y + (j.y - e.y) / s }, z = {
+      x: i.x + (O.x - i.x) / (1 - s),
+      y: i.y + (O.y - i.y) / (1 - s)
+    };
+    return new E(e, T, z, i);
+  }
+  static getUtils() {
+    return y;
+  }
+  getUtils() {
+    return E.getUtils();
+  }
+  static get PolyBezier() {
+    return V;
+  }
+  valueOf() {
+    return this.toString();
+  }
+  toString() {
+    return y.pointsToString(this.points);
+  }
+  toSVG() {
+    if (this._3d)
+      return !1;
+    const e = this.points, n = e[0].x, i = e[0].y, s = ["M", n, i, this.order === 2 ? "Q" : "C"];
+    for (let c = 1, r = e.length; c < r; c++)
+      s.push(e[c].x), s.push(e[c].y);
+    return s.join(" ");
+  }
+  setRatios(e) {
+    if (e.length !== this.points.length)
+      throw new Error("incorrect number of ratio values");
+    this.ratios = e, this._lut = [];
+  }
+  verify() {
+    const e = this.coordDigest();
+    e !== this._print && (this._print = e, this.update());
+  }
+  coordDigest() {
+    return this.points.map(function(e, n) {
+      return "" + n + e.x + e.y + (e.z ? e.z : 0);
+    }).join("");
+  }
+  update() {
+    this._lut = [], this.dpoints = y.derive(this.points, this._3d), this.computedirection();
+  }
+  computedirection() {
+    const e = this.points, n = y.angle(e[0], e[this.order], e[1]);
+    this.clockwise = n > 0;
+  }
+  length() {
+    return y.length(this.derivative.bind(this));
+  }
+  static getABC(e = 2, n, i, s, c = 0.5) {
+    const r = y.projectionratio(c, e), l = 1 - r, u = {
+      x: r * n.x + l * s.x,
+      y: r * n.y + l * s.y
+    }, f = y.abcratio(c, e);
+    return { A: {
+      x: i.x + (i.x - u.x) / f,
+      y: i.y + (i.y - u.y) / f
+    }, B: i, C: u, S: n, E: s };
+  }
+  getABC(e, n) {
+    n = n || this.get(e);
+    let i = this.points[0], s = this.points[this.order];
+    return E.getABC(this.order, i, n, s, e);
+  }
+  getLUT(e) {
+    if (this.verify(), e = e || 100, this._lut.length === e + 1)
+      return this._lut;
+    this._lut = [], e++, this._lut = [];
+    for (let n = 0, i, s; n < e; n++)
+      s = n / (e - 1), i = this.compute(s), i.t = s, this._lut.push(i);
+    return this._lut;
+  }
+  on(e, n) {
+    n = n || 5;
+    const i = this.getLUT(), s = [];
+    for (let c = 0, r, l = 0; c < i.length; c++)
+      r = i[c], y.dist(r, e) < n && (s.push(r), l += c / i.length);
+    return s.length ? t /= s.length : !1;
+  }
+  project(e) {
+    const n = this.getLUT(), i = n.length - 1, s = y.closest(n, e), c = s.mpos, r = (c - 1) / i, l = (c + 1) / i, u = 0.1 / i;
+    let f = s.mdist, h = r, a = h, p;
+    f += 1;
+    for (let g; h < l + u; h += u)
+      p = this.compute(h), g = y.dist(e, p), g < f && (f = g, a = h);
+    return a = a < 0 ? 0 : a > 1 ? 1 : a, p = this.compute(a), p.t = a, p.d = f, p;
+  }
+  get(e) {
+    return this.compute(e);
+  }
+  point(e) {
+    return this.points[e];
+  }
+  compute(e) {
+    return this.ratios ? y.computeWithRatios(e, this.points, this.ratios, this._3d) : y.compute(e, this.points, this._3d, this.ratios);
+  }
+  raise() {
+    const e = this.points, n = [e[0]], i = e.length;
+    for (let s = 1, c, r; s < i; s++)
+      c = e[s], r = e[s - 1], n[s] = {
+        x: (i - s) / i * c.x + s / i * r.x,
+        y: (i - s) / i * c.y + s / i * r.y
+      };
+    return n[i] = e[i - 1], new E(n);
+  }
+  derivative(e) {
+    return y.compute(e, this.dpoints[0], this._3d);
+  }
+  dderivative(e) {
+    return y.compute(e, this.dpoints[1], this._3d);
+  }
+  align() {
+    let e = this.points;
+    return new E(y.align(e, { p1: e[0], p2: e[e.length - 1] }));
+  }
+  curvature(e) {
+    return y.curvature(e, this.dpoints[0], this.dpoints[1], this._3d);
+  }
+  inflections() {
+    return y.inflections(this.points);
+  }
+  normal(e) {
+    return this._3d ? this.__normal3(e) : this.__normal2(e);
+  }
+  __normal2(e) {
+    const n = this.derivative(e), i = Z(n.x * n.x + n.y * n.y);
+    return { t: e, x: -n.y / i, y: n.x / i };
+  }
+  __normal3(e) {
+    const n = this.derivative(e), i = this.derivative(e + 0.01), s = Z(n.x * n.x + n.y * n.y + n.z * n.z), c = Z(i.x * i.x + i.y * i.y + i.z * i.z);
+    n.x /= s, n.y /= s, n.z /= s, i.x /= c, i.y /= c, i.z /= c;
+    const r = {
+      x: i.y * n.z - i.z * n.y,
+      y: i.z * n.x - i.x * n.z,
+      z: i.x * n.y - i.y * n.x
+    }, l = Z(r.x * r.x + r.y * r.y + r.z * r.z);
+    r.x /= l, r.y /= l, r.z /= l;
+    const u = [
+      r.x * r.x,
+      r.x * r.y - r.z,
+      r.x * r.z + r.y,
+      r.x * r.y + r.z,
+      r.y * r.y,
+      r.y * r.z - r.x,
+      r.x * r.z - r.y,
+      r.y * r.z + r.x,
+      r.z * r.z
+    ];
+    return {
+      t: e,
+      x: u[0] * n.x + u[1] * n.y + u[2] * n.z,
+      y: u[3] * n.x + u[4] * n.y + u[5] * n.z,
+      z: u[6] * n.x + u[7] * n.y + u[8] * n.z
+    };
+  }
+  hull(e) {
+    let n = this.points, i = [], s = [], c = 0;
+    for (s[c++] = n[0], s[c++] = n[1], s[c++] = n[2], this.order === 3 && (s[c++] = n[3]); n.length > 1; ) {
+      i = [];
+      for (let r = 0, l, u = n.length - 1; r < u; r++)
+        l = y.lerp(e, n[r], n[r + 1]), s[c++] = l, i.push(l);
+      n = i;
+    }
+    return s;
+  }
+  split(e, n) {
+    if (e === 0 && n)
+      return this.split(n).left;
+    if (n === 1)
+      return this.split(e).right;
+    const i = this.hull(e), s = {
+      left: this.order === 2 ? new E([i[0], i[3], i[5]]) : new E([i[0], i[4], i[7], i[9]]),
+      right: this.order === 2 ? new E([i[5], i[4], i[2]]) : new E([i[9], i[8], i[6], i[3]]),
+      span: i
+    };
+    return s.left._t1 = y.map(0, 0, 1, this._t1, this._t2), s.left._t2 = y.map(e, 0, 1, this._t1, this._t2), s.right._t1 = y.map(e, 0, 1, this._t1, this._t2), s.right._t2 = y.map(1, 0, 1, this._t1, this._t2), n ? (n = y.map(n, e, 1, 0, 1), s.right.split(n).left) : s;
+  }
+  extrema() {
+    const e = {};
+    let n = [];
+    return this.dims.forEach(
+      (function(i) {
+        let s = function(r) {
+          return r[i];
+        }, c = this.dpoints[0].map(s);
+        e[i] = y.droots(c), this.order === 3 && (c = this.dpoints[1].map(s), e[i] = e[i].concat(y.droots(c))), e[i] = e[i].filter(function(r) {
+          return r >= 0 && r <= 1;
+        }), n = n.concat(e[i].sort(y.numberSort));
+      }).bind(this)
+    ), e.values = n.sort(y.numberSort).filter(function(i, s) {
+      return n.indexOf(i) === s;
+    }), e;
+  }
+  bbox() {
+    const e = this.extrema(), n = {};
+    return this.dims.forEach(
+      (function(i) {
+        n[i] = y.getminmax(this, i, e[i]);
+      }).bind(this)
+    ), n;
+  }
+  overlaps(e) {
+    const n = this.bbox(), i = e.bbox();
+    return y.bboxoverlap(n, i);
+  }
+  offset(e, n) {
+    if (typeof n < "u") {
+      const i = this.get(e), s = this.normal(e), c = {
+        c: i,
+        n: s,
+        x: i.x + s.x * n,
+        y: i.y + s.y * n
+      };
+      return this._3d && (c.z = i.z + s.z * n), c;
+    }
+    if (this._linear) {
+      const i = this.normal(0), s = this.points.map(function(c) {
+        const r = {
+          x: c.x + e * i.x,
+          y: c.y + e * i.y
+        };
+        return c.z && i.z && (r.z = c.z + e * i.z), r;
+      });
+      return [new E(s)];
+    }
+    return this.reduce().map(function(i) {
+      return i._linear ? i.offset(e)[0] : i.scale(e);
+    });
+  }
+  simple() {
+    if (this.order === 3) {
+      const s = y.angle(this.points[0], this.points[3], this.points[1]), c = y.angle(this.points[0], this.points[3], this.points[2]);
+      if (s > 0 && c < 0 || s < 0 && c > 0)
+        return !1;
+    }
+    const e = this.normal(0), n = this.normal(1);
+    let i = e.x * n.x + e.y * n.y;
+    return this._3d && (i += e.z * n.z), G(ot(i)) < ct / 3;
+  }
+  reduce() {
+    let e, n = 0, i = 0, s = 0.01, c, r = [], l = [], u = this.extrema().values;
+    for (u.indexOf(0) === -1 && (u = [0].concat(u)), u.indexOf(1) === -1 && u.push(1), n = u[0], e = 1; e < u.length; e++)
+      i = u[e], c = this.split(n, i), c._t1 = n, c._t2 = i, r.push(c), n = i;
+    return r.forEach(function(f) {
+      for (n = 0, i = 0; i <= 1; )
+        for (i = n + s; i <= 1 + s; i += s)
+          if (c = f.split(n, i), !c.simple()) {
+            if (i -= s, G(n - i) < s)
+              return [];
+            c = f.split(n, i), c._t1 = y.map(n, 0, 1, f._t1, f._t2), c._t2 = y.map(i, 0, 1, f._t1, f._t2), l.push(c), n = i;
+            break;
+          }
+      n < 1 && (c = f.split(n, 1), c._t1 = y.map(n, 0, 1, f._t1, f._t2), c._t2 = f._t2, l.push(c));
+    }), l;
+  }
+  translate(e, n, i) {
+    i = typeof i == "number" ? i : n;
+    const s = this.order;
+    let c = this.points.map((r, l) => (1 - l / s) * n + l / s * i);
+    return new E(
+      this.points.map((r, l) => ({
+        x: r.x + e.x * c[l],
+        y: r.y + e.y * c[l]
+      }))
+    );
+  }
+  scale(e) {
+    const n = this.order;
+    let i = !1;
+    if (typeof e == "function" && (i = e), i && n === 2)
+      return this.raise().scale(i);
+    const s = this.clockwise, c = this.points;
+    if (this._linear)
+      return this.translate(
+        this.normal(0),
+        i ? i(0) : e,
+        i ? i(1) : e
+      );
+    const r = i ? i(0) : e, l = i ? i(1) : e, u = [this.offset(0, 10), this.offset(1, 10)], f = [], h = y.lli4(u[0], u[0].c, u[1], u[1].c);
+    if (!h)
+      throw new Error("cannot scale this curve. Try reducing it first.");
+    return [0, 1].forEach(function(a) {
+      const p = f[a * n] = y.copy(c[a * n]);
+      p.x += (a ? l : r) * u[a].n.x, p.y += (a ? l : r) * u[a].n.y;
+    }), i ? ([0, 1].forEach(function(a) {
+      if (!(n === 2 && a)) {
+        var p = c[a + 1], g = {
+          x: p.x - h.x,
+          y: p.y - h.y
+        }, _ = i ? i((a + 1) / n) : e;
+        i && !s && (_ = -_);
+        var C = Z(g.x * g.x + g.y * g.y);
+        g.x /= C, g.y /= C, f[a + 1] = {
+          x: p.x + _ * g.x,
+          y: p.y + _ * g.y
+        };
+      }
+    }), new E(f)) : ([0, 1].forEach((a) => {
+      if (n === 2 && a)
+        return;
+      const p = f[a * n], g = this.derivative(a), _ = { x: p.x + g.x, y: p.y + g.y };
+      f[a + 1] = y.lli4(p, _, h, c[a + 1]);
+    }), new E(f));
+  }
+  outline(e, n, i, s) {
+    if (n = n === void 0 ? e : n, this._linear) {
+      const z = this.normal(0), d = this.points[0], x = this.points[this.points.length - 1];
+      let m, v, w;
+      i === void 0 && (i = e, s = n), m = { x: d.x + z.x * e, y: d.y + z.y * e }, w = { x: x.x + z.x * i, y: x.y + z.y * i }, v = { x: (m.x + w.x) / 2, y: (m.y + w.y) / 2 };
+      const b = [m, v, w];
+      m = { x: d.x - z.x * n, y: d.y - z.y * n }, w = { x: x.x - z.x * s, y: x.y - z.y * s }, v = { x: (m.x + w.x) / 2, y: (m.y + w.y) / 2 };
+      const k = [w, v, m], q = y.makeline(k[2], b[0]), M = y.makeline(b[2], k[0]), I = [q, new E(b), M, new E(k)];
+      return new V(I);
+    }
+    const c = this.reduce(), r = c.length, l = [];
+    let u = [], f, h = 0, a = this.length();
+    const p = typeof i < "u" && typeof s < "u";
+    function g(z, d, x, m, v) {
+      return function(w) {
+        const b = m / x, k = (m + v) / x, q = d - z;
+        return y.map(w, 0, 1, z + b * q, z + k * q);
+      };
+    }
+    c.forEach(function(z) {
+      const d = z.length();
+      p ? (l.push(
+        z.scale(g(e, i, a, h, d))
+      ), u.push(
+        z.scale(g(-n, -s, a, h, d))
+      )) : (l.push(z.scale(e)), u.push(z.scale(-n))), h += d;
+    }), u = u.map(function(z) {
+      return f = z.points, f[3] ? z.points = [f[3], f[2], f[1], f[0]] : z.points = [f[2], f[1], f[0]], z;
+    }).reverse();
+    const _ = l[0].points[0], C = l[r - 1].points[l[r - 1].points.length - 1], A = u[r - 1].points[u[r - 1].points.length - 1], S = u[0].points[0], j = y.makeline(A, _), O = y.makeline(C, S), T = [j].concat(l).concat([O]).concat(u);
+    return new V(T);
+  }
+  outlineshapes(e, n, i) {
+    n = n || e;
+    const s = this.outline(e, n).curves, c = [];
+    for (let r = 1, l = s.length; r < l / 2; r++) {
+      const u = y.makeshape(
+        s[r],
+        s[l - r],
+        i
+      );
+      u.startcap.virtual = r > 1, u.endcap.virtual = r < l / 2 - 1, c.push(u);
+    }
+    return c;
+  }
+  intersects(e, n) {
+    return e ? e.p1 && e.p2 ? this.lineIntersects(e) : (e instanceof E && (e = e.reduce()), this.curveintersects(
+      this.reduce(),
+      e,
+      n
+    )) : this.selfintersects(n);
+  }
+  lineIntersects(e) {
+    const n = K(e.p1.x, e.p2.x), i = K(e.p1.y, e.p2.y), s = B(e.p1.x, e.p2.x), c = B(e.p1.y, e.p2.y);
+    return y.roots(this.points, e).filter((r) => {
+      var l = this.get(r);
+      return y.between(l.x, n, s) && y.between(l.y, i, c);
+    });
+  }
+  selfintersects(e) {
+    const n = this.reduce(), i = n.length - 2, s = [];
+    for (let c = 0, r, l, u; c < i; c++)
+      l = n.slice(c, c + 1), u = n.slice(c + 2), r = this.curveintersects(l, u, e), s.push(...r);
+    return s;
+  }
+  curveintersects(e, n, i) {
+    const s = [];
+    e.forEach(function(r) {
+      n.forEach(function(l) {
+        r.overlaps(l) && s.push({ left: r, right: l });
+      });
+    });
+    let c = [];
+    return s.forEach(function(r) {
+      const l = y.pairiteration(
+        r.left,
+        r.right,
+        i
+      );
+      l.length > 0 && (c = c.concat(l));
+    }), c;
+  }
+  arcs(e) {
+    return e = e || 0.5, this._iterate(e, []);
+  }
+  _error(e, n, i, s) {
+    const c = (s - i) / 4, r = this.get(i + c), l = this.get(s - c), u = y.dist(e, n), f = y.dist(e, r), h = y.dist(e, l);
+    return G(f - u) + G(h - u);
+  }
+  _iterate(e, n) {
+    let i = 0, s = 1, c;
+    do {
+      c = 0, s = 1;
+      let r = this.get(i), l, u, f, h, a = !1, p = !1, g, _ = s, C = 1;
+      do
+        if (p = a, h = f, _ = (i + s) / 2, l = this.get(_), u = this.get(s), f = y.getccenter(r, l, u), f.interval = {
+          start: i,
+          end: s
+        }, a = this._error(f, r, i, s) <= e, g = p && !a, g || (C = s), a) {
+          if (s >= 1) {
+            if (f.interval.end = C = 1, h = f, s > 1) {
+              let S = {
+                x: f.x + f.r * rt(f.e),
+                y: f.y + f.r * st(f.e)
+              };
+              f.e += y.angle({ x: f.x, y: f.y }, S, this.get(1));
+            }
+            break;
+          }
+          s = s + (s - i) / 2;
+        } else
+          s = _;
+      while (!g && c++ < 100);
+      if (c >= 100)
+        break;
+      h = h || f, n.push(h), i = C;
+    } while (s < 1);
+    return n;
+  }
+}
+function lt(o) {
+  let e = [], n = [], i = !1, s = !1, c = [], r = "", l = "", u = {
+    type: "Feature",
+    properties: {
+      fillColor: "",
+      MGValue: 1
+    },
+    geometry: {
+      type: "Polygon",
+      coordinates: [[]]
+    }
+  };
+  const f = (d, x) => {
+    u.properties.fillColor = d || "#ff0", u.properties.MGValue = x || 1, l = d || "#ff0";
+  }, h = (d, x) => {
+    i || (i = !0, f(d || "#ff0", x || 1), o.on("click", a), o.getCanvas().style.cursor = "crosshair");
+  }, a = () => {
+    if (s = !s, s)
+      r = C(), e.push(r), n.push(r), u.geometry.coordinates[0].length = 0, c.length = 0, o.addSource(r, { type: "geojson", data: u }), o.scrollZoom.disable(), o.dragPan.disable(), o.doubleClickZoom.disable(), o.addLayer({
+        id: r,
+        type: "fill",
+        source: r,
+        paint: {
+          "fill-antialias": !0,
+          "fill-color": l,
+          "fill-opacity": 0.8,
+          "fill-outline-color": "black"
+        }
+      }), o.addLayer({
+        id: "draw" + r,
+        type: "line",
+        source: r,
+        paint: {
+          "line-width": 2,
+          "line-color": "black"
+        }
+      }), o.on("mousemove", S);
+    else {
+      if (o.scrollZoom.enable(), o.dragPan.enable(), o.doubleClickZoom.enable(), o.removeLayer("draw" + r), o.off("mousemove", S), T(c)) {
+        alert("落区自相交，请重画"), e.pop(), n.pop(), o.removeLayer(r), o.removeSource(r);
+        return;
+      }
+      const d = [...c.slice(c.length / 5), ...c.slice(0, c.length / 5)], m = new E(d).getLUT(100);
+      u.geometry.coordinates[0].length = 0;
+      for (let w = 0; w < m.length; w++) {
+        const b = o.unproject(m[w]);
+        u.geometry.coordinates[0].push(b.toArray());
+      }
+      const v = o.getSource(r);
+      v !== void 0 && v.setData(JSON.parse(JSON.stringify(u)));
+    }
+  }, p = (d) => {
+    c.push(d.point), u.geometry.coordinates[0].push(d.lngLat.toArray());
+    const x = o.getSource(r);
+    x !== void 0 && x.setData(u);
+  }, g = () => {
+    const d = n.slice(0, e.length), x = [];
+    return d.forEach((m) => {
+      const v = o.getSource(m);
+      x.push(v.serialize().data);
+    }), x;
+  }, _ = () => {
+    e.forEach((d) => o.removeLayer(d)), n.forEach((d) => o.removeSource(d)), e.length = 0, n.length = 0, o.off("click", a), o.getCanvas().style.cursor = "pointer", i = !1;
+  }, C = () => {
+    let d = (/* @__PURE__ */ new Date()).getTime();
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(m) {
+      const v = (d + Math.random() * 16) % 16 | 0;
+      return d = Math.floor(d / 16), (m === "x" ? v : v & 3 | 8).toString(16);
+    });
+  }, S = ((d, x) => {
+    let m = 0;
+    return function(...v) {
+      const w = (/* @__PURE__ */ new Date()).getTime();
+      w - m < x || (m = w, d(...v));
+    };
+  })(p, 20), j = () => {
+    e.length && (o.removeLayer(e[e.length - 1]), e.pop());
+  }, O = () => {
+    if (n.length) {
+      const d = e.length - n.length, x = n.slice(d);
+      if (console.log(x), d !== 0 && x.length) {
+        const m = o.getSource(x[0]);
+        console.log(m, "source");
+        let v = "";
+        m && (v = m.serialize().data.valueOf().properties.fillColor), o.getLayer(x[0]) || (e.push(x[0]), o.addLayer({
+          id: x[0],
+          type: "fill",
+          source: x[0],
+          paint: {
+            "fill-color": v,
+            "fill-opacity": 0.8,
+            "fill-outline-color": "black"
+          }
+        }));
+      }
+    }
+  }, T = (d) => {
+    let x = !1, m = d, v = [], w = m.length - 1;
+    for (let k = 0; k < w; k++) {
+      let q = m[k], M = m[k + 1];
+      (q.x != M.x || q.y != M.y) && v.push(q);
+    }
+    let b = v.length - 1;
+    for (let k = 0; k < b; k++) {
+      let q = v[k], M = v[k + 1];
+      for (let I = k + 2; I < b; I++) {
+        let W = v[I], D = v[I + 1], Y = z(q, M, W, D);
+        if (Y == null && M.x == D.x && M.y == D.y && (Y = { x: M.x, y: M.y }), Y != null) {
+          x = !0;
+          break;
+        }
+      }
+      if (x)
+        break;
+    }
+    return x;
+  }, z = (d, x, m, v) => {
+    var w = null, b = (d.x - m.x) * (x.y - m.y) - (d.y - m.y) * (x.x - m.x), k = (d.x - v.x) * (x.y - v.y) - (d.y - v.y) * (x.x - v.x);
+    if (b * k >= 0)
+      return w;
+    var q = (m.x - d.x) * (v.y - d.y) - (m.y - d.y) * (v.x - d.x), M = q + b - k;
+    if (q * M >= 0)
+      return w;
+    var I = q / (k - b), W = I * (x.x - d.x), D = I * (x.y - d.y);
+    return w = { x: d.x + W, y: d.y + D }, w;
+  };
+  return { isStart: i, start: h, getFeatures: g, clear: _, revoke: j, redo: O, setColor: f };
+}
+const ut = { drawFreehand: lt };
+export {
+  ut as default
+};

package/dist/index.umd.cjs ADDED Viewed

@@ -0,0 +1 @@

package/dist/vite.svg ADDED Viewed

@@ -0,0 +1 @@

+ <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

package/index.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+// 导出函数的声明
+declare module '@turf/turf'
+export default function (map: any): {
+  isStart: Boolean
+  start: (color: string, MGValue: number) => void
+  setColor: (color: string, MGValue: number) => void
+  getFeatures: () => void
+  clear: () => void
+  revoke: () => void
+  redo: () => void
+}
+export function draw(map: any): {
+  isStart: Boolean
+  start: (color: string, MGValue: number) => void
+  setColor: (color: string, MGValue: number) => void
+  getFeatures: () => void
+  clear: () => void
+  revoke: () => void
+  redo: () => void
+}

package/package.json ADDED Viewed

@@ -0,0 +1,35 @@
+{
+  "name": "gs-maplibre-draw",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "index.d.ts"
+  ],
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "types": "./index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.umd.cjs"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "push": "npm version --no-git-tag-version patch && npm publish"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.0.4",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.10"
+  },
+  "dependencies": {
+    "@turf/turf": "^6.5.0",
+    "@types/geojson": "^7946.0.14",
+    "maplibre-gl": "^4.1.1",
+    "view-ui-plus": "^1.3.16",
+    "vue": "^3.4.21"
+  }
+}