gisviewer-vue3-arcgis 1.0.280 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/closest.mjs

@@ -0,0 +1,119 @@
+import { squaredDistance as v, lerp as z } from "../../math.mjs";
+function x(N, h, A, g, b, r, w) {
+  const $ = N[h], j = N[h + 1], l = N[A] - $, M = N[A + 1] - j;
+  let u;
+  if (l === 0 && M === 0)
+    u = h;
+  else {
+    const y = ((b - $) * l + (r - j) * M) / (l * l + M * M);
+    if (y > 1)
+      u = A;
+    else if (y > 0) {
+      for (let k = 0; k < g; ++k)
+        w[k] = z(
+          N[h + k],
+          N[A + k],
+          y
+        );
+      w.length = g;
+      return;
+    } else
+      u = h;
+  }
+  for (let y = 0; y < g; ++y)
+    w[y] = N[u + y];
+  w.length = g;
+}
+function B(N, h, A, g, b) {
+  let r = N[h], w = N[h + 1];
+  for (h += g; h < A; h += g) {
+    const $ = N[h], j = N[h + 1], l = v(r, w, $, j);
+    l > b && (b = l), r = $, w = j;
+  }
+  return b;
+}
+function G(N, h, A, g, b) {
+  for (let r = 0, w = A.length; r < w; ++r) {
+    const $ = A[r];
+    b = B(N, h, $, g, b), h = $;
+  }
+  return b;
+}
+function E(N, h, A, g, b, r, w, $, j, l, M) {
+  if (h == A)
+    return l;
+  let u, y;
+  if (b === 0) {
+    if (y = v(
+      w,
+      $,
+      N[h],
+      N[h + 1]
+    ), y < l) {
+      for (u = 0; u < g; ++u)
+        j[u] = N[h + u];
+      return j.length = g, y;
+    }
+    return l;
+  }
+  M = M || [NaN, NaN];
+  let k = h + g;
+  for (; k < A; )
+    if (x(
+      N,
+      k - g,
+      k,
+      g,
+      w,
+      $,
+      M
+    ), y = v(w, $, M[0], M[1]), y < l) {
+      for (l = y, u = 0; u < g; ++u)
+        j[u] = M[u];
+      j.length = g, k += g;
+    } else
+      k += g * Math.max(
+        (Math.sqrt(y) - Math.sqrt(l)) / b | 0,
+        1
+      );
+  if (r && (x(
+    N,
+    A - g,
+    h,
+    g,
+    w,
+    $,
+    M
+  ), y = v(w, $, M[0], M[1]), y < l)) {
+    for (l = y, u = 0; u < g; ++u)
+      j[u] = M[u];
+    j.length = g;
+  }
+  return l;
+}
+function H(N, h, A, g, b, r, w, $, j, l, M) {
+  M = M || [NaN, NaN];
+  for (let u = 0, y = A.length; u < y; ++u) {
+    const k = A[u];
+    l = E(
+      N,
+      h,
+      k,
+      g,
+      b,
+      r,
+      w,
+      $,
+      j,
+      l,
+      M
+    ), h = k;
+  }
+  return l;
+}
+export {
+  G as arrayMaxSquaredDelta,
+  H as assignClosestArrayPoint,
+  E as assignClosestPoint,
+  B as maxSquaredDelta
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/contains.mjs

@@ -0,0 +1,41 @@
+import { forEachCorner as R } from "../../extent.mjs";
+function p(i, u, n, e, l) {
+  return !R(
+    l,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+     * @return {boolean} Contains (x, y).
+     */
+    function(r) {
+      return !h(
+        i,
+        u,
+        n,
+        e,
+        r[0],
+        r[1]
+      );
+    }
+  );
+}
+function h(i, u, n, e, l, t) {
+  let r = 0, c = i[n - e], f = i[n - e + 1];
+  for (; u < n; u += e) {
+    const g = i[u], o = i[u + 1];
+    f <= t ? o > t && (g - c) * (t - f) - (l - c) * (o - f) > 0 && r++ : o <= t && (g - c) * (t - f) - (l - c) * (o - f) < 0 && r--, c = g, f = o;
+  }
+  return r !== 0;
+}
+function x(i, u, n, e, l, t) {
+  if (n.length === 0 || !h(i, u, n[0], e, l, t))
+    return !1;
+  for (let r = 1, c = n.length; r < c; ++r)
+    if (h(i, n[r - 1], n[r], e, l, t))
+      return !1;
+  return !0;
+}
+export {
+  p as linearRingContainsExtent,
+  h as linearRingContainsXY,
+  x as linearRingsContainsXY
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/deflate.mjs

@@ -0,0 +1,32 @@
+function g(l, r, e, u) {
+  for (let t = 0, i = e.length; t < i; ++t)
+    l[r++] = e[t];
+  return r;
+}
+function f(l, r, e, u) {
+  for (let t = 0, i = e.length; t < i; ++t) {
+    const n = e[t];
+    for (let o = 0; o < u; ++o)
+      l[r++] = n[o];
+  }
+  return r;
+}
+function h(l, r, e, u, t) {
+  t = t || [];
+  let i = 0;
+  for (let n = 0, o = e.length; n < o; ++n) {
+    const a = f(
+      l,
+      r,
+      e[n],
+      u
+    );
+    t[i++] = a, r = a;
+  }
+  return t.length = i, t;
+}
+export {
+  g as deflateCoordinate,
+  f as deflateCoordinates,
+  h as deflateCoordinatesArray
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/inflate.mjs

@@ -0,0 +1,42 @@
+function C(j, e, g, h, l) {
+  l = l !== void 0 ? l : [];
+  let u = 0;
+  for (let n = e; n < g; n += h)
+    l[u++] = j.slice(n, n + h);
+  return l.length = u, l;
+}
+function y(j, e, g, h, l) {
+  l = l !== void 0 ? l : [];
+  let u = 0;
+  for (let n = 0, f = g.length; n < f; ++n) {
+    const t = g[n];
+    l[u++] = C(
+      j,
+      e,
+      t,
+      h,
+      l[u]
+    ), e = t;
+  }
+  return l.length = u, l;
+}
+function A(j, e, g, h, l) {
+  l = l !== void 0 ? l : [];
+  let u = 0;
+  for (let n = 0, f = g.length; n < f; ++n) {
+    const t = g[n];
+    l[u++] = t.length === 1 && t[0] === e ? [] : y(
+      j,
+      e,
+      t,
+      h,
+      l[u]
+    ), e = t[t.length - 1];
+  }
+  return l.length = u, l;
+}
+export {
+  C as inflateCoordinates,
+  y as inflateCoordinatesArray,
+  A as inflateMultiCoordinatesArray
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/interiorpoint.mjs

@@ -0,0 +1,38 @@
+import { ascending as M } from "../../array.mjs";
+import { linearRingsContainsXY as X } from "./contains.mjs";
+function b(o, p, g, c, I, h, i) {
+  let n, u, y, t, e, m, x;
+  const r = I[h + 1], f = [];
+  for (let l = 0, L = g.length; l < L; ++l) {
+    const A = g[l];
+    for (t = o[A - c], m = o[A - c + 1], n = p; n < A; n += c)
+      e = o[n], x = o[n + 1], (r <= m && x <= r || m <= r && r <= x) && (y = (r - m) / (x - m) * (e - t) + t, f.push(y)), t = e, m = x;
+  }
+  let N = NaN, P = -1 / 0;
+  for (f.sort(M), t = f[0], n = 1, u = f.length; n < u; ++n) {
+    e = f[n];
+    const l = Math.abs(e - t);
+    l > P && (y = (t + e) / 2, X(o, p, g, c, y, r) && (N = y, P = l)), t = e;
+  }
+  return isNaN(N) && (N = I[h]), i ? (i.push(N, r, P), i) : [N, r, P];
+}
+function R(o, p, g, c, I) {
+  let h = [];
+  for (let i = 0, n = g.length; i < n; ++i) {
+    const u = g[i];
+    h = b(
+      o,
+      p,
+      u,
+      c,
+      I,
+      2 * i,
+      h
+    ), p = u[u.length - 1];
+  }
+  return h;
+}
+export {
+  b as getInteriorPointOfArray,
+  R as getInteriorPointsOfMultiArray
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/interpolate.mjs

@@ -0,0 +1,27 @@
+import { binarySearch as M } from "../../array.mjs";
+import { lerp as P } from "../../math.mjs";
+function k(p, l, w, h, A, r, x) {
+  let u, g;
+  const b = (w - l) / h;
+  if (b === 1)
+    u = l;
+  else if (b === 2)
+    u = l, g = A;
+  else if (b !== 0) {
+    let c = p[l], e = p[l + 1], m = 0;
+    const y = [0];
+    for (let N = l + h; N < w; N += h) {
+      const q = p[N], v = p[N + 1];
+      m += Math.sqrt((q - c) * (q - c) + (v - e) * (v - e)), y.push(m), c = q, e = v;
+    }
+    const L = A * m, n = M(y, L);
+    n < 0 ? (g = (L - y[-n - 2]) / (y[-n - 1] - y[-n - 2]), u = l + (-n - 2) * h) : u = l + n * h;
+  }
+  x = x > 1 ? x : 2, r = r || new Array(x);
+  for (let c = 0; c < x; ++c)
+    r[c] = u === void 0 ? NaN : g === void 0 ? p[u + c] : P(p[u + c], p[u + h + c], g);
+  return r;
+}
+export {
+  k as interpolatePoint
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/intersectsextent.mjs

@@ -0,0 +1,78 @@
+import { extendFlatCoordinates as l, createEmpty as L, intersects as n, intersectsSegment as y } from "../../extent.mjs";
+import { linearRingContainsXY as c, linearRingContainsExtent as S } from "./contains.mjs";
+import { forEach as A } from "./segments.mjs";
+function R(g, f, u, m, r, i) {
+  return i = i ?? l(L(), g, f, u, m), n(r, i) ? i[0] >= r[0] && i[2] <= r[2] || i[1] >= r[1] && i[3] <= r[3] ? !0 : A(
+    g,
+    f,
+    u,
+    m,
+    /**
+     * @param {import("../../coordinate.js").Coordinate} point1 Start point.
+     * @param {import("../../coordinate.js").Coordinate} point2 End point.
+     * @return {boolean} `true` if the segment and the extent intersect,
+     *     `false` otherwise.
+     */
+    function(p, h) {
+      return y(r, p, h);
+    }
+  ) : !1;
+}
+function F(g, f, u, m, r) {
+  return !!(R(g, f, u, m, r) || c(
+    g,
+    f,
+    u,
+    m,
+    r[0],
+    r[1]
+  ) || c(
+    g,
+    f,
+    u,
+    m,
+    r[0],
+    r[3]
+  ) || c(
+    g,
+    f,
+    u,
+    m,
+    r[2],
+    r[1]
+  ) || c(
+    g,
+    f,
+    u,
+    m,
+    r[2],
+    r[3]
+  ));
+}
+function j(g, f, u, m, r) {
+  if (!F(g, f, u[0], m, r))
+    return !1;
+  if (u.length === 1)
+    return !0;
+  for (let i = 1, p = u.length; i < p; ++i)
+    if (S(
+      g,
+      u[i - 1],
+      u[i],
+      m,
+      r
+    ) && !R(
+      g,
+      u[i - 1],
+      u[i],
+      m,
+      r
+    ))
+      return !1;
+  return !0;
+}
+export {
+  R as intersectsLineString,
+  F as intersectsLinearRing,
+  j as intersectsLinearRingArray
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/length.mjs

@@ -0,0 +1,11 @@
+function y(n, c, u, x) {
+  let e = n[c], g = n[c + 1], r = 0;
+  for (let t = c + x; t < u; t += x) {
+    const h = n[t], l = n[t + 1];
+    r += Math.sqrt((h - e) * (h - e) + (l - g) * (l - g)), e = h, g = l;
+  }
+  return r;
+}
+export {
+  y as lineStringLength
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/linechunk.mjs

@@ -0,0 +1,26 @@
+import { lerp as q } from "../../math.mjs";
+function j(o, l, w, b, n) {
+  const y = [];
+  let u = w, s = 0, c = l.slice(w, 2);
+  for (; s < o && u + n < b; ) {
+    const [t, e] = c.slice(-2), M = l[u + n], i = l[u + n + 1], p = Math.sqrt(
+      (M - t) * (M - t) + (i - e) * (i - e)
+    );
+    if (s += p, s >= o) {
+      const h = (o - s + p) / p, m = q(t, M, h), x = q(e, i, h);
+      c.push(m, x), y.push(c), c = [m, x], s == o && (u += n), s = 0;
+    } else if (s < o)
+      c.push(
+        l[u + n],
+        l[u + n + 1]
+      ), u += n;
+    else {
+      const h = p - s, m = q(t, M, h / p), x = q(e, i, h / p);
+      c.push(m, x), y.push(c), c = [m, x], s = 0, u += n;
+    }
+  }
+  return s > 0 && y.push(c), y;
+}
+export {
+  j as lineChunk
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/orient.mjs

@@ -0,0 +1,62 @@
+import { coordinates as p } from "./reverse.mjs";
+function f(u, e, l, o) {
+  let n = 0, i = u[l - o], t = u[l - o + 1];
+  for (; e < l; e += o) {
+    const r = u[e], c = u[e + 1];
+    n += (r - i) * (c + t), i = r, t = c;
+  }
+  return n === 0 ? void 0 : n > 0;
+}
+function d(u, e, l, o, n) {
+  n = n !== void 0 ? n : !1;
+  for (let i = 0, t = l.length; i < t; ++i) {
+    const r = l[i], c = f(
+      u,
+      e,
+      r,
+      o
+    );
+    if (i === 0) {
+      if (n && c || !n && !c)
+        return !1;
+    } else if (n && !c || !n && c)
+      return !1;
+    e = r;
+  }
+  return !0;
+}
+function x(u, e, l, o, n) {
+  n = n !== void 0 ? n : !1;
+  for (let i = 0, t = l.length; i < t; ++i) {
+    const r = l[i], c = f(
+      u,
+      e,
+      r,
+      o
+    );
+    (i === 0 ? n && c || !n && !c : n && !c || !n && c) && p(u, e, r, o), e = r;
+  }
+  return e;
+}
+function k(u, e) {
+  const l = [];
+  let o = 0, n = 0, i;
+  for (let t = 0, r = e.length; t < r; ++t) {
+    const c = e[t], s = f(u, o, c, 2);
+    if (i === void 0 && (i = s), s === i)
+      l.push(e.slice(n, t + 1));
+    else {
+      if (l.length === 0)
+        continue;
+      l[l.length - 1].push(e[n]);
+    }
+    n = t + 1, o = c;
+  }
+  return l;
+}
+export {
+  k as inflateEnds,
+  f as linearRingIsClockwise,
+  d as linearRingsAreOriented,
+  x as orientLinearRings
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/reverse.mjs

@@ -0,0 +1,12 @@
+function x(h, m, u, c) {
+  for (; m < u - c; ) {
+    for (let p = 0; p < c; ++p) {
+      const w = h[m + p];
+      h[m + p] = h[u - c + p], h[u - c + p] = w;
+    }
+    m += c, u -= c;
+  }
+}
+export {
+  x as coordinates
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/segments.mjs

@@ -0,0 +1,13 @@
+function p(n, c, u, r, h) {
+  let l;
+  for (c += r; c < u; c += r)
+    if (l = h(
+      n.slice(c - r, c),
+      n.slice(c, c + r)
+    ), l)
+      return l;
+  return !1;
+}
+export {
+  p as forEach
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/simplify.mjs

@@ -0,0 +1,89 @@
+import { squaredSegmentDistance as I } from "../../math.mjs";
+function J(n, u, A, y, D, q, c) {
+  const w = (A - u) / y;
+  if (w < 3) {
+    for (; u < A; u += y)
+      q[c++] = n[u], q[c++] = n[u + 1];
+    return c;
+  }
+  const g = new Array(w);
+  g[0] = 1, g[w - 1] = 1;
+  const x = [u, A - y];
+  let h = 0;
+  for (; x.length > 0; ) {
+    const k = x.pop(), z = x.pop();
+    let P = 0;
+    const S = n[z], M = n[z + 1], b = n[k], E = n[k + 1];
+    for (let v = z + y; v < k; v += y) {
+      const G = n[v], H = n[v + 1], B = I(G, H, S, M, b, E);
+      B > P && (h = v, P = B);
+    }
+    P > D && (g[(h - u) / y] = 1, z + y < h && x.push(z, h), h + y < k && x.push(h, k));
+  }
+  for (let k = 0; k < w; ++k)
+    g[k] && (q[c++] = n[u + k * y], q[c++] = n[u + k * y + 1]);
+  return c;
+}
+function N(n, u, A, y, D, q, c, w) {
+  for (let g = 0, x = A.length; g < x; ++g) {
+    const h = A[g];
+    c = J(
+      n,
+      u,
+      h,
+      y,
+      D,
+      q,
+      c
+    ), w.push(c), u = h;
+  }
+  return c;
+}
+function j(n, u) {
+  return u * Math.round(n / u);
+}
+function K(n, u, A, y, D, q, c) {
+  if (u == A)
+    return c;
+  let w = j(n[u], D), g = j(n[u + 1], D);
+  u += y, q[c++] = w, q[c++] = g;
+  let x, h;
+  do
+    if (x = j(n[u], D), h = j(n[u + 1], D), u += y, u == A)
+      return q[c++] = x, q[c++] = h, c;
+  while (x == w && h == g);
+  for (; u < A; ) {
+    const k = j(n[u], D), z = j(n[u + 1], D);
+    if (u += y, k == x && z == h)
+      continue;
+    const P = x - w, S = h - g, M = k - w, b = z - g;
+    if (P * b == S * M && (P < 0 && M < P || P == M || P > 0 && M > P) && (S < 0 && b < S || S == b || S > 0 && b > S)) {
+      x = k, h = z;
+      continue;
+    }
+    q[c++] = x, q[c++] = h, w = x, g = h, x = k, h = z;
+  }
+  return q[c++] = x, q[c++] = h, c;
+}
+function Q(n, u, A, y, D, q, c, w) {
+  for (let g = 0, x = A.length; g < x; ++g) {
+    const h = A[g];
+    c = K(
+      n,
+      u,
+      h,
+      y,
+      D,
+      q,
+      c
+    ), w.push(c), u = h;
+  }
+  return c;
+}
+export {
+  J as douglasPeucker,
+  N as douglasPeuckerArray,
+  K as quantize,
+  Q as quantizeArray,
+  j as snap
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/straightchunk.mjs

@@ -0,0 +1,11 @@
+function E(q, k, e, s, m) {
+  let y = e, d = e, i = 0, t = 0, a = e, M, n, l, h, r, o, x, f, c, u;
+  for (n = e; n < s; n += m) {
+    const g = k[n], p = k[n + 1];
+    r !== void 0 && (c = g - r, u = p - o, h = Math.sqrt(c * c + u * u), x !== void 0 && (t += l, M = Math.acos((x * c + f * u) / (l * h)), M > q && (t > i && (i = t, y = a, d = n), t = 0, a = n - m)), l = h, x = c, f = u), r = g, o = p;
+  }
+  return t += h, t > i ? [a, n] : [y, d];
+}
+export {
+  E as matchingChunk
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/flat/textpath.mjs

@@ -0,0 +1,61 @@
+import { lerp as w } from "../../math.mjs";
+import { rotate as U } from "./transform.mjs";
+function _(b, e, S, m, g, p, H, M, j, z, A, B, J = !0) {
+  let c = b[e], i = b[e + 1], r = 0, u = 0, l = 0, t = 0;
+  function I() {
+    r = c, u = i, e += m, c = b[e], i = b[e + 1], t += l, l = Math.sqrt((c - r) * (c - r) + (i - u) * (i - u));
+  }
+  do
+    I();
+  while (e < S - m && t + l < p);
+  let h = l === 0 ? 0 : (p - t) / l;
+  const X = w(r, c, h), D = w(u, i, h), E = e - m, K = t, Y = p + M * j(z, g, A);
+  for (; e < S - m && t + l < Y; )
+    I();
+  h = l === 0 ? 0 : (Y - t) / l;
+  const k = w(r, c, h), F = w(u, i, h);
+  let y = !1;
+  if (J)
+    if (B) {
+      const n = [X, D, k, F];
+      U(n, 0, 4, 2, B, n, n), y = n[0] > n[2];
+    } else
+      y = X > k;
+  const o = Math.PI, O = [], N = E + m === e;
+  e = E, l = 0, t = K, c = b[e], i = b[e + 1];
+  let s;
+  if (N) {
+    I(), s = Math.atan2(i - u, c - r), y && (s += s > 0 ? -o : o);
+    const n = (k + X) / 2, a = (F + D) / 2;
+    return O[0] = [n, a, (Y - p) / 2, s, g], O;
+  }
+  g = g.replace(/\n/g, " ");
+  for (let n = 0, a = g.length; n < a; ) {
+    I();
+    let L = Math.atan2(i - u, c - r);
+    if (y && (L += L > 0 ? -o : o), s !== void 0) {
+      let v = L - s;
+      if (v += v > o ? -2 * o : v < -o ? 2 * o : 0, Math.abs(v) > H)
+        return null;
+    }
+    s = L;
+    const q = n;
+    let P = 0;
+    for (; n < a; ++n) {
+      const v = y ? a - n - 1 : n, G = M * j(z, g[v], A);
+      if (e + m < S && t + l < p + P + G / 2)
+        break;
+      P += G;
+    }
+    if (n === q)
+      continue;
+    const Q = y ? g.substring(a - q, a - n) : g.substring(q, n);
+    h = l === 0 ? 0 : (p + P / 2 - t) / l;
+    const R = w(r, c, h), T = w(u, i, h);
+    O.push([R, T, P / 2, L, Q]), p += P;
+  }
+  return O;
+}
+export {
+  _ as drawTextOnPath
+};