ts-maps 0.3.2 → 0.3.4

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

@@ -575,7 +575,7 @@ var init_registry = __esm(() => {
   OPERATORS = {};
 });
 
-// src/core-map/style-spec/expressions/operators/conversion.ts
+// src/core-map/style-spec/expressions/operators/binding.ts
 function mergeDeps(children) {
   let z = false;
   let f = false;
@@ -590,6 +590,70 @@ function mergeDeps(children) {
   }
   return { dependsOnZoom: z, dependsOnFeature: f, dependsOnFeatureState: s };
 }
+function registerBindingOps() {
+  registerOperator("let", (args, compile, path) => {
+    if (args.length < 3 || args.length % 2 === 0)
+      throw new ExpressionError(`"let" expects name/value pairs followed by a body, got ${args.length} arguments`, ["let", ...args], path);
+    const names = [];
+    const values = [];
+    for (let i = 0;i < args.length - 1; i += 2) {
+      const name = args[i];
+      if (typeof name !== "string")
+        throw new ExpressionError(`"let": binding name must be a string, got ${typeof name}`, ["let", ...args], path);
+      names.push(name);
+      values.push(compile(args[i + 1], "value", path.concat(i + 2)));
+    }
+    const body = compile(args[args.length - 1], "value", path.concat(args.length));
+    return {
+      evaluate: (ctx) => {
+        const bindings = { ...ctx.bindings };
+        for (let i = 0;i < names.length; i++)
+          bindings[names[i]] = values[i].evaluate(ctx);
+        return body.evaluate({ ...ctx, bindings });
+      },
+      returnType: body.returnType,
+      ...mergeDeps([...values, body])
+    };
+  });
+  registerOperator("var", (args, _compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"var" expects 1 argument, got ${args.length}`, ["var", ...args], path);
+    const name = args[0];
+    if (typeof name !== "string")
+      throw new ExpressionError(`"var": name must be a string, got ${typeof name}`, ["var", ...args], path);
+    return {
+      evaluate: (ctx) => {
+        if (!ctx.bindings || !(name in ctx.bindings))
+          throw new ExpressionError(`"var": unbound name ${JSON.stringify(name)}`, ["var", name]);
+        return ctx.bindings[name];
+      },
+      returnType: "value",
+      dependsOnZoom: false,
+      dependsOnFeature: false,
+      dependsOnFeatureState: false
+    };
+  });
+}
+var init_binding = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
+// src/core-map/style-spec/expressions/operators/conversion.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 registerConversionOps() {
   registerOperator("to-string", (args, compile, path) => {
     if (args.length !== 1)
@@ -611,7 +675,7 @@ function registerConversionOps() {
         }
       },
       returnType: "string",
-      ...mergeDeps([inner])
+      ...mergeDeps2([inner])
     };
   });
   registerOperator("to-number", (args, compile, path) => {
@@ -644,7 +708,7 @@ function registerConversionOps() {
         throw new ExpressionError('"to-number": could not convert any argument to a number', expr);
       },
       returnType: "number",
-      ...mergeDeps(children)
+      ...mergeDeps2(children)
     };
   });
   registerOperator("to-boolean", (args, compile, path) => {
@@ -669,7 +733,7 @@ function registerConversionOps() {
         return Boolean(v);
       },
       returnType: "boolean",
-      ...mergeDeps([inner])
+      ...mergeDeps2([inner])
     };
   });
   registerOperator("to-rgba", (args, compile, path) => {
@@ -691,7 +755,7 @@ function registerConversionOps() {
         ];
       },
       returnType: "array",
-      ...mergeDeps([inner])
+      ...mergeDeps2([inner])
     };
   });
   registerOperator("to-color", (args, compile, path) => {
@@ -710,7 +774,7 @@ function registerConversionOps() {
         throw new ExpressionError('"to-color": could not convert any argument to a color', expr);
       },
       returnType: "color",
-      ...mergeDeps(children)
+      ...mergeDeps2(children)
     };
   });
 }
@@ -744,8 +808,142 @@ var init_conversion = __esm(() => {
   init_registry();
 });
 
+// src/core-map/style-spec/expressions/operators/geometry.ts
+function toRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+function haversine(a, b) {
+  const [lng1, lat1] = a;
+  const [lng2, lat2] = b;
+  const dLat = toRadians(lat2 - lat1);
+  const dLng = toRadians(lng2 - lng1);
+  const sinLat = Math.sin(dLat / 2);
+  const sinLng = Math.sin(dLng / 2);
+  const h = sinLat * sinLat + Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) * sinLng * sinLng;
+  return 2 * EARTH_RADIUS * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function pointInRing(point, ring) {
+  const [x, y] = point;
+  let inside = false;
+  for (let i = 0, j = ring.length - 1;i < ring.length; j = i++) {
+    const [xi, yi] = ring[i];
+    const [xj, yj] = ring[j];
+    const cross = (xj - xi) * (y - yi) - (yj - yi) * (x - xi);
+    if (Math.abs(cross) < 0.000000000001 && Math.min(xi, xj) - 0.000000000001 <= x && x <= Math.max(xi, xj) + 0.000000000001 && Math.min(yi, yj) - 0.000000000001 <= y && y <= Math.max(yi, yj) + 0.000000000001) {
+      return true;
+    }
+    if (yi > y !== yj > y) {
+      const at = xi + (y - yi) / (yj - yi) * (xj - xi);
+      if (x < at)
+        inside = !inside;
+    }
+  }
+  return inside;
+}
+function pointInPolygon(point, polygon) {
+  if (!polygon.length || !pointInRing(point, polygon[0]))
+    return false;
+  for (let i = 1;i < polygon.length; i++) {
+    if (pointInRing(point, polygon[i]))
+      return false;
+  }
+  return true;
+}
+function polygonsOf(geometry) {
+  if (!geometry)
+    return [];
+  if (geometry.type === "Polygon")
+    return [geometry.coordinates];
+  if (geometry.type === "MultiPolygon")
+    return geometry.coordinates;
+  if (geometry.type === "Feature")
+    return polygonsOf(geometry.geometry);
+  if (geometry.type === "FeatureCollection")
+    return (geometry.features ?? []).flatMap((f) => polygonsOf(f));
+  return [];
+}
+function positionsOf(geometry) {
+  if (!geometry)
+    return [];
+  switch (geometry.type) {
+    case "Point":
+      return [geometry.coordinates];
+    case "MultiPoint":
+    case "LineString":
+      return geometry.coordinates;
+    case "MultiLineString":
+    case "Polygon":
+      return geometry.coordinates.flat();
+    case "MultiPolygon":
+      return geometry.coordinates.flat(2);
+    case "Feature":
+      return positionsOf(geometry.geometry);
+    case "FeatureCollection":
+      return (geometry.features ?? []).flatMap((f) => positionsOf(f));
+    default:
+      return [];
+  }
+}
+function featureGeometry(ctx) {
+  const accessor = ctx.feature?.geometry;
+  return typeof accessor === "function" ? accessor() : undefined;
+}
+function noDeps() {
+  return { dependsOnZoom: false, dependsOnFeature: true, dependsOnFeatureState: false };
+}
+function registerGeometryOps() {
+  registerOperator("within", (args, _compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"within" expects 1 argument, got ${args.length}`, ["within", ...args], path);
+    const polygons = polygonsOf(args[0]);
+    if (!polygons.length)
+      throw new ExpressionError('"within": argument must be a GeoJSON Polygon or MultiPolygon', ["within", ...args], path);
+    return {
+      evaluate: (ctx) => {
+        const geometry = featureGeometry(ctx);
+        const points = positionsOf(geometry);
+        if (!points.length)
+          return false;
+        return points.every((point) => polygons.some((polygon) => pointInPolygon(point, polygon)));
+      },
+      returnType: "boolean",
+      ...noDeps()
+    };
+  });
+  registerOperator("distance", (args, _compile, path) => {
+    if (args.length !== 1)
+      throw new ExpressionError(`"distance" expects 1 argument, got ${args.length}`, ["distance", ...args], path);
+    const targets = positionsOf(args[0]);
+    if (!targets.length)
+      throw new ExpressionError('"distance": argument must be a GeoJSON geometry', ["distance", ...args], path);
+    return {
+      evaluate: (ctx) => {
+        const points = positionsOf(featureGeometry(ctx));
+        if (!points.length)
+          return Infinity;
+        let nearest = Infinity;
+        for (const point of points) {
+          for (const target of targets) {
+            const d = haversine(point, target);
+            if (d < nearest)
+              nearest = d;
+          }
+        }
+        return nearest;
+      },
+      returnType: "number",
+      ...noDeps()
+    };
+  });
+}
+var EARTH_RADIUS = 6371008.8;
+var init_geometry = __esm(() => {
+  init_errors();
+  init_registry();
+});
+
 // src/core-map/style-spec/expressions/operators/interpolate.ts
-function mergeDeps2(children) {
+function mergeDeps3(children) {
   let z = false;
   let f = false;
   let s = false;
@@ -967,7 +1165,7 @@ function registerInterpolateOps() {
         return blend(stopOutputs[idx].evaluate(ctx), stopOutputs[idx + 1].evaluate(ctx), t);
       },
       returnType,
-      ...mergeDeps2(children)
+      ...mergeDeps3(children)
     };
   });
   registerOperator("step", (args, compile, path, expected) => {
@@ -1001,7 +1199,7 @@ function registerInterpolateOps() {
         return stopOutputs[idx].evaluate(ctx);
       },
       returnType,
-      ...mergeDeps2(children)
+      ...mergeDeps3(children)
     };
   });
 }
@@ -1012,7 +1210,7 @@ var init_interpolate = __esm(() => {
 });
 
 // src/core-map/style-spec/expressions/operators/logical.ts
-function mergeDeps3(children) {
+function mergeDeps4(children) {
   let z = false;
   let f = false;
   let s = false;
@@ -1049,7 +1247,7 @@ function registerLogicalOps() {
     return {
       evaluate: (ctx) => !inner.evaluate(ctx),
       returnType: "boolean",
-      ...mergeDeps3([inner])
+      ...mergeDeps4([inner])
     };
   });
   registerOperator("==", (args, compile, path) => {
@@ -1060,7 +1258,7 @@ function registerLogicalOps() {
     return {
       evaluate: (ctx) => strictEq(a.evaluate(ctx), b.evaluate(ctx)),
       returnType: "boolean",
-      ...mergeDeps3([a, b])
+      ...mergeDeps4([a, b])
     };
   });
   registerOperator("!=", (args, compile, path) => {
@@ -1071,7 +1269,7 @@ function registerLogicalOps() {
     return {
       evaluate: (ctx) => !strictEq(a.evaluate(ctx), b.evaluate(ctx)),
       returnType: "boolean",
-      ...mergeDeps3([a, b])
+      ...mergeDeps4([a, b])
     };
   });
   const comparator = (name) => {
@@ -1097,7 +1295,7 @@ function registerLogicalOps() {
           }
         },
         returnType: "boolean",
-        ...mergeDeps3([a, b])
+        ...mergeDeps4([a, b])
       };
     });
   };
@@ -1115,7 +1313,7 @@ function registerLogicalOps() {
         return true;
       },
       returnType: "boolean",
-      ...mergeDeps3(children)
+      ...mergeDeps4(children)
     };
   });
   registerOperator("any", (args, compile, path) => {
@@ -1128,7 +1326,7 @@ function registerLogicalOps() {
         return false;
       },
       returnType: "boolean",
-      ...mergeDeps3(children)
+      ...mergeDeps4(children)
     };
   });
   registerOperator("none", (args, compile, path) => {
@@ -1141,7 +1339,7 @@ function registerLogicalOps() {
         return true;
       },
       returnType: "boolean",
-      ...mergeDeps3(children)
+      ...mergeDeps4(children)
     };
   });
   registerOperator("case", (args, compile, path, expected) => {
@@ -1170,7 +1368,7 @@ function registerLogicalOps() {
         return fallback.evaluate(ctx);
       },
       returnType: expected,
-      ...mergeDeps3(all)
+      ...mergeDeps4(all)
     };
   });
   registerOperator("match", (args, compile, path, expected) => {
@@ -1207,7 +1405,7 @@ function registerLogicalOps() {
         return fallback.evaluate(ctx);
       },
       returnType: expected,
-      ...mergeDeps3(all)
+      ...mergeDeps4(all)
     };
   });
   registerOperator("coalesce", (args, compile, path, expected) => {
@@ -1224,12 +1422,29 @@ function registerLogicalOps() {
         return null;
       },
       returnType: expected,
-      ...mergeDeps3(children)
+      ...mergeDeps4(children)
     };
   });
   registerOperator("in", (args, compile, path) => {
     if (args.length < 1)
       throw new ExpressionError('"in" expects at least 1 argument', ["in", ...args], path);
+    if (args.length === 2 && Array.isArray(args[1])) {
+      const needle = compile(args[0], "value", path.concat(1));
+      const haystack2 = compile(args[1], "value", path.concat(2));
+      return {
+        evaluate: (ctx) => {
+          const x = needle.evaluate(ctx);
+          const hay = haystack2.evaluate(ctx);
+          if (Array.isArray(hay))
+            return hay.some((value) => strictEq(x, value));
+          if (typeof hay === "string")
+            return typeof x === "string" && hay.includes(x);
+          return false;
+        },
+        returnType: "boolean",
+        ...mergeDeps4([needle, haystack2])
+      };
+    }
     const input = compile(args[0], "value", path.concat(1));
     const haystack = args.slice(1);
     return {
@@ -1241,7 +1456,7 @@ function registerLogicalOps() {
         return false;
       },
       returnType: "boolean",
-      ...mergeDeps3([input])
+      ...mergeDeps4([input])
     };
   });
   registerOperator("!in", (args, compile, path) => {
@@ -1258,7 +1473,7 @@ function registerLogicalOps() {
         return true;
       },
       returnType: "boolean",
-      ...mergeDeps3([input])
+      ...mergeDeps4([input])
     };
   });
   registerOperator("!has", (args, _compile, path) => {
@@ -1468,6 +1683,17 @@ function registerLookupOps() {
       dependsOnFeatureState: false
     };
   });
+  registerOperator("heatmap-density", (args, _compile, path) => {
+    if (args.length !== 0)
+      throw new ExpressionError(`"heatmap-density" takes no arguments, got ${args.length}`, ["heatmap-density", ...args], path);
+    return {
+      evaluate: (ctx) => ctx.heatmapDensity ?? 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);
@@ -1510,7 +1736,7 @@ function expectNumber(value, op, expr) {
     throw new ExpressionError(`"${op}": expected number, got ${String(value)}`, expr);
   return value;
 }
-function mergeDeps4(children) {
+function mergeDeps5(children) {
   let z = false;
   let f = false;
   let s = false;
@@ -1536,7 +1762,7 @@ function registerMathOps() {
         return acc;
       },
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
   registerOperator("*", (args, compile, path) => {
@@ -1550,7 +1776,7 @@ function registerMathOps() {
         return acc;
       },
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
   registerOperator("-", (args, compile, path) => {
@@ -1563,7 +1789,7 @@ function registerMathOps() {
       return {
         evaluate: (ctx) => -expectNumber(a2.evaluate(ctx), "-", expr),
         returnType: "number",
-        ...mergeDeps4(children)
+        ...mergeDeps5(children)
       };
     }
     const a = children[0];
@@ -1571,7 +1797,7 @@ function registerMathOps() {
     return {
       evaluate: (ctx) => expectNumber(a.evaluate(ctx), "-", expr) - expectNumber(b.evaluate(ctx), "-", expr),
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
   registerOperator("/", (args, compile, path) => {
@@ -1589,7 +1815,7 @@ function registerMathOps() {
         return av / bv;
       },
       returnType: "number",
-      ...mergeDeps4([a, b])
+      ...mergeDeps5([a, b])
     };
   });
   registerOperator("%", (args, compile, path) => {
@@ -1607,7 +1833,7 @@ function registerMathOps() {
         return av % bv;
       },
       returnType: "number",
-      ...mergeDeps4([a, b])
+      ...mergeDeps5([a, b])
     };
   });
   registerOperator("^", (args, compile, path) => {
@@ -1619,7 +1845,7 @@ function registerMathOps() {
     return {
       evaluate: (ctx) => expectNumber(a.evaluate(ctx), "^", expr) ** expectNumber(b.evaluate(ctx), "^", expr),
       returnType: "number",
-      ...mergeDeps4([a, b])
+      ...mergeDeps5([a, b])
     };
   });
   registerOperator("min", (args, compile, path) => {
@@ -1638,7 +1864,7 @@ function registerMathOps() {
         return m;
       },
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
   registerOperator("max", (args, compile, path) => {
@@ -1657,7 +1883,7 @@ function registerMathOps() {
         return m;
       },
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
   const unary = (name, fn, validate) => {
@@ -1674,7 +1900,7 @@ function registerMathOps() {
           return fn(v);
         },
         returnType: "number",
-        ...mergeDeps4([inner])
+        ...mergeDeps5([inner])
       };
     });
   };
@@ -1698,6 +1924,18 @@ function registerMathOps() {
     if (n <= 0)
       throw new ExpressionError('"log2": input must be positive', expr);
   });
+  unary("sin", Math.sin);
+  unary("cos", Math.cos);
+  unary("tan", Math.tan);
+  unary("asin", Math.asin, (n, expr) => {
+    if (n < -1 || n > 1)
+      throw new ExpressionError('"asin": input must be in [-1, 1]', expr);
+  });
+  unary("acos", Math.acos, (n, expr) => {
+    if (n < -1 || n > 1)
+      throw new ExpressionError('"acos": input must be in [-1, 1]', expr);
+  });
+  unary("atan", Math.atan);
   registerOperator("e", (args, _compile, path) => {
     if (args.length !== 0)
       throw new ExpressionError(`"e" takes no arguments, got ${args.length}`, ["e", ...args], path);
@@ -1746,7 +1984,7 @@ function registerMathOps() {
         return a + (b - a) * Math.random();
       },
       returnType: "number",
-      ...mergeDeps4(children)
+      ...mergeDeps5(children)
     };
   });
 }
@@ -1755,8 +1993,31 @@ var init_math = __esm(() => {
   init_registry();
 });
 
+// src/core-map/style-spec/expressions/formatted.ts
+class Formatted {
+  sections;
+  constructor(sections) {
+    this.sections = sections;
+  }
+  toString() {
+    let out = "";
+    for (const section of this.sections)
+      out += section.text;
+    return out;
+  }
+  get uniform() {
+    return isUniform(this.sections);
+  }
+}
+function isUniform(sections) {
+  return sections.every((s) => s.scale === undefined && s.fontStack === undefined && s.color === undefined);
+}
+function isFormatted(value) {
+  return value instanceof Formatted || !!value && typeof value === "object" && Array.isArray(value.sections);
+}
+
 // src/core-map/style-spec/expressions/operators/string.ts
-function mergeDeps5(children) {
+function mergeDeps6(children) {
   let z = false;
   let f = false;
   let s = false;
@@ -1794,7 +2055,7 @@ function registerStringOps() {
         return out;
       },
       returnType: "string",
-      ...mergeDeps5(children)
+      ...mergeDeps6(children)
     };
   });
   registerOperator("downcase", (args, compile, path) => {
@@ -1804,7 +2065,7 @@ function registerStringOps() {
     return {
       evaluate: (ctx) => toStr(inner.evaluate(ctx)).toLowerCase(),
       returnType: "string",
-      ...mergeDeps5([inner])
+      ...mergeDeps6([inner])
     };
   });
   registerOperator("upcase", (args, compile, path) => {
@@ -1814,7 +2075,122 @@ function registerStringOps() {
     return {
       evaluate: (ctx) => toStr(inner.evaluate(ctx)).toUpperCase(),
       returnType: "string",
-      ...mergeDeps5([inner])
+      ...mergeDeps6([inner])
+    };
+  });
+  registerOperator("index-of", (args, compile, path) => {
+    if (args.length !== 2 && args.length !== 3)
+      throw new ExpressionError(`"index-of" expects 2 or 3 arguments, got ${args.length}`, ["index-of", ...args], path);
+    const needle = compile(args[0], "value", path.concat(1));
+    const haystack = compile(args[1], "value", path.concat(2));
+    const from = args.length === 3 ? compile(args[2], "number", path.concat(3)) : undefined;
+    const children = from ? [needle, haystack, from] : [needle, haystack];
+    return {
+      evaluate: (ctx) => {
+        const target = needle.evaluate(ctx);
+        const source = haystack.evaluate(ctx);
+        const start = from ? Number(from.evaluate(ctx)) : 0;
+        if (Array.isArray(source))
+          return source.indexOf(target, start);
+        return toStr(source).indexOf(toStr(target), start);
+      },
+      returnType: "number",
+      ...mergeDeps6(children)
+    };
+  });
+  registerOperator("slice", (args, compile, path) => {
+    if (args.length !== 2 && args.length !== 3)
+      throw new ExpressionError(`"slice" expects 2 or 3 arguments, got ${args.length}`, ["slice", ...args], path);
+    const input = compile(args[0], "value", path.concat(1));
+    const start = compile(args[1], "number", path.concat(2));
+    const end = args.length === 3 ? compile(args[2], "number", path.concat(3)) : undefined;
+    const children = end ? [input, start, end] : [input, start];
+    return {
+      evaluate: (ctx) => {
+        const source = input.evaluate(ctx);
+        const from = Number(start.evaluate(ctx));
+        const to = end ? Number(end.evaluate(ctx)) : undefined;
+        if (Array.isArray(source))
+          return to === undefined ? source.slice(from) : source.slice(from, to);
+        const text = toStr(source);
+        return to === undefined ? text.slice(from) : text.slice(from, to);
+      },
+      returnType: "value",
+      ...mergeDeps6(children)
+    };
+  });
+  registerOperator("number-format", (args, compile, path) => {
+    if (args.length !== 2)
+      throw new ExpressionError(`"number-format" expects 2 arguments, got ${args.length}`, ["number-format", ...args], path);
+    const value = compile(args[0], "number", path.concat(1));
+    const rawOptions = args[1];
+    if (rawOptions === null || typeof rawOptions !== "object" || Array.isArray(rawOptions))
+      throw new ExpressionError('"number-format": second argument must be an options object', ["number-format", ...args], path);
+    const opts = rawOptions;
+    const locale = typeof opts.locale === "string" ? opts.locale : undefined;
+    const format = {};
+    if (typeof opts.currency === "string") {
+      format.style = "currency";
+      format.currency = opts.currency;
+    }
+    if (typeof opts["min-fraction-digits"] === "number")
+      format.minimumFractionDigits = opts["min-fraction-digits"];
+    if (typeof opts["max-fraction-digits"] === "number")
+      format.maximumFractionDigits = opts["max-fraction-digits"];
+    const formatter = new Intl.NumberFormat(locale, format);
+    return {
+      evaluate: (ctx) => formatter.format(Number(value.evaluate(ctx))),
+      returnType: "string",
+      ...mergeDeps6([value])
+    };
+  });
+  registerOperator("format", (args, compile, path) => {
+    if (args.length === 0)
+      throw new ExpressionError('"format" expects at least 1 argument', ["format"], path);
+    const sections = [];
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      const isOptions = arg !== null && typeof arg === "object" && !Array.isArray(arg);
+      if (isOptions)
+        continue;
+      const section = { value: compile(arg, "value", path.concat(i + 1)) };
+      const options = args[i + 1];
+      if (options !== null && typeof options === "object" && !Array.isArray(options)) {
+        const opts = options;
+        const scale = opts["font-scale"];
+        if (typeof scale === "number")
+          section.scale = scale;
+        else if (Array.isArray(scale))
+          section.scale = compile(scale, "number", path.concat(i + 2, "font-scale"));
+        const font = opts["text-font"];
+        if (Array.isArray(font) && font[0] === "literal" && Array.isArray(font[1]))
+          section.fontStack = font[1].map(String);
+        else if (Array.isArray(font) && font.every((f) => typeof f === "string"))
+          section.fontStack = font;
+        const color = opts["text-color"];
+        if (typeof color === "string")
+          section.color = color;
+        else if (Array.isArray(color))
+          section.color = compile(color, "value", path.concat(i + 2, "text-color"));
+      }
+      sections.push(section);
+    }
+    const deps = sections.flatMap((s) => [
+      s.value,
+      typeof s.scale === "object" ? s.scale : undefined,
+      typeof s.color === "object" ? s.color : undefined
+    ].filter(Boolean));
+    return {
+      evaluate: (ctx) => {
+        return new Formatted(sections.map((section) => ({
+          text: toStr(section.value.evaluate(ctx)),
+          scale: typeof section.scale === "object" ? Number(section.scale.evaluate(ctx)) : section.scale,
+          fontStack: section.fontStack,
+          color: typeof section.color === "object" ? toStr(section.color.evaluate(ctx)) : section.color
+        })));
+      },
+      returnType: "formatted",
+      ...mergeDeps6(deps)
     };
   });
   registerOperator("resolved-locale", (args, _compile, path) => {
@@ -1845,6 +2221,8 @@ function boot() {
   registerConversionOps();
   registerStringOps();
   registerInterpolateOps();
+  registerBindingOps();
+  registerGeometryOps();
 }
 function compileLiteral(value, expected, path) {
   if (expected === "color") {
@@ -1899,7 +2277,9 @@ var BOOTED = false;
 var init_compile = __esm(() => {
   init_Color();
   init_errors();
+  init_binding();
   init_conversion();
+  init_geometry();
   init_interpolate();
   init_logical();
   init_lookup();
@@ -2015,6 +2395,18 @@ var init_legacyFilter = __esm(() => {
 });
 
 // src/core-map/style-spec/expressions/index.ts
+var exports_expressions = {};
+__export(exports_expressions, {
+  ExpressionError: () => ExpressionError,
+  compile: () => compile,
+  convertLegacyFilter: () => convertLegacyFilter,
+  evaluate: () => evaluate,
+  formatColor: () => formatColor,
+  isExpression: () => isExpression,
+  lerpColor: () => lerpColor,
+  parseColor: () => parseColor,
+  validateExpression: () => validateExpression
+});
 function evaluate(expr, ctx, expectedType = "value") {
   if (!isExpression(expr)) {
     if (Array.isArray(expr))
@@ -2044,7 +2436,7 @@ var init_expressions = __esm(() => {
 });
 
 // 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 backgroundPaint, fillPaint, fillExtrusionPaint, linePaint, circlePaint, symbolPaint, rasterPaint, hillshadePaint, heatmapPaint, paintPropertySchemas, visibility, backgroundLayout, fillLayout, fillExtrusionLayout, lineLayout, circleLayout, symbolLayout, rasterLayout, hillshadeLayout, heatmapLayout, layoutPropertySchemas, layerTypes, sourceTypes;
 var init_schema = __esm(() => {
   backgroundPaint = {
     "background-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
@@ -2122,6 +2514,21 @@ var init_schema = __esm(() => {
     "raster-resampling": { type: "enum", values: ["linear", "nearest"], default: "linear", sdk: "gl" },
     "raster-fade-duration": { type: "number", default: 300, minimum: 0, sdk: "gl" }
   };
+  hillshadePaint = {
+    "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, sdk: "gl" },
+    "hillshade-illumination-anchor": { type: "enum", values: ["map", "viewport"], default: "viewport", sdk: "gl" },
+    "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, sdk: "gl" },
+    "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, sdk: "gl" },
+    "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, sdk: "gl" },
+    "hillshade-accent-color": { type: "color", default: "#000000", transition: true, sdk: "gl" }
+  };
+  heatmapPaint = {
+    "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, sdk: "gl" },
+    "heatmap-weight": { type: "number", default: 1, minimum: 0, sdk: "gl" },
+    "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, sdk: "gl" },
+    "heatmap-color": { type: "color", default: undefined, sdk: "gl" },
+    "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, sdk: "gl" }
+  };
   paintPropertySchemas = {
     background: backgroundPaint,
     fill: fillPaint,
@@ -2129,7 +2536,9 @@ var init_schema = __esm(() => {
     line: linePaint,
     circle: circlePaint,
     symbol: symbolPaint,
-    raster: rasterPaint
+    raster: rasterPaint,
+    hillshade: hillshadePaint,
+    heatmap: heatmapPaint
   };
   visibility = { type: "enum", values: ["visible", "none"], default: "visible", sdk: "gl" };
   backgroundLayout = {
@@ -2211,6 +2620,12 @@ var init_schema = __esm(() => {
   rasterLayout = {
     visibility
   };
+  hillshadeLayout = {
+    visibility
+  };
+  heatmapLayout = {
+    visibility
+  };
   layoutPropertySchemas = {
     background: backgroundLayout,
     fill: fillLayout,
@@ -2218,9 +2633,11 @@ var init_schema = __esm(() => {
     line: lineLayout,
     circle: circleLayout,
     symbol: symbolLayout,
-    raster: rasterLayout
+    raster: rasterLayout,
+    hillshade: hillshadeLayout,
+    heatmap: heatmapLayout
   };
-  layerTypes = ["background", "fill", "fill-extrusion", "line", "circle", "symbol", "raster"];
+  layerTypes = ["background", "fill", "fill-extrusion", "line", "circle", "symbol", "raster", "hillshade", "heatmap"];
   sourceTypes = ["vector", "raster", "raster-dem", "geojson"];
 });