gisviewer-vue3-arcgis 1.0.281 → 1.0.282

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

@@ -0,0 +1,367 @@
+import { fromString as m, withAlpha as y, toString as v, rgbaToLcha as d, lchaToRgba as A } from "../color.mjs";
+import { parse as T, LiteralExpression as M, ColorType as E, Ops as t } from "./expression.mjs";
+function R() {
+  return {
+    variables: {},
+    properties: {},
+    resolution: NaN,
+    featureId: null,
+    geometryType: ""
+  };
+}
+function H(a, l, s) {
+  const n = T(a, l, s);
+  return p(n);
+}
+function p(a, l) {
+  if (a instanceof M) {
+    if (a.type === E && typeof a.value == "string") {
+      const n = m(a.value);
+      return function() {
+        return n;
+      };
+    }
+    return function() {
+      return a.value;
+    };
+  }
+  const s = a.operator;
+  switch (s) {
+    case t.Number:
+    case t.String:
+    case t.Coalesce:
+      return C(a);
+    case t.Get:
+    case t.Var:
+    case t.Has:
+      return S(a);
+    case t.Id:
+      return (n) => n.featureId;
+    case t.GeometryType:
+      return (n) => n.geometryType;
+    case t.Concat: {
+      const n = a.args.map((e) => p(e));
+      return (e) => "".concat(...n.map((r) => r(e).toString()));
+    }
+    case t.Resolution:
+      return (n) => n.resolution;
+    case t.Any:
+    case t.All:
+    case t.Between:
+    case t.In:
+    case t.Not:
+      return N(a);
+    case t.Equal:
+    case t.NotEqual:
+    case t.LessThan:
+    case t.LessThanOrEqualTo:
+    case t.GreaterThan:
+    case t.GreaterThanOrEqualTo:
+      return q(a);
+    case t.Multiply:
+    case t.Divide:
+    case t.Add:
+    case t.Subtract:
+    case t.Clamp:
+    case t.Mod:
+    case t.Pow:
+    case t.Abs:
+    case t.Floor:
+    case t.Ceil:
+    case t.Round:
+    case t.Sin:
+    case t.Cos:
+    case t.Atan:
+    case t.Sqrt:
+      return b(a);
+    case t.Case:
+      return I(a);
+    case t.Match:
+      return O(a);
+    case t.Interpolate:
+      return $(a);
+    case t.ToString:
+      return G(a);
+    default:
+      throw new Error(`Unsupported operator ${s}`);
+  }
+}
+function C(a, l) {
+  const s = a.operator, n = a.args.length, e = new Array(n);
+  for (let r = 0; r < n; ++r)
+    e[r] = p(a.args[r]);
+  switch (s) {
+    case t.Coalesce:
+      return (r) => {
+        for (let o = 0; o < n; ++o) {
+          const c = e[o](r);
+          if (typeof c < "u" && c !== null)
+            return c;
+        }
+        throw new Error("Expected one of the values to be non-null");
+      };
+    case t.Number:
+    case t.String:
+      return (r) => {
+        for (let o = 0; o < n; ++o) {
+          const c = e[o](r);
+          if (typeof c === s)
+            return c;
+        }
+        throw new Error(`Expected one of the values to be a ${s}`);
+      };
+    default:
+      throw new Error(`Unsupported assertion operator ${s}`);
+  }
+}
+function S(a, l) {
+  const n = (
+    /** @type {string} */
+    /** @type {LiteralExpression} */
+    a.args[0].value
+  );
+  switch (a.operator) {
+    case t.Get:
+      return (e) => {
+        const r = a.args;
+        let o = e.properties[n];
+        for (let c = 1, u = r.length; c < u; ++c) {
+          const f = (
+            /** @type {string|number} */
+            /** @type {LiteralExpression} */
+            r[c].value
+          );
+          o = o[f];
+        }
+        return o;
+      };
+    case t.Var:
+      return (e) => e.variables[n];
+    case t.Has:
+      return (e) => {
+        const r = a.args;
+        if (!(n in e.properties))
+          return !1;
+        let o = e.properties[n];
+        for (let c = 1, u = r.length; c < u; ++c) {
+          const f = (
+            /** @type {string|number} */
+            /** @type {LiteralExpression} */
+            r[c].value
+          );
+          if (!o || !Object.hasOwn(o, f))
+            return !1;
+          o = o[f];
+        }
+        return !0;
+      };
+    default:
+      throw new Error(`Unsupported accessor operator ${a.operator}`);
+  }
+}
+function q(a, l) {
+  const s = a.operator, n = p(a.args[0]), e = p(a.args[1]);
+  switch (s) {
+    case t.Equal:
+      return (r) => n(r) === e(r);
+    case t.NotEqual:
+      return (r) => n(r) !== e(r);
+    case t.LessThan:
+      return (r) => n(r) < e(r);
+    case t.LessThanOrEqualTo:
+      return (r) => n(r) <= e(r);
+    case t.GreaterThan:
+      return (r) => n(r) > e(r);
+    case t.GreaterThanOrEqualTo:
+      return (r) => n(r) >= e(r);
+    default:
+      throw new Error(`Unsupported comparison operator ${s}`);
+  }
+}
+function N(a, l) {
+  const s = a.operator, n = a.args.length, e = new Array(n);
+  for (let r = 0; r < n; ++r)
+    e[r] = p(a.args[r]);
+  switch (s) {
+    case t.Any:
+      return (r) => {
+        for (let o = 0; o < n; ++o)
+          if (e[o](r))
+            return !0;
+        return !1;
+      };
+    case t.All:
+      return (r) => {
+        for (let o = 0; o < n; ++o)
+          if (!e[o](r))
+            return !1;
+        return !0;
+      };
+    case t.Between:
+      return (r) => {
+        const o = e[0](r), c = e[1](r), u = e[2](r);
+        return o >= c && o <= u;
+      };
+    case t.In:
+      return (r) => {
+        const o = e[0](r);
+        for (let c = 1; c < n; ++c)
+          if (o === e[c](r))
+            return !0;
+        return !1;
+      };
+    case t.Not:
+      return (r) => !e[0](r);
+    default:
+      throw new Error(`Unsupported logical operator ${s}`);
+  }
+}
+function b(a, l) {
+  const s = a.operator, n = a.args.length, e = new Array(n);
+  for (let r = 0; r < n; ++r)
+    e[r] = p(a.args[r]);
+  switch (s) {
+    case t.Multiply:
+      return (r) => {
+        let o = 1;
+        for (let c = 0; c < n; ++c)
+          o *= e[c](r);
+        return o;
+      };
+    case t.Divide:
+      return (r) => e[0](r) / e[1](r);
+    case t.Add:
+      return (r) => {
+        let o = 0;
+        for (let c = 0; c < n; ++c)
+          o += e[c](r);
+        return o;
+      };
+    case t.Subtract:
+      return (r) => e[0](r) - e[1](r);
+    case t.Clamp:
+      return (r) => {
+        const o = e[0](r), c = e[1](r);
+        if (o < c)
+          return c;
+        const u = e[2](r);
+        return o > u ? u : o;
+      };
+    case t.Mod:
+      return (r) => e[0](r) % e[1](r);
+    case t.Pow:
+      return (r) => Math.pow(e[0](r), e[1](r));
+    case t.Abs:
+      return (r) => Math.abs(e[0](r));
+    case t.Floor:
+      return (r) => Math.floor(e[0](r));
+    case t.Ceil:
+      return (r) => Math.ceil(e[0](r));
+    case t.Round:
+      return (r) => Math.round(e[0](r));
+    case t.Sin:
+      return (r) => Math.sin(e[0](r));
+    case t.Cos:
+      return (r) => Math.cos(e[0](r));
+    case t.Atan:
+      return n === 2 ? (r) => Math.atan2(e[0](r), e[1](r)) : (r) => Math.atan(e[0](r));
+    case t.Sqrt:
+      return (r) => Math.sqrt(e[0](r));
+    default:
+      throw new Error(`Unsupported numeric operator ${s}`);
+  }
+}
+function I(a, l) {
+  const s = a.args.length, n = new Array(s);
+  for (let e = 0; e < s; ++e)
+    n[e] = p(a.args[e]);
+  return (e) => {
+    for (let r = 0; r < s - 1; r += 2)
+      if (n[r](e))
+        return n[r + 1](e);
+    return n[s - 1](e);
+  };
+}
+function O(a, l) {
+  const s = a.args.length, n = new Array(s);
+  for (let e = 0; e < s; ++e)
+    n[e] = p(a.args[e]);
+  return (e) => {
+    const r = n[0](e);
+    for (let o = 1; o < s - 1; o += 2)
+      if (r === n[o](e))
+        return n[o + 1](e);
+    return n[s - 1](e);
+  };
+}
+function $(a, l) {
+  const s = a.args.length, n = new Array(s);
+  for (let e = 0; e < s; ++e)
+    n[e] = p(a.args[e]);
+  return (e) => {
+    const r = n[0](e), o = n[1](e);
+    let c, u;
+    for (let i = 2; i < s; i += 2) {
+      const f = n[i](e);
+      let h = n[i + 1](e);
+      const w = Array.isArray(h);
+      if (w && (h = y(h)), f >= o)
+        return i === 2 ? h : w ? L(
+          r,
+          o,
+          c,
+          u,
+          f,
+          h
+        ) : g(
+          r,
+          o,
+          c,
+          u,
+          f,
+          h
+        );
+      c = f, u = h;
+    }
+    return u;
+  };
+}
+function G(a, l) {
+  const s = a.operator, n = a.args.length, e = new Array(n);
+  for (let r = 0; r < n; ++r)
+    e[r] = p(a.args[r]);
+  switch (s) {
+    case t.ToString:
+      return (r) => {
+        const o = e[0](r);
+        return a.args[0].type === E ? v(o) : o.toString();
+      };
+    default:
+      throw new Error(`Unsupported convert operator ${s}`);
+  }
+}
+function g(a, l, s, n, e, r) {
+  const o = e - s;
+  if (o === 0)
+    return n;
+  const c = l - s, u = a === 1 ? c / o : (Math.pow(a, c) - 1) / (Math.pow(a, o) - 1);
+  return n + u * (r - n);
+}
+function L(a, l, s, n, e, r) {
+  if (e - s === 0)
+    return n;
+  const c = d(n), u = d(r);
+  let i = u[2] - c[2];
+  i > 180 ? i -= 360 : i < -180 && (i += 360);
+  const f = [
+    g(a, l, s, c[0], e, u[0]),
+    g(a, l, s, c[1], e, u[1]),
+    c[2] + g(a, l, s, 0, e, i),
+    g(a, l, s, n[3], e, r[3])
+  ];
+  return A(f);
+}
+export {
+  H as buildExpression,
+  R as newEvaluationContext
+};