@tileflow/core 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/native.js

@@ -4606,6 +4606,15 @@ function validateTileflowThemeSelection(value) {
   return value === "system" || isTileflowThemeName(value);
 }
 var tileflowThemeBlendLimits = Object.freeze({ maximumThemes: 8, minimumThemes: 2 });
+function validateTileflowThemeBlendSelection(value) {
+  if (!value || typeof value !== "object") return false;
+  const { position, themes } = value;
+  return Array.isArray(themes) && themes.length >= tileflowThemeBlendLimits.minimumThemes && themes.length <= tileflowThemeBlendLimits.maximumThemes && themes.every((theme) => isTileflowThemeName(theme)) && typeof position === "number" && Number.isFinite(position) && position >= 0 && position <= themes.length - 1;
+}
+function nearestTileflowBlendTheme(blend) {
+  const index = Math.min(blend.themes.length - 1, Math.max(0, Math.round(blend.position)));
+  return blend.themes[index];
+}
 function resolveTileflowRuntimeTheme(map2, selection, colorScheme) {
   let name;
   if (selection === void 0) {
@@ -4849,14 +4858,695 @@ function snapshotView(input) {
     ...parsed.zoom === void 0 ? {} : { zoom: parsed.zoom }
   };
 }
+
+// src/theme-blend.ts
+var TileflowThemeBlendError = class extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "TileflowThemeBlendError");
+  }
+};
+var BlendLeaf = class {
+  constructor(values) {
+    __publicField(this, "values", values);
+  }
+};
+var imageProperties = /* @__PURE__ */ new Set([
+  "icon-image",
+  "fill-pattern",
+  "line-pattern",
+  "background-pattern",
+  "fill-extrusion-pattern"
+]);
+var opacityProperties = {
+  background: "background-opacity",
+  circle: "circle-opacity",
+  fill: "fill-opacity",
+  "fill-extrusion": "fill-extrusion-opacity",
+  heatmap: "heatmap-opacity",
+  line: "line-opacity",
+  raster: "raster-opacity"
+};
+var featureOperators = /* @__PURE__ */ new Set([
+  "feature-state",
+  "geometry-type",
+  "get",
+  "has",
+  "id",
+  "in",
+  "properties"
+]);
+var maximumBranches = 24;
+function planTileflowThemeBlend(styles, options = {}) {
+  if (styles.length < 2)
+    throw new TileflowThemeBlendError("A theme blend needs two or more themes.");
+  const [base2] = styles;
+  assertSameStructure(styles, base2);
+  const mixedImages = new Set(imageProperties);
+  if (options.iconImages === "switch") mixedImages.delete("icon-image");
+  const paints = [];
+  const switches = [];
+  const imageGroups = collectImageNames(styles, base2, mixedImages);
+  const symbolLayers = /* @__PURE__ */ new Set();
+  const images = /* @__PURE__ */ new Map();
+  let splitLayers = 0;
+  let copiedLayers = 0;
+  let switchedLayers = 0;
+  const layers = [];
+  for (const [index, layer] of base2.layers.entries()) {
+    const variants = styles.map((style) => style.layers[index]);
+    layers.push(...planLayer(variants, String(layer.type)));
+  }
+  const switchesByLayer = /* @__PURE__ */ new Map();
+  for (const entry of switches) {
+    const list = switchesByLayer.get(entry.layer) ?? [];
+    list.push(entry);
+    switchesByLayer.set(entry.layer, list);
+  }
+  const sky = differingRoot(styles, "sky");
+  const light = differingRoot(styles, "light");
+  const metadata = alignInteractionManifest(base2.metadata, layers);
+  return {
+    themes: styles.length,
+    paints,
+    images: [...images.values()],
+    switches,
+    ...sky === void 0 ? {} : { sky },
+    ...light === void 0 ? {} : { light },
+    summary: { splitLayers, copiedLayers, switchedLayers, switchedValues: switches.length },
+    styleAt(position) {
+      const at = clampPosition(position, styles.length);
+      const dominant = Math.round(at);
+      const style = {
+        ...base2,
+        ...metadata === void 0 ? {} : { metadata },
+        // Symbols show the nearest theme, as the label cross-fade leaves them between changes.
+        layers: layers.map(
+          (layer) => fillLayer(
+            layer,
+            symbolLayers.has(String(layer.id)) ? dominant : at,
+            dominant,
+            switchesByLayer.get(String(layer.id))
+          )
+        )
+      };
+      if (sky !== void 0) style.sky = fillTemplate(sky, at);
+      if (light !== void 0) style.light = fillTemplate(light, at);
+      return style;
+    }
+  };
+  function planLayer(variants, type) {
+    const [layer] = variants;
+    const id = String(layer.id);
+    const paint = { ...layer.paint };
+    const layout = { ...layer.layout };
+    const follows = type === "symbol" ? "dominant" : "position";
+    const ownPaints = [];
+    const ownSwitches = [];
+    const driven = [];
+    const paintOf = (variant) => variant.paint ?? {};
+    for (const group of ["layout", "paint"]) {
+      const target = group === "paint" ? paint : layout;
+      for (const property of propertyNames(variants, group)) {
+        const values = variants.map(
+          (variant) => variant[group]?.[property]
+        );
+        if (values.every((value) => same(value, values[0]))) continue;
+        if (mixedImages.has(property)) {
+          const tuples = imageTuples(values);
+          if (tuples && tuples.every((names) => imageGroups.get(names[0])?.size === 1)) {
+            for (const names of tuples) {
+              if (names.every((name) => name === names[0])) continue;
+              images.set(JSON.stringify(names), {
+                names,
+                follows: property === "icon-image" ? "dominant" : "position"
+              });
+            }
+            continue;
+          }
+        }
+        if (group === "layout" || values.includes(void 0) || imageProperties.has(property)) {
+          ownSwitches.push({ group, property, values });
+          continue;
+        }
+        if (values.some(isDataDriven)) {
+          driven.push(property);
+          continue;
+        }
+        const template = tryMixTemplate(values);
+        if (template === void 0) {
+          ownSwitches.push({ group, property, values });
+          continue;
+        }
+        ownPaints.push({ property, template });
+        target[property] = template;
+      }
+    }
+    const planned = { ...layer, paint, layout };
+    let results = [{ layer: planned, extra: [] }];
+    if (driven.length > 0) {
+      const split = type === "symbol" ? void 0 : splitLayer();
+      const copies = split ?? (type === "symbol" ? void 0 : copyLayer());
+      if (copies) results = copies;
+      else
+        for (const property of driven)
+          ownSwitches.push({
+            group: "paint",
+            property,
+            values: variants.map((variant) => paintOf(variant)[property])
+          });
+    }
+    if (options.featureSwitches === "layers" && results.length === 1 && ownSwitches.some((entry) => entry.values.some(isDataDriven)))
+      results = switchLayer();
+    for (const result of results) {
+      const resultId = String(result.layer.id);
+      if (type === "symbol") symbolLayers.add(resultId);
+      const overridden = new Set(result.extra.map((entry) => entry.property));
+      for (const entry of [
+        ...ownPaints.filter((own) => !overridden.has(own.property)),
+        ...result.extra
+      ])
+        paints.push({ layer: resultId, property: entry.property, template: entry.template, follows });
+      if (result.visibility)
+        switches.push({
+          layer: resultId,
+          group: "layout",
+          property: "visibility",
+          values: result.visibility
+        });
+      else for (const entry of ownSwitches) switches.push({ layer: resultId, ...entry });
+    }
+    return results.map((result) => result.layer);
+    function switchLayer() {
+      switchedLayers += variants.length;
+      return variants.map((_, theme) => {
+        const copyPaint = { ...paint };
+        const copyLayout = { ...layout };
+        for (const entry of ownSwitches) {
+          const target = entry.group === "paint" ? copyPaint : copyLayout;
+          const value = entry.values[theme];
+          if (value === void 0) delete target[entry.property];
+          else target[entry.property] = value;
+        }
+        const shown = copyLayout.visibility === "none" ? "none" : "visible";
+        return {
+          layer: { ...planned, id: `${id}::theme-${theme}`, paint: copyPaint, layout: copyLayout },
+          extra: [],
+          visibility: variants.map((__, nearest) => nearest === theme ? shown : "none")
+        };
+      });
+    }
+    function splitLayer() {
+      if (isLegacyFilter(layer.filter)) return void 0;
+      const branches = splitBranches(
+        Object.fromEntries(
+          driven.map((property) => [
+            property,
+            variants.map((variant) => paintOf(variant)[property])
+          ])
+        )
+      );
+      if (!branches) return void 0;
+      const groups = /* @__PURE__ */ new Map();
+      for (const branch of branches) {
+        const key = JSON.stringify(branch.valuesByProperty);
+        let group = groups.get(key);
+        if (!group) {
+          const templates = {};
+          for (const [property, values] of Object.entries(branch.valuesByProperty)) {
+            const template = tryMixTemplate(values);
+            if (template === void 0) return void 0;
+            templates[property] = template;
+          }
+          group = { templates, conditions: [] };
+          groups.set(key, group);
+        }
+        group.conditions.push(
+          branch.conditions.length === 1 ? branch.conditions[0] : ["all", ...branch.conditions]
+        );
+      }
+      splitLayers += groups.size;
+      return [...groups.values()].map((group, number3) => {
+        const chosen = group.conditions.length === 1 ? group.conditions[0] : ["any", ...group.conditions];
+        return {
+          layer: {
+            ...planned,
+            id: `${id}::branch-${number3}`,
+            filter: layer.filter === void 0 ? chosen : ["all", layer.filter, chosen],
+            paint: { ...paint, ...group.templates }
+          },
+          extra: Object.entries(group.templates).filter(([, template]) => containsLeaf(template)).map(([property, template]) => ({ property, template }))
+        };
+      });
+    }
+    function copyLayer() {
+      const opacity = opacityProperties[type];
+      if (!opacity || variants.some((variant) => isDataDriven(paintOf(variant)[opacity])))
+        return void 0;
+      copiedLayers += variants.length;
+      return variants.map((variant, theme) => {
+        const weight = new BlendLeaf(variants.map((_, other) => other === theme ? 1 : 0));
+        const template = scaleByWeight(paint[opacity] ?? 1, weight);
+        const copyPaint = { ...paint, [opacity]: template };
+        for (const property of driven) copyPaint[property] = paintOf(variant)[property];
+        return {
+          layer: { ...planned, id: `${id}::theme-${theme}`, paint: copyPaint },
+          extra: [{ property: opacity, template }]
+        };
+      });
+    }
+  }
+}
+function fillTileflowThemeBlendTemplate(template, position) {
+  return fillTemplate(template, position);
+}
+function fillLayer(layer, position, dominant, layerSwitches) {
+  const filled = { ...layer };
+  for (const group of ["layout", "paint"]) {
+    const values = layer[group];
+    if (!values) continue;
+    const out = {};
+    for (const [key, value] of Object.entries(values)) out[key] = fillTemplate(value, position);
+    for (const entry of layerSwitches ?? []) {
+      if (entry.group !== group) continue;
+      const value = entry.values[dominant];
+      if (value === void 0) delete out[entry.property];
+      else out[entry.property] = value;
+    }
+    if (Object.keys(out).length > 0) filled[group] = out;
+    else delete filled[group];
+  }
+  return filled;
+}
+function fillTemplate(node, position) {
+  if (node instanceof BlendLeaf) return mixLeaf(node.values, position);
+  if (Array.isArray(node)) return node.map((item) => fillTemplate(item, position));
+  if (node && typeof node === "object" && containsLeaf(node)) {
+    return Object.fromEntries(
+      Object.entries(node).map(([key, value]) => [key, fillTemplate(value, position)])
+    );
+  }
+  return node;
+}
+function containsLeaf(node) {
+  if (node instanceof BlendLeaf) return true;
+  if (Array.isArray(node)) return node.some(containsLeaf);
+  if (node && typeof node === "object") return Object.values(node).some(containsLeaf);
+  return false;
+}
+function mixLeaf(values, position) {
+  const at = clampPosition(position, values.length);
+  const index = Math.min(values.length - 2, Math.floor(at));
+  const t = at - index;
+  const from = values[index];
+  const to = values[index + 1];
+  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));
+}
+function clampPosition(position, themes) {
+  if (!Number.isFinite(position)) return 0;
+  return Math.min(themes - 1, Math.max(0, position));
+}
+function assertSameStructure(styles, base2) {
+  const ids = (style) => style.layers.map((layer) => layer.id);
+  for (const style of styles) {
+    if (!same(ids(style), ids(base2)))
+      throw new TileflowThemeBlendError(
+        "Blended themes must have the same layers in the same order."
+      );
+    if (!same(style.sources, base2.sources))
+      throw new TileflowThemeBlendError("Blended themes must use the same sources.");
+    if (!same(style.sprite, base2.sprite) || !same(style.glyphs, base2.glyphs))
+      throw new TileflowThemeBlendError("Blended themes must use the same sprite and glyphs.");
+    for (const [index, layer] of style.layers.entries()) {
+      const other = base2.layers[index];
+      for (const key of ["type", "source", "source-layer", "filter", "minzoom", "maxzoom"])
+        if (!same(layer[key], other[key]))
+          throw new TileflowThemeBlendError(
+            `Blended themes differ in ${key} of layer ${JSON.stringify(layer.id)}.`
+          );
+    }
+  }
+}
+function propertyNames(variants, group) {
+  const names = /* @__PURE__ */ new Set();
+  for (const variant of variants)
+    for (const name of Object.keys(variant[group] ?? {})) names.add(name);
+  return [...names];
+}
+function differingRoot(styles, key) {
+  const values = styles.map((style) => style[key]);
+  if (values.every((value) => same(value, values[0]))) return void 0;
+  return tryMixTemplate(values);
+}
+function collectImageNames(styles, base2, properties) {
+  const uses = /* @__PURE__ */ new Map();
+  for (const [index] of base2.layers.entries()) {
+    for (const group of ["layout", "paint"]) {
+      for (const property of properties) {
+        const values = styles.map(
+          (style) => style.layers[index]?.[group]?.[property]
+        );
+        if (values[0] === void 0) continue;
+        for (const names of imageTuples(values) ?? []) {
+          const set = uses.get(names[0]) ?? /* @__PURE__ */ new Set();
+          set.add(JSON.stringify(names));
+          uses.set(names[0], set);
+        }
+      }
+    }
+  }
+  return uses;
+}
+function alignInteractionManifest(metadata, layers) {
+  if (!isRecord(metadata)) return void 0;
+  const planned = /* @__PURE__ */ new Map();
+  for (const [index, layer] of layers.entries()) {
+    const id = String(layer.id);
+    const original = /^(.+)::(?:branch|theme)-\d+$/u.exec(id)?.[1] ?? id;
+    planned.set(original, [...planned.get(original) ?? [], { id, index }]);
+  }
+  let aligned;
+  const interactions = metadata["tileflow:interaction-manifest"];
+  const domains = isRecord(interactions) ? interactions.domains : void 0;
+  if (isRecord(interactions) && isRecord(domains) && isRecord(domains.poi)) {
+    const poi = domains.poi;
+    if (Array.isArray(poi.layers)) {
+      const poiLayers = poi.layers.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry.layerId !== "string") return [entry];
+        const copies = planned.get(entry.layerId);
+        if (!copies) return [entry];
+        return copies.map(({ id, index }) => ({ ...entry, layerId: id, priority: index }));
+      });
+      aligned = {
+        ...metadata,
+        "tileflow:interaction-manifest": {
+          ...interactions,
+          domains: { ...domains, poi: { ...poi, layers: poiLayers } }
+        }
+      };
+    }
+  }
+  const overlays = metadata["tileflow:overlay-placement-manifest"];
+  if (isRecord(overlays) && isRecord(overlays.anchors)) {
+    const anchors = Object.fromEntries(
+      Object.entries(overlays.anchors).map(([placement, anchor]) => [
+        placement,
+        typeof anchor === "string" ? planned.get(anchor)?.[0]?.id ?? anchor : anchor
+      ])
+    );
+    aligned = {
+      ...aligned ?? metadata,
+      "tileflow:overlay-placement-manifest": { ...overlays, anchors }
+    };
+  }
+  return aligned;
+}
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function imageTuples(values, out = []) {
+  const [first] = values;
+  if (values.every((value) => typeof value === "string")) {
+    out.push(values);
+    return out;
+  }
+  if (!Array.isArray(first) || typeof first[0] !== "string") {
+    return values.every((value) => same(value, first)) ? out : void 0;
+  }
+  const operator = first[0];
+  if (!values.every(
+    (value) => Array.isArray(value) && value[0] === operator && value.length === first.length
+  )) {
+    return void 0;
+  }
+  const at = (index) => values.map((value) => value[index]);
+  const sameAt = (index) => at(index).every((value) => same(value, first[index]));
+  const outputs = [];
+  if (operator === "literal" || operator === "image") outputs.push(1);
+  else if (operator === "coalesce")
+    for (let index = 1; index < first.length; index += 1) outputs.push(index);
+  else if (operator === "match") {
+    if (!sameAt(1)) return void 0;
+    for (let index = 2; index < first.length - 1; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+    outputs.push(first.length - 1);
+  } else if (operator === "case") {
+    for (let index = 1; index < first.length - 1; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+    outputs.push(first.length - 1);
+  } else if (operator === "step") {
+    if (!sameAt(1)) return void 0;
+    outputs.push(2);
+    for (let index = 3; index < first.length; index += 2) {
+      if (!sameAt(index)) return void 0;
+      outputs.push(index + 1);
+    }
+  } else {
+    return values.every((value) => same(value, first)) ? out : void 0;
+  }
+  for (const index of outputs) if (!imageTuples(at(index), out)) return void 0;
+  return out;
+}
+function tryMixTemplate(values) {
+  const [first] = values;
+  if (values.every((value) => same(value, first))) return first;
+  if (Array.isArray(first) && first[0] !== "literal" && values.every((value) => Array.isArray(value) && value.length === first.length)) {
+    const items = [];
+    for (let index = 0; index < first.length; index += 1) {
+      const item = tryMixTemplate(values.map((value) => value[index]));
+      if (item === void 0 && first[index] !== void 0) return void 0;
+      items.push(item);
+    }
+    return items;
+  }
+  if (first && typeof first === "object" && !Array.isArray(first)) {
+    const keys = Object.keys(first);
+    if (!values.every((value) => value && typeof value === "object" && same(Object.keys(value), keys)))
+      return void 0;
+    const out = {};
+    for (const key of keys) {
+      const item = tryMixTemplate(values.map((value) => value[key]));
+      if (item === void 0) return void 0;
+      out[key] = item;
+    }
+    return out;
+  }
+  if (values.every((value) => typeof value === "number")) return new BlendLeaf(values);
+  if (values.every((value) => typeof value === "string" && oklab(value)))
+    return new BlendLeaf(values);
+  return void 0;
+}
+function isDataDriven(value) {
+  if (!Array.isArray(value)) return false;
+  if (typeof value[0] === "string" && featureOperators.has(value[0])) return true;
+  return value.some(isDataDriven);
+}
+var reads = (value, operator) => Array.isArray(value) && (value[0] === operator || value.some((item) => reads(item, operator)));
+function decisionOf(node) {
+  if (!Array.isArray(node) || typeof node[0] !== "string") return void 0;
+  const [operator] = node;
+  if (operator === "match" && isDataDriven(node[1])) {
+    const labels = [];
+    const outputs = [];
+    for (let index = 2; index < node.length - 1; index += 2) {
+      labels.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    outputs.push(node.at(-1));
+    return {
+      index: ["match", node[1], ...labels.flatMap((label, index) => [label, index]), labels.length],
+      outputs
+    };
+  }
+  if (operator === "case") {
+    const conditions = [];
+    const outputs = [];
+    for (let index = 1; index < node.length - 1; index += 2) {
+      conditions.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    outputs.push(node.at(-1));
+    if (!conditions.some(isDataDriven)) return void 0;
+    return {
+      index: [
+        "case",
+        ...conditions.flatMap((condition, index) => [condition, index]),
+        conditions.length
+      ],
+      outputs
+    };
+  }
+  if (operator === "step" && isDataDriven(node[1])) {
+    const outputs = [node[2]];
+    const stops = [];
+    for (let index = 3; index < node.length; index += 2) {
+      stops.push(node[index]);
+      outputs.push(node[index + 1]);
+    }
+    return {
+      index: ["step", node[1], 0, ...stops.flatMap((stop, index) => [stop, index + 1])],
+      outputs
+    };
+  }
+  return void 0;
+}
+function firstDecision(value) {
+  const decision = decisionOf(value);
+  if (decision) return decision;
+  if (!Array.isArray(value) || value[0] === "literal") return void 0;
+  for (const item of value) {
+    const found = firstDecision(item);
+    if (found) return found;
+  }
+  return void 0;
+}
+function choose(value, key, branch) {
+  const decision = decisionOf(value);
+  if (decision && JSON.stringify(decision.index) === key)
+    return choose(decision.outputs[branch], key, branch);
+  if (!Array.isArray(value) || value[0] === "literal") return value;
+  return value.map((item) => choose(item, key, branch));
+}
+function splitBranches(valuesByProperty, conditions = []) {
+  let decision;
+  for (const values of Object.values(valuesByProperty)) {
+    decision = firstDecision(values[0]);
+    if (decision) break;
+  }
+  if (!decision) {
+    const residual = Object.values(valuesByProperty).some((values) => values.some(isDataDriven));
+    return residual ? void 0 : [{ conditions, valuesByProperty }];
+  }
+  if (reads(decision.index, "zoom") || reads(decision.index, "feature-state")) return void 0;
+  const key = JSON.stringify(decision.index);
+  const branches = [];
+  for (let branch = 0; branch < decision.outputs.length; branch += 1) {
+    const chosen = Object.fromEntries(
+      Object.entries(valuesByProperty).map(([property, values]) => [
+        property,
+        values.map((value) => choose(value, key, branch))
+      ])
+    );
+    const nested = splitBranches(chosen, [...conditions, ["==", decision.index, branch]]);
+    if (!nested) return void 0;
+    branches.push(...nested);
+    if (branches.length > maximumBranches) return void 0;
+  }
+  return branches;
+}
+var isLegacyFilter = (filter) => Array.isArray(filter) && typeof filter[1] === "string" && !Array.isArray(filter[1]);
+function scaleByWeight(opacity, weight) {
+  const input = Array.isArray(opacity) ? opacity[0] === "interpolate" ? opacity[2] : opacity[1] : void 0;
+  if (Array.isArray(opacity) && (opacity[0] === "interpolate" || opacity[0] === "step") && reads(input, "zoom")) {
+    const head = opacity[0] === "interpolate" ? 3 : 2;
+    return opacity.map(
+      (item, index) => index >= head && (index - head) % 2 === (opacity[0] === "interpolate" ? 1 : 0) ? scaleByWeight(item, weight) : item
+    );
+  }
+  if (typeof opacity === "number")
+    return new BlendLeaf(weight.values.map((value) => opacity * Number(value)));
+  return ["*", opacity, weight];
+}
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+var oklabCache = /* @__PURE__ */ new Map();
+function oklab(colour) {
+  const cached2 = oklabCache.get(colour);
+  if (cached2 !== void 0) return cached2;
+  const rgba = parseColour(colour);
+  let result = null;
+  if (rgba) {
+    const [r, g, b] = rgba.slice(0, 3).map((channel) => {
+      const value = channel / 255;
+      return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    });
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    result = [
+      0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+      1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+      0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+      rgba[3]
+    ];
+  }
+  if (oklabCache.size > 4096) oklabCache.clear();
+  oklabCache.set(colour, result);
+  return result;
+}
+function colourFromOklab([lightness, a, b, alpha]) {
+  const l = (lightness + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (lightness - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (lightness - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const [red, green, blue] = [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((value) => {
+    const clamped = Math.min(1, Math.max(0, value));
+    const encoded = clamped <= 31308e-7 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
+    return Math.round(encoded * 255);
+  });
+  return `rgba(${red}, ${green}, ${blue}, ${Number(alpha.toFixed(3))})`;
+}
+function parseColour(colour) {
+  const text = colour.trim().toLowerCase();
+  const hex = /^#([\da-f]{3,8})$/u.exec(text)?.[1];
+  if (hex && [3, 4, 6, 8].includes(hex.length)) {
+    const full = hex.length <= 4 ? [...hex].map((digit) => digit + digit).join("") : hex;
+    const channels = full.match(/../gu).map((pair) => Number.parseInt(pair, 16));
+    return [channels[0], channels[1], channels[2], channels.length > 3 ? channels[3] / 255 : 1];
+  }
+  const functional = /^(rgba?|hsla?)\(([^)]+)\)$/u.exec(text);
+  if (!functional) return null;
+  const parts = functional[2].split(/[\s,/]+/u).filter(Boolean);
+  if (parts.length < 3 || parts.length > 4) return null;
+  const alpha = parts[3] === void 0 ? 1 : parseUnit(parts[3], 1);
+  if (functional[1].startsWith("rgb")) {
+    const [r, g, b] = parts.slice(0, 3).map((part) => parseUnit(part, 255));
+    if ([r, g, b, alpha].some((value) => value === null)) return null;
+    return [r, g, b, alpha];
+  }
+  const hue = Number.parseFloat(parts[0]);
+  const saturation = parseUnit(parts[1], 1);
+  const light = parseUnit(parts[2], 1);
+  if (!Number.isFinite(hue) || saturation === null || light === null || alpha === null) return null;
+  const chroma = (1 - Math.abs(2 * light - 1)) * saturation;
+  const sector = (hue % 360 + 360) % 360 / 60;
+  const x = chroma * (1 - Math.abs(sector % 2 - 1));
+  const [r1, g1, b1] = sector < 1 ? [chroma, x, 0] : sector < 2 ? [x, chroma, 0] : sector < 3 ? [0, chroma, x] : sector < 4 ? [0, x, chroma] : sector < 5 ? [x, 0, chroma] : [chroma, 0, x];
+  const offset = light - chroma / 2;
+  return [(r1 + offset) * 255, (g1 + offset) * 255, (b1 + offset) * 255, alpha];
+}
+function parseUnit(part, scale) {
+  const percentage = part.endsWith("%");
+  const value = Number.parseFloat(part);
+  if (!Number.isFinite(value)) return null;
+  return percentage ? value / 100 * scale : value;
+}
 export {
   TileflowNativeSourceError,
   TileflowNativeUrlError,
+  TileflowThemeBlendError,
   createTileflowNativeSourceController,
+  fillTileflowThemeBlendTemplate,
   loadTileflowNativeManifest,
+  nearestTileflowBlendTheme,
+  planTileflowThemeBlend,
   resolveTileflowNativeInitialView,
   resolveTileflowNativeManifestUrl,
   resolveTileflowNativeResourceUrl,
   tileflowNativeManifestLimits,
-  tileflowNativeUrlLimits
+  tileflowNativeUrlLimits,
+  tileflowThemeBlendLimits,
+  validateTileflowThemeBlendSelection
 };