gisviewer-vue3-arcgis 1.0.282 → 1.0.284

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

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

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