@tileflow/core 0.1.0-alpha.47 → 0.1.0-alpha.48

package/dist/native.d.ts

@@ -70,6 +70,104 @@ type MapLibreStyle = {
     metadata?: Record<string, unknown>;
 };
 
+declare const tileflowOverlayPlacements: readonly ["above-water", "below-roads", "above-roads", "above-buildings", "below-labels", "above-labels"];
+type TileflowOverlayPlacement = (typeof tileflowOverlayPlacements)[number];
+/**
+ * A GeoJSON FeatureCollection, the shape MapLibre clustering and `setData` accept. Features are
+ * plain objects because typed GeoJSON interfaces, such as `Feature<Point>`, have no index signature.
+ */
+type TileflowGeoJsonFeatureCollection = Readonly<{
+    features: readonly object[];
+    type: 'FeatureCollection';
+}>;
+/** MapLibre aggregate: `[operator, mapExpression]`, summed into each cluster's properties. */
+type TileflowClusterProperty = readonly [operator: unknown, map: unknown];
+/** Clustering options named as in the Mapbox and MapLibre source specifications. */
+type TileflowGeoJsonClusterOptions = Readonly<{
+    /** Group nearby points in the worker. Defaults to false. */
+    cluster?: boolean;
+    /** The last zoom that clusters; points are separate above it. MapLibre's default is 14. */
+    clusterMaxZoom?: number;
+    /** The fewest points that form a cluster. MapLibre's default is 2. */
+    clusterMinPoints?: number;
+    /** Aggregates kept on clusters, such as `{total: ['+', ['get', 'price']]}`. */
+    clusterProperties?: Readonly<Record<string, TileflowClusterProperty>>;
+    /** Cluster radius in CSS pixels. MapLibre's default is 50. */
+    clusterRadius?: number;
+}>;
+type TileflowGeoJsonSource = Readonly<TileflowGeoJsonClusterOptions & {
+    attribution?: string;
+    data: TileflowGeoJsonFeatureCollection | string;
+    kind: 'geojson';
+}>;
+type TileflowMapLibreOverlayLayer = Readonly<Record<string, unknown> & {
+    id: string;
+    source?: never;
+    type: string;
+}>;
+type TileflowMapLibreOverlay = Readonly<{
+    kind: 'maplibre-overlay';
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}>;
+/**
+ * Declare a named GeoJSON source. Omit `data` for a source the application fills at runtime through
+ * a framework adapter's `dataSources`.
+ */
+declare function geojsonSource(options?: Readonly<TileflowGeoJsonClusterOptions & {
+    attribution?: string;
+    data?: TileflowGeoJsonFeatureCollection | string;
+}>): TileflowGeoJsonSource;
+/** Group one or more ordinary MapLibre layers around one named Tileflow source. */
+declare function maplibreOverlay(options: {
+    layers: readonly TileflowMapLibreOverlayLayer[];
+    placement: TileflowOverlayPlacement;
+    source: string;
+}): TileflowMapLibreOverlay;
+/**
+ * Draw a clustering GeoJSON source: sized bubbles, their counts, and the separate points. Layers are
+ * named `<id>-clusters`, `<id>-cluster-count` and `<id>-points`. The count uses the map's label font
+ * unless `font` names another. Framework adapters zoom into a clicked cluster.
+ */
+declare function clusterOverlay(options: {
+    /** Bubble colours by point count: the first applies below `steps[0]`. */
+    colors?: readonly [string, string, string];
+    /** Zoom in when a cluster is clicked or tapped. Defaults to true. */
+    expandOnClick?: boolean;
+    /** An exact text-font stack, for maps whose labels use another font. */
+    font?: readonly string[];
+    id: string;
+    placement: TileflowOverlayPlacement;
+    /** Colour of the separate points. */
+    pointColor?: string;
+    /** Bubble radii in pixels, matching `colors`. */
+    radii?: readonly [number, number, number];
+    source: string;
+    /** The two point counts where bubbles change size and colour. */
+    steps?: readonly [number, number];
+    textColor?: string;
+}): TileflowMapLibreOverlay;
+/**
+ * Draw point density from a GeoJSON source or a hosted vector tileset. `weight` is a number or a
+ * MapLibre expression; values above 1 make a point count for more than one.
+ */
+declare function heatmapOverlay(options: {
+    /** `[density, color]` stops from 0 to 1. Start transparent so empty areas stay clear. */
+    colors?: readonly (readonly [density: number, color: string])[];
+    id: string;
+    intensity?: unknown;
+    /** Above this zoom the layer is not drawn, for handing over to points or clusters. */
+    maxZoom?: number;
+    opacity?: unknown;
+    placement: TileflowOverlayPlacement;
+    radius?: unknown;
+    source: string;
+    /** The source-layer of a vector tileset. GeoJSON sources have none. */
+    sourceLayer?: string;
+    weight?: unknown;
+}): TileflowMapLibreOverlay;
+
 /** Runtime-ready logical map with all relative theme resources already resolved. */
 type TileflowRuntimeManifestMap = TileflowRuntimeManifestMapEntry & {
     apiUrl?: string;
@@ -455,4 +553,4 @@ declare const tileflowMobileDiscoveryMaximumBytes = 4096;
 /** Bind every advertised representation to the exact Hosted origin and Map being requested. */
 declare function parseTileflowMobileDiscovery(value: unknown, discoveryUrl: string): TileflowMobileDiscovery;
 
-export { type CreateBoundaryFeatureStateOptions, type TileflowBoundaryFamily, type TileflowBoundaryFeatureState, type TileflowBoundaryRow, type TileflowBoundaryValues, type TileflowFeatureStateMap, type TileflowMobileDiscovery, type TileflowNativeAbortSignal, type TileflowNativeInitialView, type TileflowNativeInitialViewOptions, type TileflowNativeManifestAcquire, type TileflowNativeManifestLoadOptions, type TileflowNativeManifestOperation, type TileflowNativeManifestReader, type TileflowNativeManifestResponse, type TileflowNativeManifestResult, type TileflowNativeNetworkOptions, type TileflowNativeResourceUrlOptions, type TileflowNativeSource, type TileflowNativeSourceController, TileflowNativeSourceError, type TileflowNativeSourceErrorCode, type TileflowNativeSourceErrorField, type TileflowNativeSourceOptions, type TileflowNativeSourceState, TileflowNativeUrlError, type TileflowNativeUrlErrorCode, type TileflowNativeUrlField, type TileflowThemeBlendClock, TileflowThemeBlendError, type TileflowThemeBlendImage, type TileflowThemeBlendOptions, type TileflowThemeBlendPaint, type TileflowThemeBlendPlan, type TileflowThemeBlendSelection, type TileflowThemeBlendSwitch, type TileflowTimeOfDay, type TileflowTimeOfDayVariants, createBoundaryFeatureState, createTileflowNativeSourceController, fillTileflowThemeBlendTemplate, loadTileflowNativeManifest, nearestTileflowBlendTheme, parseTileflowMobileDiscovery, planTileflowThemeBlend, resolveTileflowNativeInitialView, resolveTileflowNativeManifestUrl, resolveTileflowNativeResourceUrl, tileflowBoundaryFamilies, tileflowMobileDiscoveryMaximumBytes, tileflowNativeManifestLimits, tileflowNativeUrlLimits, tileflowThemeBlendLimits, validateTileflowThemeBlendSelection };
+export { type CreateBoundaryFeatureStateOptions, type TileflowBoundaryFamily, type TileflowBoundaryFeatureState, type TileflowBoundaryRow, type TileflowBoundaryValues, type TileflowFeatureStateMap, type TileflowGeoJsonSource, type TileflowMapLibreOverlay, type TileflowMobileDiscovery, type TileflowNativeAbortSignal, type TileflowNativeInitialView, type TileflowNativeInitialViewOptions, type TileflowNativeManifestAcquire, type TileflowNativeManifestLoadOptions, type TileflowNativeManifestOperation, type TileflowNativeManifestReader, type TileflowNativeManifestResponse, type TileflowNativeManifestResult, type TileflowNativeNetworkOptions, type TileflowNativeResourceUrlOptions, type TileflowNativeSource, type TileflowNativeSourceController, TileflowNativeSourceError, type TileflowNativeSourceErrorCode, type TileflowNativeSourceErrorField, type TileflowNativeSourceOptions, type TileflowNativeSourceState, TileflowNativeUrlError, type TileflowNativeUrlErrorCode, type TileflowNativeUrlField, type TileflowOverlayPlacement, type TileflowThemeBlendClock, TileflowThemeBlendError, type TileflowThemeBlendImage, type TileflowThemeBlendOptions, type TileflowThemeBlendPaint, type TileflowThemeBlendPlan, type TileflowThemeBlendSelection, type TileflowThemeBlendSwitch, type TileflowTimeOfDay, type TileflowTimeOfDayVariants, clusterOverlay, createBoundaryFeatureState, createTileflowNativeSourceController, fillTileflowThemeBlendTemplate, geojsonSource, heatmapOverlay, loadTileflowNativeManifest, maplibreOverlay, nearestTileflowBlendTheme, parseTileflowMobileDiscovery, planTileflowThemeBlend, resolveTileflowNativeInitialView, resolveTileflowNativeManifestUrl, resolveTileflowNativeResourceUrl, tileflowBoundaryFamilies, tileflowMobileDiscoveryMaximumBytes, tileflowNativeManifestLimits, tileflowNativeUrlLimits, tileflowThemeBlendLimits, validateTileflowThemeBlendSelection };

package/dist/native.js

@@ -4326,6 +4326,18 @@ function planTileflowThemeBlend(styles, options = {}) {
 function fillTileflowThemeBlendTemplate(template, position) {
   return fillTemplate(template, position);
 }
+function mixTileflowColours(from, to, t) {
+  const a = oklab(from);
+  const b = oklab(to);
+  if (!a || !b) return void 0;
+  const alpha = a[3] + (b[3] - a[3]) * t;
+  if (alpha <= 0) return "rgba(0, 0, 0, 0)";
+  const channels = a.slice(0, 3).map((value, channel) => {
+    const from2 = value * a[3];
+    return (from2 + (b[channel] * b[3] - from2) * t) / alpha;
+  });
+  return colourFromOklab([...channels, alpha]);
+}
 function fillLayer(layer, position, dominant, layerSwitches) {
   const filled = { ...layer };
   for (const group of ["layout", "paint"]) {
@@ -4369,10 +4381,7 @@ function mixLeaf(values, position) {
   if (t <= 0 || from === to) return from;
   if (t >= 1) return to;
   if (typeof from === "number" && typeof to === "number") return from + (to - from) * t;
-  const a = oklab(String(from));
-  const b = oklab(String(to));
-  if (!a || !b) return t < 0.5 ? from : to;
-  return colourFromOklab(a.map((value, channel) => value + (b[channel] - value) * t));
+  return mixTileflowColours(String(from), String(to), t) ?? (t < 0.5 ? from : to);
 }
 function clampPosition(position, themes) {
   if (!Number.isFinite(position)) return 0;
@@ -6061,6 +6070,231 @@ init_portable_identity_rules();
 // src/runtime.ts
 init_portable_identity_rules();
 init_time_of_day();
+
+// src/overlays.ts
+init_portable_identity_rules();
+var tileflowOverlayPlacements = [
+  "above-water",
+  "below-roads",
+  "above-roads",
+  "above-buildings",
+  "below-labels",
+  "above-labels"
+];
+var tileflowClusterMetadataKey = "tileflow:cluster";
+function geojsonSource(options = {}) {
+  const data = options.data ?? { features: [], type: "FeatureCollection" };
+  if (typeof data === "string") {
+    if (!isHttpsUrl(data)) {
+      throw new Error("Tileflow GeoJSON source URLs must be absolute https:// URLs.");
+    }
+  } else if (!isPlainRecord(data) || data.type !== "FeatureCollection" || !Array.isArray(data.features)) {
+    throw new Error("Tileflow GeoJSON source data must be a FeatureCollection or an https:// URL.");
+  }
+  assertClusterOptions(options);
+  const attribution = options.attribution?.trim();
+  return Object.freeze({
+    ...attribution ? { attribution } : {},
+    ...pickClusterOptions(options),
+    data: typeof data === "string" ? data : Object.freeze(cloneJson(data)),
+    kind: "geojson"
+  });
+}
+function maplibreOverlay(options) {
+  if (!isTileflowPortableId(options.source)) {
+    throw new Error(`Invalid Tileflow overlay source ID: ${options.source}.`);
+  }
+  if (!tileflowOverlayPlacements.includes(options.placement)) {
+    throw new Error(`Invalid Tileflow overlay placement: ${String(options.placement)}.`);
+  }
+  if (!Array.isArray(options.layers) || options.layers.length < 1) {
+    throw new Error("Tileflow MapLibre overlays require at least one layer.");
+  }
+  const layers = options.layers.map((layer, index) => {
+    if (!isPlainRecord(layer)) {
+      throw new Error(`Tileflow overlay layer ${index} must be a plain object.`);
+    }
+    if (!isTileflowPortableId(layer.id)) {
+      throw new Error(`Invalid Tileflow overlay layer ID: ${String(layer.id)}.`);
+    }
+    if (layer.id === "tileflow" || layer.id.startsWith("tileflow-")) {
+      throw new Error(`Tileflow overlay layer ID is reserved: ${layer.id}.`);
+    }
+    if (typeof layer.type !== "string" || !layer.type) {
+      throw new Error(`Tileflow overlay layer ${layer.id} requires a MapLibre type.`);
+    }
+    if (Object.hasOwn(layer, "source")) {
+      throw new Error(
+        `Tileflow overlay layer ${layer.id} inherits its source from the overlay and must not declare source.`
+      );
+    }
+    return Object.freeze(cloneJson(layer));
+  });
+  return Object.freeze({
+    kind: "maplibre-overlay",
+    layers: Object.freeze(layers),
+    placement: options.placement,
+    source: options.source
+  });
+}
+function clusterOverlay(options) {
+  const colors = options.colors ?? ["#2563eb", "#7c3aed", "#db2777"];
+  const radii = options.radii ?? [16, 22, 30];
+  const [low, high] = options.steps ?? [100, 750];
+  if (!(low > 0 && high > low) || !radii.every((radius) => radius > 0)) {
+    throw new Error("Tileflow cluster steps must increase and radii must be positive.");
+  }
+  const metadata = (role) => ({
+    [tileflowClusterMetadataKey]: {
+      expandOnClick: options.expandOnClick ?? true,
+      role
+    }
+  });
+  const step = (values) => [
+    "step",
+    ["get", "point_count"],
+    values[0],
+    low,
+    values[1],
+    high,
+    values[2]
+  ];
+  return maplibreOverlay({
+    layers: [
+      {
+        filter: ["has", "point_count"],
+        id: `${options.id}-clusters`,
+        metadata: metadata("cluster"),
+        paint: {
+          "circle-color": step(colors),
+          "circle-radius": step(radii),
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 2
+        },
+        type: "circle"
+      },
+      {
+        filter: ["has", "point_count"],
+        id: `${options.id}-cluster-count`,
+        layout: {
+          "text-allow-overlap": true,
+          "text-field": ["get", "point_count_abbreviated"],
+          ...options.font ? { "text-font": [...options.font] } : {},
+          "text-ignore-placement": true,
+          "text-size": 13
+        },
+        metadata: metadata("count"),
+        paint: { "text-color": options.textColor ?? "#ffffff" },
+        type: "symbol"
+      },
+      {
+        filter: ["!", ["has", "point_count"]],
+        id: `${options.id}-points`,
+        metadata: metadata("point"),
+        paint: {
+          "circle-color": options.pointColor ?? colors[0],
+          "circle-radius": 6,
+          "circle-stroke-color": "#ffffff",
+          "circle-stroke-width": 1.5
+        },
+        type: "circle"
+      }
+    ],
+    placement: options.placement,
+    source: options.source
+  });
+}
+function heatmapOverlay(options) {
+  const colors = options.colors ?? [
+    [0, "rgba(33, 102, 172, 0)"],
+    [0.2, "#67a9cf"],
+    [0.4, "#d1e5f0"],
+    [0.6, "#fddbc7"],
+    [0.8, "#ef8a62"],
+    [1, "#b2182b"]
+  ];
+  if (colors.length < 2 || colors.some(([density], index) => {
+    const previous = colors[index - 1]?.[0] ?? -1;
+    return !(density >= 0 && density <= 1 && density > previous);
+  })) {
+    throw new Error("Tileflow heatmap colors need at least two increasing densities from 0 to 1.");
+  }
+  const paint = {
+    "heatmap-color": ["interpolate", ["linear"], ["heatmap-density"], ...colors.flat()],
+    "heatmap-intensity": options.intensity ?? 1,
+    "heatmap-opacity": options.opacity ?? 0.8,
+    "heatmap-radius": options.radius ?? 30,
+    "heatmap-weight": options.weight ?? 1
+  };
+  return maplibreOverlay({
+    layers: [
+      {
+        id: options.id,
+        ...options.maxZoom === void 0 ? {} : { maxzoom: options.maxZoom },
+        paint,
+        ...options.sourceLayer === void 0 ? {} : { "source-layer": options.sourceLayer },
+        type: "heatmap"
+      }
+    ],
+    placement: options.placement,
+    source: options.source
+  });
+}
+function pickClusterOptions(source) {
+  return {
+    ...source.cluster === void 0 ? {} : { cluster: source.cluster },
+    ...source.clusterMaxZoom === void 0 ? {} : { clusterMaxZoom: source.clusterMaxZoom },
+    ...source.clusterMinPoints === void 0 ? {} : { clusterMinPoints: source.clusterMinPoints },
+    ...source.clusterProperties === void 0 ? {} : { clusterProperties: cloneJson(source.clusterProperties) },
+    ...source.clusterRadius === void 0 ? {} : { clusterRadius: source.clusterRadius }
+  };
+}
+function assertClusterOptions(options) {
+  const { cluster, clusterMaxZoom, clusterMinPoints, clusterProperties, clusterRadius } = options;
+  if (cluster !== void 0 && typeof cluster !== "boolean") {
+    throw new Error("Tileflow GeoJSON cluster must be a boolean.");
+  }
+  if (clusterRadius !== void 0 && !(Number.isFinite(clusterRadius) && clusterRadius > 0)) {
+    throw new Error("Tileflow clusterRadius must be a positive number of pixels.");
+  }
+  if (clusterMaxZoom !== void 0 && !(Number.isFinite(clusterMaxZoom) && clusterMaxZoom >= 0 && clusterMaxZoom <= 24)) {
+    throw new Error("Tileflow clusterMaxZoom must be a zoom from 0 to 24.");
+  }
+  if (clusterMinPoints !== void 0 && !(Number.isInteger(clusterMinPoints) && clusterMinPoints >= 2)) {
+    throw new Error("Tileflow clusterMinPoints must be an integer of at least 2.");
+  }
+  if (!cluster && [clusterMaxZoom, clusterMinPoints, clusterProperties, clusterRadius].some(
+    (value) => value !== void 0
+  )) {
+    throw new Error("Tileflow cluster options require cluster: true.");
+  }
+  for (const [name, value] of Object.entries(clusterProperties ?? {})) {
+    if (!Array.isArray(value) || value.length !== 2) {
+      throw new Error(`Tileflow clusterProperties.${name} must be [operator, mapExpression].`);
+    }
+  }
+}
+function isHttpsUrl(value) {
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function cloneJson(value) {
+  if (Array.isArray(value)) return value.map(cloneJson);
+  if (!isPlainRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, cloneJson(child)])
+  );
+}
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/runtime.ts
 var defaultTileflowRuntimeView = Object.freeze({
   bearing: 0,
   center: [0, 20],
@@ -6530,10 +6764,14 @@ export {
   TileflowNativeSourceError,
   TileflowNativeUrlError,
   TileflowThemeBlendError,
+  clusterOverlay,
   createBoundaryFeatureState,
   createTileflowNativeSourceController,
   fillTileflowThemeBlendTemplate,
+  geojsonSource,
+  heatmapOverlay,
   loadTileflowNativeManifest,
+  maplibreOverlay,
   nearestTileflowBlendTheme,
   parseTileflowMobileDiscovery,
   planTileflowThemeBlend,

package/dist/runtime.d.ts

@@ -1 +1 @@
-export { L as TileflowAnalytics, cb as TileflowAppearanceSelection, cc as TileflowColorOverrides, ab as TileflowManifestFetchOptions, ac as TileflowManifestLoadOptions, ad as TileflowMapMode, ae as TileflowMapModeOptions, ar as TileflowResolvedRuntimeTheme, aP as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, aQ as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, aR as TileflowRuntimeSource, aS as TileflowRuntimeSourceValidation, aT as TileflowRuntimeStyle, aU as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, aV as TileflowRuntimeViewOptions, aW as TileflowSessionController, aX as TileflowSessionGrantResponse, j as TileflowStyleFamily, a_ as TileflowStyleFontFace, bj as TileflowThemeBlendSelection, bq as TileflowThemeSelection, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, cd as applyTileflowColorOverrides, by as assertValidTileflowRuntimeSource, bz as clearTileflowManifestCache, bB as createTileflowSessionController, bC as createTileflowSessionId, bD as defaultTileflowManifestUrl, bE as defaultTileflowRuntimeView, l as expandTileflowFamilyTemplate, bG as getTileflowAnalyticsApiUrl, bH as getTileflowStyleFontFaces, bI as inferTileflowAnalyticsFromStyleUrl, bJ as isTileflowTimeOfDay, bK as loadTileflowManifest, ce as loadTileflowRuntimeAppearance, cf as loadTileflowStyleFamily, n as materializeTileflowStyleFamily, bL as mergeTileflowAnalytics, bM as nearestTileflowBlendTheme, bN as normalizeTileflowRuntimeCenter, bO as normalizeTileflowStaticImageSize, cg as normalizeTileflowSurfaceId, bP as normalizeTileflowUrl, p as parseTileflowStyleFamily, ch as prepareTileflowStyleFamilyForRendering, bQ as resolveTileflowAnalyticsRequestUrl, ci as resolveTileflowAppearance, cj as resolveTileflowFamilyResourceUrls, bR as resolveTileflowManifestMap, bS as resolveTileflowMapMode, bT as resolveTileflowRuntimeStyle, bU as resolveTileflowRuntimeTheme, bV as resolveTileflowRuntimeThemeBlend, bW as resolveTileflowRuntimeView, bX as resolveTileflowStaticImageUrl, ck as resolveTileflowStyleResourceUrls, bY as shouldLoadTileflowManifest, bZ as startTileflowSession, o as tileflowStyleFamilyLimits, b$ as tileflowStyleFontFaceLimits, c0 as tileflowStyleFontFacesMetadataKey, c1 as tileflowThemeBlendLimits, c3 as tileflowTimesOfDay, c5 as validateTileflowRuntimeSource, c6 as validateTileflowThemeBlendSelection, c7 as validateTileflowThemeSelection, w as withTileflowFamilyTemplate } from './manifest-types-CcD4OQkJ.js';
+export { R as TileflowAnalytics, cy as TileflowAppearanceSelection, cz as TileflowColorOverrides, an as TileflowManifestFetchOptions, ao as TileflowManifestLoadOptions, aq as TileflowMapMode, ar as TileflowMapModeOptions, aG as TileflowResolvedRuntimeTheme, b2 as TileflowRuntimeCenterLike, a as TileflowRuntimeColorScheme, T as TileflowRuntimeManifest, b3 as TileflowRuntimeManifestMap, b as TileflowRuntimeManifestMapEntry, c as TileflowRuntimeManifestTheme, b4 as TileflowRuntimeSource, b5 as TileflowRuntimeSourceValidation, b6 as TileflowRuntimeStyle, b7 as TileflowRuntimeStyleOptions, d as TileflowRuntimeSystemThemes, b8 as TileflowRuntimeViewOptions, b9 as TileflowSessionController, ba as TileflowSessionGrantResponse, j as TileflowStyleFamily, be as TileflowStyleFontFace, bz as TileflowThemeBlendSelection, bG as TileflowThemeSelection, e as TileflowTimeOfDay, f as TileflowTimeOfDayVariants, cA as applyTileflowColorOverrides, bO as assertValidTileflowRuntimeSource, bP as clearTileflowManifestCache, bQ as clusterOverlay, bS as createTileflowSessionController, bT as createTileflowSessionId, bU as defaultTileflowManifestUrl, bV as defaultTileflowRuntimeView, l as expandTileflowFamilyTemplate, bX as geojsonSource, bY as getTileflowAnalyticsApiUrl, bZ as getTileflowStyleFontFaces, b_ as heatmapOverlay, c0 as inferTileflowAnalyticsFromStyleUrl, c2 as isTileflowTimeOfDay, c3 as loadTileflowManifest, cB as loadTileflowRuntimeAppearance, cC as loadTileflowStyleFamily, c4 as maplibreOverlay, n as materializeTileflowStyleFamily, c5 as mergeTileflowAnalytics, c6 as nearestTileflowBlendTheme, c7 as normalizeTileflowRuntimeCenter, c8 as normalizeTileflowStaticImageSize, cD as normalizeTileflowSurfaceId, c9 as normalizeTileflowUrl, p as parseTileflowStyleFamily, cE as prepareTileflowStyleFamilyForRendering, cb as resolveTileflowAnalyticsRequestUrl, cF as resolveTileflowAppearance, cG as resolveTileflowFamilyResourceUrls, cc as resolveTileflowManifestMap, cd as resolveTileflowMapMode, ce as resolveTileflowRuntimeStyle, cf as resolveTileflowRuntimeTheme, cg as resolveTileflowRuntimeThemeBlend, ch as resolveTileflowRuntimeView, ci as resolveTileflowStaticImageUrl, cH as resolveTileflowStyleResourceUrls, cj as shouldLoadTileflowManifest, ck as startTileflowSession, o as tileflowStyleFamilyLimits, cm as tileflowStyleFontFaceLimits, cn as tileflowStyleFontFacesMetadataKey, co as tileflowThemeBlendLimits, cq as tileflowTimesOfDay, cs as validateTileflowRuntimeSource, ct as validateTileflowThemeBlendSelection, cu as validateTileflowThemeSelection, w as withTileflowFamilyTemplate } from './manifest-types-U7JPDNAo.js';