gisviewer-vue3-arcgis 1.0.283 → 1.0.284

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

@@ -1,101 +0,0 @@
-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

@@ -1,319 +0,0 @@
-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

@@ -1,249 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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
-};