@hybridcore/ui 1.6.13 → 1.6.14

package/dist/WKT-2wsDT-nq.js

@@ -0,0 +1,2310 @@
+import { B as Q, u as X, l as U, E as Z, a as V, b as g, c as tt, d as b, e as y, s as et } from "./math-Bvt2Ubuz.js";
+import { c as x, e as st, d as R, h as T, m as it, i as nt, j as rt, k as H, l as ot, n as at, o as K, p as ht, q as lt, r as ut, s as ct, u as dt, v as gt, P as I, w as ft, x as mt, y as yt, z as _t, A as pt, B as Ct, C as Tt, D as Y, E as Pt, F as Et, G as Gt, H as xt, I as O, J as Mt, K as Ft, M as Lt, N as Rt, O as wt, Q as At } from "./Source-BSZST_GH.js";
+import { l as Nt } from "./Vector-DfTqQEln.js";
+class M extends Q {
+  /**
+   * @param {Geometry|ObjectWithGeometry<Geometry>} [geometryOrProperties]
+   *     You may pass a Geometry object directly, or an object literal containing
+   *     properties. If you pass an object literal, you may include a Geometry
+   *     associated with a `geometry` key.
+   */
+  constructor(t) {
+    if (super(), this.on, this.once, this.un, this.id_ = void 0, this.geometryName_ = "geometry", this.style_ = null, this.styleFunction_ = void 0, this.geometryChangeKey_ = null, this.addChangeListener(this.geometryName_, this.handleGeometryChanged_), t)
+      if (typeof /** @type {?} */
+      t.getSimplifiedGeometry == "function") {
+        const e = (
+          /** @type {Geometry} */
+          t
+        );
+        this.setGeometry(e);
+      } else {
+        const e = t;
+        this.setProperties(e);
+      }
+  }
+  /**
+   * Clone this feature. If the original feature has a geometry it
+   * is also cloned. The feature id is not set in the clone.
+   * @return {Feature<Geometry>} The clone.
+   * @api
+   */
+  clone() {
+    const t = (
+      /** @type {Feature<Geometry>} */
+      new M(this.hasProperties() ? this.getProperties() : null)
+    );
+    t.setGeometryName(this.getGeometryName());
+    const e = this.getGeometry();
+    e && t.setGeometry(
+      /** @type {Geometry} */
+      e.clone()
+    );
+    const s = this.getStyle();
+    return s && t.setStyle(s), t;
+  }
+  /**
+   * Get the feature's default geometry.  A feature may have any number of named
+   * geometries.  The "default" geometry (the one that is rendered by default) is
+   * set when calling {@link module:ol/Feature~Feature#setGeometry}.
+   * @return {Geometry|undefined} The default geometry for the feature.
+   * @api
+   * @observable
+   */
+  getGeometry() {
+    return (
+      /** @type {Geometry|undefined} */
+      this.get(this.geometryName_)
+    );
+  }
+  /**
+   * Get the feature identifier.  This is a stable identifier for the feature and
+   * is either set when reading data from a remote source or set explicitly by
+   * calling {@link module:ol/Feature~Feature#setId}.
+   * @return {number|string|undefined} Id.
+   * @api
+   */
+  getId() {
+    return this.id_;
+  }
+  /**
+   * Get the name of the feature's default geometry.  By default, the default
+   * geometry is named `geometry`.
+   * @return {string} Get the property name associated with the default geometry
+   *     for this feature.
+   * @api
+   */
+  getGeometryName() {
+    return this.geometryName_;
+  }
+  /**
+   * Get the feature's style. Will return what was provided to the
+   * {@link module:ol/Feature~Feature#setStyle} method.
+   * @return {import("./style/Style.js").StyleLike|undefined} The feature style.
+   * @api
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * Get the feature's style function.
+   * @return {import("./style/Style.js").StyleFunction|undefined} Return a function
+   * representing the current style of this feature.
+   * @api
+   */
+  getStyleFunction() {
+    return this.styleFunction_;
+  }
+  /**
+   * @private
+   */
+  handleGeometryChange_() {
+    this.changed();
+  }
+  /**
+   * @private
+   */
+  handleGeometryChanged_() {
+    this.geometryChangeKey_ && (X(this.geometryChangeKey_), this.geometryChangeKey_ = null);
+    const t = this.getGeometry();
+    t && (this.geometryChangeKey_ = U(
+      t,
+      Z.CHANGE,
+      this.handleGeometryChange_,
+      this
+    )), this.changed();
+  }
+  /**
+   * Set the default geometry for the feature.  This will update the property
+   * with the name returned by {@link module:ol/Feature~Feature#getGeometryName}.
+   * @param {Geometry|undefined} geometry The new geometry.
+   * @api
+   * @observable
+   */
+  setGeometry(t) {
+    this.set(this.geometryName_, t);
+  }
+  /**
+   * Set the style for the feature to override the layer style.  This can be a
+   * single style object, an array of styles, or a function that takes a
+   * resolution and returns an array of styles. To unset the feature style, call
+   * `setStyle()` without arguments or a falsey value.
+   * @param {import("./style/Style.js").StyleLike} [style] Style for this feature.
+   * @api
+   * @fires module:ol/events/Event~BaseEvent#event:change
+   */
+  setStyle(t) {
+    this.style_ = t, this.styleFunction_ = t ? It(t) : void 0, this.changed();
+  }
+  /**
+   * Set the feature id.  The feature id is considered stable and may be used when
+   * requesting features or comparing identifiers returned from a remote source.
+   * The feature id can be used with the
+   * {@link module:ol/source/Vector~VectorSource#getFeatureById} method.
+   * @param {number|string|undefined} id The feature id.
+   * @api
+   * @fires module:ol/events/Event~BaseEvent#event:change
+   */
+  setId(t) {
+    this.id_ = t, this.changed();
+  }
+  /**
+   * Set the property name to be used when getting the feature's default geometry.
+   * When calling {@link module:ol/Feature~Feature#getGeometry}, the value of the property with
+   * this name will be returned.
+   * @param {string} name The property name of the default geometry.
+   * @api
+   */
+  setGeometryName(t) {
+    this.removeChangeListener(this.geometryName_, this.handleGeometryChanged_), this.geometryName_ = t, this.addChangeListener(this.geometryName_, this.handleGeometryChanged_), this.handleGeometryChanged_();
+  }
+}
+function It(r) {
+  if (typeof r == "function")
+    return r;
+  let t;
+  return Array.isArray(r) ? t = r : (V(typeof /** @type {?} */
+  r.getZIndex == "function", 41), t = [
+    /** @type {import("./style/Style.js").default} */
+    r
+  ]), function() {
+    return t;
+  };
+}
+class Ot {
+  constructor() {
+    this.dataProjection = void 0, this.defaultFeatureProjection = void 0, this.supportedMediaTypes = null;
+  }
+  /**
+   * Adds the data projection to the read options.
+   * @param {Document|Element|Object|string} source Source.
+   * @param {ReadOptions} [options] Options.
+   * @return {ReadOptions|undefined} Options.
+   * @protected
+   */
+  getReadOptions(t, e) {
+    if (e) {
+      let s = e.dataProjection ? x(e.dataProjection) : this.readProjection(t);
+      e.extent && s && s.getUnits() === "tile-pixels" && (s = x(s), s.setWorldExtent(e.extent)), e = {
+        dataProjection: s,
+        featureProjection: e.featureProjection
+      };
+    }
+    return this.adaptOptions(e);
+  }
+  /**
+   * Sets the `dataProjection` on the options, if no `dataProjection`
+   * is set.
+   * @param {WriteOptions|ReadOptions|undefined} options
+   *     Options.
+   * @protected
+   * @return {WriteOptions|ReadOptions|undefined}
+   *     Updated options.
+   */
+  adaptOptions(t) {
+    return Object.assign(
+      {
+        dataProjection: this.dataProjection,
+        featureProjection: this.defaultFeatureProjection
+      },
+      t
+    );
+  }
+  /**
+   * @abstract
+   * @return {Type} The format type.
+   */
+  getType() {
+    return g();
+  }
+  /**
+   * Read a single feature from a source.
+   *
+   * @abstract
+   * @param {Document|Element|Object|string} source Source.
+   * @param {ReadOptions} [options] Read options.
+   * @return {import("../Feature.js").FeatureLike} Feature.
+   */
+  readFeature(t, e) {
+    return g();
+  }
+  /**
+   * Read all features from a source.
+   *
+   * @abstract
+   * @param {Document|Element|ArrayBuffer|Object|string} source Source.
+   * @param {ReadOptions} [options] Read options.
+   * @return {Array<import("../Feature.js").FeatureLike>} Features.
+   */
+  readFeatures(t, e) {
+    return g();
+  }
+  /**
+   * Read a single geometry from a source.
+   *
+   * @abstract
+   * @param {Document|Element|Object|string} source Source.
+   * @param {ReadOptions} [options] Read options.
+   * @return {import("../geom/Geometry.js").default} Geometry.
+   */
+  readGeometry(t, e) {
+    return g();
+  }
+  /**
+   * Read the projection from a source.
+   *
+   * @abstract
+   * @param {Document|Element|Object|string} source Source.
+   * @return {import("../proj/Projection.js").default|undefined} Projection.
+   */
+  readProjection(t) {
+    return g();
+  }
+  /**
+   * Encode a feature in this format.
+   *
+   * @abstract
+   * @param {import("../Feature.js").default} feature Feature.
+   * @param {WriteOptions} [options] Write options.
+   * @return {string|ArrayBuffer} Result.
+   */
+  writeFeature(t, e) {
+    return g();
+  }
+  /**
+   * Encode an array of features in this format.
+   *
+   * @abstract
+   * @param {Array<import("../Feature.js").default>} features Features.
+   * @param {WriteOptions} [options] Write options.
+   * @return {string|ArrayBuffer} Result.
+   */
+  writeFeatures(t, e) {
+    return g();
+  }
+  /**
+   * Write a single geometry in this format.
+   *
+   * @abstract
+   * @param {import("../geom/Geometry.js").default} geometry Geometry.
+   * @param {WriteOptions} [options] Write options.
+   * @return {string|ArrayBuffer} Result.
+   */
+  writeGeometry(t, e) {
+    return g();
+  }
+}
+function k(r, t, e) {
+  const s = e ? x(e.featureProjection) : null, i = e ? x(e.dataProjection) : null;
+  let n;
+  if (s && i && !st(s, i) ? n = (t ? r.clone() : r).transform(
+    t ? s : i,
+    t ? i : s
+  ) : n = r, t && e && /** @type {WriteOptions} */
+  e.decimals !== void 0) {
+    const o = Math.pow(
+      10,
+      /** @type {WriteOptions} */
+      e.decimals
+    ), a = function(h) {
+      for (let c = 0, l = h.length; c < l; ++c)
+        h[c] = Math.round(h[c] * o) / o;
+      return h;
+    };
+    n === r && (n = r.clone()), n.applyTransform(a);
+  }
+  return n;
+}
+function D(r, t, e, s, i, n, o) {
+  let a, h;
+  const c = (e - t) / s;
+  if (c === 1)
+    a = t;
+  else if (c === 2)
+    a = t, h = i;
+  else if (c !== 0) {
+    let l = r[t], f = r[t + 1], d = 0;
+    const m = [0];
+    for (let E = t + s; E < e; E += s) {
+      const A = r[E], N = r[E + 1];
+      d += Math.sqrt((A - l) * (A - l) + (N - f) * (N - f)), m.push(d), l = A, f = N;
+    }
+    const P = i * d, _ = tt(m, P);
+    _ < 0 ? (h = (P - m[-_ - 2]) / (m[-_ - 1] - m[-_ - 2]), a = t + (-_ - 2) * s) : a = t + _ * s;
+  }
+  o = o > 1 ? o : 2, n = n || new Array(o);
+  for (let l = 0; l < o; ++l)
+    n[l] = a === void 0 ? NaN : h === void 0 ? r[a + l] : b(r[a + l], r[a + s + l], h);
+  return n;
+}
+function v(r, t, e, s, i, n) {
+  if (e == t)
+    return null;
+  let o;
+  if (i < r[t + s - 1])
+    return n ? (o = r.slice(t, t + s), o[s - 1] = i, o) : null;
+  if (r[e - 1] < i)
+    return n ? (o = r.slice(e - s, e), o[s - 1] = i, o) : null;
+  if (i == r[t + s - 1])
+    return r.slice(t, t + s);
+  let a = t / s, h = e / s;
+  for (; a < h; ) {
+    const d = a + h >> 1;
+    i < r[(d + 1) * s - 1] ? h = d : a = d + 1;
+  }
+  const c = r[a * s - 1];
+  if (i == c)
+    return r.slice((a - 1) * s, (a - 1) * s + s);
+  const l = r[(a + 1) * s - 1], f = (i - c) / (l - c);
+  o = [];
+  for (let d = 0; d < s - 1; ++d)
+    o.push(
+      b(
+        r[(a - 1) * s + d],
+        r[a * s + d],
+        f
+      )
+    );
+  return o.push(i), o;
+}
+function vt(r, t, e, s, i, n, o) {
+  if (o)
+    return v(
+      r,
+      t,
+      e[e.length - 1],
+      s,
+      i,
+      n
+    );
+  let a;
+  if (i < r[s - 1])
+    return n ? (a = r.slice(0, s), a[s - 1] = i, a) : null;
+  if (r[r.length - 1] < i)
+    return n ? (a = r.slice(r.length - s), a[s - 1] = i, a) : null;
+  for (let h = 0, c = e.length; h < c; ++h) {
+    const l = e[h];
+    if (t != l) {
+      if (i < r[t + s - 1])
+        return null;
+      if (i <= r[l - 1])
+        return v(
+          r,
+          t,
+          l,
+          s,
+          i,
+          !1
+        );
+      t = l;
+    }
+  }
+  return null;
+}
+class p extends R {
+  /**
+   * @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.flatMidpoint_ = null, this.flatMidpointRevision_ = -1, 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
+    );
+  }
+  /**
+   * Append the passed coordinate to the coordinates of the linestring.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @api
+   */
+  appendCoordinate(t) {
+    this.flatCoordinates ? y(this.flatCoordinates, t) : this.flatCoordinates = t.slice(), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!LineString} Clone.
+   * @api
+   */
+  clone() {
+    const t = new p(
+      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.
+   */
+  closestPointXY(t, e, s, i) {
+    return i < T(this.getExtent(), t, e) ? i : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      it(
+        this.flatCoordinates,
+        0,
+        this.flatCoordinates.length,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), nt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      this.maxDelta_,
+      !1,
+      t,
+      e,
+      s,
+      i
+    ));
+  }
+  /**
+   * Iterate over each segment, calling the provided callback.
+   * If the callback returns a truthy value the function returns that
+   * value immediately. Otherwise the function returns `false`.
+   *
+   * @param {function(this: S, import("../coordinate.js").Coordinate, import("../coordinate.js").Coordinate): T} callback Function
+   *     called for each segment. The function will receive two arguments, the start and end coordinates of the segment.
+   * @return {T|boolean} Value.
+   * @template T,S
+   * @api
+   */
+  forEachSegment(t) {
+    return rt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Returns the coordinate at `m` using linear interpolation, or `null` if no
+   * such coordinate exists.
+   *
+   * `extrapolate` controls extrapolation beyond the range of Ms in the
+   * MultiLineString. If `extrapolate` is `true` then Ms less than the first
+   * M will return the first coordinate and Ms greater than the last M will
+   * return the last coordinate.
+   *
+   * @param {number} m M.
+   * @param {boolean} [extrapolate] Extrapolate. Default is `false`.
+   * @return {import("../coordinate.js").Coordinate|null} Coordinate.
+   * @api
+   */
+  getCoordinateAtM(t, e) {
+    return this.layout != "XYM" && this.layout != "XYZM" ? null : (e = e !== void 0 ? e : !1, v(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e
+    ));
+  }
+  /**
+   * Return the coordinates of the linestring.
+   * @return {Array<import("../coordinate.js").Coordinate>} Coordinates.
+   * @api
+   */
+  getCoordinates() {
+    return H(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * Return the coordinate at the provided fraction along the linestring.
+   * The `fraction` is a number between 0 and 1, where 0 is the start of the
+   * linestring and 1 is the end.
+   * @param {number} fraction Fraction.
+   * @param {import("../coordinate.js").Coordinate} [dest] Optional coordinate whose values will
+   *     be modified. If not provided, a new coordinate will be returned.
+   * @return {import("../coordinate.js").Coordinate} Coordinate of the interpolated point.
+   * @api
+   */
+  getCoordinateAt(t, e) {
+    return D(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      this.stride
+    );
+  }
+  /**
+   * Return the length of the linestring on projected plane.
+   * @return {number} Length (on projected plane).
+   * @api
+   */
+  getLength() {
+    return Nt(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * @return {Array<number>} Flat midpoint.
+   */
+  getFlatMidpoint() {
+    return this.flatMidpointRevision_ != this.getRevision() && (this.flatMidpoint_ = this.getCoordinateAt(0.5, this.flatMidpoint_), this.flatMidpointRevision_ = this.getRevision()), this.flatMidpoint_;
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {LineString} Simplified LineString.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [];
+    return e.length = ot(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t,
+      e,
+      0
+    ), new p(e, "XY");
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "LineString";
+  }
+  /**
+   * 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
+   */
+  intersectsExtent(t) {
+    return at(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Set the coordinates of the linestring.
+   * @param {!Array<import("../coordinate.js").Coordinate>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = K(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+class F extends R {
+  /**
+   * @param {Array<Array<import("../coordinate.js").Coordinate>|LineString>|Array<number>} coordinates
+   *     Coordinates or LineString geometries. (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] Flat coordinate ends for internal use.
+   */
+  constructor(t, e, s) {
+    if (super(), this.ends_ = [], this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, Array.isArray(t[0]))
+      this.setCoordinates(
+        /** @type {Array<Array<import("../coordinate.js").Coordinate>>} */
+        t,
+        e
+      );
+    else if (e !== void 0 && s)
+      this.setFlatCoordinates(
+        e,
+        /** @type {Array<number>} */
+        t
+      ), this.ends_ = s;
+    else {
+      let i = this.getLayout();
+      const n = (
+        /** @type {Array<LineString>} */
+        t
+      ), o = [], a = [];
+      for (let h = 0, c = n.length; h < c; ++h) {
+        const l = n[h];
+        h === 0 && (i = l.getLayout()), y(o, l.getFlatCoordinates()), a.push(o.length);
+      }
+      this.setFlatCoordinates(i, o), this.ends_ = a;
+    }
+  }
+  /**
+   * Append the passed linestring to the multilinestring.
+   * @param {LineString} lineString LineString.
+   * @api
+   */
+  appendLineString(t) {
+    this.flatCoordinates ? y(this.flatCoordinates, t.getFlatCoordinates().slice()) : this.flatCoordinates = t.getFlatCoordinates().slice(), this.ends_.push(this.flatCoordinates.length), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!MultiLineString} Clone.
+   * @api
+   */
+  clone() {
+    const t = new F(
+      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.
+   */
+  closestPointXY(t, e, s, i) {
+    return i < T(this.getExtent(), t, e) ? i : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      ht(
+        this.flatCoordinates,
+        0,
+        this.ends_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), lt(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      this.maxDelta_,
+      !1,
+      t,
+      e,
+      s,
+      i
+    ));
+  }
+  /**
+   * Returns the coordinate at `m` using linear interpolation, or `null` if no
+   * such coordinate exists.
+   *
+   * `extrapolate` controls extrapolation beyond the range of Ms in the
+   * MultiLineString. If `extrapolate` is `true` then Ms less than the first
+   * M will return the first coordinate and Ms greater than the last M will
+   * return the last coordinate.
+   *
+   * `interpolate` controls interpolation between consecutive LineStrings
+   * within the MultiLineString. If `interpolate` is `true` the coordinates
+   * will be linearly interpolated between the last coordinate of one LineString
+   * and the first coordinate of the next LineString.  If `interpolate` is
+   * `false` then the function will return `null` for Ms falling between
+   * LineStrings.
+   *
+   * @param {number} m M.
+   * @param {boolean} [extrapolate] Extrapolate. Default is `false`.
+   * @param {boolean} [interpolate] Interpolate. Default is `false`.
+   * @return {import("../coordinate.js").Coordinate|null} Coordinate.
+   * @api
+   */
+  getCoordinateAtM(t, e, s) {
+    return this.layout != "XYM" && this.layout != "XYZM" || this.flatCoordinates.length === 0 ? null : (e = e !== void 0 ? e : !1, s = s !== void 0 ? s : !1, vt(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      e,
+      s
+    ));
+  }
+  /**
+   * Return the coordinates of the multilinestring.
+   * @return {Array<Array<import("../coordinate.js").Coordinate>>} Coordinates.
+   * @api
+   */
+  getCoordinates() {
+    return ut(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride
+    );
+  }
+  /**
+   * @return {Array<number>} Ends.
+   */
+  getEnds() {
+    return this.ends_;
+  }
+  /**
+   * Return the linestring at the specified index.
+   * @param {number} index Index.
+   * @return {LineString} LineString.
+   * @api
+   */
+  getLineString(t) {
+    return t < 0 || this.ends_.length <= t ? null : new p(
+      this.flatCoordinates.slice(
+        t === 0 ? 0 : this.ends_[t - 1],
+        this.ends_[t]
+      ),
+      this.layout
+    );
+  }
+  /**
+   * Return the linestrings of this multilinestring.
+   * @return {Array<LineString>} LineStrings.
+   * @api
+   */
+  getLineStrings() {
+    const t = this.flatCoordinates, e = this.ends_, s = this.layout, i = [];
+    let n = 0;
+    for (let o = 0, a = e.length; o < a; ++o) {
+      const h = e[o], c = new p(
+        t.slice(n, h),
+        s
+      );
+      i.push(c), n = h;
+    }
+    return i;
+  }
+  /**
+   * @return {Array<number>} Flat midpoints.
+   */
+  getFlatMidpoints() {
+    const t = [], e = this.flatCoordinates;
+    let s = 0;
+    const i = this.ends_, n = this.stride;
+    for (let o = 0, a = i.length; o < a; ++o) {
+      const h = i[o], c = D(
+        e,
+        s,
+        h,
+        n,
+        0.5
+      );
+      y(t, c), s = h;
+    }
+    return t;
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {MultiLineString} Simplified MultiLineString.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [], s = [];
+    return e.length = ct(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      t,
+      e,
+      0,
+      s
+    ), new F(e, "XY", s);
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "MultiLineString";
+  }
+  /**
+   * 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
+   */
+  intersectsExtent(t) {
+    return dt(
+      this.flatCoordinates,
+      0,
+      this.ends_,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Set the coordinates of the multilinestring.
+   * @param {!Array<Array<import("../coordinate.js").Coordinate>>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 2), this.flatCoordinates || (this.flatCoordinates = []);
+    const s = gt(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.ends_
+    );
+    this.flatCoordinates.length = s.length === 0 ? 0 : s[s.length - 1], this.changed();
+  }
+}
+class w extends R {
+  /**
+   * @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(), e && !Array.isArray(t[0]) ? this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ) : this.setCoordinates(
+      /** @type {Array<import("../coordinate.js").Coordinate>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Append the passed point to this multipoint.
+   * @param {Point} point Point.
+   * @api
+   */
+  appendPoint(t) {
+    this.flatCoordinates ? y(this.flatCoordinates, t.getFlatCoordinates()) : this.flatCoordinates = t.getFlatCoordinates().slice(), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!MultiPoint} Clone.
+   * @api
+   */
+  clone() {
+    const t = new w(
+      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.
+   */
+  closestPointXY(t, e, s, i) {
+    if (i < T(this.getExtent(), t, e))
+      return i;
+    const n = this.flatCoordinates, o = this.stride;
+    for (let a = 0, h = n.length; a < h; a += o) {
+      const c = et(
+        t,
+        e,
+        n[a],
+        n[a + 1]
+      );
+      if (c < i) {
+        i = c;
+        for (let l = 0; l < o; ++l)
+          s[l] = n[a + l];
+        s.length = o;
+      }
+    }
+    return i;
+  }
+  /**
+   * Return the coordinates of the multipoint.
+   * @return {Array<import("../coordinate.js").Coordinate>} Coordinates.
+   * @api
+   */
+  getCoordinates() {
+    return H(
+      this.flatCoordinates,
+      0,
+      this.flatCoordinates.length,
+      this.stride
+    );
+  }
+  /**
+   * Return the point at the specified index.
+   * @param {number} index Index.
+   * @return {Point} Point.
+   * @api
+   */
+  getPoint(t) {
+    const e = this.flatCoordinates ? this.flatCoordinates.length / this.stride : 0;
+    return t < 0 || e <= t ? null : new I(
+      this.flatCoordinates.slice(
+        t * this.stride,
+        (t + 1) * this.stride
+      ),
+      this.layout
+    );
+  }
+  /**
+   * Return the points of this multipoint.
+   * @return {Array<Point>} Points.
+   * @api
+   */
+  getPoints() {
+    const t = this.flatCoordinates, e = this.layout, s = this.stride, i = [];
+    for (let n = 0, o = t.length; n < o; n += s) {
+      const a = new I(t.slice(n, n + s), e);
+      i.push(a);
+    }
+    return i;
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "MultiPoint";
+  }
+  /**
+   * 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
+   */
+  intersectsExtent(t) {
+    const e = this.flatCoordinates, s = this.stride;
+    for (let i = 0, n = e.length; i < n; i += s) {
+      const o = e[i], a = e[i + 1];
+      if (ft(t, o, a))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Set the coordinates of the multipoint.
+   * @param {!Array<import("../coordinate.js").Coordinate>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 1), this.flatCoordinates || (this.flatCoordinates = []), this.flatCoordinates.length = K(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride
+    ), this.changed();
+  }
+}
+function St(r, t, e, s) {
+  const i = [];
+  let n = yt();
+  for (let o = 0, a = e.length; o < a; ++o) {
+    const h = e[o];
+    n = mt(
+      r,
+      t,
+      h[0],
+      s
+    ), i.push((n[0] + n[2]) / 2, (n[1] + n[3]) / 2), t = h[h.length - 1];
+  }
+  return i;
+}
+class L extends R {
+  /**
+   * @param {Array<Array<Array<import("../coordinate.js").Coordinate>>|Polygon>|Array<number>} coordinates Coordinates.
+   *     For internal use, flat coordinates in combination with `layout` and `endss` are also accepted.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @param {Array<Array<number>>} [endss] Array of ends for internal use with flat coordinates.
+   */
+  constructor(t, e, s) {
+    if (super(), this.endss_ = [], this.flatInteriorPointsRevision_ = -1, this.flatInteriorPoints_ = null, this.maxDelta_ = -1, this.maxDeltaRevision_ = -1, this.orientedRevision_ = -1, this.orientedFlatCoordinates_ = null, !s && !Array.isArray(t[0])) {
+      let i = this.getLayout();
+      const n = (
+        /** @type {Array<Polygon>} */
+        t
+      ), o = [], a = [];
+      for (let h = 0, c = n.length; h < c; ++h) {
+        const l = n[h];
+        h === 0 && (i = l.getLayout());
+        const f = o.length, d = l.getEnds();
+        for (let m = 0, P = d.length; m < P; ++m)
+          d[m] += f;
+        y(o, l.getFlatCoordinates()), a.push(d);
+      }
+      e = i, t = o, s = a;
+    }
+    e !== void 0 && s ? (this.setFlatCoordinates(
+      e,
+      /** @type {Array<number>} */
+      t
+    ), this.endss_ = s) : this.setCoordinates(
+      /** @type {Array<Array<Array<import("../coordinate.js").Coordinate>>>} */
+      t,
+      e
+    );
+  }
+  /**
+   * Append the passed polygon to this multipolygon.
+   * @param {Polygon} polygon Polygon.
+   * @api
+   */
+  appendPolygon(t) {
+    let e;
+    if (!this.flatCoordinates)
+      this.flatCoordinates = t.getFlatCoordinates().slice(), e = t.getEnds().slice(), this.endss_.push();
+    else {
+      const s = this.flatCoordinates.length;
+      y(this.flatCoordinates, t.getFlatCoordinates()), e = t.getEnds().slice();
+      for (let i = 0, n = e.length; i < n; ++i)
+        e[i] += s;
+    }
+    this.endss_.push(e), this.changed();
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!MultiPolygon} Clone.
+   * @api
+   */
+  clone() {
+    const t = this.endss_.length, e = new Array(t);
+    for (let i = 0; i < t; ++i)
+      e[i] = this.endss_[i].slice();
+    const s = new L(
+      this.flatCoordinates.slice(),
+      this.layout,
+      e
+    );
+    return s.applyProperties(this), s;
+  }
+  /**
+   * @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, s, i) {
+    return i < T(this.getExtent(), t, e) ? i : (this.maxDeltaRevision_ != this.getRevision() && (this.maxDelta_ = Math.sqrt(
+      _t(
+        this.flatCoordinates,
+        0,
+        this.endss_,
+        this.stride,
+        0
+      )
+    ), this.maxDeltaRevision_ = this.getRevision()), pt(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.endss_,
+      this.stride,
+      this.maxDelta_,
+      !0,
+      t,
+      e,
+      s,
+      i
+    ));
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    return Ct(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.endss_,
+      this.stride,
+      t,
+      e
+    );
+  }
+  /**
+   * Return the area of the multipolygon on projected plane.
+   * @return {number} Area (on projected plane).
+   * @api
+   */
+  getArea() {
+    return Tt(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.endss_,
+      this.stride
+    );
+  }
+  /**
+   * Get the coordinate array for this geometry.  This array has the structure
+   * of a GeoJSON coordinate array for multi-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<Array<import("../coordinate.js").Coordinate>>>} Coordinates.
+   * @api
+   */
+  getCoordinates(t) {
+    let e;
+    return t !== void 0 ? (e = this.getOrientedFlatCoordinates().slice(), Y(
+      e,
+      0,
+      this.endss_,
+      this.stride,
+      t
+    )) : e = this.flatCoordinates, Pt(
+      e,
+      0,
+      this.endss_,
+      this.stride
+    );
+  }
+  /**
+   * @return {Array<Array<number>>} Endss.
+   */
+  getEndss() {
+    return this.endss_;
+  }
+  /**
+   * @return {Array<number>} Flat interior points.
+   */
+  getFlatInteriorPoints() {
+    if (this.flatInteriorPointsRevision_ != this.getRevision()) {
+      const t = St(
+        this.flatCoordinates,
+        0,
+        this.endss_,
+        this.stride
+      );
+      this.flatInteriorPoints_ = Et(
+        this.getOrientedFlatCoordinates(),
+        0,
+        this.endss_,
+        this.stride,
+        t
+      ), this.flatInteriorPointsRevision_ = this.getRevision();
+    }
+    return this.flatInteriorPoints_;
+  }
+  /**
+   * Return the interior points as {@link module:ol/geom/MultiPoint~MultiPoint multipoint}.
+   * @return {MultiPoint} Interior points as XYM coordinates, where M is
+   * the length of the horizontal intersection that the point belongs to.
+   * @api
+   */
+  getInteriorPoints() {
+    return new w(this.getFlatInteriorPoints().slice(), "XYM");
+  }
+  /**
+   * @return {Array<number>} Oriented flat coordinates.
+   */
+  getOrientedFlatCoordinates() {
+    if (this.orientedRevision_ != this.getRevision()) {
+      const t = this.flatCoordinates;
+      Gt(t, 0, this.endss_, this.stride) ? this.orientedFlatCoordinates_ = t : (this.orientedFlatCoordinates_ = t.slice(), this.orientedFlatCoordinates_.length = Y(
+        this.orientedFlatCoordinates_,
+        0,
+        this.endss_,
+        this.stride
+      )), this.orientedRevision_ = this.getRevision();
+    }
+    return this.orientedFlatCoordinates_;
+  }
+  /**
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {MultiPolygon} Simplified MultiPolygon.
+   * @protected
+   */
+  getSimplifiedGeometryInternal(t) {
+    const e = [], s = [];
+    return e.length = xt(
+      this.flatCoordinates,
+      0,
+      this.endss_,
+      this.stride,
+      Math.sqrt(t),
+      e,
+      0,
+      s
+    ), new L(e, "XY", s);
+  }
+  /**
+   * Return the polygon at the specified index.
+   * @param {number} index Index.
+   * @return {Polygon} Polygon.
+   * @api
+   */
+  getPolygon(t) {
+    if (t < 0 || this.endss_.length <= t)
+      return null;
+    let e;
+    if (t === 0)
+      e = 0;
+    else {
+      const n = this.endss_[t - 1];
+      e = n[n.length - 1];
+    }
+    const s = this.endss_[t].slice(), i = s[s.length - 1];
+    if (e !== 0)
+      for (let n = 0, o = s.length; n < o; ++n)
+        s[n] -= e;
+    return new O(
+      this.flatCoordinates.slice(e, i),
+      this.layout,
+      s
+    );
+  }
+  /**
+   * Return the polygons of this multipolygon.
+   * @return {Array<Polygon>} Polygons.
+   * @api
+   */
+  getPolygons() {
+    const t = this.layout, e = this.flatCoordinates, s = this.endss_, i = [];
+    let n = 0;
+    for (let o = 0, a = s.length; o < a; ++o) {
+      const h = s[o].slice(), c = h[h.length - 1];
+      if (n !== 0)
+        for (let f = 0, d = h.length; f < d; ++f)
+          h[f] -= n;
+      const l = new O(
+        e.slice(n, c),
+        t,
+        h
+      );
+      i.push(l), n = c;
+    }
+    return i;
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "MultiPolygon";
+  }
+  /**
+   * 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
+   */
+  intersectsExtent(t) {
+    return Mt(
+      this.getOrientedFlatCoordinates(),
+      0,
+      this.endss_,
+      this.stride,
+      t
+    );
+  }
+  /**
+   * Set the coordinates of the multipolygon.
+   * @param {!Array<Array<Array<import("../coordinate.js").Coordinate>>>} coordinates Coordinates.
+   * @param {import("./Geometry.js").GeometryLayout} [layout] Layout.
+   * @api
+   */
+  setCoordinates(t, e) {
+    this.setLayout(e, t, 3), this.flatCoordinates || (this.flatCoordinates = []);
+    const s = Ft(
+      this.flatCoordinates,
+      0,
+      t,
+      this.stride,
+      this.endss_
+    );
+    if (s.length === 0)
+      this.flatCoordinates.length = 0;
+    else {
+      const i = s[s.length - 1];
+      this.flatCoordinates.length = i.length === 0 ? 0 : i[i.length - 1];
+    }
+    this.changed();
+  }
+}
+class C extends Lt {
+  /**
+   * @param {Array<Geometry>} [geometries] Geometries.
+   */
+  constructor(t) {
+    super(), this.geometries_ = t || null, this.changeEventsKeys_ = [], this.listenGeometriesChange_();
+  }
+  /**
+   * @private
+   */
+  unlistenGeometriesChange_() {
+    this.changeEventsKeys_.forEach(X), this.changeEventsKeys_.length = 0;
+  }
+  /**
+   * @private
+   */
+  listenGeometriesChange_() {
+    if (this.geometries_)
+      for (let t = 0, e = this.geometries_.length; t < e; ++t)
+        this.changeEventsKeys_.push(
+          U(this.geometries_[t], Z.CHANGE, this.changed, this)
+        );
+  }
+  /**
+   * Make a complete copy of the geometry.
+   * @return {!GeometryCollection} Clone.
+   * @api
+   */
+  clone() {
+    const t = new C(null);
+    return t.setGeometries(this.geometries_), 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.
+   */
+  closestPointXY(t, e, s, i) {
+    if (i < T(this.getExtent(), t, e))
+      return i;
+    const n = this.geometries_;
+    for (let o = 0, a = n.length; o < a; ++o)
+      i = n[o].closestPointXY(
+        t,
+        e,
+        s,
+        i
+      );
+    return i;
+  }
+  /**
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @return {boolean} Contains (x, y).
+   */
+  containsXY(t, e) {
+    const s = this.geometries_;
+    for (let i = 0, n = s.length; i < n; ++i)
+      if (s[i].containsXY(t, e))
+        return !0;
+    return !1;
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @protected
+   * @return {import("../extent.js").Extent} extent Extent.
+   */
+  computeExtent(t) {
+    Rt(t);
+    const e = this.geometries_;
+    for (let s = 0, i = e.length; s < i; ++s)
+      wt(t, e[s].getExtent());
+    return t;
+  }
+  /**
+   * Return the geometries that make up this geometry collection.
+   * @return {Array<Geometry>} Geometries.
+   * @api
+   */
+  getGeometries() {
+    return j(this.geometries_);
+  }
+  /**
+   * @return {Array<Geometry>} Geometries.
+   */
+  getGeometriesArray() {
+    return this.geometries_;
+  }
+  /**
+   * @return {Array<Geometry>} Geometries.
+   */
+  getGeometriesArrayRecursive() {
+    let t = [];
+    const e = this.geometries_;
+    for (let s = 0, i = e.length; s < i; ++s)
+      e[s].getType() === this.getType() ? t = t.concat(
+        /** @type {GeometryCollection} */
+        e[s].getGeometriesArrayRecursive()
+      ) : t.push(e[s]);
+    return t;
+  }
+  /**
+   * Create a simplified version of this geometry using the Douglas Peucker algorithm.
+   * @param {number} squaredTolerance Squared tolerance.
+   * @return {GeometryCollection} Simplified GeometryCollection.
+   */
+  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 = [], s = this.geometries_;
+    let i = !1;
+    for (let n = 0, o = s.length; n < o; ++n) {
+      const a = s[n], h = a.getSimplifiedGeometry(t);
+      e.push(h), h !== a && (i = !0);
+    }
+    if (i) {
+      const n = new C(null);
+      return n.setGeometriesArray(e), n;
+    }
+    return this.simplifiedGeometryMaxMinSquaredTolerance = t, this;
+  }
+  /**
+   * Get the type of this geometry.
+   * @return {import("./Geometry.js").Type} Geometry type.
+   * @api
+   */
+  getType() {
+    return "GeometryCollection";
+  }
+  /**
+   * 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
+   */
+  intersectsExtent(t) {
+    const e = this.geometries_;
+    for (let s = 0, i = e.length; s < i; ++s)
+      if (e[s].intersectsExtent(t))
+        return !0;
+    return !1;
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return this.geometries_.length === 0;
+  }
+  /**
+   * Rotate the geometry around a given coordinate. This modifies the geometry
+   * coordinates in place.
+   * @param {number} angle Rotation angle in radians.
+   * @param {import("../coordinate.js").Coordinate} anchor The rotation center.
+   * @api
+   */
+  rotate(t, e) {
+    const s = this.geometries_;
+    for (let i = 0, n = s.length; i < n; ++i)
+      s[i].rotate(t, e);
+    this.changed();
+  }
+  /**
+   * 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, s) {
+    s || (s = At(this.getExtent()));
+    const i = this.geometries_;
+    for (let n = 0, o = i.length; n < o; ++n)
+      i[n].scale(t, e, s);
+    this.changed();
+  }
+  /**
+   * Set the geometries that make up this geometry collection.
+   * @param {Array<Geometry>} geometries Geometries.
+   * @api
+   */
+  setGeometries(t) {
+    this.setGeometriesArray(j(t));
+  }
+  /**
+   * @param {Array<Geometry>} geometries Geometries.
+   */
+  setGeometriesArray(t) {
+    this.unlistenGeometriesChange_(), this.geometries_ = t, this.listenGeometriesChange_(), this.changed();
+  }
+  /**
+   * 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
+   */
+  applyTransform(t) {
+    const e = this.geometries_;
+    for (let s = 0, i = e.length; s < i; ++s)
+      e[s].applyTransform(t);
+    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
+   */
+  translate(t, e) {
+    const s = this.geometries_;
+    for (let i = 0, n = s.length; i < n; ++i)
+      s[i].translate(t, e);
+    this.changed();
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.unlistenGeometriesChange_(), super.disposeInternal();
+  }
+}
+function j(r) {
+  const t = [];
+  for (let e = 0, s = r.length; e < s; ++e)
+    t.push(r[e].clone());
+  return t;
+}
+class Yt extends Ot {
+  constructor() {
+    super();
+  }
+  /**
+   * @return {import("./Feature.js").Type} Format.
+   */
+  getType() {
+    return "text";
+  }
+  /**
+   * Read the feature from the source.
+   *
+   * @param {Document|Element|Object|string} source Source.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @return {import("../Feature.js").default} Feature.
+   * @api
+   */
+  readFeature(t, e) {
+    return this.readFeatureFromText(
+      G(t),
+      this.adaptOptions(e)
+    );
+  }
+  /**
+   * @abstract
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @protected
+   * @return {import("../Feature.js").default} Feature.
+   */
+  readFeatureFromText(t, e) {
+    return g();
+  }
+  /**
+   * Read the features from the source.
+   *
+   * @param {Document|Element|Object|string} source Source.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @return {Array<import("../Feature.js").default>} Features.
+   * @api
+   */
+  readFeatures(t, e) {
+    return this.readFeaturesFromText(
+      G(t),
+      this.adaptOptions(e)
+    );
+  }
+  /**
+   * @abstract
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @protected
+   * @return {Array<import("../Feature.js").default>} Features.
+   */
+  readFeaturesFromText(t, e) {
+    return g();
+  }
+  /**
+   * Read the geometry from the source.
+   *
+   * @param {Document|Element|Object|string} source Source.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @return {import("../geom/Geometry.js").default} Geometry.
+   * @api
+   */
+  readGeometry(t, e) {
+    return this.readGeometryFromText(
+      G(t),
+      this.adaptOptions(e)
+    );
+  }
+  /**
+   * @abstract
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @protected
+   * @return {import("../geom/Geometry.js").default} Geometry.
+   */
+  readGeometryFromText(t, e) {
+    return g();
+  }
+  /**
+   * Read the projection from the source.
+   *
+   * @param {Document|Element|Object|string} source Source.
+   * @return {import("../proj/Projection.js").default|undefined} Projection.
+   * @api
+   */
+  readProjection(t) {
+    return this.readProjectionFromText(G(t));
+  }
+  /**
+   * @param {string} text Text.
+   * @protected
+   * @return {import("../proj/Projection.js").default|undefined} Projection.
+   */
+  readProjectionFromText(t) {
+    return this.dataProjection;
+  }
+  /**
+   * Encode a feature as a string.
+   *
+   * @param {import("../Feature.js").default} feature Feature.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @return {string} Encoded feature.
+   * @api
+   */
+  writeFeature(t, e) {
+    return this.writeFeatureText(t, this.adaptOptions(e));
+  }
+  /**
+   * @abstract
+   * @param {import("../Feature.js").default} feature Features.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeFeatureText(t, e) {
+    return g();
+  }
+  /**
+   * Encode an array of features as string.
+   *
+   * @param {Array<import("../Feature.js").default>} features Features.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @return {string} Encoded features.
+   * @api
+   */
+  writeFeatures(t, e) {
+    return this.writeFeaturesText(t, this.adaptOptions(e));
+  }
+  /**
+   * @abstract
+   * @param {Array<import("../Feature.js").default>} features Features.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeFeaturesText(t, e) {
+    return g();
+  }
+  /**
+   * Write a single geometry.
+   *
+   * @param {import("../geom/Geometry.js").default} geometry Geometry.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @return {string} Geometry.
+   * @api
+   */
+  writeGeometry(t, e) {
+    return this.writeGeometryText(t, this.adaptOptions(e));
+  }
+  /**
+   * @abstract
+   * @param {import("../geom/Geometry.js").default} geometry Geometry.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeGeometryText(t, e) {
+    return g();
+  }
+}
+function G(r) {
+  return typeof r == "string" ? r : "";
+}
+const kt = {
+  POINT: I,
+  LINESTRING: p,
+  POLYGON: O,
+  MULTIPOINT: w,
+  MULTILINESTRING: F,
+  MULTIPOLYGON: L
+}, B = "EMPTY", W = "Z", z = "M", jt = "ZM", u = {
+  START: 0,
+  TEXT: 1,
+  LEFT_PAREN: 2,
+  RIGHT_PAREN: 3,
+  NUMBER: 4,
+  COMMA: 5,
+  EOF: 6
+}, Xt = {
+  Point: "POINT",
+  LineString: "LINESTRING",
+  Polygon: "POLYGON",
+  MultiPoint: "MULTIPOINT",
+  MultiLineString: "MULTILINESTRING",
+  MultiPolygon: "MULTIPOLYGON",
+  GeometryCollection: "GEOMETRYCOLLECTION",
+  Circle: "CIRCLE"
+};
+class Ut {
+  /**
+   * @param {string} wkt WKT string.
+   */
+  constructor(t) {
+    this.wkt = t, this.index_ = -1;
+  }
+  /**
+   * @param {string} c Character.
+   * @return {boolean} Whether the character is alphabetic.
+   * @private
+   */
+  isAlpha_(t) {
+    return t >= "a" && t <= "z" || t >= "A" && t <= "Z";
+  }
+  /**
+   * @param {string} c Character.
+   * @param {boolean} [decimal] Whether the string number
+   *     contains a dot, i.e. is a decimal number.
+   * @return {boolean} Whether the character is numeric.
+   * @private
+   */
+  isNumeric_(t, e) {
+    return e = e !== void 0 ? e : !1, t >= "0" && t <= "9" || t == "." && !e;
+  }
+  /**
+   * @param {string} c Character.
+   * @return {boolean} Whether the character is whitespace.
+   * @private
+   */
+  isWhiteSpace_(t) {
+    return t == " " || t == "	" || t == "\r" || t == `
+`;
+  }
+  /**
+   * @return {string} Next string character.
+   * @private
+   */
+  nextChar_() {
+    return this.wkt.charAt(++this.index_);
+  }
+  /**
+   * Fetch and return the next token.
+   * @return {Token} Next string token.
+   */
+  nextToken() {
+    const t = this.nextChar_(), e = this.index_;
+    let s = t, i;
+    if (t == "(")
+      i = u.LEFT_PAREN;
+    else if (t == ",")
+      i = u.COMMA;
+    else if (t == ")")
+      i = u.RIGHT_PAREN;
+    else if (this.isNumeric_(t) || t == "-")
+      i = u.NUMBER, s = this.readNumber_();
+    else if (this.isAlpha_(t))
+      i = u.TEXT, s = this.readText_();
+    else {
+      if (this.isWhiteSpace_(t))
+        return this.nextToken();
+      if (t === "")
+        i = u.EOF;
+      else
+        throw new Error("Unexpected character: " + t);
+    }
+    return { position: e, value: s, type: i };
+  }
+  /**
+   * @return {number} Numeric token value.
+   * @private
+   */
+  readNumber_() {
+    let t;
+    const e = this.index_;
+    let s = !1, i = !1;
+    do
+      t == "." ? s = !0 : (t == "e" || t == "E") && (i = !0), t = this.nextChar_();
+    while (this.isNumeric_(t, s) || // if we haven't detected a scientific number before, 'e' or 'E'
+    // hint that we should continue to read
+    !i && (t == "e" || t == "E") || // once we know that we have a scientific number, both '-' and '+'
+    // are allowed
+    i && (t == "-" || t == "+"));
+    return parseFloat(this.wkt.substring(e, this.index_--));
+  }
+  /**
+   * @return {string} String token value.
+   * @private
+   */
+  readText_() {
+    let t;
+    const e = this.index_;
+    do
+      t = this.nextChar_();
+    while (this.isAlpha_(t));
+    return this.wkt.substring(e, this.index_--).toUpperCase();
+  }
+}
+class Zt {
+  /**
+   * @param {Lexer} lexer The lexer.
+   */
+  constructor(t) {
+    this.lexer_ = t, this.token_ = {
+      position: 0,
+      type: u.START
+    }, this.layout_ = "XY";
+  }
+  /**
+   * Fetch the next token form the lexer and replace the active token.
+   * @private
+   */
+  consume_() {
+    this.token_ = this.lexer_.nextToken();
+  }
+  /**
+   * Tests if the given type matches the type of the current token.
+   * @param {TokenType} type Token type.
+   * @return {boolean} Whether the token matches the given type.
+   */
+  isTokenType(t) {
+    return this.token_.type == t;
+  }
+  /**
+   * If the given type matches the current token, consume it.
+   * @param {TokenType} type Token type.
+   * @return {boolean} Whether the token matches the given type.
+   */
+  match(t) {
+    const e = this.isTokenType(t);
+    return e && this.consume_(), e;
+  }
+  /**
+   * Try to parse the tokens provided by the lexer.
+   * @return {import("../geom/Geometry.js").default} The geometry.
+   */
+  parse() {
+    return this.consume_(), this.parseGeometry_();
+  }
+  /**
+   * Try to parse the dimensional info.
+   * @return {import("../geom/Geometry.js").GeometryLayout} The layout.
+   * @private
+   */
+  parseGeometryLayout_() {
+    let t = "XY";
+    const e = this.token_;
+    if (this.isTokenType(u.TEXT)) {
+      const s = e.value;
+      s === W ? t = "XYZ" : s === z ? t = "XYM" : s === jt && (t = "XYZM"), t !== "XY" && this.consume_();
+    }
+    return t;
+  }
+  /**
+   * @return {Array<import("../geom/Geometry.js").default>} A collection of geometries.
+   * @private
+   */
+  parseGeometryCollectionText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = [];
+      do
+        t.push(this.parseGeometry_());
+      while (this.match(u.COMMA));
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<number>} All values in a point.
+   * @private
+   */
+  parsePointText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = this.parsePoint_();
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<number>>} All points in a linestring.
+   * @private
+   */
+  parseLineStringText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = this.parsePointList_();
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<Array<number>>>} All points in a polygon.
+   * @private
+   */
+  parsePolygonText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = this.parseLineStringTextList_();
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<number>>} All points in a multipoint.
+   * @private
+   */
+  parseMultiPointText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      let t;
+      if (this.token_.type == u.LEFT_PAREN ? t = this.parsePointTextList_() : t = this.parsePointList_(), this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<Array<number>>>} All linestring points
+   *                                          in a multilinestring.
+   * @private
+   */
+  parseMultiLineStringText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = this.parseLineStringTextList_();
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<Array<Array<number>>>>} All polygon points in a multipolygon.
+   * @private
+   */
+  parseMultiPolygonText_() {
+    if (this.match(u.LEFT_PAREN)) {
+      const t = this.parsePolygonTextList_();
+      if (this.match(u.RIGHT_PAREN))
+        return t;
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<number>} A point.
+   * @private
+   */
+  parsePoint_() {
+    const t = [], e = this.layout_.length;
+    for (let s = 0; s < e; ++s) {
+      const i = this.token_;
+      if (this.match(u.NUMBER))
+        t.push(
+          /** @type {number} */
+          i.value
+        );
+      else
+        break;
+    }
+    if (t.length == e)
+      return t;
+    throw new Error(this.formatErrorMessage_());
+  }
+  /**
+   * @return {Array<Array<number>>} An array of points.
+   * @private
+   */
+  parsePointList_() {
+    const t = [this.parsePoint_()];
+    for (; this.match(u.COMMA); )
+      t.push(this.parsePoint_());
+    return t;
+  }
+  /**
+   * @return {Array<Array<number>>} An array of points.
+   * @private
+   */
+  parsePointTextList_() {
+    const t = [this.parsePointText_()];
+    for (; this.match(u.COMMA); )
+      t.push(this.parsePointText_());
+    return t;
+  }
+  /**
+   * @return {Array<Array<Array<number>>>} An array of points.
+   * @private
+   */
+  parseLineStringTextList_() {
+    const t = [this.parseLineStringText_()];
+    for (; this.match(u.COMMA); )
+      t.push(this.parseLineStringText_());
+    return t;
+  }
+  /**
+   * @return {Array<Array<Array<Array<number>>>>} An array of points.
+   * @private
+   */
+  parsePolygonTextList_() {
+    const t = [this.parsePolygonText_()];
+    for (; this.match(u.COMMA); )
+      t.push(this.parsePolygonText_());
+    return t;
+  }
+  /**
+   * @return {boolean} Whether the token implies an empty geometry.
+   * @private
+   */
+  isEmptyGeometry_() {
+    const t = this.isTokenType(u.TEXT) && this.token_.value == B;
+    return t && this.consume_(), t;
+  }
+  /**
+   * Create an error message for an unexpected token error.
+   * @return {string} Error message.
+   * @private
+   */
+  formatErrorMessage_() {
+    return "Unexpected `" + this.token_.value + "` at position " + this.token_.position + " in `" + this.lexer_.wkt + "`";
+  }
+  /**
+   * @return {import("../geom/Geometry.js").default} The geometry.
+   * @private
+   */
+  parseGeometry_() {
+    const t = this.token_;
+    if (this.match(u.TEXT)) {
+      const e = (
+        /** @type {string} */
+        t.value
+      );
+      this.layout_ = this.parseGeometryLayout_();
+      const s = this.isEmptyGeometry_();
+      if (e == "GEOMETRYCOLLECTION") {
+        if (s)
+          return new C([]);
+        const o = this.parseGeometryCollectionText_();
+        return new C(o);
+      }
+      const i = kt[e];
+      if (!i)
+        throw new Error("Invalid geometry type: " + e);
+      let n;
+      if (s)
+        e == "POINT" ? n = [NaN, NaN] : n = [];
+      else
+        switch (e) {
+          case "POINT": {
+            n = this.parsePointText_();
+            break;
+          }
+          case "LINESTRING": {
+            n = this.parseLineStringText_();
+            break;
+          }
+          case "POLYGON": {
+            n = this.parsePolygonText_();
+            break;
+          }
+          case "MULTIPOINT": {
+            n = this.parseMultiPointText_();
+            break;
+          }
+          case "MULTILINESTRING": {
+            n = this.parseMultiLineStringText_();
+            break;
+          }
+          case "MULTIPOLYGON": {
+            n = this.parseMultiPolygonText_();
+            break;
+          }
+        }
+      return new i(n, this.layout_);
+    }
+    throw new Error(this.formatErrorMessage_());
+  }
+}
+class Jt extends Yt {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(t) {
+    super(), t = t || {}, this.splitCollection_ = t.splitCollection !== void 0 ? t.splitCollection : !1;
+  }
+  /**
+   * Parse a WKT string.
+   * @param {string} wkt WKT string.
+   * @return {import("../geom/Geometry.js").default}
+   *     The geometry created.
+   * @private
+   */
+  parse_(t) {
+    const e = new Ut(t);
+    return new Zt(e).parse();
+  }
+  /**
+   * @protected
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @return {import("../Feature.js").default} Feature.
+   */
+  readFeatureFromText(t, e) {
+    const s = this.readGeometryFromText(t, e), i = new M();
+    return i.setGeometry(s), i;
+  }
+  /**
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @protected
+   * @return {Array<Feature>} Features.
+   */
+  readFeaturesFromText(t, e) {
+    let s = [];
+    const i = this.readGeometryFromText(t, e);
+    this.splitCollection_ && i.getType() == "GeometryCollection" ? s = /** @type {GeometryCollection} */
+    i.getGeometriesArray() : s = [i];
+    const n = [];
+    for (let o = 0, a = s.length; o < a; ++o) {
+      const h = new M();
+      h.setGeometry(s[o]), n.push(h);
+    }
+    return n;
+  }
+  /**
+   * @param {string} text Text.
+   * @param {import("./Feature.js").ReadOptions} [options] Read options.
+   * @protected
+   * @return {import("../geom/Geometry.js").default} Geometry.
+   */
+  readGeometryFromText(t, e) {
+    const s = this.parse_(t);
+    return k(s, !1, e);
+  }
+  /**
+   * @param {import("../Feature.js").default} feature Features.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeFeatureText(t, e) {
+    const s = t.getGeometry();
+    return s ? this.writeGeometryText(s, e) : "";
+  }
+  /**
+   * @param {Array<import("../Feature.js").default>} features Features.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeFeaturesText(t, e) {
+    if (t.length == 1)
+      return this.writeFeatureText(t[0], e);
+    const s = [];
+    for (let n = 0, o = t.length; n < o; ++n)
+      s.push(t[n].getGeometry());
+    const i = new C(s);
+    return this.writeGeometryText(i, e);
+  }
+  /**
+   * @param {import("../geom/Geometry.js").default} geometry Geometry.
+   * @param {import("./Feature.js").WriteOptions} [options] Write options.
+   * @protected
+   * @return {string} Text.
+   */
+  writeGeometryText(t, e) {
+    return J(k(t, !0, e));
+  }
+}
+function $(r) {
+  const t = r.getCoordinates();
+  return t.length === 0 ? "" : t.join(" ");
+}
+function bt(r) {
+  const t = [], e = r.getPoints();
+  for (let s = 0, i = e.length; s < i; ++s)
+    t.push("(" + $(e[s]) + ")");
+  return t.join(",");
+}
+function Ht(r) {
+  const t = [], e = r.getGeometries();
+  for (let s = 0, i = e.length; s < i; ++s)
+    t.push(J(e[s]));
+  return t.join(",");
+}
+function S(r) {
+  const t = r.getCoordinates(), e = [];
+  for (let s = 0, i = t.length; s < i; ++s)
+    e.push(t[s].join(" "));
+  return e.join(",");
+}
+function Kt(r) {
+  const t = [], e = r.getLineStrings();
+  for (let s = 0, i = e.length; s < i; ++s)
+    t.push("(" + S(e[s]) + ")");
+  return t.join(",");
+}
+function q(r) {
+  const t = [], e = r.getLinearRings();
+  for (let s = 0, i = e.length; s < i; ++s)
+    t.push("(" + S(e[s]) + ")");
+  return t.join(",");
+}
+function Dt(r) {
+  const t = [], e = r.getPolygons();
+  for (let s = 0, i = e.length; s < i; ++s)
+    t.push("(" + q(e[s]) + ")");
+  return t.join(",");
+}
+function Bt(r) {
+  const t = r.getLayout();
+  let e = "";
+  return (t === "XYZ" || t === "XYZM") && (e += W), (t === "XYM" || t === "XYZM") && (e += z), e;
+}
+const Wt = {
+  Point: $,
+  LineString: S,
+  Polygon: q,
+  MultiPoint: bt,
+  MultiLineString: Kt,
+  MultiPolygon: Dt,
+  GeometryCollection: Ht
+};
+function J(r) {
+  const t = r.getType(), e = Wt[t], s = e(r);
+  let i = Xt[t];
+  if (typeof /** @type {?} */
+  r.getFlatCoordinates == "function") {
+    const n = Bt(
+      /** @type {import("../geom/SimpleGeometry.js").default} */
+      r
+    );
+    n.length > 0 && (i += " " + n);
+  }
+  return s.length === 0 ? i + " " + B : i + "(" + s + ")";
+}
+export {
+  M as F,
+  C as G,
+  p as L,
+  w as M,
+  Jt as W,
+  F as a,
+  L as b,
+  Ot as c,
+  k as t
+};