ts-maps 0.2.7 → 0.3.0

package/dist/core-map/style-spec/index.js

@@ -0,0 +1,2529 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core-map/style-spec/diff.ts
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (a === null || b === null)
+    return a === b;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ao = a;
+    const bo = b;
+    const keysA = Object.keys(ao);
+    const keysB = Object.keys(bo);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const k of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(bo, k))
+        return false;
+      if (!deepEqual(ao[k], bo[k]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function fullReset(next) {
+  return { commands: [{ command: "setStyle", args: [next] }] };
+}
+function indexLayers(layers) {
+  const out = {};
+  for (const layer of layers)
+    out[layer.id] = layer;
+  return out;
+}
+function diffPaint(prev, next, commands) {
+  const prevPaint = prev.paint || {};
+  const nextPaint = next.paint || {};
+  for (const key of Object.keys(nextPaint)) {
+    if (!deepEqual(prevPaint[key], nextPaint[key]))
+      commands.push({ command: "setPaintProperty", args: [next.id, key, nextPaint[key]] });
+  }
+  for (const key of Object.keys(prevPaint)) {
+    if (!(key in nextPaint))
+      commands.push({ command: "setPaintProperty", args: [next.id, key, undefined] });
+  }
+}
+function diffLayout(prev, next, commands) {
+  const prevLayout = prev.layout || {};
+  const nextLayout = next.layout || {};
+  for (const key of Object.keys(nextLayout)) {
+    if (!deepEqual(prevLayout[key], nextLayout[key]))
+      commands.push({ command: "setLayoutProperty", args: [next.id, key, nextLayout[key]] });
+  }
+  for (const key of Object.keys(prevLayout)) {
+    if (!(key in nextLayout))
+      commands.push({ command: "setLayoutProperty", args: [next.id, key, undefined] });
+  }
+}
+function diffStyles(prev, next) {
+  if (prev.version !== next.version)
+    return fullReset(next);
+  if (!deepEqual(prev.sprite, next.sprite))
+    return fullReset(next);
+  if (prev.glyphs !== next.glyphs)
+    return fullReset(next);
+  const commands = [];
+  if (!deepEqual(prev.transition, next.transition) && next.transition !== undefined)
+    commands.push({ command: "setTransition", args: [next.transition] });
+  if (!deepEqual(prev.light, next.light) && next.light !== undefined)
+    commands.push({ command: "setLight", args: [next.light] });
+  const prevSources = prev.sources || {};
+  const nextSources = next.sources || {};
+  for (const id of Object.keys(prevSources)) {
+    if (!(id in nextSources)) {
+      commands.push({ command: "removeSource", args: [id] });
+    }
+  }
+  for (const id of Object.keys(nextSources)) {
+    const p = prevSources[id];
+    const n = nextSources[id];
+    if (p === undefined) {
+      commands.push({ command: "addSource", args: [id, n] });
+      continue;
+    }
+    if (deepEqual(p, n))
+      continue;
+    if (p.type === "geojson" && n.type === "geojson") {
+      const pNoData = { ...p, data: undefined };
+      const nNoData = { ...n, data: undefined };
+      if (deepEqual(pNoData, nNoData)) {
+        commands.push({ command: "setSourceData", args: [id, n.data] });
+        continue;
+      }
+    }
+    commands.push({ command: "removeSource", args: [id] });
+    commands.push({ command: "addSource", args: [id, n] });
+  }
+  const prevLayers = prev.layers || [];
+  const nextLayers = next.layers || [];
+  const prevById = indexLayers(prevLayers);
+  const nextById = indexLayers(nextLayers);
+  for (const layer of prevLayers) {
+    if (!(layer.id in nextById))
+      commands.push({ command: "removeLayer", args: [layer.id] });
+  }
+  const prevOrder = prevLayers.filter((l) => (l.id in nextById)).map((l) => l.id);
+  const nextOrder = nextLayers.filter((l) => (l.id in prevById)).map((l) => l.id);
+  if (prevOrder.length !== nextOrder.length)
+    return fullReset(next);
+  for (let i = 0;i < prevOrder.length; i++) {
+    if (prevOrder[i] !== nextOrder[i])
+      return fullReset(next);
+  }
+  for (let i = 0;i < nextLayers.length; i++) {
+    const n = nextLayers[i];
+    const p = prevById[n.id];
+    if (p === undefined) {
+      let before;
+      for (let j = i + 1;j < nextLayers.length; j++) {
+        if (nextLayers[j].id in prevById) {
+          before = nextLayers[j].id;
+          break;
+        }
+      }
+      commands.push({ command: "addLayer", args: [n, before] });
+      continue;
+    }
+    if (p.type !== n.type) {
+      commands.push({ command: "removeLayer", args: [n.id] });
+      let before;
+      for (let j = i + 1;j < nextLayers.length; j++) {
+        if (nextLayers[j].id in prevById && nextLayers[j].id !== n.id) {
+          before = nextLayers[j].id;
+          break;
+        }
+      }
+      commands.push({ command: "addLayer", args: [n, before] });
+      continue;
+    }
+    const pSource = p.source;
+    const nSource = n.source;
+    const pSourceLayer = p["source-layer"];
+    const nSourceLayer = n["source-layer"];
+    if (pSource !== nSource || pSourceLayer !== nSourceLayer) {
+      commands.push({ command: "removeLayer", args: [n.id] });
+      let before;
+      for (let j = i + 1;j < nextLayers.length; j++) {
+        if (nextLayers[j].id in prevById && nextLayers[j].id !== n.id) {
+          before = nextLayers[j].id;
+          break;
+        }
+      }
+      commands.push({ command: "addLayer", args: [n, before] });
+      continue;
+    }
+    if (p.minzoom !== n.minzoom || p.maxzoom !== n.maxzoom)
+      commands.push({ command: "setLayerZoomRange", args: [n.id, n.minzoom, n.maxzoom] });
+    const pFilter = p.filter;
+    const nFilter = n.filter;
+    if (!deepEqual(pFilter, nFilter))
+      commands.push({ command: "setFilter", args: [n.id, nFilter] });
+    diffPaint(p, n, commands);
+    diffLayout(p, n, commands);
+  }
+  return { commands };
+}
+
+// src/core-map/style-spec/expressions/Color.ts
+function clamp01(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function clampByte(n) {
+  return n < 0 ? 0 : n > 255 ? 255 : n;
+}
+function hexDigit(ch) {
+  const c = ch.charCodeAt(0);
+  if (c >= 48 && c <= 57)
+    return c - 48;
+  if (c >= 97 && c <= 102)
+    return c - 87;
+  if (c >= 65 && c <= 70)
+    return c - 55;
+  return Number.NaN;
+}
+function parseHex(hex) {
+  const len = hex.length;
+  if (len === 3 || len === 4) {
+    const r = hexDigit(hex[0]);
+    const g = hexDigit(hex[1]);
+    const b = hexDigit(hex[2]);
+    const a = len === 4 ? hexDigit(hex[3]) : 15;
+    if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a))
+      return null;
+    return [r * 17 / 255, g * 17 / 255, b * 17 / 255, a * 17 / 255];
+  }
+  if (len === 6 || len === 8) {
+    const r = hexDigit(hex[0]) << 4 | hexDigit(hex[1]);
+    const g = hexDigit(hex[2]) << 4 | hexDigit(hex[3]);
+    const b = hexDigit(hex[4]) << 4 | hexDigit(hex[5]);
+    const a = len === 8 ? hexDigit(hex[6]) << 4 | hexDigit(hex[7]) : 255;
+    if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a))
+      return null;
+    return [r / 255, g / 255, b / 255, a / 255];
+  }
+  return null;
+}
+function parseRgbComponent(input) {
+  const s = input.trim();
+  if (s.endsWith("%")) {
+    const n2 = Number.parseFloat(s.slice(0, -1));
+    if (Number.isNaN(n2))
+      return Number.NaN;
+    return clamp01(n2 / 100);
+  }
+  const n = Number.parseFloat(s);
+  if (Number.isNaN(n))
+    return Number.NaN;
+  return clampByte(n) / 255;
+}
+function parseAlpha(input) {
+  const s = input.trim();
+  if (s.endsWith("%")) {
+    const n2 = Number.parseFloat(s.slice(0, -1));
+    if (Number.isNaN(n2))
+      return Number.NaN;
+    return clamp01(n2 / 100);
+  }
+  const n = Number.parseFloat(s);
+  if (Number.isNaN(n))
+    return Number.NaN;
+  return clamp01(n);
+}
+function hslToRgb(h, s, l) {
+  const hn = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hn / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (hn < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (hn < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (hn < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (hn < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (hn < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return [clamp01(r + m), clamp01(g + m), clamp01(b + m)];
+}
+function splitArgs(body) {
+  if (body.includes(","))
+    return body.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const slashIdx = body.indexOf("/");
+  const main = slashIdx >= 0 ? body.slice(0, slashIdx) : body;
+  const alpha = slashIdx >= 0 ? body.slice(slashIdx + 1) : "";
+  const parts = main.trim().split(/\s+/).filter((s) => s.length > 0);
+  if (alpha.trim().length > 0)
+    parts.push(alpha.trim());
+  return parts;
+}
+function parseColor(css) {
+  if (typeof css !== "string")
+    return null;
+  const s = css.trim().toLowerCase();
+  if (s.length === 0)
+    return null;
+  if (s.startsWith("#"))
+    return parseHex(s.slice(1));
+  const openIdx = s.indexOf("(");
+  if (openIdx > 0 && s.endsWith(")")) {
+    const fn = s.slice(0, openIdx);
+    const body = s.slice(openIdx + 1, -1);
+    const args = splitArgs(body);
+    if (fn === "rgb" || fn === "rgba") {
+      if (args.length < 3 || args.length > 4)
+        return null;
+      const r = parseRgbComponent(args[0]);
+      const g = parseRgbComponent(args[1]);
+      const b = parseRgbComponent(args[2]);
+      const a = args.length === 4 ? parseAlpha(args[3]) : 1;
+      if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a))
+        return null;
+      return [r, g, b, a];
+    }
+    if (fn === "hsl" || fn === "hsla") {
+      if (args.length < 3 || args.length > 4)
+        return null;
+      const hRaw = args[0].trim();
+      const h = Number.parseFloat(hRaw.endsWith("deg") ? hRaw.slice(0, -3) : hRaw);
+      const sStr = args[1].trim();
+      const lStr = args[2].trim();
+      if (!sStr.endsWith("%") || !lStr.endsWith("%"))
+        return null;
+      const sat = Number.parseFloat(sStr.slice(0, -1)) / 100;
+      const lig = Number.parseFloat(lStr.slice(0, -1)) / 100;
+      if (Number.isNaN(h) || Number.isNaN(sat) || Number.isNaN(lig))
+        return null;
+      const [r, g, b] = hslToRgb(h, clamp01(sat), clamp01(lig));
+      const a = args.length === 4 ? parseAlpha(args[3]) : 1;
+      if (Number.isNaN(a))
+        return null;
+      return [r, g, b, a];
+    }
+    return null;
+  }
+  const named = NAMED_COLORS[s];
+  if (named !== undefined)
+    return parseColor(named);
+  return null;
+}
+function lerpColor(a, b, t) {
+  const u = t < 0 ? 0 : t > 1 ? 1 : t;
+  return [
+    a[0] + (b[0] - a[0]) * u,
+    a[1] + (b[1] - a[1]) * u,
+    a[2] + (b[2] - a[2]) * u,
+    a[3] + (b[3] - a[3]) * u
+  ];
+}
+function formatColor(c) {
+  const r = Math.round(clamp01(c[0]) * 255);
+  const g = Math.round(clamp01(c[1]) * 255);
+  const b = Math.round(clamp01(c[2]) * 255);
+  const a = clamp01(c[3]);
+  const aStr = a === 1 ? "1" : String(Number(a.toFixed(4)));
+  return `rgba(${r},${g},${b},${aStr})`;
+}
+var NAMED_COLORS;
+var init_Color = __esm(() => {
+  NAMED_COLORS = {
+    aliceblue: "#f0f8ff",
+    antiquewhite: "#faebd7",
+    aqua: "#00ffff",
+    aquamarine: "#7fffd4",
+    azure: "#f0ffff",
+    beige: "#f5f5dc",
+    bisque: "#ffe4c4",
+    black: "#000000",
+    blanchedalmond: "#ffebcd",
+    blue: "#0000ff",
+    blueviolet: "#8a2be2",
+    brown: "#a52a2a",
+    burlywood: "#deb887",
+    cadetblue: "#5f9ea0",
+    chartreuse: "#7fff00",
+    chocolate: "#d2691e",
+    coral: "#ff7f50",
+    cornflowerblue: "#6495ed",
+    cornsilk: "#fff8dc",
+    crimson: "#dc143c",
+    cyan: "#00ffff",
+    darkblue: "#00008b",
+    darkcyan: "#008b8b",
+    darkgoldenrod: "#b8860b",
+    darkgray: "#a9a9a9",
+    darkgreen: "#006400",
+    darkgrey: "#a9a9a9",
+    darkkhaki: "#bdb76b",
+    darkmagenta: "#8b008b",
+    darkolivegreen: "#556b2f",
+    darkorange: "#ff8c00",
+    darkorchid: "#9932cc",
+    darkred: "#8b0000",
+    darksalmon: "#e9967a",
+    darkseagreen: "#8fbc8f",
+    darkslateblue: "#483d8b",
+    darkslategray: "#2f4f4f",
+    darkslategrey: "#2f4f4f",
+    darkturquoise: "#00ced1",
+    darkviolet: "#9400d3",
+    deeppink: "#ff1493",
+    deepskyblue: "#00bfff",
+    dimgray: "#696969",
+    dimgrey: "#696969",
+    dodgerblue: "#1e90ff",
+    firebrick: "#b22222",
+    floralwhite: "#fffaf0",
+    forestgreen: "#228b22",
+    fuchsia: "#ff00ff",
+    gainsboro: "#dcdcdc",
+    ghostwhite: "#f8f8ff",
+    gold: "#ffd700",
+    goldenrod: "#daa520",
+    gray: "#808080",
+    green: "#008000",
+    greenyellow: "#adff2f",
+    grey: "#808080",
+    honeydew: "#f0fff0",
+    hotpink: "#ff69b4",
+    indianred: "#cd5c5c",
+    indigo: "#4b0082",
+    ivory: "#fffff0",
+    khaki: "#f0e68c",
+    lavender: "#e6e6fa",
+    lavenderblush: "#fff0f5",
+    lawngreen: "#7cfc00",
+    lemonchiffon: "#fffacd",
+    lightblue: "#add8e6",
+    lightcoral: "#f08080",
+    lightcyan: "#e0ffff",
+    lightgoldenrodyellow: "#fafad2",
+    lightgray: "#d3d3d3",
+    lightgreen: "#90ee90",
+    lightgrey: "#d3d3d3",
+    lightpink: "#ffb6c1",
+    lightsalmon: "#ffa07a",
+    lightseagreen: "#20b2aa",
+    lightskyblue: "#87cefa",
+    lightslategray: "#778899",
+    lightslategrey: "#778899",
+    lightsteelblue: "#b0c4de",
+    lightyellow: "#ffffe0",
+    lime: "#00ff00",
+    limegreen: "#32cd32",
+    linen: "#faf0e6",
+    magenta: "#ff00ff",
+    maroon: "#800000",
+    mediumaquamarine: "#66cdaa",
+    mediumblue: "#0000cd",
+    mediumorchid: "#ba55d3",
+    mediumpurple: "#9370db",
+    mediumseagreen: "#3cb371",
+    mediumslateblue: "#7b68ee",
+    mediumspringgreen: "#00fa9a",
+    mediumturquoise: "#48d1cc",
+    mediumvioletred: "#c71585",
+    midnightblue: "#191970",
+    mintcream: "#f5fffa",
+    mistyrose: "#ffe4e1",
+    moccasin: "#ffe4b5",
+    navajowhite: "#ffdead",
+    navy: "#000080",
+    oldlace: "#fdf5e6",
+    olive: "#808000",
+    olivedrab: "#6b8e23",
+    orange: "#ffa500",
+    orangered: "#ff4500",
+    orchid: "#da70d6",
+    palegoldenrod: "#eee8aa",
+    palegreen: "#98fb98",
+    paleturquoise: "#afeeee",
+    palevioletred: "#db7093",
+    papayawhip: "#ffefd5",
+    peachpuff: "#ffdab9",
+    peru: "#cd853f",
+    pink: "#ffc0cb",
+    plum: "#dda0dd",
+    powderblue: "#b0e0e6",
+    purple: "#800080",
+    rebeccapurple: "#663399",
+    red: "#ff0000",
+    rosybrown: "#bc8f8f",
+    royalblue: "#4169e1",
+    saddlebrown: "#8b4513",
+    salmon: "#fa8072",
+    sandybrown: "#f4a460",
+    seagreen: "#2e8b57",
+    seashell: "#fff5ee",
+    sienna: "#a0522d",
+    silver: "#c0c0c0",
+    skyblue: "#87ceeb",
+    steelblue: "#4682b4",
+    slateblue: "#6a5acd",
+    slategray: "#708090",
+    slategrey: "#708090",
+    snow: "#fffafa",
+    springgreen: "#00ff7f",
+    tan: "#d2b48c",
+    teal: "#008080",
+    thistle: "#d8bfd8",
+    tomato: "#ff6347",
+    transparent: "rgba(0,0,0,0)",
+    turquoise: "#40e0d0",
+    violet: "#ee82ee",
+    wheat: "#f5deb3",
+    white: "#ffffff",
+    whitesmoke: "#f5f5f5",
+    yellow: "#ffff00",
+    yellowgreen: "#9acd32"
+  };
+});
+
+// src/core-map/style-spec/expressions/errors.ts
+var ExpressionError;
+var init_errors = __esm(() => {
+  ExpressionError = class ExpressionError extends Error {
+    constructor(message, expression, path = []) {
+      const prefix = path.length > 0 ? `[${path.map((p) => JSON.stringify(p)).join("][")}] ` : "";
+      super(`${prefix}${message}`);
+      this.name = "ExpressionError";
+      this.expression = expression;
+      this.path = path.slice();
+    }
+  };
+});
+
+// src/core-map/style-spec/expressions/registry.ts
+function registerOperator(name, fn) {
+  OPERATORS[name] = fn;
+}
+function getOperator(name) {
+  return OPERATORS[name];
+}
+function hasOperator(name) {
+  return Object.prototype.hasOwnProperty.call(OPERATORS, name);
+}
+var OPERATORS;
+var init_registry = __esm(() => {
+  OPERATORS = {};
+});
+
+// src/core-map/style-spec/expressions/operators/conversion.ts
+function mergeDeps(children) {
+  let z = false;
+  let f = false;
+  let s = false;
+  for (const c of children) {
+    if (c.dependsOnZoom)
+      z = true;
+    if (c.dependsOnFeature)
+      f = true;
+    if (c.dependsOnFeatureState)
+      s = true;
+  }
+  return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
+}
+function registerConversionOps() {
+  registerOperator("to-string", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"to-string" expects 1 argument, got ${args.length}`, ["to-string", ...args], path);
+    const inner = compile(args[0], "value", path.concat(1));
+    return {
+      evaluate: (ctx) => {
+        const v = inner.evaluate(ctx);
+        if (v === null || v === undefined)
+          return "";
+        if (typeof v === "string")
+          return v;
+        if (typeof v === "number" || typeof v === "boolean")
+          return String(v);
+        try {
+          return JSON.stringify(v);
+        } catch {
+          return String(v);
+        }
+      },
+      returnType: "string",
+      ...mergeDeps([inner])
+    };
+  });
+  registerOperator("to-number", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"to-number" expects at least 1 argument', ["to-number", ...args], path);
+    const children = args.map((a, i) => compile(a, "value", path.concat(i + 1)));
+    const expr = ["to-number", ...args];
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++) {
+          const v = children[i].evaluate(ctx);
+          if (v === null || v === undefined)
+            continue;
+          if (typeof v === "number") {
+            if (!Number.isNaN(v))
+              return v;
+            continue;
+          }
+          if (typeof v === "boolean")
+            return v ? 1 : 0;
+          if (typeof v === "string") {
+            const s = v.trim();
+            if (s.length === 0)
+              continue;
+            const n = Number(s);
+            if (!Number.isNaN(n))
+              return n;
+          }
+        }
+        throw new ExpressionError('"to-number": could not convert any argument to a number', expr);
+      },
+      returnType: "number",
+      ...mergeDeps(children)
+    };
+  });
+  registerOperator("to-boolean", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"to-boolean" expects 1 argument, got ${args.length}`, ["to-boolean", ...args], path);
+    const inner = compile(args[0], "value", path.concat(1));
+    return {
+      evaluate: (ctx) => {
+        const v = inner.evaluate(ctx);
+        if (v === null || v === undefined)
+          return false;
+        if (typeof v === "number")
+          return v !== 0 && !Number.isNaN(v);
+        if (typeof v === "string")
+          return v.length > 0;
+        if (typeof v === "boolean")
+          return v;
+        if (Array.isArray(v))
+          return v.length > 0;
+        if (typeof v === "object")
+          return true;
+        return Boolean(v);
+      },
+      returnType: "boolean",
+      ...mergeDeps([inner])
+    };
+  });
+  registerOperator("to-rgba", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"to-rgba" expects 1 argument, got ${args.length}`, ["to-rgba", ...args], path);
+    const inner = compile(args[0], "color", path.concat(1));
+    const expr = ["to-rgba", ...args];
+    return {
+      evaluate: (ctx) => {
+        const v = inner.evaluate(ctx);
+        const rgba = coerceColor(v);
+        if (!rgba)
+          throw new ExpressionError(`"to-rgba": cannot convert ${String(v)} to a color`, expr);
+        return [
+          Math.round(rgba[0] * 255),
+          Math.round(rgba[1] * 255),
+          Math.round(rgba[2] * 255),
+          rgba[3]
+        ];
+      },
+      returnType: "array",
+      ...mergeDeps([inner])
+    };
+  });
+  registerOperator("to-color", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"to-color" expects at least 1 argument', ["to-color", ...args], path);
+    const children = args.map((a, i) => compile(a, "value", path.concat(i + 1)));
+    const expr = ["to-color", ...args];
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++) {
+          const v = children[i].evaluate(ctx);
+          const rgba = coerceColor(v);
+          if (rgba)
+            return formatRgba(rgba);
+        }
+        throw new ExpressionError('"to-color": could not convert any argument to a color', expr);
+      },
+      returnType: "color",
+      ...mergeDeps(children)
+    };
+  });
+}
+function coerceColor(v) {
+  if (typeof v === "string")
+    return parseColor(v);
+  if (Array.isArray(v) && (v.length === 3 || v.length === 4)) {
+    const r = Number(v[0]);
+    const g = Number(v[1]);
+    const b = Number(v[2]);
+    const a = v.length === 4 ? Number(v[3]) : 1;
+    if ([r, g, b, a].some(Number.isNaN))
+      return null;
+    return [clamp012(r / 255), clamp012(g / 255), clamp012(b / 255), clamp012(a)];
+  }
+  return null;
+}
+function clamp012(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function formatRgba(c) {
+  const r = Math.round(clamp012(c[0]) * 255);
+  const g = Math.round(clamp012(c[1]) * 255);
+  const b = Math.round(clamp012(c[2]) * 255);
+  const a = clamp012(c[3]);
+  return `rgba(${r},${g},${b},${a === 1 ? "1" : String(Number(a.toFixed(4)))})`;
+}
+var init_conversion = __esm(() => {
+  init_Color();
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/interpolate.ts
+function mergeDeps2(children) {
+  let z = false;
+  let f = false;
+  let s = false;
+  for (const c of children) {
+    if (c.dependsOnZoom)
+      z = true;
+    if (c.dependsOnFeature)
+      f = true;
+    if (c.dependsOnFeatureState)
+      s = true;
+  }
+  return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
+}
+function findStop(stops, x) {
+  if (stops.length === 0 || x < stops[0])
+    return -1;
+  let lo = 0;
+  let hi = stops.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (stops[mid] <= x)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return lo;
+}
+function linearT(a, b, x) {
+  if (a === b)
+    return 0;
+  const t = (x - a) / (b - a);
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function exponentialT(base, a, b, x) {
+  if (a === b)
+    return 0;
+  if (base === 1)
+    return linearT(a, b, x);
+  const diff = b - a;
+  const progress = x - a;
+  const t = (base ** progress - 1) / (base ** diff - 1);
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function cubicBezierT(x1, y1, x2, y2) {
+  const cx = 3 * x1;
+  const bx = 3 * (x2 - x1) - cx;
+  const ax = 1 - cx - bx;
+  const cy = 3 * y1;
+  const by = 3 * (y2 - y1) - cy;
+  const ay = 1 - cy - by;
+  const sampleX = (t) => ((ax * t + bx) * t + cx) * t;
+  const sampleY = (t) => ((ay * t + by) * t + cy) * t;
+  const sampleDerivX = (t) => (3 * ax * t + 2 * bx) * t + cx;
+  return (u) => {
+    if (u <= 0)
+      return 0;
+    if (u >= 1)
+      return 1;
+    let t = u;
+    for (let i = 0;i < 8; i++) {
+      const x = sampleX(t) - u;
+      if (Math.abs(x) < 0.000001)
+        return sampleY(t);
+      const d = sampleDerivX(t);
+      if (Math.abs(d) < 0.000001)
+        break;
+      t -= x / d;
+    }
+    let lo = 0;
+    let hi = 1;
+    let tt = u;
+    for (let i = 0;i < 20; i++) {
+      const x = sampleX(tt) - u;
+      if (Math.abs(x) < 0.000001)
+        return sampleY(tt);
+      if (x > 0)
+        hi = tt;
+      else
+        lo = tt;
+      tt = (lo + hi) / 2;
+    }
+    return sampleY(tt);
+  };
+}
+function parseInterp(spec, path) {
+  if (!Array.isArray(spec) || spec.length === 0)
+    throw new ExpressionError('"interpolate": interpolation type required', spec, path);
+  const head = spec[0];
+  if (head === "linear")
+    return { kind: "linear" };
+  if (head === "exponential") {
+    const base = Number(spec[1]);
+    if (!Number.isFinite(base) || base <= 0)
+      throw new ExpressionError('"interpolate": exponential base must be a positive number', spec, path);
+    return { kind: "exponential", base };
+  }
+  if (head === "cubic-bezier") {
+    const x1 = Number(spec[1]);
+    const y1 = Number(spec[2]);
+    const x2 = Number(spec[3]);
+    const y2 = Number(spec[4]);
+    if ([x1, y1, x2, y2].some((n) => !Number.isFinite(n)))
+      throw new ExpressionError('"interpolate": cubic-bezier requires 4 numeric control points', spec, path);
+    return { kind: "cubic-bezier", bezier: cubicBezierT(x1, y1, x2, y2) };
+  }
+  throw new ExpressionError(`"interpolate": unknown interpolation type ${JSON.stringify(head)}`, spec, path);
+}
+function pickBlender(returnType) {
+  if (returnType === "number") {
+    return (a, b, t) => {
+      const av = Number(a);
+      const bv = Number(b);
+      return av + (bv - av) * t;
+    };
+  }
+  if (returnType === "color") {
+    return (a, b, t) => {
+      const ac = toRgba(a);
+      const bc = toRgba(b);
+      if (!ac || !bc)
+        return a;
+      return formatRgba2(lerpColor(ac, bc, t));
+    };
+  }
+  if (returnType === "string") {
+    return (a, b, t) => {
+      if (typeof a !== "string" || typeof b !== "string")
+        return t < 1 ? a : b;
+      const ac = toRgba(a);
+      const bc = toRgba(b);
+      if (!ac || !bc)
+        return t < 1 ? a : b;
+      return formatRgba2(lerpColor(ac, bc, t));
+    };
+  }
+  if (returnType === "array") {
+    return (a, b, t) => {
+      if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+        return a;
+      const out = new Array(a.length);
+      for (let i = 0;i < a.length; i++) {
+        const av = Number(a[i]);
+        const bv = Number(b[i]);
+        out[i] = av + (bv - av) * t;
+      }
+      return out;
+    };
+  }
+  return (a, _b, t) => t < 1 ? a : _b;
+}
+function toRgba(v) {
+  if (typeof v === "string")
+    return parseColor(v);
+  if (Array.isArray(v) && (v.length === 3 || v.length === 4)) {
+    const r = Number(v[0]) / 255;
+    const g = Number(v[1]) / 255;
+    const b = Number(v[2]) / 255;
+    const a = v.length === 4 ? Number(v[3]) : 1;
+    if ([r, g, b, a].some(Number.isNaN))
+      return null;
+    return [clamp013(r), clamp013(g), clamp013(b), clamp013(a)];
+  }
+  return null;
+}
+function clamp013(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function formatRgba2(c) {
+  const r = Math.round(clamp013(c[0]) * 255);
+  const g = Math.round(clamp013(c[1]) * 255);
+  const b = Math.round(clamp013(c[2]) * 255);
+  const a = clamp013(c[3]);
+  return `rgba(${r},${g},${b},${a === 1 ? "1" : String(Number(a.toFixed(4)))})`;
+}
+function registerInterpolateOps() {
+  registerOperator("interpolate", (args, compile, path, expected) => {
+    if (args.length < 4 || args.length % 2 !== 0)
+      throw new ExpressionError(`"interpolate" expects interpolation, input, (stop, value)+ — got ${args.length} arguments`, ["interpolate", ...args], path);
+    const interp = parseInterp(args[0], path.concat(1));
+    const input = compile(args[1], "number", path.concat(2));
+    const stopExpected = expected === "value" ? "value" : expected;
+    const stopInputs = [];
+    const stopOutputs = [];
+    for (let i = 2;i < args.length; i += 2) {
+      const stopIn = args[i];
+      if (typeof stopIn !== "number")
+        throw new ExpressionError(`"interpolate": stop input at position ${i} must be a number literal`, ["interpolate", ...args], path.concat(i + 1));
+      stopInputs.push(stopIn);
+      stopOutputs.push(compile(args[i + 1], stopExpected, path.concat(i + 2)));
+    }
+    for (let i = 1;i < stopInputs.length; i++) {
+      if (stopInputs[i] <= stopInputs[i - 1])
+        throw new ExpressionError('"interpolate": stop inputs must be strictly increasing', ["interpolate", ...args], path);
+    }
+    const returnType = expected !== "value" ? expected : stopOutputs[0].returnType;
+    const blend = pickBlender(returnType);
+    const children = [input, ...stopOutputs];
+    return {
+      evaluate: (ctx) => {
+        const x = Number(input.evaluate(ctx));
+        if (!Number.isFinite(x))
+          return stopOutputs[0].evaluate(ctx);
+        const idx = findStop(stopInputs, x);
+        if (idx < 0)
+          return stopOutputs[0].evaluate(ctx);
+        if (idx >= stopInputs.length - 1)
+          return stopOutputs[stopOutputs.length - 1].evaluate(ctx);
+        const a = stopInputs[idx];
+        const b = stopInputs[idx + 1];
+        let t;
+        if (interp.kind === "linear")
+          t = linearT(a, b, x);
+        else if (interp.kind === "exponential")
+          t = exponentialT(interp.base, a, b, x);
+        else {
+          const u = linearT(a, b, x);
+          t = interp.bezier(u);
+        }
+        return blend(stopOutputs[idx].evaluate(ctx), stopOutputs[idx + 1].evaluate(ctx), t);
+      },
+      returnType,
+      ...mergeDeps2(children)
+    };
+  });
+  registerOperator("step", (args, compile, path, expected) => {
+    if (args.length < 4 || args.length % 2 !== 0)
+      throw new ExpressionError(`"step" expects input, fallback, (stop, value)+ — got ${args.length} arguments`, ["step", ...args], path);
+    const input = compile(args[0], "number", path.concat(1));
+    const fallback = compile(args[1], expected, path.concat(2));
+    const stopInputs = [];
+    const stopOutputs = [];
+    for (let i = 2;i < args.length; i += 2) {
+      const stopIn = args[i];
+      if (typeof stopIn !== "number")
+        throw new ExpressionError(`"step": stop input at position ${i} must be a number literal`, ["step", ...args], path.concat(i + 1));
+      stopInputs.push(stopIn);
+      stopOutputs.push(compile(args[i + 1], expected, path.concat(i + 2)));
+    }
+    for (let i = 1;i < stopInputs.length; i++) {
+      if (stopInputs[i] <= stopInputs[i - 1])
+        throw new ExpressionError('"step": stop inputs must be strictly increasing', ["step", ...args], path);
+    }
+    const returnType = expected !== "value" ? expected : stopOutputs.length > 0 ? stopOutputs[0].returnType : fallback.returnType;
+    const children = [input, fallback, ...stopOutputs];
+    return {
+      evaluate: (ctx) => {
+        const x = Number(input.evaluate(ctx));
+        if (!Number.isFinite(x))
+          return fallback.evaluate(ctx);
+        const idx = findStop(stopInputs, x);
+        if (idx < 0)
+          return fallback.evaluate(ctx);
+        return stopOutputs[idx].evaluate(ctx);
+      },
+      returnType,
+      ...mergeDeps2(children)
+    };
+  });
+}
+var init_interpolate = __esm(() => {
+  init_Color();
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/logical.ts
+function mergeDeps3(children) {
+  let z = false;
+  let f = false;
+  let s = false;
+  for (const c of children) {
+    if (c.dependsOnZoom)
+      z = true;
+    if (c.dependsOnFeature)
+      f = true;
+    if (c.dependsOnFeatureState)
+      s = true;
+  }
+  return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
+}
+function strictEq(a, b) {
+  if (a === b)
+    return true;
+  return false;
+}
+function compare(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    if (Number.isNaN(a) || Number.isNaN(b))
+      return Number.NaN;
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  if (typeof a === "string" && typeof b === "string")
+    return a < b ? -1 : a > b ? 1 : 0;
+  return Number.NaN;
+}
+function registerLogicalOps() {
+  registerOperator("!", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"!" expects 1 argument, got ${args.length}`, ["!", ...args], path);
+    const inner = compile(args[0], "boolean", path.concat(1));
+    return {
+      evaluate: (ctx) => !inner.evaluate(ctx),
+      returnType: "boolean",
+      ...mergeDeps3([inner])
+    };
+  });
+  registerOperator("==", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"==" expects 2 arguments, got ${args.length}`, ["==", ...args], path);
+    const a = compile(args[0], "value", path.concat(1));
+    const b = compile(args[1], "value", path.concat(2));
+    return {
+      evaluate: (ctx) => strictEq(a.evaluate(ctx), b.evaluate(ctx)),
+      returnType: "boolean",
+      ...mergeDeps3([a, b])
+    };
+  });
+  registerOperator("!=", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"!=" expects 2 arguments, got ${args.length}`, ["!=", ...args], path);
+    const a = compile(args[0], "value", path.concat(1));
+    const b = compile(args[1], "value", path.concat(2));
+    return {
+      evaluate: (ctx) => !strictEq(a.evaluate(ctx), b.evaluate(ctx)),
+      returnType: "boolean",
+      ...mergeDeps3([a, b])
+    };
+  });
+  const comparator = (name) => {
+    registerOperator(name, (args, compile, path) => {
+      if (args.length !== 2)
+        throw new ExpressionError(`"${name}" expects 2 arguments, got ${args.length}`, [name, ...args], path);
+      const a = compile(args[0], "value", path.concat(1));
+      const b = compile(args[1], "value", path.concat(2));
+      return {
+        evaluate: (ctx) => {
+          const cmp = compare(a.evaluate(ctx), b.evaluate(ctx));
+          if (Number.isNaN(cmp))
+            return false;
+          switch (name) {
+            case "<":
+              return cmp < 0;
+            case "<=":
+              return cmp <= 0;
+            case ">":
+              return cmp > 0;
+            case ">=":
+              return cmp >= 0;
+          }
+        },
+        returnType: "boolean",
+        ...mergeDeps3([a, b])
+      };
+    });
+  };
+  comparator("<");
+  comparator("<=");
+  comparator(">");
+  comparator(">=");
+  registerOperator("all", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "boolean", path.concat(i + 1)));
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++)
+          if (!children[i].evaluate(ctx))
+            return false;
+        return true;
+      },
+      returnType: "boolean",
+      ...mergeDeps3(children)
+    };
+  });
+  registerOperator("any", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "boolean", path.concat(i + 1)));
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++)
+          if (children[i].evaluate(ctx))
+            return true;
+        return false;
+      },
+      returnType: "boolean",
+      ...mergeDeps3(children)
+    };
+  });
+  registerOperator("none", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "boolean", path.concat(i + 1)));
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++)
+          if (children[i].evaluate(ctx))
+            return false;
+        return true;
+      },
+      returnType: "boolean",
+      ...mergeDeps3(children)
+    };
+  });
+  registerOperator("case", (args, compile, path, expected) => {
+    if (args.length < 3 || args.length % 2 !== 1)
+      throw new ExpressionError(`"case" expects an odd number of arguments >= 3 (cond, val, ..., fallback), got ${args.length}`, ["case", ...args], path);
+    const branches = [];
+    for (let i = 0;i < args.length - 1; i += 2) {
+      branches.push({
+        cond: compile(args[i], "boolean", path.concat(i + 1)),
+        val: compile(args[i + 1], expected, path.concat(i + 2))
+      });
+    }
+    const fallback = compile(args[args.length - 1], expected, path.concat(args.length));
+    const all = [fallback];
+    for (const b of branches) {
+      all.push(b.cond);
+      all.push(b.val);
+    }
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < branches.length; i++) {
+          const br = branches[i];
+          if (br.cond.evaluate(ctx))
+            return br.val.evaluate(ctx);
+        }
+        return fallback.evaluate(ctx);
+      },
+      returnType: expected,
+      ...mergeDeps3(all)
+    };
+  });
+  registerOperator("match", (args, compile, path, expected) => {
+    if (args.length < 4 || args.length % 2 !== 0)
+      throw new ExpressionError(`"match" expects input, (label, value)+, fallback — got ${args.length} arguments`, ["match", ...args], path);
+    const input = compile(args[0], "value", path.concat(1));
+    const branches = [];
+    for (let i = 1;i < args.length - 1; i += 2) {
+      const label = args[i];
+      const labels = Array.isArray(label) ? label : [label];
+      for (const l of labels) {
+        if (typeof l !== "string" && typeof l !== "number" && typeof l !== "boolean")
+          throw new ExpressionError('"match" labels must be strings, numbers, or booleans', ["match", ...args], path.concat(i + 1));
+      }
+      branches.push({
+        labels,
+        val: compile(args[i + 1], expected, path.concat(i + 2))
+      });
+    }
+    const fallback = compile(args[args.length - 1], expected, path.concat(args.length));
+    const all = [input, fallback];
+    for (const b of branches)
+      all.push(b.val);
+    return {
+      evaluate: (ctx) => {
+        const x = input.evaluate(ctx);
+        for (let i = 0;i < branches.length; i++) {
+          const br = branches[i];
+          for (let j = 0;j < br.labels.length; j++) {
+            if (strictEq(x, br.labels[j]))
+              return br.val.evaluate(ctx);
+          }
+        }
+        return fallback.evaluate(ctx);
+      },
+      returnType: expected,
+      ...mergeDeps3(all)
+    };
+  });
+  registerOperator("coalesce", (args, compile, path, expected) => {
+    if (args.length === 0)
+      throw new ExpressionError('"coalesce" expects at least 1 argument', ["coalesce"], path);
+    const children = args.map((a, i) => compile(a, expected, path.concat(i + 1)));
+    return {
+      evaluate: (ctx) => {
+        for (let i = 0;i < children.length; i++) {
+          const v = children[i].evaluate(ctx);
+          if (v !== null && v !== undefined)
+            return v;
+        }
+        return null;
+      },
+      returnType: expected,
+      ...mergeDeps3(children)
+    };
+  });
+  registerOperator("in", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"in" expects at least 1 argument', ["in", ...args], path);
+    const input = compile(args[0], "value", path.concat(1));
+    const haystack = args.slice(1);
+    return {
+      evaluate: (ctx) => {
+        const x = input.evaluate(ctx);
+        for (let i = 0;i < haystack.length; i++)
+          if (strictEq(x, haystack[i]))
+            return true;
+        return false;
+      },
+      returnType: "boolean",
+      ...mergeDeps3([input])
+    };
+  });
+  registerOperator("!in", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"!in" expects at least 1 argument', ["!in", ...args], path);
+    const input = compile(args[0], "value", path.concat(1));
+    const haystack = args.slice(1);
+    return {
+      evaluate: (ctx) => {
+        const x = input.evaluate(ctx);
+        for (let i = 0;i < haystack.length; i++)
+          if (strictEq(x, haystack[i]))
+            return false;
+        return true;
+      },
+      returnType: "boolean",
+      ...mergeDeps3([input])
+    };
+  });
+  registerOperator("!has", (args, _compile, path) => {
+    if (args.length < 1 || args.length > 2)
+      throw new ExpressionError(`"!has" expects 1 or 2 arguments, got ${args.length}`, ["!has", ...args], path);
+    if (typeof args[0] !== "string")
+      throw new ExpressionError('"!has" key must be a string literal', ["!has", ...args], path);
+    const key = args[0];
+    return {
+      evaluate: (ctx) => {
+        const props = ctx.feature ? ctx.feature.properties : undefined;
+        return props ? !Object.prototype.hasOwnProperty.call(props, key) : true;
+      },
+      returnType: "boolean",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+}
+var init_logical = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/lookup.ts
+function registerLookupOps() {
+  registerOperator("literal", (args, _compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"literal" expects 1 argument, got ${args.length}`, ["literal", ...args], path);
+    const value = args[0];
+    return {
+      evaluate: () => value,
+      returnType: inferLiteralType(value),
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("get", (args, compile, path) => {
+    if (args.length < 1 || args.length > 2)
+      throw new ExpressionError(`"get" expects 1 or 2 arguments, got ${args.length}`, ["get", ...args], path);
+    if (typeof args[0] !== "string")
+      throw new ExpressionError('"get" key must be a string literal', ["get", ...args], path);
+    const key = args[0];
+    if (args.length === 2) {
+      const obj = compile(args[1], "value", path.concat(2));
+      return {
+        evaluate: (ctx) => {
+          const o = obj.evaluate(ctx);
+          if (o && typeof o === "object")
+            return o[key];
+          return;
+        },
+        returnType: "value",
+        dependsOnZoom: obj.dependsOnZoom,
+        dependsOnFeature: obj.dependsOnFeature,
+        dependsOnFeatureState: obj.dependsOnFeatureState
+      };
+    }
+    return {
+      evaluate: (ctx) => {
+        const props = ctx.feature ? ctx.feature.properties : undefined;
+        return props ? props[key] : undefined;
+      },
+      returnType: "value",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("has", (args, compile, path) => {
+    if (args.length < 1 || args.length > 2)
+      throw new ExpressionError(`"has" expects 1 or 2 arguments, got ${args.length}`, ["has", ...args], path);
+    if (typeof args[0] !== "string")
+      throw new ExpressionError('"has" key must be a string literal', ["has", ...args], path);
+    const key = args[0];
+    if (args.length === 2) {
+      const obj = compile(args[1], "value", path.concat(2));
+      return {
+        evaluate: (ctx) => {
+          const o = obj.evaluate(ctx);
+          if (o && typeof o === "object")
+            return Object.prototype.hasOwnProperty.call(o, key);
+          return false;
+        },
+        returnType: "boolean",
+        dependsOnZoom: obj.dependsOnZoom,
+        dependsOnFeature: obj.dependsOnFeature,
+        dependsOnFeatureState: obj.dependsOnFeatureState
+      };
+    }
+    return {
+      evaluate: (ctx) => {
+        const props = ctx.feature ? ctx.feature.properties : undefined;
+        return props ? Object.prototype.hasOwnProperty.call(props, key) : false;
+      },
+      returnType: "boolean",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("at", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"at" expects 2 arguments, got ${args.length}`, ["at", ...args], path);
+    const idx = compile(args[0], "number", path.concat(1));
+    const arr = compile(args[1], "array", path.concat(2));
+    return {
+      evaluate: (ctx) => {
+        const a = arr.evaluate(ctx);
+        const i = idx.evaluate(ctx);
+        if (!Array.isArray(a) || typeof i !== "number")
+          return;
+        if (i < 0 || i >= a.length || !Number.isFinite(i))
+          return;
+        return a[Math.floor(i)];
+      },
+      returnType: "value",
+      dependsOnZoom: idx.dependsOnZoom || arr.dependsOnZoom,
+      dependsOnFeature: idx.dependsOnFeature || arr.dependsOnFeature,
+      dependsOnFeatureState: idx.dependsOnFeatureState || arr.dependsOnFeatureState
+    };
+  });
+  registerOperator("length", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"length" expects 1 argument, got ${args.length}`, ["length", ...args], path);
+    const inner = compile(args[0], "value", path.concat(1));
+    return {
+      evaluate: (ctx) => {
+        const v = inner.evaluate(ctx);
+        if (typeof v === "string" || Array.isArray(v))
+          return v.length;
+        return 0;
+      },
+      returnType: "number",
+      dependsOnZoom: inner.dependsOnZoom,
+      dependsOnFeature: inner.dependsOnFeature,
+      dependsOnFeatureState: inner.dependsOnFeatureState
+    };
+  });
+  registerOperator("properties", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"properties" takes no arguments, got ${args.length}`, ["properties", ...args], path);
+    return {
+      evaluate: (ctx) => ctx.feature ? ctx.feature.properties : {},
+      returnType: "value",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("geometry-type", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"geometry-type" takes no arguments, got ${args.length}`, ["geometry-type", ...args], path);
+    return {
+      evaluate: (ctx) => {
+        if (!ctx.feature)
+          return "Unknown";
+        switch (ctx.feature.type) {
+          case 1:
+            return "Point";
+          case 2:
+            return "LineString";
+          case 3:
+            return "Polygon";
+          default:
+            return "Unknown";
+        }
+      },
+      returnType: "string",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("id", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"id" takes no arguments, got ${args.length}`, ["id", ...args], path);
+    return {
+      evaluate: (ctx) => ctx.feature ? ctx.feature.id : undefined,
+      returnType: "value",
+      dependsOnZoom: false,
+      dependsOnFeature: true,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("zoom", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"zoom" takes no arguments, got ${args.length}`, ["zoom", ...args], path);
+    return {
+      evaluate: (ctx) => ctx.zoom,
+      returnType: "number",
+      dependsOnZoom: true,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("line-progress", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"line-progress" takes no arguments, got ${args.length}`, ["line-progress", ...args], path);
+    return {
+      evaluate: (ctx) => ctx.lineProgress ?? 0,
+      returnType: "number",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("feature-state", (args, _compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"feature-state" expects 1 argument, got ${args.length}`, ["feature-state", ...args], path);
+    if (typeof args[0] !== "string")
+      throw new ExpressionError('"feature-state" key must be a string literal', ["feature-state", ...args], path);
+    const key = args[0];
+    return {
+      evaluate: (ctx) => {
+        const state = ctx.featureState;
+        return state ? state[key] : undefined;
+      },
+      returnType: "value",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: true
+    };
+  });
+}
+function inferLiteralType(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return "string";
+  if (typeof value === "number")
+    return "number";
+  if (typeof value === "boolean")
+    return "boolean";
+  if (Array.isArray(value))
+    return "array";
+  return "value";
+}
+var init_lookup = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/math.ts
+function expectNumber(value, op, expr) {
+  if (typeof value !== "number" || Number.isNaN(value))
+    throw new ExpressionError(`"${op}": expected number, got ${String(value)}`, expr);
+  return value;
+}
+function mergeDeps4(children) {
+  let z = false;
+  let f = false;
+  let s = false;
+  for (const c of children) {
+    if (c.dependsOnZoom)
+      z = true;
+    if (c.dependsOnFeature)
+      f = true;
+    if (c.dependsOnFeatureState)
+      s = true;
+  }
+  return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
+}
+function registerMathOps() {
+  registerOperator("+", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "number", path.concat(i + 1)));
+    const expr = ["+", ...args];
+    return {
+      evaluate: (ctx) => {
+        let acc = 0;
+        for (let i = 0;i < children.length; i++)
+          acc += expectNumber(children[i].evaluate(ctx), "+", expr);
+        return acc;
+      },
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+  registerOperator("*", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "number", path.concat(i + 1)));
+    const expr = ["*", ...args];
+    return {
+      evaluate: (ctx) => {
+        let acc = 1;
+        for (let i = 0;i < children.length; i++)
+          acc *= expectNumber(children[i].evaluate(ctx), "*", expr);
+        return acc;
+      },
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+  registerOperator("-", (args, compile, path) => {
+    if (args.length !== 1 && args.length !== 2)
+      throw new ExpressionError(`"-" expects 1 or 2 arguments, got ${args.length}`, ["-", ...args], path);
+    const children = args.map((a2, i) => compile(a2, "number", path.concat(i + 1)));
+    const expr = ["-", ...args];
+    if (children.length === 1) {
+      const a2 = children[0];
+      return {
+        evaluate: (ctx) => -expectNumber(a2.evaluate(ctx), "-", expr),
+        returnType: "number",
+        ...mergeDeps4(children)
+      };
+    }
+    const a = children[0];
+    const b = children[1];
+    return {
+      evaluate: (ctx) => expectNumber(a.evaluate(ctx), "-", expr) - expectNumber(b.evaluate(ctx), "-", expr),
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+  registerOperator("/", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"/" expects 2 arguments, got ${args.length}`, ["/", ...args], path);
+    const a = compile(args[0], "number", path.concat(1));
+    const b = compile(args[1], "number", path.concat(2));
+    const expr = ["/", ...args];
+    return {
+      evaluate: (ctx) => {
+        const av = expectNumber(a.evaluate(ctx), "/", expr);
+        const bv = expectNumber(b.evaluate(ctx), "/", expr);
+        if (bv === 0)
+          throw new ExpressionError('"/": divide by zero', expr);
+        return av / bv;
+      },
+      returnType: "number",
+      ...mergeDeps4([a, b])
+    };
+  });
+  registerOperator("%", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"%" expects 2 arguments, got ${args.length}`, ["%", ...args], path);
+    const a = compile(args[0], "number", path.concat(1));
+    const b = compile(args[1], "number", path.concat(2));
+    const expr = ["%", ...args];
+    return {
+      evaluate: (ctx) => {
+        const av = expectNumber(a.evaluate(ctx), "%", expr);
+        const bv = expectNumber(b.evaluate(ctx), "%", expr);
+        if (bv === 0)
+          throw new ExpressionError('"%": divide by zero', expr);
+        return av % bv;
+      },
+      returnType: "number",
+      ...mergeDeps4([a, b])
+    };
+  });
+  registerOperator("^", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"^" expects 2 arguments, got ${args.length}`, ["^", ...args], path);
+    const a = compile(args[0], "number", path.concat(1));
+    const b = compile(args[1], "number", path.concat(2));
+    const expr = ["^", ...args];
+    return {
+      evaluate: (ctx) => expectNumber(a.evaluate(ctx), "^", expr) ** expectNumber(b.evaluate(ctx), "^", expr),
+      returnType: "number",
+      ...mergeDeps4([a, b])
+    };
+  });
+  registerOperator("min", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"min" expects at least 1 argument', ["min"], path);
+    const children = args.map((a, i) => compile(a, "number", path.concat(i + 1)));
+    const expr = ["min", ...args];
+    return {
+      evaluate: (ctx) => {
+        let m = Infinity;
+        for (let i = 0;i < children.length; i++) {
+          const v = expectNumber(children[i].evaluate(ctx), "min", expr);
+          if (v < m)
+            m = v;
+        }
+        return m;
+      },
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+  registerOperator("max", (args, compile, path) => {
+    if (args.length < 1)
+      throw new ExpressionError('"max" expects at least 1 argument', ["max"], path);
+    const children = args.map((a, i) => compile(a, "number", path.concat(i + 1)));
+    const expr = ["max", ...args];
+    return {
+      evaluate: (ctx) => {
+        let m = -Infinity;
+        for (let i = 0;i < children.length; i++) {
+          const v = expectNumber(children[i].evaluate(ctx), "max", expr);
+          if (v > m)
+            m = v;
+        }
+        return m;
+      },
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+  const unary = (name, fn, validate) => {
+    registerOperator(name, (args, compile, path) => {
+      if (args.length !== 1)
+        throw new ExpressionError(`"${name}" expects 1 argument, got ${args.length}`, [name, ...args], path);
+      const inner = compile(args[0], "number", path.concat(1));
+      const expr = [name, ...args];
+      return {
+        evaluate: (ctx) => {
+          const v = expectNumber(inner.evaluate(ctx), name, expr);
+          if (validate)
+            validate(v, expr);
+          return fn(v);
+        },
+        returnType: "number",
+        ...mergeDeps4([inner])
+      };
+    });
+  };
+  unary("abs", Math.abs);
+  unary("floor", Math.floor);
+  unary("ceil", Math.ceil);
+  unary("round", Math.round);
+  unary("sqrt", Math.sqrt, (n, expr) => {
+    if (n < 0)
+      throw new ExpressionError('"sqrt": input must be non-negative', expr);
+  });
+  unary("ln", Math.log, (n, expr) => {
+    if (n <= 0)
+      throw new ExpressionError('"ln": input must be positive', expr);
+  });
+  unary("log10", Math.log10, (n, expr) => {
+    if (n <= 0)
+      throw new ExpressionError('"log10": input must be positive', expr);
+  });
+  unary("log2", Math.log2, (n, expr) => {
+    if (n <= 0)
+      throw new ExpressionError('"log2": input must be positive', expr);
+  });
+  registerOperator("e", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"e" takes no arguments, got ${args.length}`, ["e", ...args], path);
+    return {
+      evaluate: () => Math.E,
+      returnType: "number",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("pi", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"pi" takes no arguments, got ${args.length}`, ["pi", ...args], path);
+    return {
+      evaluate: () => Math.PI,
+      returnType: "number",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+  registerOperator("rand", (args, compile, path) => {
+    if (args.length < 2 || args.length > 3)
+      throw new ExpressionError(`"rand" expects 2 or 3 arguments, got ${args.length}`, ["rand", ...args], path);
+    const min = compile(args[0], "number", path.concat(1));
+    const max = compile(args[1], "number", path.concat(2));
+    const seed = args.length === 3 ? compile(args[2], "number", path.concat(3)) : null;
+    const expr = ["rand", ...args];
+    let state = 1;
+    const nextSeeded = () => {
+      state = state * 1664525 + 1013904223 >>> 0;
+      return state / 4294967296;
+    };
+    const children = seed ? [min, max, seed] : [min, max];
+    return {
+      evaluate: (ctx) => {
+        const a = expectNumber(min.evaluate(ctx), "rand", expr);
+        const b = expectNumber(max.evaluate(ctx), "rand", expr);
+        if (seed) {
+          const s = expectNumber(seed.evaluate(ctx), "rand", expr);
+          state = Math.floor(s) >>> 0 || 1;
+          nextSeeded();
+          return a + (b - a) * nextSeeded();
+        }
+        return a + (b - a) * Math.random();
+      },
+      returnType: "number",
+      ...mergeDeps4(children)
+    };
+  });
+}
+var init_math = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/string.ts
+function mergeDeps5(children) {
+  let z = false;
+  let f = false;
+  let s = false;
+  for (const c of children) {
+    if (c.dependsOnZoom)
+      z = true;
+    if (c.dependsOnFeature)
+      f = true;
+    if (c.dependsOnFeatureState)
+      s = true;
+  }
+  return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
+}
+function toStr(v) {
+  if (v === null || v === undefined)
+    return "";
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function registerStringOps() {
+  registerOperator("concat", (args, compile, path) => {
+    const children = args.map((a, i) => compile(a, "value", path.concat(i + 1)));
+    return {
+      evaluate: (ctx) => {
+        let out = "";
+        for (let i = 0;i < children.length; i++)
+          out += toStr(children[i].evaluate(ctx));
+        return out;
+      },
+      returnType: "string",
+      ...mergeDeps5(children)
+    };
+  });
+  registerOperator("downcase", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"downcase" expects 1 argument, got ${args.length}`, ["downcase", ...args], path);
+    const inner = compile(args[0], "string", path.concat(1));
+    return {
+      evaluate: (ctx) => toStr(inner.evaluate(ctx)).toLowerCase(),
+      returnType: "string",
+      ...mergeDeps5([inner])
+    };
+  });
+  registerOperator("upcase", (args, compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"upcase" expects 1 argument, got ${args.length}`, ["upcase", ...args], path);
+    const inner = compile(args[0], "string", path.concat(1));
+    return {
+      evaluate: (ctx) => toStr(inner.evaluate(ctx)).toUpperCase(),
+      returnType: "string",
+      ...mergeDeps5([inner])
+    };
+  });
+  registerOperator("resolved-locale", (args, _compile, path) => {
+    if (args.length !== 0 && args.length !== 1)
+      throw new ExpressionError(`"resolved-locale" expects 0 or 1 arguments, got ${args.length}`, ["resolved-locale", ...args], path);
+    return {
+      evaluate: () => "en",
+      returnType: "string",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+}
+var init_string = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/compile.ts
+function boot() {
+  if (BOOTED)
+    return;
+  BOOTED = true;
+  registerLookupOps();
+  registerLogicalOps();
+  registerMathOps();
+  registerConversionOps();
+  registerStringOps();
+  registerInterpolateOps();
+}
+function compileLiteral(value, expected, path) {
+  if (expected === "color") {
+    if (typeof value !== "string")
+      throw new ExpressionError(`expected color string, got ${typeof value}`, value, path);
+    const rgba = parseColor(value);
+    if (!rgba)
+      throw new ExpressionError(`invalid color string ${JSON.stringify(value)}`, value, path);
+    return {
+      evaluate: () => value,
+      returnType: "color",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  }
+  if (expected === "number") {
+    if (typeof value !== "number" || Number.isNaN(value))
+      throw new ExpressionError(`expected number, got ${String(value)}`, value, path);
+  } else if (expected === "boolean") {
+    if (typeof value !== "boolean")
+      throw new ExpressionError(`expected boolean, got ${typeof value}`, value, path);
+  } else if (expected === "string" || expected === "formatted" || expected === "resolvedImage") {
+    if (typeof value !== "string")
+      throw new ExpressionError(`expected string, got ${typeof value}`, value, path);
+  }
+  const returnType = value === null ? "null" : typeof value === "string" ? "string" : typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : Array.isArray(value) ? "array" : "value";
+  return {
+    evaluate: () => value,
+    returnType,
+    dependsOnZoom: false,
+    dependsOnFeature: false,
+    dependsOnFeatureState: false
+  };
+}
+function compile(expr, expectedType = "value", path = []) {
+  boot();
+  if (Array.isArray(expr)) {
+    const head = expr[0];
+    if (typeof head === "string") {
+      const op = getOperator(head);
+      if (op) {
+        const args = expr.slice(1);
+        return op(args, compile, path, expectedType);
+      }
+    }
+    return compileLiteral(expr, "array", path);
+  }
+  return compileLiteral(expr, expectedType, path);
+}
+var BOOTED = false;
+var init_compile = __esm(() => {
+  init_Color();
+  init_errors();
+  init_conversion();
+  init_interpolate();
+  init_logical();
+  init_lookup();
+  init_math();
+  init_string();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/validate.ts
+function isExpression(value) {
+  boot();
+  if (!Array.isArray(value) || value.length === 0)
+    return false;
+  const head = value[0];
+  return typeof head === "string" && hasOperator(head);
+}
+function validateExpression(value, expectedType) {
+  const errors = [];
+  try {
+    compile(value, expectedType, []);
+  } catch (err) {
+    if (err instanceof ExpressionError)
+      errors.push(err.message);
+    else if (err instanceof Error)
+      errors.push(err.message);
+    else
+      errors.push(String(err));
+  }
+  return errors;
+}
+var init_validate = __esm(() => {
+  init_compile();
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/legacyFilter.ts
+function isLegacyShape(filter) {
+  if (filter.length === 0)
+    return false;
+  const head = filter[0];
+  if (typeof head !== "string")
+    return false;
+  if (head === "has" || head === "!has" || head === "in" || head === "!in")
+    return typeof filter[1] === "string";
+  if (COMPARATORS.has(head))
+    return typeof filter[1] === "string";
+  if (COMBINATORS.has(head)) {
+    for (let i = 1;i < filter.length; i++) {
+      const child = filter[i];
+      if (Array.isArray(child) && isLegacyShape(child))
+        return true;
+    }
+    return false;
+  }
+  return false;
+}
+function convertSpecial(prop) {
+  if (prop === "$type")
+    return ["geometry-type"];
+  if (prop === "$id")
+    return ["id"];
+  return ["get", prop];
+}
+function convertInner(filter) {
+  const head = filter[0];
+  if (typeof head !== "string")
+    return filter;
+  if (head === "has") {
+    if (typeof filter[1] !== "string")
+      return filter;
+    return ["has", filter[1]];
+  }
+  if (head === "!has") {
+    if (typeof filter[1] !== "string")
+      return filter;
+    return ["!has", filter[1]];
+  }
+  if (head === "in" || head === "!in") {
+    if (typeof filter[1] !== "string")
+      return filter;
+    return [head, convertSpecial(filter[1]), ...filter.slice(2)];
+  }
+  if (COMPARATORS.has(head)) {
+    if (typeof filter[1] !== "string")
+      return filter;
+    return [head, convertSpecial(filter[1]), filter[2]];
+  }
+  if (COMBINATORS.has(head)) {
+    const converted = [head];
+    for (let i = 1;i < filter.length; i++) {
+      const child = filter[i];
+      if (Array.isArray(child) && isLegacyShape(child))
+        converted.push(convertInner(child));
+      else
+        converted.push(child);
+    }
+    return converted;
+  }
+  return filter;
+}
+function convertLegacyFilter(filter) {
+  if (!Array.isArray(filter))
+    return filter;
+  if (!isLegacyShape(filter))
+    return filter;
+  return convertInner(filter);
+}
+var COMPARATORS, COMBINATORS;
+var init_legacyFilter = __esm(() => {
+  COMPARATORS = new Set(["==", "!=", "<", "<=", ">", ">="]);
+  COMBINATORS = new Set(["all", "any", "none"]);
+});
+
+// src/core-map/style-spec/expressions/index.ts
+function evaluate(expr, ctx, expectedType = "value") {
+  if (!isExpression(expr)) {
+    if (Array.isArray(expr))
+      return expr;
+    return expr;
+  }
+  const compiled = compile(expr, expectedType, []);
+  try {
+    return compiled.evaluate(ctx);
+  } catch (err) {
+    if (err instanceof ExpressionError)
+      throw err;
+    if (err instanceof Error)
+      throw new ExpressionError(err.message, expr);
+    throw new ExpressionError(String(err), expr);
+  }
+}
+var init_expressions = __esm(() => {
+  init_compile();
+  init_errors();
+  init_validate();
+  init_Color();
+  init_compile();
+  init_errors();
+  init_legacyFilter();
+  init_validate();
+});
+
+// src/core-map/style-spec/schema.ts
+var backgroundPaint, fillPaint, fillExtrusionPaint, linePaint, circlePaint, symbolPaint, rasterPaint, paintPropertySchemas, visibility, backgroundLayout, fillLayout, fillExtrusionLayout, lineLayout, circleLayout, symbolLayout, rasterLayout, layoutPropertySchemas, layerTypes, sourceTypes;
+var init_schema = __esm(() => {
+  backgroundPaint = {
+    "background-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "background-pattern": { type: "resolvedImage", transition: true, sdk: "gl" }
+  };
+  fillPaint = {
+    "fill-antialias": { type: "boolean", default: true, sdk: "gl" },
+    "fill-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "fill-outline-color": { type: "color", transition: true, sdk: "gl" },
+    "fill-pattern": { type: "resolvedImage", transition: true, sdk: "gl" },
+    "fill-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "fill-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" }
+  };
+  fillExtrusionPaint = {
+    "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "fill-extrusion-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "fill-extrusion-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "fill-extrusion-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" },
+    "fill-extrusion-pattern": { type: "resolvedImage", transition: true, sdk: "gl" },
+    "fill-extrusion-height": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "fill-extrusion-base": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "fill-extrusion-vertical-gradient": { type: "boolean", default: true, sdk: "gl" }
+  };
+  linePaint = {
+    "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "line-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "line-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "line-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" },
+    "line-width": { type: "number", default: 1, minimum: 0, transition: true, sdk: "gl" },
+    "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "line-offset": { type: "number", default: 0, transition: true, sdk: "gl" },
+    "line-blur": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "line-dasharray": { type: "array", transition: true, sdk: "gl" },
+    "line-pattern": { type: "resolvedImage", transition: true, sdk: "gl" },
+    "line-gradient": { type: "color", sdk: "gl" }
+  };
+  circlePaint = {
+    "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, sdk: "gl" },
+    "circle-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "circle-blur": { type: "number", default: 0, transition: true, sdk: "gl" },
+    "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "circle-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "circle-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" },
+    "circle-pitch-scale": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" },
+    "circle-pitch-alignment": { type: "enum", values: ["map", "viewport"], default: "viewport", sdk: "gl" },
+    "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "circle-stroke-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" }
+  };
+  symbolPaint = {
+    "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "icon-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, sdk: "gl" },
+    "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "icon-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "icon-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" },
+    "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "text-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, sdk: "gl" },
+    "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, sdk: "gl" },
+    "text-translate": { type: "array", length: 2, default: [0, 0], transition: true, sdk: "gl" },
+    "text-translate-anchor": { type: "enum", values: ["map", "viewport"], default: "map", sdk: "gl" }
+  };
+  rasterPaint = {
+    "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "raster-hue-rotate": { type: "number", default: 0, transition: true, sdk: "gl" },
+    "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, sdk: "gl" },
+    "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, sdk: "gl" },
+    "raster-resampling": { type: "enum", values: ["linear", "nearest"], default: "linear", sdk: "gl" },
+    "raster-fade-duration": { type: "number", default: 300, minimum: 0, sdk: "gl" }
+  };
+  paintPropertySchemas = {
+    background: backgroundPaint,
+    fill: fillPaint,
+    "fill-extrusion": fillExtrusionPaint,
+    line: linePaint,
+    circle: circlePaint,
+    symbol: symbolPaint,
+    raster: rasterPaint
+  };
+  visibility = { type: "enum", values: ["visible", "none"], default: "visible", sdk: "gl" };
+  backgroundLayout = {
+    visibility
+  };
+  fillLayout = {
+    visibility,
+    "fill-sort-key": { type: "number", sdk: "gl" }
+  };
+  fillExtrusionLayout = {
+    visibility
+  };
+  lineLayout = {
+    visibility,
+    "line-cap": { type: "enum", values: ["butt", "round", "square"], default: "butt", sdk: "gl" },
+    "line-join": { type: "enum", values: ["bevel", "round", "miter"], default: "miter", sdk: "gl" },
+    "line-miter-limit": { type: "number", default: 2, sdk: "gl" },
+    "line-round-limit": { type: "number", default: 1.05, sdk: "gl" },
+    "line-sort-key": { type: "number", sdk: "gl" }
+  };
+  circleLayout = {
+    visibility,
+    "circle-sort-key": { type: "number", sdk: "gl" }
+  };
+  symbolLayout = {
+    visibility,
+    "symbol-placement": { type: "enum", values: ["point", "line", "line-center"], default: "point", sdk: "gl" },
+    "symbol-spacing": { type: "number", default: 250, minimum: 1, sdk: "gl" },
+    "symbol-avoid-edges": { type: "boolean", default: false, sdk: "gl" },
+    "symbol-sort-key": { type: "number", sdk: "gl" },
+    "symbol-z-order": { type: "enum", values: ["auto", "viewport-y", "source"], default: "auto", sdk: "gl" },
+    "icon-allow-overlap": { type: "boolean", default: false, sdk: "gl" },
+    "icon-ignore-placement": { type: "boolean", default: false, sdk: "gl" },
+    "icon-optional": { type: "boolean", default: false, sdk: "gl" },
+    "icon-rotation-alignment": { type: "enum", values: ["map", "viewport", "auto"], default: "auto", sdk: "gl" },
+    "icon-size": { type: "number", default: 1, minimum: 0, sdk: "gl" },
+    "icon-text-fit": { type: "enum", values: ["none", "width", "height", "both"], default: "none", sdk: "gl" },
+    "icon-text-fit-padding": { type: "array", length: 4, default: [0, 0, 0, 0], sdk: "gl" },
+    "icon-image": { type: "resolvedImage", sdk: "gl" },
+    "icon-rotate": { type: "number", default: 0, sdk: "gl" },
+    "icon-padding": { type: "padding", default: 2, sdk: "gl" },
+    "icon-keep-upright": { type: "boolean", default: false, sdk: "gl" },
+    "icon-offset": { type: "array", length: 2, default: [0, 0], sdk: "gl" },
+    "icon-anchor": {
+      type: "enum",
+      values: ["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"],
+      default: "center",
+      sdk: "gl"
+    },
+    "icon-pitch-alignment": { type: "enum", values: ["map", "viewport", "auto"], default: "auto", sdk: "gl" },
+    "text-pitch-alignment": { type: "enum", values: ["map", "viewport", "auto"], default: "auto", sdk: "gl" },
+    "text-rotation-alignment": { type: "enum", values: ["map", "viewport", "auto"], default: "auto", sdk: "gl" },
+    "text-field": { type: "formatted", default: "", sdk: "gl" },
+    "text-font": { type: "array", default: ["Open Sans Regular", "Arial Unicode MS Regular"], sdk: "gl" },
+    "text-size": { type: "number", default: 16, minimum: 0, sdk: "gl" },
+    "text-max-width": { type: "number", default: 10, minimum: 0, sdk: "gl" },
+    "text-line-height": { type: "number", default: 1.2, sdk: "gl" },
+    "text-letter-spacing": { type: "number", default: 0, sdk: "gl" },
+    "text-justify": { type: "enum", values: ["auto", "left", "center", "right"], default: "center", sdk: "gl" },
+    "text-radial-offset": { type: "number", default: 0, sdk: "gl" },
+    "text-variable-anchor": { type: "array", sdk: "gl" },
+    "text-anchor": {
+      type: "enum",
+      values: ["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"],
+      default: "center",
+      sdk: "gl"
+    },
+    "text-max-angle": { type: "number", default: 45, sdk: "gl" },
+    "text-writing-mode": { type: "array", sdk: "gl" },
+    "text-rotate": { type: "number", default: 0, sdk: "gl" },
+    "text-padding": { type: "number", default: 2, minimum: 0, sdk: "gl" },
+    "text-keep-upright": { type: "boolean", default: true, sdk: "gl" },
+    "text-transform": { type: "enum", values: ["none", "uppercase", "lowercase"], default: "none", sdk: "gl" },
+    "text-offset": { type: "array", length: 2, default: [0, 0], sdk: "gl" },
+    "text-allow-overlap": { type: "boolean", default: false, sdk: "gl" },
+    "text-ignore-placement": { type: "boolean", default: false, sdk: "gl" },
+    "text-optional": { type: "boolean", default: false, sdk: "gl" }
+  };
+  rasterLayout = {
+    visibility
+  };
+  layoutPropertySchemas = {
+    background: backgroundLayout,
+    fill: fillLayout,
+    "fill-extrusion": fillExtrusionLayout,
+    line: lineLayout,
+    circle: circleLayout,
+    symbol: symbolLayout,
+    raster: rasterLayout
+  };
+  layerTypes = ["background", "fill", "fill-extrusion", "line", "circle", "symbol", "raster"];
+  sourceTypes = ["vector", "raster", "raster-dem", "geojson"];
+});
+
+// src/core-map/style-spec/validate.ts
+function pushError(errors, message, path) {
+  errors.push({ message, path: path.slice() });
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function expressionTypeFor(t) {
+  switch (t) {
+    case "color":
+      return "color";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "enum":
+      return "string";
+    case "padding":
+      return "value";
+    case "formatted":
+      return "formatted";
+    case "resolvedImage":
+      return "resolvedImage";
+  }
+}
+function matchesSchema(value, schema) {
+  if (Array.isArray(value)) {
+    if (isExpression(value)) {
+      const errs = validateExpression(value, expressionTypeFor(schema.type));
+      return errs.length === 0 ? true : errs;
+    }
+    if (schema.type === "array") {
+      if (schema.length !== undefined && value.length !== schema.length)
+        return false;
+      return true;
+    }
+    if (schema.type === "padding") {
+      return value.length === 2 || value.length === 4;
+    }
+    return false;
+  }
+  switch (schema.type) {
+    case "color":
+      return typeof value === "string";
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value))
+        return false;
+      if (schema.minimum !== undefined && value < schema.minimum)
+        return false;
+      if (schema.maximum !== undefined && value > schema.maximum)
+        return false;
+      return true;
+    case "string":
+      return typeof value === "string";
+    case "boolean":
+      return typeof value === "boolean";
+    case "enum":
+      return typeof value === "string" && (schema.values ? schema.values.includes(value) : true);
+    case "padding":
+      return typeof value === "number";
+    case "formatted":
+      return typeof value === "string";
+    case "resolvedImage":
+      return typeof value === "string";
+    case "array":
+      return false;
+  }
+}
+function validateProperty(schemas, layerType, kind, name, value, path) {
+  const errors = [];
+  const schema = schemas ? schemas[name] : undefined;
+  if (!schema) {
+    pushError(errors, `Unknown ${kind} property "${name}" for layer type "${layerType}"`, path);
+    return errors;
+  }
+  const result = matchesSchema(value, schema);
+  if (result === true)
+    return errors;
+  if (result === false) {
+    pushError(errors, `Invalid value for ${kind} property "${name}" (expected ${describeSchema(schema)})`, path);
+    return errors;
+  }
+  for (const message of result)
+    pushError(errors, `Invalid expression for ${kind} property "${name}": ${message}`, path);
+  return errors;
+}
+function describeSchema(schema) {
+  if (schema.type === "enum" && schema.values)
+    return `one of ${schema.values.map((v) => `"${v}"`).join(", ")}`;
+  if (schema.type === "array" && schema.length !== undefined)
+    return `array of length ${schema.length}`;
+  return schema.type;
+}
+function validatePaintProperty(layerType, name, value) {
+  const schemas = paintPropertySchemas[layerType];
+  return validateProperty(schemas, layerType, "paint", name, value, ["paint", name]);
+}
+function validateLayoutProperty(layerType, name, value) {
+  const schemas = layoutPropertySchemas[layerType];
+  return validateProperty(schemas, layerType, "layout", name, value, ["layout", name]);
+}
+function validateSource(source, id) {
+  const errors = [];
+  const path = id !== undefined ? ["sources", id] : ["source"];
+  if (!isPlainObject(source)) {
+    pushError(errors, "Source must be an object", path);
+    return errors;
+  }
+  const type = source.type;
+  if (typeof type !== "string") {
+    pushError(errors, 'Source is missing required "type" property', path.concat("type"));
+    return errors;
+  }
+  if (!sourceTypes.includes(type)) {
+    pushError(errors, `Unknown source type "${type}"`, path.concat("type"));
+    return errors;
+  }
+  if (type === "vector" || type === "raster" || type === "raster-dem") {
+    const hasUrl = typeof source.url === "string";
+    const hasTiles = Array.isArray(source.tiles) && source.tiles.length > 0;
+    if (!hasUrl && !hasTiles) {
+      pushError(errors, `Source of type "${type}" must define either "url" or a non-empty "tiles" array`, path);
+    }
+    if (source.tiles !== undefined && !Array.isArray(source.tiles))
+      pushError(errors, '"tiles" must be an array of URL templates', path.concat("tiles"));
+    if (source.url !== undefined && typeof source.url !== "string")
+      pushError(errors, '"url" must be a string', path.concat("url"));
+    if (source.minzoom !== undefined && typeof source.minzoom !== "number")
+      pushError(errors, '"minzoom" must be a number', path.concat("minzoom"));
+    if (source.maxzoom !== undefined && typeof source.maxzoom !== "number")
+      pushError(errors, '"maxzoom" must be a number', path.concat("maxzoom"));
+  }
+  if (type === "geojson") {
+    if (source.data === undefined)
+      pushError(errors, 'GeoJSON source is missing required "data" property', path.concat("data"));
+  }
+  return errors;
+}
+function validateLayer(layer, sources) {
+  const errors = [];
+  const path = ["layer"];
+  if (!isPlainObject(layer)) {
+    pushError(errors, "Layer must be an object", path);
+    return errors;
+  }
+  if (typeof layer.id !== "string" || layer.id.length === 0)
+    pushError(errors, 'Layer is missing required "id" property', path.concat("id"));
+  const type = layer.type;
+  if (typeof type !== "string") {
+    pushError(errors, 'Layer is missing required "type" property', path.concat("type"));
+    return errors;
+  }
+  if (!layerTypes.includes(type)) {
+    pushError(errors, `Unknown layer type "${type}"`, path.concat("type"));
+    return errors;
+  }
+  const layerType = type;
+  if (layerType !== "background") {
+    if (typeof layer.source !== "string") {
+      pushError(errors, `Layer of type "${layerType}" is missing required "source" property`, path.concat("source"));
+    } else if (sources && !(layer.source in sources)) {
+      pushError(errors, `Layer references undefined source "${layer.source}"`, path.concat("source"));
+    }
+  }
+  if (layer.minzoom !== undefined && typeof layer.minzoom !== "number")
+    pushError(errors, '"minzoom" must be a number', path.concat("minzoom"));
+  if (layer.maxzoom !== undefined && typeof layer.maxzoom !== "number")
+    pushError(errors, '"maxzoom" must be a number', path.concat("maxzoom"));
+  const paint = layer.paint;
+  if (paint !== undefined) {
+    if (!isPlainObject(paint)) {
+      pushError(errors, 'Layer "paint" must be an object', path.concat("paint"));
+    } else {
+      const schemas = paintPropertySchemas[layerType];
+      for (const name of Object.keys(paint)) {
+        const subErrors = validateProperty(schemas, layerType, "paint", name, paint[name], path.concat("paint", name));
+        for (const e of subErrors)
+          errors.push(e);
+      }
+    }
+  }
+  const layout = layer.layout;
+  if (layout !== undefined) {
+    if (!isPlainObject(layout)) {
+      pushError(errors, 'Layer "layout" must be an object', path.concat("layout"));
+    } else {
+      const schemas = layoutPropertySchemas[layerType];
+      for (const name of Object.keys(layout)) {
+        const subErrors = validateProperty(schemas, layerType, "layout", name, layout[name], path.concat("layout", name));
+        for (const e of subErrors)
+          errors.push(e);
+      }
+    }
+  }
+  return errors;
+}
+function validateStyle(style) {
+  const errors = [];
+  if (!isPlainObject(style)) {
+    pushError(errors, "Style must be an object", []);
+    return errors;
+  }
+  if (style.version === undefined) {
+    pushError(errors, 'Style is missing required "version" property', ["version"]);
+  } else if (style.version !== 8) {
+    pushError(errors, `Unsupported style version: ${String(style.version)} (expected 8)`, ["version"]);
+  }
+  const sources = style.sources;
+  if (sources === undefined) {
+    pushError(errors, 'Style is missing required "sources" property', ["sources"]);
+  } else if (!isPlainObject(sources)) {
+    pushError(errors, 'Style "sources" must be an object', ["sources"]);
+  } else {
+    for (const id of Object.keys(sources)) {
+      const sourceErrors = validateSource(sources[id], id);
+      for (const e of sourceErrors)
+        errors.push(e);
+    }
+  }
+  const layers = style.layers;
+  if (layers === undefined) {
+    pushError(errors, 'Style is missing required "layers" property', ["layers"]);
+  } else if (!Array.isArray(layers)) {
+    pushError(errors, 'Style "layers" must be an array', ["layers"]);
+  } else {
+    const seenIds = new Set;
+    const sourceMap = isPlainObject(sources) ? sources : undefined;
+    for (let i = 0;i < layers.length; i++) {
+      const layer = layers[i];
+      const layerPath = ["layers", String(i)];
+      if (!isPlainObject(layer)) {
+        pushError(errors, "Layer must be an object", layerPath);
+        continue;
+      }
+      if (typeof layer.id === "string") {
+        if (seenIds.has(layer.id))
+          pushError(errors, `Duplicate layer id "${layer.id}"`, layerPath.concat("id"));
+        else
+          seenIds.add(layer.id);
+      }
+      const subErrors = validateLayer(layer, sourceMap);
+      for (const e of subErrors) {
+        const relPath = e.path ? e.path.slice(1) : [];
+        errors.push({ message: e.message, path: layerPath.concat(relPath) });
+      }
+    }
+  }
+  if (style.name !== undefined && typeof style.name !== "string")
+    pushError(errors, '"name" must be a string', ["name"]);
+  if (style.zoom !== undefined && typeof style.zoom !== "number")
+    pushError(errors, '"zoom" must be a number', ["zoom"]);
+  if (style.bearing !== undefined && typeof style.bearing !== "number")
+    pushError(errors, '"bearing" must be a number', ["bearing"]);
+  if (style.pitch !== undefined && typeof style.pitch !== "number")
+    pushError(errors, '"pitch" must be a number', ["pitch"]);
+  if (style.center !== undefined) {
+    const c = style.center;
+    if (!Array.isArray(c) || c.length !== 2 || typeof c[0] !== "number" || typeof c[1] !== "number")
+      pushError(errors, '"center" must be a [lng, lat] tuple', ["center"]);
+  }
+  if (style.glyphs !== undefined && typeof style.glyphs !== "string")
+    pushError(errors, '"glyphs" must be a string template', ["glyphs"]);
+  if (style.sprite !== undefined) {
+    const s = style.sprite;
+    if (typeof s !== "string" && !Array.isArray(s))
+      pushError(errors, '"sprite" must be a string or an array of sprite sources', ["sprite"]);
+  }
+  return errors;
+}
+var init_validate2 = __esm(() => {
+  init_expressions();
+  init_schema();
+});
+
+// src/core-map/style-spec/index.ts
+init_expressions();
+init_schema();
+init_validate2();
+export {
+  validateStyle,
+  validateSource,
+  validatePaintProperty,
+  validateLayoutProperty,
+  validateLayer,
+  validateExpression,
+  sourceTypes,
+  parseColor,
+  paintPropertySchemas,
+  lerpColor,
+  layoutPropertySchemas,
+  layerTypes,
+  isExpression,
+  formatColor,
+  evaluate as evaluateExpression,
+  diffStyles,
+  convertLegacyFilter,
+  compile as compileExpression,
+  ExpressionError
+};