iflow-engine-base 4.0.15 → 4.0.18

package/dist/chunks/index-Cyv0HpPm.js

@@ -0,0 +1,438 @@
+function y(t, e) {
+  this.x = t, this.y = e;
+}
+y.prototype = {
+  /**
+   * Clone this point, returning a new point that can be modified
+   * without affecting the old one.
+   * @return {Point} the clone
+   */
+  clone() {
+    return new y(this.x, this.y);
+  },
+  /**
+   * Add this point's x & y coordinates to another point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
+  add(t) {
+    return this.clone()._add(t);
+  },
+  /**
+   * Subtract this point's x & y coordinates to from point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
+  sub(t) {
+    return this.clone()._sub(t);
+  },
+  /**
+   * Multiply this point's x & y coordinates by point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
+  multByPoint(t) {
+    return this.clone()._multByPoint(t);
+  },
+  /**
+   * Divide this point's x & y coordinates by point,
+   * yielding a new point.
+   * @param {Point} p the other point
+   * @return {Point} output point
+   */
+  divByPoint(t) {
+    return this.clone()._divByPoint(t);
+  },
+  /**
+   * Multiply this point's x & y coordinates by a factor,
+   * yielding a new point.
+   * @param {number} k factor
+   * @return {Point} output point
+   */
+  mult(t) {
+    return this.clone()._mult(t);
+  },
+  /**
+   * Divide this point's x & y coordinates by a factor,
+   * yielding a new point.
+   * @param {number} k factor
+   * @return {Point} output point
+   */
+  div(t) {
+    return this.clone()._div(t);
+  },
+  /**
+   * Rotate this point around the 0, 0 origin by an angle a,
+   * given in radians
+   * @param {number} a angle to rotate around, in radians
+   * @return {Point} output point
+   */
+  rotate(t) {
+    return this.clone()._rotate(t);
+  },
+  /**
+   * Rotate this point around p point by an angle a,
+   * given in radians
+   * @param {number} a angle to rotate around, in radians
+   * @param {Point} p Point to rotate around
+   * @return {Point} output point
+   */
+  rotateAround(t, e) {
+    return this.clone()._rotateAround(t, e);
+  },
+  /**
+   * Multiply this point by a 4x1 transformation matrix
+   * @param {[number, number, number, number]} m transformation matrix
+   * @return {Point} output point
+   */
+  matMult(t) {
+    return this.clone()._matMult(t);
+  },
+  /**
+   * Calculate this point but as a unit vector from 0, 0, meaning
+   * that the distance from the resulting point to the 0, 0
+   * coordinate will be equal to 1 and the angle from the resulting
+   * point to the 0, 0 coordinate will be the same as before.
+   * @return {Point} unit vector point
+   */
+  unit() {
+    return this.clone()._unit();
+  },
+  /**
+   * Compute a perpendicular point, where the new y coordinate
+   * is the old x coordinate and the new x coordinate is the old y
+   * coordinate multiplied by -1
+   * @return {Point} perpendicular point
+   */
+  perp() {
+    return this.clone()._perp();
+  },
+  /**
+   * Return a version of this point with the x & y coordinates
+   * rounded to integers.
+   * @return {Point} rounded point
+   */
+  round() {
+    return this.clone()._round();
+  },
+  /**
+   * Return the magnitude of this point: this is the Euclidean
+   * distance from the 0, 0 coordinate to this point's x and y
+   * coordinates.
+   * @return {number} magnitude
+   */
+  mag() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  },
+  /**
+   * Judge whether this point is equal to another point, returning
+   * true or false.
+   * @param {Point} other the other point
+   * @return {boolean} whether the points are equal
+   */
+  equals(t) {
+    return this.x === t.x && this.y === t.y;
+  },
+  /**
+   * Calculate the distance from this point to another point
+   * @param {Point} p the other point
+   * @return {number} distance
+   */
+  dist(t) {
+    return Math.sqrt(this.distSqr(t));
+  },
+  /**
+   * Calculate the distance from this point to another point,
+   * without the square root step. Useful if you're comparing
+   * relative distances.
+   * @param {Point} p the other point
+   * @return {number} distance
+   */
+  distSqr(t) {
+    const e = t.x - this.x, n = t.y - this.y;
+    return e * e + n * n;
+  },
+  /**
+   * Get the angle from the 0, 0 coordinate to this point, in radians
+   * coordinates.
+   * @return {number} angle
+   */
+  angle() {
+    return Math.atan2(this.y, this.x);
+  },
+  /**
+   * Get the angle from this point to another point, in radians
+   * @param {Point} b the other point
+   * @return {number} angle
+   */
+  angleTo(t) {
+    return Math.atan2(this.y - t.y, this.x - t.x);
+  },
+  /**
+   * Get the angle between this point and another point, in radians
+   * @param {Point} b the other point
+   * @return {number} angle
+   */
+  angleWith(t) {
+    return this.angleWithSep(t.x, t.y);
+  },
+  /**
+   * Find the angle of the two vectors, solving the formula for
+   * the cross product a x b = |a||b|sin(θ) for θ.
+   * @param {number} x the x-coordinate
+   * @param {number} y the y-coordinate
+   * @return {number} the angle in radians
+   */
+  angleWithSep(t, e) {
+    return Math.atan2(
+      this.x * e - this.y * t,
+      this.x * t + this.y * e
+    );
+  },
+  /** @param {[number, number, number, number]} m */
+  _matMult(t) {
+    const e = t[0] * this.x + t[1] * this.y, n = t[2] * this.x + t[3] * this.y;
+    return this.x = e, this.y = n, this;
+  },
+  /** @param {Point} p */
+  _add(t) {
+    return this.x += t.x, this.y += t.y, this;
+  },
+  /** @param {Point} p */
+  _sub(t) {
+    return this.x -= t.x, this.y -= t.y, this;
+  },
+  /** @param {number} k */
+  _mult(t) {
+    return this.x *= t, this.y *= t, this;
+  },
+  /** @param {number} k */
+  _div(t) {
+    return this.x /= t, this.y /= t, this;
+  },
+  /** @param {Point} p */
+  _multByPoint(t) {
+    return this.x *= t.x, this.y *= t.y, this;
+  },
+  /** @param {Point} p */
+  _divByPoint(t) {
+    return this.x /= t.x, this.y /= t.y, this;
+  },
+  _unit() {
+    return this._div(this.mag()), this;
+  },
+  _perp() {
+    const t = this.y;
+    return this.y = this.x, this.x = -t, this;
+  },
+  /** @param {number} angle */
+  _rotate(t) {
+    const e = Math.cos(t), n = Math.sin(t), i = e * this.x - n * this.y, s = n * this.x + e * this.y;
+    return this.x = i, this.y = s, this;
+  },
+  /**
+   * @param {number} angle
+   * @param {Point} p
+   */
+  _rotateAround(t, e) {
+    const n = Math.cos(t), i = Math.sin(t), s = e.x + n * (this.x - e.x) - i * (this.y - e.y), r = e.y + i * (this.x - e.x) + n * (this.y - e.y);
+    return this.x = s, this.y = r, this;
+  },
+  _round() {
+    return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+  },
+  constructor: y
+};
+y.convert = function(t) {
+  if (t instanceof y)
+    return (
+      /** @type {Point} */
+      t
+    );
+  if (Array.isArray(t))
+    return new y(+t[0], +t[1]);
+  if (t.x !== void 0 && t.y !== void 0)
+    return new y(+t.x, +t.y);
+  throw new Error("Expected [x, y] or {x, y} point format");
+};
+class _ {
+  /**
+   * @param {Pbf} pbf
+   * @param {number} end
+   * @param {number} extent
+   * @param {string[]} keys
+   * @param {(number | string | boolean)[]} values
+   */
+  constructor(e, n, i, s, r) {
+    for (this.properties = /* @__PURE__ */ Object.create(null), this.extent = i, this.type = 0, this.id = void 0, this._pbf = e, this._geometry = -1, this._keys = s, this._values = r; e.pos < n; ) {
+      const o = e.readVarint();
+      if (o === 8) this.id = e.readVarint();
+      else if (o === 18) {
+        const h = e.readVarint() + e.pos;
+        for (; e.pos < h; ) {
+          const u = s[e.readVarint()], l = r[e.readVarint()];
+          this.properties[u] = l;
+        }
+      } else o === 24 ? this.type = /** @type {0 | 1 | 2 | 3} */
+      e.readVarint() : (o === 34 && (this._geometry = e.pos), e.skip(o));
+    }
+  }
+  loadGeometry() {
+    if (this._geometry < 0) throw new Error("feature has no geometry");
+    const e = this._pbf;
+    e.pos = this._geometry;
+    const n = e.readVarint() + e.pos, i = [];
+    let s, r = 1, o = 0, h = 0, u = 0;
+    for (; e.pos < n; ) {
+      if (o <= 0) {
+        const l = e.readVarint();
+        if (r = l & 7, o = l >> 3, o === 0) continue;
+      }
+      if (o--, r === 1)
+        h += e.readSVarint(), u += e.readSVarint(), s && i.push(s), s = [new y(h, u)];
+      else if (r === 2)
+        h += e.readSVarint(), u += e.readSVarint(), s && s.push(new y(h, u));
+      else if (r === 7)
+        s && s.push(s[0].clone());
+      else
+        throw new Error(`unknown command ${r}`);
+    }
+    return s && i.push(s), i;
+  }
+  bbox() {
+    if (this._geometry < 0) throw new Error("feature has no geometry");
+    const e = this._pbf;
+    e.pos = this._geometry;
+    const n = e.readVarint() + e.pos;
+    let i = 1, s = 0, r = 0, o = 0, h = 1 / 0, u = -1 / 0, l = 1 / 0, c = -1 / 0;
+    for (; e.pos < n; ) {
+      if (s <= 0) {
+        const x = e.readVarint();
+        if (i = x & 7, s = x >> 3, s === 0) continue;
+      }
+      if (s--, i === 1 || i === 2)
+        r += e.readSVarint(), o += e.readSVarint(), r < h && (h = r), r > u && (u = r), o < l && (l = o), o > c && (c = o);
+      else if (i !== 7)
+        throw new Error(`unknown command ${i}`);
+    }
+    return [h, l, u, c];
+  }
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   * @return {Feature}
+   */
+  toGeoJSON(e, n, i) {
+    const s = this.extent * Math.pow(2, i), r = this.extent * e, o = this.extent * n, h = this.loadGeometry();
+    function u(a) {
+      return [
+        (a.x + r) * 360 / s - 180,
+        360 / Math.PI * Math.atan(Math.exp((1 - (a.y + o) * 2 / s) * Math.PI)) - 90
+      ];
+    }
+    function l(a) {
+      return a.map(u);
+    }
+    let c;
+    if (this.type === 1) {
+      const a = [];
+      for (const f of h)
+        a.push(f[0]);
+      const d = l(a);
+      c = a.length === 1 ? { type: "Point", coordinates: d[0] } : { type: "MultiPoint", coordinates: d };
+    } else if (this.type === 2) {
+      const a = h.map(l);
+      c = a.length === 1 ? { type: "LineString", coordinates: a[0] } : { type: "MultiLineString", coordinates: a };
+    } else if (this.type === 3) {
+      const a = g(h), d = [];
+      for (const f of a)
+        d.push(f.map(l));
+      c = d.length === 1 ? { type: "Polygon", coordinates: d[0] } : { type: "MultiPolygon", coordinates: d };
+    } else
+      throw new Error("unknown feature type");
+    const x = {
+      type: "Feature",
+      geometry: c,
+      properties: this.properties
+    };
+    return this.id != null && (x.id = this.id), x;
+  }
+}
+_.types = ["Unknown", "Point", "LineString", "Polygon"];
+function g(t) {
+  const e = t.length;
+  if (e <= 1) return [t];
+  const n = [];
+  let i, s;
+  for (let r = 0; r < e; r++) {
+    const o = w(t[r]);
+    o !== 0 && (s === void 0 && (s = o < 0), s === o < 0 ? (i && n.push(i), i = [t[r]]) : i && i.push(t[r]));
+  }
+  return i && n.push(i), n;
+}
+function w(t) {
+  let e = 0;
+  for (let n = 0, i = t.length, s = i - 1, r, o; n < i; s = n++)
+    r = t[n], o = t[s], e += (o.x - r.x) * (r.y + o.y);
+  return e;
+}
+class p {
+  /**
+   * @param {Pbf} pbf
+   * @param {number} [end]
+   */
+  constructor(e, n) {
+    for (this.version = 1, this.name = "", this.extent = 4096, this.length = 0, this._pbf = e, this._keys = [], this._values = [], this._features = [], n === void 0 && (n = e.length); e.pos < n; ) {
+      const i = e.readVarint();
+      i === 10 ? this.name = e.readString() : i === 18 ? (this._features.push(e.pos), e.skip(i)) : i === 26 ? this._keys.push(e.readString()) : i === 34 ? this._values.push(m(e)) : i === 40 ? this.extent = e.readVarint() : i === 120 ? this.version = e.readVarint() : e.skip(i);
+    }
+    this.length = this._features.length;
+  }
+  /** return feature `i` from this layer as a `VectorTileFeature`
+   * @param {number} i
+   */
+  feature(e) {
+    if (e < 0 || e >= this._features.length) throw new Error("feature index out of bounds");
+    this._pbf.pos = this._features[e];
+    const n = this._pbf.readVarint() + this._pbf.pos;
+    return new _(this._pbf, n, this.extent, this._keys, this._values);
+  }
+}
+function m(t) {
+  let e = null;
+  const n = t.readVarint() + t.pos;
+  for (; t.pos < n; ) {
+    const i = t.readVarint();
+    e = i === 10 ? t.readString() : i === 21 ? t.readFloat() : i === 25 ? t.readDouble() : i === 32 ? t.readVarint64() : i === 40 ? t.readVarint() : i === 48 ? t.readSVarint() : i === 56 ? t.readBoolean() : (t.skip(i), null);
+  }
+  if (e == null)
+    throw new Error("unknown feature value");
+  return e;
+}
+class V {
+  /**
+   * @param {Pbf} pbf
+   * @param {number} [end]
+   */
+  constructor(e, n = e.length) {
+    const i = /* @__PURE__ */ Object.create(null);
+    for (; e.pos < n; ) {
+      const s = e.readVarint();
+      if (s === 26) {
+        const r = new p(e, e.readVarint() + e.pos);
+        r.length && (i[r.name] = r);
+      } else e.skip(s);
+    }
+    this.layers = i;
+  }
+}
+export {
+  V as VectorTile,
+  _ as VectorTileFeature,
+  p as VectorTileLayer,
+  g as classifyRings
+};