gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/expr/expression.mjs

@@ -0,0 +1,649 @@
+import { ascending as q } from "../array.mjs";
+import { fromString as O } from "../color.mjs";
+import { toSize as L } from "../size.mjs";
+let T = 0;
+const m = 1 << T++, f = 1 << T++, b = 1 << T++, $ = 1 << T++, M = 1 << T++, C = 1 << T++, x = Math.pow(2, T) - 1, N = {
+  [m]: "boolean",
+  [f]: "number",
+  [b]: "string",
+  [$]: "color",
+  [M]: "number[]",
+  [C]: "size"
+}, z = Object.keys(N).map(Number).sort(q);
+function B(r) {
+  return r in N;
+}
+function I(r) {
+  const t = [];
+  for (const e of z)
+    S(r, e) && t.push(N[e]);
+  return t.length === 0 ? "untyped" : t.length < 3 ? t.join(" or ") : t.slice(0, -1).join(", ") + ", or " + t[t.length - 1];
+}
+function S(r, t) {
+  return (r & t) === t;
+}
+function E(r, t) {
+  return r === t;
+}
+class h {
+  /**
+   * @param {number} type The value type.
+   * @param {LiteralValue} value The literal value.
+   */
+  constructor(t, e) {
+    if (!B(t))
+      throw new Error(
+        `literal expressions must have a specific type, got ${I(t)}`
+      );
+    this.type = t, this.value = e;
+  }
+}
+class R {
+  /**
+   * @param {number} type The return type.
+   * @param {string} operator The operator.
+   * @param {...Expression} args The arguments.
+   */
+  constructor(t, e, ...n) {
+    this.type = t, this.operator = e, this.args = n;
+  }
+}
+function rr() {
+  return {
+    variables: /* @__PURE__ */ new Set(),
+    properties: /* @__PURE__ */ new Set(),
+    featureId: !1,
+    geometryType: !1,
+    mapState: !1
+  };
+}
+function w(r, t, e) {
+  switch (typeof r) {
+    case "boolean": {
+      if (E(t, b))
+        return new h(b, r ? "true" : "false");
+      if (!S(t, m))
+        throw new Error(
+          `got a boolean, but expected ${I(t)}`
+        );
+      return new h(m, r);
+    }
+    case "number": {
+      if (E(t, C))
+        return new h(C, L(r));
+      if (E(t, m))
+        return new h(m, !!r);
+      if (E(t, b))
+        return new h(b, r.toString());
+      if (!S(t, f))
+        throw new Error(`got a number, but expected ${I(t)}`);
+      return new h(f, r);
+    }
+    case "string": {
+      if (E(t, $))
+        return new h($, O(r));
+      if (E(t, m))
+        return new h(m, !!r);
+      if (!S(t, b))
+        throw new Error(`got a string, but expected ${I(t)}`);
+      return new h(b, r);
+    }
+  }
+  if (!Array.isArray(r))
+    throw new Error("expression must be an array or a primitive value");
+  if (r.length === 0)
+    throw new Error("empty expression");
+  if (typeof r[0] == "string")
+    return W(r, t, e);
+  for (const n of r)
+    if (typeof n != "number")
+      throw new Error("expected an array of numbers");
+  if (E(t, C)) {
+    if (r.length !== 2)
+      throw new Error(
+        `expected an array of two values for a size, got ${r.length}`
+      );
+    return new h(C, r);
+  }
+  if (E(t, $)) {
+    if (r.length === 3)
+      return new h($, [...r, 1]);
+    if (r.length === 4)
+      return new h($, r);
+    throw new Error(
+      `expected an array of 3 or 4 values for a color, got ${r.length}`
+    );
+  }
+  if (!S(t, M))
+    throw new Error(
+      `got an array of numbers, but expected ${I(t)}`
+    );
+  return new h(M, r);
+}
+const a = {
+  Get: "get",
+  Var: "var",
+  Concat: "concat",
+  GeometryType: "geometry-type",
+  LineMetric: "line-metric",
+  Any: "any",
+  All: "all",
+  Not: "!",
+  Resolution: "resolution",
+  Zoom: "zoom",
+  Time: "time",
+  Equal: "==",
+  NotEqual: "!=",
+  GreaterThan: ">",
+  GreaterThanOrEqualTo: ">=",
+  LessThan: "<",
+  LessThanOrEqualTo: "<=",
+  Multiply: "*",
+  Divide: "/",
+  Add: "+",
+  Subtract: "-",
+  Clamp: "clamp",
+  Mod: "%",
+  Pow: "^",
+  Abs: "abs",
+  Floor: "floor",
+  Ceil: "ceil",
+  Round: "round",
+  Sin: "sin",
+  Cos: "cos",
+  Atan: "atan",
+  Sqrt: "sqrt",
+  Match: "match",
+  Between: "between",
+  Interpolate: "interpolate",
+  Coalesce: "coalesce",
+  Case: "case",
+  In: "in",
+  Number: "number",
+  String: "string",
+  Array: "array",
+  Color: "color",
+  Id: "id",
+  Band: "band",
+  Palette: "palette",
+  ToString: "to-string",
+  Has: "has"
+}, j = {
+  [a.Get]: s(l(1, 1 / 0), G),
+  [a.Var]: s(l(1, 1), F),
+  [a.Has]: s(l(1, 1 / 0), G),
+  [a.Id]: s(V, A),
+  [a.Concat]: s(
+    l(2, 1 / 0),
+    p(b)
+  ),
+  [a.GeometryType]: s(D, A),
+  [a.LineMetric]: s(A),
+  [a.Resolution]: s(v, A),
+  [a.Zoom]: s(v, A),
+  [a.Time]: s(v, A),
+  [a.Any]: s(
+    l(2, 1 / 0),
+    p(m)
+  ),
+  [a.All]: s(
+    l(2, 1 / 0),
+    p(m)
+  ),
+  [a.Not]: s(
+    l(1, 1),
+    p(m)
+  ),
+  [a.Equal]: s(
+    l(2, 2),
+    p(x)
+  ),
+  [a.NotEqual]: s(
+    l(2, 2),
+    p(x)
+  ),
+  [a.GreaterThan]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.GreaterThanOrEqualTo]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.LessThan]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.LessThanOrEqualTo]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.Multiply]: s(
+    l(2, 1 / 0),
+    k
+  ),
+  [a.Coalesce]: s(
+    l(2, 1 / 0),
+    k
+  ),
+  [a.Divide]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.Add]: s(
+    l(2, 1 / 0),
+    p(f)
+  ),
+  [a.Subtract]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.Clamp]: s(
+    l(3, 3),
+    p(f)
+  ),
+  [a.Mod]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.Pow]: s(
+    l(2, 2),
+    p(f)
+  ),
+  [a.Abs]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Floor]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Ceil]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Round]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Sin]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Cos]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Atan]: s(
+    l(1, 2),
+    p(f)
+  ),
+  [a.Sqrt]: s(
+    l(1, 1),
+    p(f)
+  ),
+  [a.Match]: s(
+    l(4, 1 / 0),
+    P,
+    J
+  ),
+  [a.Between]: s(
+    l(3, 3),
+    p(f)
+  ),
+  [a.Interpolate]: s(
+    l(6, 1 / 0),
+    P,
+    Z
+  ),
+  [a.Case]: s(
+    l(3, 1 / 0),
+    H,
+    K
+  ),
+  [a.In]: s(l(2, 2), Q),
+  [a.Number]: s(
+    l(1, 1 / 0),
+    p(x)
+  ),
+  [a.String]: s(
+    l(1, 1 / 0),
+    p(x)
+  ),
+  [a.Array]: s(
+    l(1, 1 / 0),
+    p(f)
+  ),
+  [a.Color]: s(
+    l(1, 4),
+    p(f)
+  ),
+  [a.Band]: s(
+    l(1, 3),
+    p(f)
+  ),
+  [a.Palette]: s(
+    l(2, 2),
+    U
+  ),
+  [a.ToString]: s(
+    l(1, 1),
+    p(m | f | b | $)
+  )
+};
+function G(r, t, e) {
+  const n = r.length - 1, i = new Array(n);
+  for (let u = 0; u < n; ++u) {
+    const o = r[u + 1];
+    switch (typeof o) {
+      case "number": {
+        i[u] = new h(f, o);
+        break;
+      }
+      case "string": {
+        i[u] = new h(b, o);
+        break;
+      }
+      default:
+        throw new Error(
+          `expected a string key or numeric array index for a get operation, got ${o}`
+        );
+    }
+    u === 0 && e.properties.add(String(o));
+  }
+  return i;
+}
+function F(r, t, e) {
+  const n = r[1];
+  if (typeof n != "string")
+    throw new Error("expected a string argument for var operation");
+  return e.variables.add(n), [new h(b, n)];
+}
+function V(r, t, e) {
+  e.featureId = !0;
+}
+function D(r, t, e) {
+  e.geometryType = !0;
+}
+function v(r, t, e) {
+  e.mapState = !0;
+}
+function A(r, t, e) {
+  const n = r[0];
+  if (r.length !== 1)
+    throw new Error(`expected no arguments for ${n} operation`);
+  return [];
+}
+function l(r, t) {
+  return function(e, n, i) {
+    const u = e[0], o = e.length - 1;
+    if (r === t) {
+      if (o !== r) {
+        const g = r === 1 ? "" : "s";
+        throw new Error(
+          `expected ${r} argument${g} for ${u}, got ${o}`
+        );
+      }
+    } else if (o < r || o > t) {
+      const g = t === 1 / 0 ? `${r} or more` : `${r} to ${t}`;
+      throw new Error(
+        `expected ${g} arguments for ${u}, got ${o}`
+      );
+    }
+  };
+}
+function k(r, t, e) {
+  const n = r.length - 1, i = new Array(n);
+  for (let u = 0; u < n; ++u) {
+    const o = w(r[u + 1], t, e);
+    i[u] = o;
+  }
+  return i;
+}
+function p(r) {
+  return function(t, e, n) {
+    const i = t.length - 1, u = new Array(i);
+    for (let o = 0; o < i; ++o) {
+      const g = w(t[o + 1], r, n);
+      u[o] = g;
+    }
+    return u;
+  };
+}
+function H(r, t, e) {
+  const n = r[0], i = r.length - 1;
+  if (i % 2 === 0)
+    throw new Error(
+      `expected an odd number of arguments for ${n}, got ${i} instead`
+    );
+}
+function P(r, t, e) {
+  const n = r[0], i = r.length - 1;
+  if (i % 2 === 1)
+    throw new Error(
+      `expected an even number of arguments for operation ${n}, got ${i} instead`
+    );
+}
+function J(r, t, e) {
+  const n = r.length - 1, i = b | f | m, u = w(r[1], i, e), o = w(r[r.length - 1], t, e), g = new Array(n - 2);
+  for (let c = 0; c < n - 2; c += 2) {
+    try {
+      const y = w(r[c + 2], u.type, e);
+      g[c] = y;
+    } catch (y) {
+      throw new Error(
+        `failed to parse argument ${c + 1} of match expression: ${y.message}`
+      );
+    }
+    try {
+      const y = w(r[c + 3], o.type, e);
+      g[c + 1] = y;
+    } catch (y) {
+      throw new Error(
+        `failed to parse argument ${c + 2} of match expression: ${y.message}`
+      );
+    }
+  }
+  return [u, ...g, o];
+}
+function Z(r, t, e) {
+  const n = r[1];
+  let i;
+  switch (n[0]) {
+    case "linear":
+      i = 1;
+      break;
+    case "exponential":
+      const c = n[1];
+      if (typeof c != "number" || c <= 0)
+        throw new Error(
+          `expected a number base for exponential interpolation, got ${JSON.stringify(c)} instead`
+        );
+      i = c;
+      break;
+    default:
+      throw new Error(
+        `invalid interpolation type: ${JSON.stringify(n)}`
+      );
+  }
+  const u = new h(f, i);
+  let o;
+  try {
+    o = w(r[2], f, e);
+  } catch (c) {
+    throw new Error(
+      `failed to parse argument 1 in interpolate expression: ${c.message}`
+    );
+  }
+  const g = new Array(r.length - 3);
+  for (let c = 0; c < g.length; c += 2) {
+    try {
+      const y = w(r[c + 3], f, e);
+      g[c] = y;
+    } catch (y) {
+      throw new Error(
+        `failed to parse argument ${c + 2} for interpolate expression: ${y.message}`
+      );
+    }
+    try {
+      const y = w(r[c + 4], t, e);
+      g[c + 1] = y;
+    } catch (y) {
+      throw new Error(
+        `failed to parse argument ${c + 3} for interpolate expression: ${y.message}`
+      );
+    }
+  }
+  return [u, o, ...g];
+}
+function K(r, t, e) {
+  const n = w(r[r.length - 1], t, e), i = new Array(r.length - 1);
+  for (let u = 0; u < i.length - 1; u += 2) {
+    try {
+      const o = w(r[u + 1], m, e);
+      i[u] = o;
+    } catch (o) {
+      throw new Error(
+        `failed to parse argument ${u} of case expression: ${o.message}`
+      );
+    }
+    try {
+      const o = w(r[u + 2], n.type, e);
+      i[u + 1] = o;
+    } catch (o) {
+      throw new Error(
+        `failed to parse argument ${u + 1} of case expression: ${o.message}`
+      );
+    }
+  }
+  return i[i.length - 1] = n, i;
+}
+function Q(r, t, e) {
+  let n = r[2];
+  if (!Array.isArray(n))
+    throw new Error(
+      'the second argument for the "in" operator must be an array'
+    );
+  let i;
+  if (typeof n[0] == "string") {
+    if (n[0] !== "literal")
+      throw new Error(
+        'for the "in" operator, a string array should be wrapped in a "literal" operator to disambiguate from expressions'
+      );
+    if (!Array.isArray(n[1]))
+      throw new Error(
+        'failed to parse "in" expression: the literal operator must be followed by an array'
+      );
+    n = n[1], i = b;
+  } else
+    i = f;
+  const u = new Array(n.length);
+  for (let g = 0; g < u.length; g++)
+    try {
+      const c = w(n[g], i, e);
+      u[g] = c;
+    } catch (c) {
+      throw new Error(
+        `failed to parse haystack item ${g} for "in" expression: ${c.message}`
+      );
+    }
+  return [w(r[1], i, e), ...u];
+}
+function U(r, t, e) {
+  let n;
+  try {
+    n = w(r[1], f, e);
+  } catch (o) {
+    throw new Error(
+      `failed to parse first argument in palette expression: ${o.message}`
+    );
+  }
+  const i = r[2];
+  if (!Array.isArray(i))
+    throw new Error("the second argument of palette must be an array");
+  const u = new Array(i.length);
+  for (let o = 0; o < u.length; o++) {
+    let g;
+    try {
+      g = w(i[o], $, e);
+    } catch (c) {
+      throw new Error(
+        `failed to parse color at index ${o} in palette expression: ${c.message}`
+      );
+    }
+    if (!(g instanceof h))
+      throw new Error(
+        `the palette color at index ${o} must be a literal value`
+      );
+    u[o] = g;
+  }
+  return [n, ...u];
+}
+function s(...r) {
+  return function(t, e, n) {
+    const i = t[0];
+    let u;
+    for (let o = 0; o < r.length; o++) {
+      const g = r[o](t, e, n);
+      if (o == r.length - 1) {
+        if (!g)
+          throw new Error(
+            "expected last argument validator to return the parsed args"
+          );
+        u = g;
+      }
+    }
+    return new R(e, i, ...u);
+  };
+}
+function W(r, t, e) {
+  const n = r[0], i = j[n];
+  if (!i)
+    throw new Error(`unknown operator: ${n}`);
+  return i(r, t, e);
+}
+function X(r) {
+  if (!r)
+    return "";
+  const t = r.getType();
+  switch (t) {
+    case "Point":
+    case "LineString":
+    case "Polygon":
+      return t;
+    case "MultiPoint":
+    case "MultiLineString":
+    case "MultiPolygon":
+      return (
+        /** @type {'Point'|'LineString'|'Polygon'} */
+        t.substring(5)
+      );
+    case "Circle":
+      return "Polygon";
+    case "GeometryCollection":
+      return X(
+        /** @type {import("../geom/GeometryCollection.js").default} */
+        r.getGeometries()[0]
+      );
+    default:
+      return "";
+  }
+}
+export {
+  x as AnyType,
+  m as BooleanType,
+  R as CallExpression,
+  $ as ColorType,
+  h as LiteralExpression,
+  M as NumberArrayType,
+  f as NumberType,
+  a as Ops,
+  C as SizeType,
+  b as StringType,
+  X as computeGeometryType,
+  S as includesType,
+  E as isType,
+  rr as newParsingContext,
+  w as parse,
+  I as typeName
+};

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

@@ -0,0 +1,11 @@
+const E = {
+  UNKNOWN: 0,
+  INTERSECTING: 1,
+  ABOVE: 2,
+  RIGHT: 4,
+  BELOW: 8,
+  LEFT: 16
+};
+export {
+  E as default
+};