gisviewer-vue3-arcgis 1.0.281 → 1.0.282

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

@@ -0,0 +1,101 @@
+import { createOrUpdateFromCoordinate as l, containsXY as f } from "../extent.mjs";
+import { squaredDistance as h } from "../math.mjs";
+import c from "./SimpleGeometry.mjs";
+import { deflateCoordinate as C } from "./flat/deflate.mjs";
+class r extends c {
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  constructor(t, e) {
+    super(), this.setCoordinates(t, e);
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Point} Clone.
+   * @api
+   * @override
+   */
+  clone() {
+    const t = new r(this.flatCoordinates.slice(), this.layout);
+    return t.applyProperties(this), t;
+  }
+  /**
+   * @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, i, n) {
+    const s = this.flatCoordinates, a = h(
+      t,
+      e,
+      s[0],
+      s[1]
+    );
+    if (a < n) {
+      const d = this.stride;
+      for (let o = 0; o < d; ++o)
+        i[o] = s[o];
+      return i.length = d, a;
+    }
+    return n;
+  }
+  /**
+   * Return the coordinate of the point.
+   * @return {import("../coordinate.js").Coordinate} Coordinates.
+   * @api
+   * @override
+   */
+  getCoordinates() {
+    return this.flatCoordinates.slice();
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @override
+   */
+  computeExtent(t) {
+    return l(this.flatCoordinates, t);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  getType() {
+    return "Point";
+  }
+  /**
+   * 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 f(t, this.flatCoordinates[0], this.flatCoordinates[1]);
+  }
+  /**
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   * @override
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 0), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = C(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+const y = r;
+export {
+  y as default
+};

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

@@ -0,0 +1,319 @@
+import { extend as C } from "../array.mjs";
+import { isEmpty as m, closestSquaredDistanceXY as _, getCenter as u } from "../extent.mjs";
+import l from "./LinearRing.mjs";
+import c from "./Point.mjs";
+import p from "./SimpleGeometry.mjs";
+import { linearRings as R } from "./flat/area.mjs";
+import { arrayMaxSquaredDelta as F, assignClosestArrayPoint as y } from "./flat/closest.mjs";
+import { linearRingsContainsXY as v } from "./flat/contains.mjs";
+import { deflateCoordinatesArray as P } from "./flat/deflate.mjs";
+import { inflateCoordinatesArray as I } from "./flat/inflate.mjs";
+import { getInteriorPointOfArray as X } from "./flat/interiorpoint.mjs";
+import { intersectsLinearRingArray as Y } from "./flat/intersectsextent.mjs";
+import { orientLinearRings as d, linearRingsAreOriented as w } from "./flat/orient.mjs";
+import { quantizeArray as x } from "./flat/simplify.mjs";
+class o extends p {
+  /**
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>|!Array<number>} coordinates
+   *     Array of linear rings that define the polygon. The first linear ring of the
+   *     array defines the outer-boundary or surface of the polygon. Each subsequent
+   *     linear ring defines a hole in the surface of the polygon. A linear ring is
+   *     an array of vertices' coordinates where the first coordinate and the last are
+   *     equivalent. (For internal use, flat coordinates in combination with
+   *     `layout` and `ends` are also accepted.)
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @param {Array<number>} [ends] Ends (for internal use with flat coordinates).
+   */
+  constructor(t, i, e) {
+    super(), this.ends_ = [], this.flatInteriorPointRevision_ = -1, this.flatInteriorPoint_ = null, this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, this.orientedRevision_ = -1, this.orientedFlatCoordinates_ = null, i !== void 0 && e ? (this.setFlatCoordinates(
+      i,
+      /** @type {Array<number>} */
+      t
+    ), this.ends_ = e) : this.setCoordinates(
+      /** @type {Array<Array<import("../coordinate.js").Coordinate>>} */
+      t,
+      i
+    );
+  }
+  /**
+   * Append the passed linear ring to this polygon.
+   * @param {LinearRing} linearRing Linear ring.
+   * @api
+   */
+  appendLinearRing(t) {
+    this.flatCoordinates ? C(this.flatCoordinates, t.getFlatCoordinates()) : this.flatCoordinates = t.getFlatCoordinates().slice(), this.ends_.push(this.flatCoordinates.length), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!Polygon} Clone.
+   * @api
+   * @override
+   */
+  clone() {
+    const t = new o(
+      this.flatCoordinates.slice(),
+      this.layout,
+      this.ends_.slice()
+    );
+    return t.applyProperties(this), t;
+  }
+  /**
+   * @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, i, e, s) {
+    return s < _(this.getExtent(), t, i) ? s : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      F(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), y(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      i,
+      e,
+      s
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   * @override
+   */
+  containsXY(t, i) {
+    return v(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      i
+    );
+  }
+  /**
+   * Return the area of the polygon on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return R(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride
+    );
+  }
+  /**
+   * Get the coordinate array for this geometry.  This array has the structure
+   * of a GeoJSON coordinate array for polygons.
+   *
+   * @param {boolean} [right] Orient coordinates according to the right-hand
+   *     rule (counter-clockwise for exterior and clockwise for interior rings).
+   *     If `false`, coordinates will be oriented according to the left-hand rule
+   *     (clockwise for exterior and counter-clockwise for interior rings).
+   *     By default, coordinate orientation will depend on how the geometry was
+   *     constructed.
+   * @return {Array<Array<import("../coordinate.js").Coordinate>>} Coordinates.
+   * @api
+   * @override
+   */
+  getCoordinates(t) {
+    let i;
+    return t !== void 0 ? (i = this.getOrientedFlatCoordinates().slice(), d(i, 0, this.ends_, this.stride, t)) : i = this.flatCoordinates, I(i, 0, this.ends_, this.stride);
+  }
+  /**
+   * @return {Array<number>} Ends.
+   */
+  getEnds() {
+    return this.ends_;
+  }
+  /**
+   * @return {Array<number>} Interior point.
+   */
+  getFlatInteriorPoint() {
+    if (this.flatInteriorPointRevision_ != this.getRevision()) {
+      const t = u(this.getExtent());
+      this.flatInteriorPoint_ = X(
+        this.getOrientedFlatCoordinates(),
+        0,
+        this.ends_,
+        this.stride,
+        t,
+        0
+      ), this.flatInteriorPointRevision_ = this.getRevision();
+    }
+    return (
+      /** @type {import("../coordinate.js").Coordinate} */
+      this.flatInteriorPoint_
+    );
+  }
+  /**
+   * Return an interior point of the polygon.
+   * @return {Point} Interior point as XYM coordinate, where M is the
+   * length of the horizontal intersection that the point belongs to.
+   * @api
+   */
+  getInteriorPoint() {
+    return new c(this.getFlatInteriorPoint(), "XYM");
+  }
+  /**
+   * Return the number of rings of the polygon,  this includes the exterior
+   * ring and any interior rings.
+   *
+   * @return {number} Number of rings.
+   * @api
+   */
+  getLinearRingCount() {
+    return this.ends_.length;
+  }
+  /**
+   * Return the Nth linear ring of the polygon geometry. Return `null` if the
+   * given index is out of range.
+   * The exterior linear ring is available at index `0` and the interior rings
+   * at index `1` and beyond.
+   *
+   * @param {number} index Index.
+   * @return {LinearRing|null} Linear ring.
+   * @api
+   */
+  getLinearRing(t) {
+    return t < 0 || this.ends_.length <= t ? null : new l(
+      this.flatCoordinates.slice(
+        t === 0 ? 0 : this.ends_[t - 1],
+        this.ends_[t]
+      ),
+      this.layout
+    );
+  }
+  /**
+   * Return the linear rings of the polygon.
+   * @return {Array<LinearRing>} Linear rings.
+   * @api
+   */
+  getLinearRings() {
+    const t = this.layout, i = this.flatCoordinates, e = this.ends_, s = [];
+    let r = 0;
+    for (let a = 0, f = e.length; a < f; ++a) {
+      const h = e[a], g = new l(
+        i.slice(r, h),
+        t
+      );
+      s.push(g), r = h;
+    }
+    return s;
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      w(t, 0, this.ends_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = d(
+        this.orientedFlatCoordinates_,
+        0,
+        this.ends_,
+        this.stride
+      )), this.orientedRevision_ = this.getRevision();
+    }
+    return (
+      /** @type {Array<number>} */
+      this.orientedFlatCoordinates_
+    );
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {Polygon} Simplified Polygon.
+   * @protected
+   * @override
+   */
+  getSimplifiedGeometryInternal(t) {
+    const i = [], e = [];
+    return i.length = x(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      Math.sqrt(t),
+      i,
+      0,
+      e
+    ), new o(i, "XY", e);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   * @override
+   */
+  getType() {
+    return "Polygon";
+  }
+  /**
+   * 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 Y(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.ends_,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Set the coordinates of the polygon.
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   * @override
+   */
+  setCoordinates(t, i) {
+    this.setLayout(i, t, 2), this.flatCoordinates || (this.flatCoordinates = []);
+    const e = P(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = e.length === 0 ? 0 : e[e.length - 1], this.changed();
+  }
+}
+function B(n) {
+  if (m(n))
+    throw new Error("Cannot create polygon from empty extent");
+  const t = n[0], i = n[1], e = n[2], s = n[3], r = [
+    t,
+    i,
+    t,
+    s,
+    e,
+    s,
+    e,
+    i,
+    t,
+    i
+  ];
+  return new o(r, "XY", [r.length]);
+}
+export {
+  o as default,
+  B as fromExtent
+};

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

@@ -0,0 +1,249 @@
+import { createOrUpdateFromFlatCoordinates as l, getCenter as d } from "../extent.mjs";
+import { abstract as n } from "../util.mjs";
+import h from "./Geometry.mjs";
+import { rotate as f, scale as m, translate as g, transform2D as u } from "./flat/transform.mjs";
+class C extends h {
+  constructor() {
+    super(), this.layout = "XY", this.stride = 2, this.flatCoordinates;
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   * @override
+   */
+  computeExtent(t) {
+    return l(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * @abstract
+   * @return {Array<*> | null} Coordinates.
+   */
+  getCoordinates() {
+    return n();
+  }
+  /**
+   * Return the first coordinate of the geometry.
+   * @return {import("../coordinate.js").Coordinate} First coordinate.
+   * @api
+   */
+  getFirstCoordinate() {
+    return this.flatCoordinates.slice(0, this.stride);
+  }
+  /**
+   * @return {Array<number>} Flat coordinates.
+   */
+  getFlatCoordinates() {
+    return this.flatCoordinates;
+  }
+  /**
+   * Return the last coordinate of the geometry.
+   * @return {import("../coordinate.js").Coordinate} Last point.
+   * @api
+   */
+  getLastCoordinate() {
+    return this.flatCoordinates.slice(
+      this.flatCoordinates.length - this.stride
+    );
+  }
+  /**
+   * Return the {@link import("./Geometry.js").GeometryLayout layout} of the geometry.
+   * @return {import("./Geometry.js").GeometryLayout} Layout.
+   * @api
+   */
+  getLayout() {
+    return this.layout;
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker algorithm.
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {SimpleGeometry} Simplified geometry.
+   * @override
+   */
+  getSimplifiedGeometry(t) {
+    if (this.simplifiedGeometryRevision !== this.getRevision() && (this.simplifiedGeometryMaxMinSquaredTolerance = 0, this.simplifiedGeometryRevision = this.getRevision()), t < 0 || this.simplifiedGeometryMaxMinSquaredTolerance !== 0 && t <= this.simplifiedGeometryMaxMinSquaredTolerance)
+      return this;
+    const e = this.getSimplifiedGeometryInternal(t);
+    return e.getFlatCoordinates().length < this.flatCoordinates.length ? e : (this.simplifiedGeometryMaxMinSquaredTolerance = t, this);
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {SimpleGeometry} Simplified geometry.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    return this;
+  }
+  /**
+   * @return {number} Stride.
+   */
+  getStride() {
+    return this.stride;
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout} layout Layout.
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   */
+  setFlatCoordinates(t, e) {
+    this.stride = a(t), this.layout = t, this.flatCoordinates = e;
+  }
+  /**
+   * @abstract
+   * @param {!Array<*>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   */
+  setCoordinates(t, e) {
+    n();
+  }
+  /**
+   * @param {import("./Geometry.js").GeometryLayout|undefined} layout Layout.
+   * @param {Array<*>} coordinates Coordinates.
+   * @param {number} nesting Nesting.
+   * @protected
+   */
+  setLayout(t, e, i) {
+    let s;
+    if (t)
+      s = a(t);
+    else {
+      for (let o = 0; o < i; ++o) {
+        if (e.length === 0) {
+          this.layout = "XY", this.stride = 2;
+          return;
+        }
+        e = /** @type {Array<unknown>} */
+        e[0];
+      }
+      s = e.length, t = c(s);
+    }
+    this.layout = t, this.stride = s;
+  }
+  /**
+   * 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.
+   * @param {import("../proj.js").TransformFunction} transformFn Transform function.
+   * Called with a flat array of geometry coordinates.
+   * @api
+   * @override
+   */
+  applyTransform(t) {
+    this.flatCoordinates && (t(
+      this.flatCoordinates,
+      this.flatCoordinates,
+      this.layout.startsWith("XYZ") ? 3 : 2,
+      this.stride
+    ), this.changed());
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @param {number} angle Rotation angle in counter-clockwise radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   * @override
+   */
+  rotate(t, e) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const s = this.getStride();
+      f(
+        i,
+        0,
+        i.length,
+        s,
+        t,
+        e,
+        i
+      ), this.changed();
+    }
+  }
+  /**
+   * Scale the geometry (with an optional origin).  This modifies the geometry
+   * coordinates in place.
+   * @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
+   * @override
+   */
+  scale(t, e, i) {
+    e === void 0 && (e = t), i || (i = d(this.getExtent()));
+    const s = this.getFlatCoordinates();
+    if (s) {
+      const o = this.getStride();
+      m(
+        s,
+        0,
+        s.length,
+        o,
+        t,
+        e,
+        i,
+        s
+      ), this.changed();
+    }
+  }
+  /**
+   * Translate the geometry.  This modifies the geometry coordinates in place.  If
+   * instead you want a new geometry, first `clone()` this geometry.
+   * @param {number} deltaX Delta X.
+   * @param {number} deltaY Delta Y.
+   * @api
+   * @override
+   */
+  translate(t, e) {
+    const i = this.getFlatCoordinates();
+    if (i) {
+      const s = this.getStride();
+      g(
+        i,
+        0,
+        i.length,
+        s,
+        t,
+        e,
+        i
+      ), this.changed();
+    }
+  }
+}
+function c(r) {
+  let t;
+  return r == 2 ? t = "XY" : r == 3 ? t = "XYZ" : r == 4 && (t = "XYZM"), /** @type {import("./Geometry.js").GeometryLayout} */
+  t;
+}
+function a(r) {
+  let t;
+  return r == "XY" ? t = 2 : r == "XYZ" || r == "XYM" ? t = 3 : r == "XYZM" && (t = 4), /** @type {number} */
+  t;
+}
+function G(r, t, e) {
+  const i = r.getFlatCoordinates();
+  if (!i)
+    return null;
+  const s = r.getStride();
+  return u(
+    i,
+    0,
+    i.length,
+    s,
+    t,
+    e
+  );
+}
+const M = C;
+export {
+  M as default,
+  c as getLayoutForStride,
+  a as getStrideForLayout,
+  G as transformGeom2D
+};

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

@@ -0,0 +1,22 @@
+function R(c, n, r, i) {
+  let l = 0;
+  const t = c[r - i], x = c[r - i + 1];
+  let u = 0, e = 0;
+  for (; n < r; n += i) {
+    const g = c[n] - t, y = c[n + 1] - x;
+    l += e * g - u * y, u = g, e = y;
+  }
+  return l / 2;
+}
+function h(c, n, r, i) {
+  let l = 0;
+  for (let t = 0, x = r.length; t < x; ++t) {
+    const u = r[t];
+    l += R(c, n, u, i), n = u;
+  }
+  return l;
+}
+export {
+  R as linearRing,
+  h as linearRings
+};

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

@@ -0,0 +1,18 @@
+import { createOrUpdateFromFlatCoordinates as p, createEmpty as s } from "../../extent.mjs";
+function g(a, n, o, l) {
+  const i = [];
+  let t = s();
+  for (let e = 0, c = o.length; e < c; ++e) {
+    const r = o[e];
+    t = p(
+      a,
+      n,
+      r[0],
+      l
+    ), i.push((t[0] + t[2]) / 2, (t[1] + t[3]) / 2), n = r[r.length - 1];
+  }
+  return i;
+}
+export {
+  g as linearRingss
+};