gisviewer-vue3-arcgis 1.0.281 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/extent.mjs

@@ -0,0 +1,239 @@
+import u from "./extent/Relationship.mjs";
+function b(i) {
+  const r = C();
+  for (let o = 0, f = i.length; o < f; ++o)
+    A(r, i[o]);
+  return r;
+}
+function d(i, r, o) {
+  return o ? (o[0] = i[0] - r, o[1] = i[1] - r, o[2] = i[2] + r, o[3] = i[3] + r, o) : [
+    i[0] - r,
+    i[1] - r,
+    i[2] + r,
+    i[3] + r
+  ];
+}
+function D(i, r) {
+  return r ? (r[0] = i[0], r[1] = i[1], r[2] = i[2], r[3] = i[3], r) : i.slice();
+}
+function z(i, r, o) {
+  let f, n;
+  return r < i[0] ? f = i[0] - r : i[2] < r ? f = r - i[2] : f = 0, o < i[1] ? n = i[1] - o : i[3] < o ? n = o - i[3] : n = 0, f * f + n * n;
+}
+function J(i, r) {
+  return S(i, r[0], r[1]);
+}
+function P(i, r) {
+  return i[0] <= r[0] && r[2] <= i[2] && i[1] <= r[1] && r[3] <= i[3];
+}
+function S(i, r, o) {
+  return i[0] <= r && r <= i[2] && i[1] <= o && o <= i[3];
+}
+function w(i, r) {
+  const o = i[0], f = i[1], n = i[2], s = i[3], a = r[0], E = r[1];
+  let c = u.UNKNOWN;
+  return a < o ? c = c | u.LEFT : a > n && (c = c | u.RIGHT), E < f ? c = c | u.BELOW : E > s && (c = c | u.ABOVE), c === u.UNKNOWN && (c = u.INTERSECTING), c;
+}
+function C() {
+  return [1 / 0, 1 / 0, -1 / 0, -1 / 0];
+}
+function O(i, r, o, f, n) {
+  return n ? (n[0] = i, n[1] = r, n[2] = o, n[3] = f, n) : [i, r, o, f];
+}
+function N(i) {
+  return O(1 / 0, 1 / 0, -1 / 0, -1 / 0, i);
+}
+function Q(i, r) {
+  const o = i[0], f = i[1];
+  return O(o, f, o, f, r);
+}
+function Z(i, r, o, f, n) {
+  const s = N(n);
+  return B(s, i, r, o, f);
+}
+function _(i, r) {
+  return i[0] == r[0] && i[2] == r[2] && i[1] == r[1] && i[3] == r[3];
+}
+function $(i, r) {
+  return r[0] < i[0] && (i[0] = r[0]), r[2] > i[2] && (i[2] = r[2]), r[1] < i[1] && (i[1] = r[1]), r[3] > i[3] && (i[3] = r[3]), i;
+}
+function A(i, r) {
+  r[0] < i[0] && (i[0] = r[0]), r[0] > i[2] && (i[2] = r[0]), r[1] < i[1] && (i[1] = r[1]), r[1] > i[3] && (i[3] = r[1]);
+}
+function B(i, r, o, f, n) {
+  for (; o < f; o += n)
+    L(i, r[o], r[o + 1]);
+  return i;
+}
+function L(i, r, o) {
+  i[0] = Math.min(i[0], r), i[1] = Math.min(i[1], o), i[2] = Math.max(i[2], r), i[3] = Math.max(i[3], o);
+}
+function j(i, r) {
+  let o;
+  return o = r(M(i)), o || (o = r(X(i)), o) || (o = r(W(i)), o) || (o = r(F(i)), o) ? o : !1;
+}
+function k(i) {
+  let r = 0;
+  return H(i) || (r = T(i) * G(i)), r;
+}
+function M(i) {
+  return [i[0], i[1]];
+}
+function X(i) {
+  return [i[2], i[1]];
+}
+function U(i) {
+  return [(i[0] + i[2]) / 2, (i[1] + i[3]) / 2];
+}
+function v(i, r) {
+  let o;
+  if (r === "bottom-left")
+    o = M(i);
+  else if (r === "bottom-right")
+    o = X(i);
+  else if (r === "top-left")
+    o = F(i);
+  else if (r === "top-right")
+    o = W(i);
+  else
+    throw new Error("Invalid corner");
+  return o;
+}
+function t(i, r, o, f, n) {
+  const [s, a, E, c, h, g, p, l] = Y(
+    i,
+    r,
+    o,
+    f
+  );
+  return O(
+    Math.min(s, E, h, p),
+    Math.min(a, c, g, l),
+    Math.max(s, E, h, p),
+    Math.max(a, c, g, l),
+    n
+  );
+}
+function Y(i, r, o, f) {
+  const n = r * f[0] / 2, s = r * f[1] / 2, a = Math.cos(o), E = Math.sin(o), c = n * a, h = n * E, g = s * a, p = s * E, l = i[0], m = i[1];
+  return [
+    l - c + p,
+    m - h - g,
+    l - c - p,
+    m - h + g,
+    l + c - p,
+    m + h + g,
+    l + c + p,
+    m + h - g,
+    l - c + p,
+    m - h - g
+  ];
+}
+function G(i) {
+  return i[3] - i[1];
+}
+function x(i, r, o) {
+  const f = o || C();
+  return V(i, r) ? (i[0] > r[0] ? f[0] = i[0] : f[0] = r[0], i[1] > r[1] ? f[1] = i[1] : f[1] = r[1], i[2] < r[2] ? f[2] = i[2] : f[2] = r[2], i[3] < r[3] ? f[3] = i[3] : f[3] = r[3]) : N(f), f;
+}
+function F(i) {
+  return [i[0], i[3]];
+}
+function W(i) {
+  return [i[2], i[3]];
+}
+function T(i) {
+  return i[2] - i[0];
+}
+function V(i, r) {
+  return i[0] <= r[2] && i[2] >= r[0] && i[1] <= r[3] && i[3] >= r[1];
+}
+function H(i) {
+  return i[2] < i[0] || i[3] < i[1];
+}
+function e(i, r) {
+  return r ? (r[0] = i[0], r[1] = i[1], r[2] = i[2], r[3] = i[3], r) : i;
+}
+function ii(i, r, o) {
+  let f = !1;
+  const n = w(i, r), s = w(i, o);
+  if (n === u.INTERSECTING || s === u.INTERSECTING)
+    f = !0;
+  else {
+    const a = i[0], E = i[1], c = i[2], h = i[3], g = r[0], p = r[1], l = o[0], m = o[1], R = (m - p) / (l - g);
+    let y, I;
+    s & u.ABOVE && !(n & u.ABOVE) && (y = l - (m - h) / R, f = y >= a && y <= c), !f && s & u.RIGHT && !(n & u.RIGHT) && (I = m - (l - c) * R, f = I >= E && I <= h), !f && s & u.BELOW && !(n & u.BELOW) && (y = l - (m - E) / R, f = y >= a && y <= c), !f && s & u.LEFT && !(n & u.LEFT) && (I = m - (l - a) * R, f = I >= E && I <= h);
+  }
+  return f;
+}
+function q(i, r) {
+  const o = r.getExtent(), f = U(i);
+  if (r.canWrapX() && (f[0] < o[0] || f[0] >= o[2])) {
+    const n = T(o), a = Math.floor(
+      (f[0] - o[0]) / n
+    ) * n;
+    i[0] -= a, i[2] -= a;
+  }
+  return i;
+}
+function ri(i, r, o) {
+  if (r.canWrapX()) {
+    const f = r.getExtent();
+    if (!isFinite(i[0]) || !isFinite(i[2]))
+      return [[f[0], i[1], f[2], i[3]]];
+    q(i, r);
+    const n = T(f);
+    if (T(i) > n && !o)
+      return [[f[0], i[1], f[2], i[3]]];
+    if (i[0] < f[0])
+      return [
+        [i[0] + n, i[1], f[2], i[3]],
+        [f[0], i[1], i[2], i[3]]
+      ];
+    if (i[2] > f[2])
+      return [
+        [i[0], i[1], f[2], i[3]],
+        [f[0], i[1], i[2] - n, i[3]]
+      ];
+  }
+  return [i];
+}
+export {
+  b as boundingExtent,
+  d as buffer,
+  D as clone,
+  z as closestSquaredDistanceXY,
+  J as containsCoordinate,
+  P as containsExtent,
+  S as containsXY,
+  w as coordinateRelationship,
+  C as createEmpty,
+  O as createOrUpdate,
+  N as createOrUpdateEmpty,
+  Q as createOrUpdateFromCoordinate,
+  Z as createOrUpdateFromFlatCoordinates,
+  _ as equals,
+  $ as extend,
+  A as extendCoordinate,
+  B as extendFlatCoordinates,
+  L as extendXY,
+  j as forEachCorner,
+  k as getArea,
+  M as getBottomLeft,
+  X as getBottomRight,
+  U as getCenter,
+  v as getCorner,
+  t as getForViewAndSize,
+  G as getHeight,
+  x as getIntersection,
+  Y as getRotatedViewport,
+  F as getTopLeft,
+  W as getTopRight,
+  T as getWidth,
+  V as intersects,
+  ii as intersectsSegment,
+  H as isEmpty,
+  e as returnOrUpdate,
+  ri as wrapAndSliceX,
+  q as wrapX
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/featureloader.mjs

@@ -0,0 +1,54 @@
+let p = !1;
+function c(r, n, o, d, i, a, t) {
+  const e = new XMLHttpRequest();
+  e.open(
+    "GET",
+    typeof r == "function" ? r(o, d, i) : r,
+    !0
+  ), n.getType() == "arraybuffer" && (e.responseType = "arraybuffer"), e.withCredentials = p, e.onload = function(u) {
+    if (!e.status || e.status >= 200 && e.status < 300) {
+      const f = n.getType();
+      try {
+        let s;
+        f == "text" || f == "json" ? s = e.responseText : f == "xml" ? s = e.responseXML || e.responseText : f == "arraybuffer" && (s = /** @type {ArrayBuffer} */
+        e.response), s ? a(
+          /** @type {Array<FeatureType>} */
+          n.readFeatures(s, {
+            extent: o,
+            featureProjection: i
+          }),
+          n.readProjection(s)
+        ) : t();
+      } catch {
+        t();
+      }
+    } else
+      t();
+  }, e.onerror = t, e.send();
+}
+function h(r, n) {
+  return function(o, d, i, a, t) {
+    c(
+      r,
+      n,
+      o,
+      d,
+      i,
+      /**
+       * @param {Array<FeatureType>} features The loaded features.
+       * @param {import("./proj/Projection.js").default} dataProjection Data
+       * projection.
+       */
+      (e, u) => {
+        this.addFeatures(e), a !== void 0 && a(e);
+      },
+      () => {
+        this.changed(), t !== void 0 && t();
+      }
+    );
+  };
+}
+export {
+  c as loadFeaturesXhr,
+  h as xhr
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/functions.mjs

@@ -0,0 +1,35 @@
+import { equals as i } from "./array.mjs";
+function u() {
+  return !0;
+}
+function l() {
+  return !1;
+}
+function c() {
+}
+function a(n) {
+  let e, t, r;
+  return function() {
+    const s = Array.prototype.slice.call(arguments);
+    return (!t || this !== r || !i(s, t)) && (r = this, t = s, e = n.apply(this, arguments)), e;
+  };
+}
+function f(n) {
+  function e() {
+    let t;
+    try {
+      t = n();
+    } catch (r) {
+      return Promise.reject(r);
+    }
+    return t instanceof Promise ? t : Promise.resolve(t);
+  }
+  return e();
+}
+export {
+  l as FALSE,
+  u as TRUE,
+  c as VOID,
+  a as memoizeOne,
+  f as toPromise
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/Geometry.mjs

@@ -0,0 +1,235 @@
+import y from "../Object.mjs";
+import { createEmpty as g, createOrUpdateEmpty as d, returnOrUpdate as N, getHeight as f } from "../extent.mjs";
+import { memoizeOne as E } from "../functions.mjs";
+import { get as T, getTransform as l } from "../proj.mjs";
+import { compose as v, create as G } from "../transform.mjs";
+import { abstract as n } from "../util.mjs";
+import { transform2D as R } from "./flat/transform.mjs";
+const u = G(), _ = [NaN, NaN];
+class S extends y {
+  constructor() {
+    super(), this.extent_ = g(), this.extentRevision_ = -1, this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = 0, this.simplifyTransformedInternal = E(
+      (t, e, r) => {
+        if (!r)
+          return this.getSimplifiedGeometry(e);
+        const i = this.clone();
+        return i.applyTransform(r), i.getSimplifiedGeometry(e);
+      }
+    );
+  }
+  /**
+   * Get a transformed and simplified version of the geometry.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @param {import("../proj.js").TransformFunction} [transform] Optional transform function.
+   * @return {Geometry} Simplified geometry.
+   */
+  simplifyTransformed(t, e) {
+    return this.simplifyTransformedInternal(
+      this.getRevision(),
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @abstract
+   * @return {!Geometry} Clone.
+   */
+  clone() {
+    return n();
+  }
+  /**
+   * @abstract
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   */
+  closestPointXY(t, e, r, i) {
+    return n();
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    return this.closestPointXY(t, e, _, Number.MIN_VALUE) === 0;
+  }
+  /**
+   * Return the closest point of the geometry to the passed point as
+   * {@link module:ol/coordinate~Coordinate coordinate}.
+   * @param {import("../coordinate.js").Coordinate} point Point.
+   * @param {import("../coordinate.js").Coordinate} [closestPoint] Closest point.
+   * @return {import("../coordinate.js").Coordinate} Closest point.
+   * @api
+   */
+  getClosestPoint(t, e) {
+    return e = e || [NaN, NaN], this.closestPointXY(t[0], t[1], e, 1 / 0), e;
+  }
+  /**
+   * Returns true if this geometry includes the specified coordinate. If the
+   * coordinate is on the boundary of the geometry, returns false.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @return {boolean} Contains coordinate.
+   * @api
+   */
+  intersectsCoordinate(t) {
+    return this.containsXY(t[0], t[1]);
+  }
+  /**
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    return n();
+  }
+  /**
+   * Get the extent of the geometry.
+   * @param {import("../extent.js").Extent} [extent] Extent.
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  getExtent(t) {
+    if (this.extentRevision_ != this.getRevision()) {
+      const e = this.computeExtent(this.extent_);
+      (isNaN(e[0]) || isNaN(e[1])) && d(e), this.extentRevision_ = this.getRevision();
+    }
+    return N(this.extent_, t);
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} angle Rotation angle in radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    n();
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @abstract
+   * @param {number} sx The scaling factor in the x-direction.
+   * @param {number} [sy] The scaling factor in the y-direction (defaults to sx).
+   * @param {import("../coordinate.js").Coordinate} [anchor] The scale origin (defaults to the center
+   *     of the geometry extent).
+   * @api
+   */
+  scale(t, e, r) {
+    n();
+  }
+  /**
+   * Create a simplified version of this geometry.  For linestrings, this uses
+   * the [Douglas Peucker](https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)
+   * algorithm.  For polygons, a quantization-based
+   * simplification is used to preserve topology.
+   * @param {number} tolerance The tolerance distance for simplification.
+   * @return {Geometry} A new, simplified version of the original geometry.
+   * @api
+   */
+  simplify(t) {
+    return this.getSimplifiedGeometry(t * t);
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker
+   * algorithm.
+   * See https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm.
+   * @abstract
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Geometry} Simplified geometry.
+   */
+  getSimplifiedGeometry(t) {
+    return n();
+  }
+  /**
+   * Get the type of this geometry.
+   * @abstract
+   * @return {Type} Geometry type.
+   */
+  getType() {
+    return n();
+  }
+  /**
+   * Apply a transform function to the coordinates of the geometry.
+   * The geometry is modified in place.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   * @abstract
+   * @param {import("../proj.js").TransformFunction} transformFn Transform function.
+   * Called with a flat array of geometry coordinates.
+   */
+  applyTransform(t) {
+    n();
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @abstract
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   */
+  intersectsExtent(t) {
+    return n();
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @abstract
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   */
+  translate(t, e) {
+    n();
+  }
+  /**
+   * Transform each coordinate of the geometry from one coordinate reference
+   * system to another. The geometry is modified in place.
+   * For example, a line will be transformed to a line and a circle to a circle.
+   * If you do not want the geometry modified in place, first `clone()` it and
+   * then use this function on the clone.
+   *
+   * @param {import("../proj.js").ProjectionLike} source The current projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @param {import("../proj.js").ProjectionLike} destination The desired projection.  Can be a
+   *     string identifier or a {@link module:ol/proj/Projection~Projection} object.
+   * @return {this} This geometry.  Note that original geometry is
+   *     modified in place.
+   * @api
+   */
+  transform(t, e) {
+    const r = T(t), i = r.getUnits() == "tile-pixels" ? function(m, h, a) {
+      const x = r.getExtent(), s = r.getWorldExtent(), p = f(s) / f(x);
+      v(
+        u,
+        s[0],
+        s[3],
+        p,
+        -p,
+        0,
+        0,
+        0
+      );
+      const o = R(
+        m,
+        0,
+        m.length,
+        a,
+        u,
+        h
+      ), c = l(r, e);
+      return c ? c(o, o, a) : o;
+    } : l(r, e);
+    return this.applyTransform(i), this;
+  }
+}
+const P = S;
+export {
+  P as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/geom/LinearRing.mjs

@@ -0,0 +1,147 @@
+import { closestSquaredDistanceXY as o } from "../extent.mjs";
+import a from "./SimpleGeometry.mjs";
+import { linearRing as n } from "./flat/area.mjs";
+import { maxSquaredDelta as l, assignClosestPoint as h } from "./flat/closest.mjs";
+import { deflateCoordinates as d } from "./flat/deflate.mjs";
+import { inflateCoordinates as f } from "./flat/inflate.mjs";
+import { douglasPeucker as m } from "./flat/simplify.mjs";
+class i extends a {
+  /**
+   * @param {Array<import("../coordinate.js").Coordinate>|Array<number>} coordinates Coordinates.
+   *     For internal use, flat coordinates in combination with `layout` are also accepted.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, e !== void 0 && !Array.isArray(t[0]) ? this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ) : this.setCoordinates(
+      /** @type {Array<import("../coordinate.js").Coordinate>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!LinearRing} Clone.
+   * @api
+   * @override
+   */
+  clone() {
+    return new i(this.flatCoordinates.slice(), this.layout);
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {import("../coordinate.js").Coordinate} closestPoint Closest point.
+   * @param {number} minSquaredDistance Minimum squared distance.
+   * @return {number} Minimum squared distance.
+   * @override
+   */
+  closestPointXY(t, e, r, s) {
+    return s < o(this.getExtent(), t, e) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      l(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), h(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      r,
+      s
+    ));
+  }
+  /**
+   * Return the area of the linear ring on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return n(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * Return the coordinates of the linear ring.
+   * @return {Array<import("../coordinate.js").Coordinate>} Coordinates.
+   * @api
+   * @override
+   */
+  getCoordinates() {
+    return f(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {LinearRing} Simplified LinearRing.
+   * @protected
+   * @override
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [];
+    return e.length = m(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      0
+    ), new i(e, "XY");
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  getType() {
+    return "LinearRing";
+  }
+  /**
+   * Test if the geometry and the passed extent intersect.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {boolean} `true` if the geometry and the extent intersect.
+   * @api
+   * @override
+   */
+  intersectsExtent(t) {
+    return !1;
+  }
+  /**
+   * Set the coordinates of the linear ring.
+   * @param {!Array<import("../coordinate.js").Coordinate>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   * @override
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = d(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+const D = i;
+export {
+  D as default
+};