@tileflow/dev 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/chunk-RSBV4L2Y.js

@@ -0,0 +1,671 @@
+import {
+  TileflowAssetDirectoryError,
+  resolveTileflowAssetDirectories
+} from "./chunk-BL3FK4GO.js";
+import {
+  isPathWithin
+} from "./chunk-D4OE4ITL.js";
+
+// src/font-pipeline.ts
+import { createHash } from "crypto";
+import { lstat, readdir, readFile, realpath, stat } from "fs/promises";
+import { createRequire } from "module";
+import { extname, join } from "path";
+import {
+  compareCodeUnits,
+  getTileflowStyleFontFaces,
+  hashTileflowFontBundleManifest,
+  parseResolvedTileflowMap,
+  tileflowMapIdSchema,
+  tileflowStyleFontFaceLimits,
+  tileflowStyleFontFacesMetadataKey,
+  tileflowThemeNameSchema
+} from "@tileflow/core";
+
+// src/public-paths.ts
+function hasUnsafeUrlCharacter(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 31 || codePoint === 127 || "\\?#".includes(character)) return true;
+  }
+  return false;
+}
+function normalizeTileflowBasePath(value = "") {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") return "";
+  if (hasUnsafeUrlCharacter(trimmed)) throw invalidBasePath(value);
+  const withoutEdges = trimmed.replace(/^\/+|\/+$/gu, "");
+  if (!withoutEdges) return "";
+  const segments = withoutEdges.split("/");
+  if (segments.some((segment) => !isSafeRouteSegment(segment))) throw invalidBasePath(value);
+  return `/${segments.join("/")}`;
+}
+function joinTileflowPublicUrl(publicBase, basePath) {
+  const normalizedBase = normalizePublicBase(publicBase);
+  const trimmedPath = normalizeTileflowBasePath(basePath).replace(/^\//u, "");
+  if (!trimmedPath) return publicBaseWithoutResource(normalizedBase);
+  if (!normalizedBase || normalizedBase === "/") return `/${trimmedPath}`;
+  if (normalizedBase === ".") return `./${trimmedPath}`;
+  if (normalizedBase === "..") return `../${trimmedPath}`;
+  return `${normalizedBase}/${trimmedPath}`;
+}
+function resolveTileflowArtifactPublicUrls(publicBase, basePath) {
+  const publicBaseUrl = joinTileflowPublicUrl(publicBase, basePath);
+  if (publicBaseUrl.startsWith("./") || publicBaseUrl.startsWith("../")) {
+    return { publicBaseUrl, styleBaseUrl: "." };
+  }
+  return { assetBaseUrl: publicBaseUrl, publicBaseUrl, styleBaseUrl: publicBaseUrl };
+}
+function getTileflowAssetBasePath(basePath) {
+  return normalizeTileflowBasePath(basePath).replace(/^\//u, "");
+}
+function getTileflowAssetFileName(basePath, fileName) {
+  const assetBasePath = getTileflowAssetBasePath(basePath);
+  assertSafeAssetFileName(fileName);
+  return assetBasePath ? `${assetBasePath}/${fileName}` : fileName;
+}
+function normalizePublicBase(value) {
+  if (value !== value.trim() || hasUnsafeUrlCharacter(value)) throw invalidPublicBase(value);
+  if (!value) return "";
+  if (value.startsWith("//")) throw invalidPublicBase(value);
+  if (/^[A-Za-z][A-Za-z\d+.-]*:/u.test(value)) {
+    let parsed;
+    try {
+      parsed = new URL(value);
+    } catch {
+      throw invalidPublicBase(value);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw invalidPublicBase(value);
+    }
+    return value.replace(/\/+$/gu, "");
+  }
+  if (value === "/") return "/";
+  const withoutTrailingSlash = value.replace(/\/+$/gu, "");
+  if (!withoutTrailingSlash) return "/";
+  if (withoutTrailingSlash.startsWith("/") || withoutTrailingSlash === "." || withoutTrailingSlash === ".." || withoutTrailingSlash.startsWith("./") || withoutTrailingSlash.startsWith("../")) {
+    return withoutTrailingSlash;
+  }
+  return `./${withoutTrailingSlash}`;
+}
+function publicBaseWithoutResource(value) {
+  if (value === ".") return "./";
+  if (value === "..") return "../";
+  return value;
+}
+function isSafeRouteSegment(segment) {
+  if (!segment || segment === "." || segment === "..") return false;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+    return false;
+  }
+  return decoded !== "." && decoded !== ".." && !decoded.includes("/") && !decoded.includes("\\") && !hasUnsafeUrlCharacter(decoded);
+}
+function assertSafeAssetFileName(fileName) {
+  if (!fileName || fileName.startsWith("/") || fileName.endsWith("/") || fileName.includes("\\") || fileName.includes("\0") || fileName.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error(`Unsafe Tileflow asset file name: ${fileName}`);
+  }
+}
+function invalidBasePath(value) {
+  return new TypeError(`Invalid Tileflow base path: ${JSON.stringify(value)}`);
+}
+function invalidPublicBase(value) {
+  return new TypeError(`Invalid Tileflow public base: ${JSON.stringify(value)}`);
+}
+
+// src/font-pipeline.ts
+var TileflowFontCompilationError = class extends Error {
+  code = "FONT_INVALID";
+  issues;
+  phase = "font-compilation";
+  constructor(issues) {
+    const normalized = [...issues].sort(
+      (left, right) => compareCodeUnits(left.path, right.path) || compareCodeUnits(left.message, right.message)
+    );
+    super(
+      [
+        "Invalid Tileflow font directories",
+        ...normalized.map((issue) => `- ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+    this.name = "TileflowFontCompilationError";
+    this.issues = normalized;
+  }
+};
+async function getTileflowFontWatchPaths(project, cwd, baseDirectory = cwd) {
+  const watchPaths = /* @__PURE__ */ new Set();
+  const issues = [];
+  for (const mapName of Object.keys(project.maps).sort(compareCodeUnits)) {
+    const resolvedMap = project.maps[mapName];
+    if (!resolvedMap) continue;
+    const fonts = parseResolvedTileflowMap(resolvedMap).fonts;
+    if (fonts === void 0) continue;
+    try {
+      const directories = await resolveTileflowAssetDirectories(fonts, {
+        baseDirectory,
+        configPath: `maps.${mapName}.fonts`,
+        cwd,
+        kind: "fonts",
+        target: "local"
+      });
+      for (const directory of directories) {
+        if (directory.watch) watchPaths.add(directory.realPath);
+      }
+    } catch (error) {
+      if (!(error instanceof TileflowAssetDirectoryError)) throw error;
+      issues.push(...error.issues);
+    }
+  }
+  if (issues.length > 0) throw new TileflowFontCompilationError(issues);
+  return [...watchPaths].sort(compareCodeUnits);
+}
+var localRequire = createRequire(import.meta.url);
+var fontkit = localRequire("fontkit");
+var maximumFontFileBytes = 1024 * 1024;
+var maximumFontFilesPerDirectory = 64;
+var maximumLicenseBytes = 2 * 1024 * 1024;
+var supportedExtensions = /* @__PURE__ */ new Set([".otf", ".ttf", ".woff2"]);
+var expressionOperators = /* @__PURE__ */ new Set([
+  "at",
+  "case",
+  "coalesce",
+  "concat",
+  "format",
+  "get",
+  "interpolate",
+  "let",
+  "literal",
+  "match",
+  "step",
+  "to-string",
+  "var"
+]);
+async function prepareTileflowStyleFonts(project, inputStyles, options) {
+  const projectMapNames = Object.keys(project.maps).sort(compareCodeUnits);
+  const styleMapNames = Object.keys(inputStyles).sort(compareCodeUnits);
+  const issues = [];
+  for (const mapName of projectMapNames) {
+    if (!tileflowMapIdSchema.safeParse(mapName).success) {
+      issues.push({ message: "Expected a portable map key", path: `maps.${mapName}` });
+    }
+  }
+  for (const mapName of styleMapNames) {
+    if (!tileflowMapIdSchema.safeParse(mapName).success) {
+      issues.push({ message: "Expected a portable map key", path: `styles.${mapName}` });
+    }
+    for (const themeName of Object.keys(inputStyles[mapName]).sort(compareCodeUnits)) {
+      if (!tileflowThemeNameSchema.safeParse(themeName).success) {
+        issues.push({
+          message: 'Expected a concrete portable theme key; "system" is browser-only',
+          path: `styles.${mapName}.${themeName}`
+        });
+      }
+    }
+  }
+  if (issues.length > 0) throw new TileflowFontCompilationError(issues);
+  const parsedMaps = new Map(
+    projectMapNames.map(
+      (mapName) => [mapName, parseResolvedTileflowMap(project.maps[mapName])]
+    )
+  );
+  if (projectMapNames.length !== styleMapNames.length || projectMapNames.some((mapName, index) => mapName !== styleMapNames[index])) {
+    throw new TileflowFontCompilationError([
+      { message: "Expected one compiled theme family for every project map", path: "styles" }
+    ]);
+  }
+  const assets = /* @__PURE__ */ new Map();
+  const bundles = {};
+  const sourceIdentities = {};
+  const styles = Object.fromEntries(
+    Object.entries(inputStyles).map(([mapName, themes]) => [mapName, { ...themes }])
+  );
+  const watchPaths = /* @__PURE__ */ new Set();
+  for (const mapName of projectMapNames) {
+    const map = parsedMaps.get(mapName);
+    const themeStyles = inputStyles[mapName];
+    if (!map || !themeStyles) continue;
+    const declaredThemeNames = Object.keys(map.themes).sort(compareCodeUnits);
+    const compiledThemeNames = Object.keys(themeStyles).sort(compareCodeUnits);
+    if (declaredThemeNames.length !== compiledThemeNames.length || declaredThemeNames.some((themeName, index) => themeName !== compiledThemeNames[index])) {
+      issues.push({
+        message: "Compiled styles must exactly match the map's declared themes",
+        path: `styles.${mapName}`
+      });
+      continue;
+    }
+    if (map.fonts === void 0) continue;
+    const configPath = `maps.${mapName}.fonts`;
+    let directories;
+    try {
+      directories = await resolveTileflowAssetDirectories(map.fonts, {
+        baseDirectory: options.baseDirectory,
+        configPath,
+        cwd: options.cwd,
+        kind: "fonts",
+        target: options.target
+      });
+    } catch (error) {
+      if (!(error instanceof TileflowAssetDirectoryError)) throw error;
+      issues.push(...error.issues);
+      continue;
+    }
+    for (const directory of directories) {
+      if (directory.watch) watchPaths.add(directory.realPath);
+    }
+    const selectedFaces = /* @__PURE__ */ new Map();
+    const namesByCaseFold = /* @__PURE__ */ new Map();
+    for (const directory of directories) {
+      const inspected = await inspectFontDirectory(directory, issues);
+      for (const face of inspected.faces) {
+        const folded = face.canonicalName.toLowerCase();
+        const previousSpelling = namesByCaseFold.get(folded);
+        if (previousSpelling && previousSpelling !== face.canonicalName) {
+          issues.push({
+            message: `Canonical font name differs from already declared "${previousSpelling}" only by case`,
+            path: `${directory.configPath}.${face.fileName}`
+          });
+          continue;
+        }
+        namesByCaseFold.set(folded, face.canonicalName);
+        selectedFaces.set(face.canonicalName, face);
+      }
+    }
+    const requiredNamesByTheme = /* @__PURE__ */ new Map();
+    const requiredNames = /* @__PURE__ */ new Set();
+    for (const themeName of compiledThemeNames) {
+      const style = themeStyles[themeName];
+      const themeRequiredNames = collectPrimaryTextFonts(style, `${mapName}.${themeName}`, issues);
+      requiredNamesByTheme.set(themeName, themeRequiredNames);
+      for (const name of themeRequiredNames) requiredNames.add(name);
+    }
+    const requiredFaces = [];
+    for (const canonicalName of [...requiredNames].sort(compareCodeUnits)) {
+      const face = selectedFaces.get(canonicalName);
+      if (face) {
+        requiredFaces.push(face);
+        continue;
+      }
+      const caseVariant = namesByCaseFold.get(canonicalName.toLowerCase());
+      const available = [...selectedFaces.keys()].sort(compareCodeUnits);
+      issues.push({
+        message: caseVariant ? `Expected exact canonical font name "${caseVariant}"` : `No declared font directory provides canonical face "${canonicalName}"${available.length > 0 ? `. Available: ${available.join(", ")}` : ""}`,
+        path: `styles.${mapName}.*.text-font`
+      });
+    }
+    if (requiredFaces.length > tileflowStyleFontFaceLimits.maximumCount) {
+      issues.push({
+        message: `At most ${tileflowStyleFontFaceLimits.maximumCount} local font faces may be used by one map`,
+        path: `styles.${mapName}.*.text-font`
+      });
+      continue;
+    }
+    const fontFaces = [];
+    const mapAssets = /* @__PURE__ */ new Map();
+    const bundleFaces = [];
+    for (const face of requiredFaces) {
+      const digest = sha256(face.source);
+      const licenseDigest = sha256(face.license);
+      const slug = slugifyFontName(face.canonicalName);
+      const fileName = `fonts/${slug}-${digest}${face.extension}`;
+      const fontAsset = {
+        contentType: contentTypeForExtension(face.extension),
+        fileName,
+        source: face.source
+      };
+      const licenseFileName = `fonts/licenses/license-${licenseDigest}.txt`;
+      const licenseAsset = {
+        contentType: "text/plain; charset=utf-8",
+        fileName: licenseFileName,
+        source: face.license
+      };
+      addAsset(assets, fontAsset);
+      addAsset(assets, licenseAsset);
+      addAsset(mapAssets, fontAsset);
+      addAsset(mapAssets, licenseAsset);
+      fontFaces.push({
+        ...face.fontFace,
+        source: joinTileflowPublicUrl(options.assetBaseUrl, fileName)
+      });
+      bundleFaces.push({
+        family: face.fontFace.family,
+        file: fileName,
+        licenseFile: licenseFileName,
+        style: face.fontFace.style ?? "normal",
+        weight: face.fontFace.weight ?? "400"
+      });
+    }
+    const sortedBundleFaces = [...bundleFaces].sort(
+      (left, right) => compareCodeUnits(fontFaceIdentity(left), fontFaceIdentity(right))
+    );
+    const fontFaceByIdentity = new Map(
+      fontFaces.map((face) => [fontFaceIdentity(face), face])
+    );
+    const sourceFaceByFamily = new Map(
+      requiredFaces.map((face) => [face.canonicalName, face.fontFace])
+    );
+    const preparedThemes = {};
+    for (const themeName of compiledThemeNames) {
+      const style = themeStyles[themeName];
+      const existingFontFaces = getTileflowStyleFontFaces(style);
+      if (existingFontFaces.length > 0) {
+        issues.push({
+          message: `Compiled styles may not predeclare ${tileflowStyleFontFacesMetadataKey}; the font pipeline owns it`,
+          path: `styles.${mapName}.${themeName}.metadata.${tileflowStyleFontFacesMetadataKey}`
+        });
+      }
+      const themeFontIdentities = new Set(
+        [...requiredNamesByTheme.get(themeName) ?? []].map((family) => {
+          const face = sourceFaceByFamily.get(family);
+          return face ? fontFaceIdentity(face) : "";
+        })
+      );
+      const themeFontFaces = sortedBundleFaces.filter((face) => themeFontIdentities.has(fontFaceIdentity(face))).map((face) => fontFaceByIdentity.get(fontFaceIdentity(face)));
+      preparedThemes[themeName] = withFontFaces(style, themeFontFaces);
+    }
+    styles[mapName] = preparedThemes;
+    sourceIdentities[mapName] = sortedBundleFaces.map((face) => ({
+      family: face.family,
+      sha256: sha256(toBytes(mapAssets.get(face.file).source)),
+      style: face.style,
+      weight: face.weight
+    }));
+    if (bundleFaces.length > 0) {
+      const files = [...mapAssets.values()].sort(
+        (left, right) => compareCodeUnits(left.fileName, right.fileName)
+      );
+      const manifest = {
+        files: files.map((file) => ({
+          byteLength: toBytes(file.source).byteLength,
+          contentType: file.contentType,
+          kind: file.fileName.startsWith("fonts/licenses/") ? "license" : "font",
+          name: file.fileName,
+          sha256: sha256(toBytes(file.source))
+        })),
+        fontFaces: sortedBundleFaces,
+        format: "tileflow-font-bundle-v1"
+      };
+      bundles[mapName] = {
+        contentHash: await hashTileflowFontBundleManifest(manifest),
+        files,
+        manifest
+      };
+    }
+  }
+  if (issues.length > 0) throw new TileflowFontCompilationError(issues);
+  return {
+    assets: [...assets.values()].sort(
+      (left, right) => compareCodeUnits(left.fileName, right.fileName)
+    ),
+    bundles,
+    sourceIdentities,
+    styles,
+    watchPaths: [...watchPaths].sort(compareCodeUnits)
+  };
+}
+function bindTileflowStyleFontBundle(style, bundle, publicBaseUrl) {
+  const current = getTileflowStyleFontFaces(style);
+  const bundleFaceByIdentity = new Map(
+    bundle.manifest.fontFaces.map((face) => [fontFaceIdentity(face), face])
+  );
+  const resolved = current.map((face) => {
+    const wanted = bundleFaceByIdentity.get(fontFaceIdentity(face));
+    if (!wanted || !(face.source === wanted.file || face.source.endsWith(`/${wanted.file}`))) {
+      return void 0;
+    }
+    return {
+      family: wanted.family,
+      source: joinTileflowPublicUrl(publicBaseUrl, wanted.file),
+      style: wanted.style,
+      weight: wanted.weight
+    };
+  });
+  if (resolved.some((face) => face === void 0)) {
+    throw new Error("Compiled style font faces do not match their canonical font bundle.");
+  }
+  return withFontFaces(style, resolved);
+}
+function replaceTileflowStyleFontSources(style, replace) {
+  const fontFaces = getTileflowStyleFontFaces(style);
+  if (fontFaces.length === 0) return style;
+  return withFontFaces(
+    style,
+    fontFaces.map((fontFace) => ({ ...fontFace, source: replace(fontFace.source) }))
+  );
+}
+async function inspectFontDirectory(directory, issues) {
+  const entries = (await readdir(directory.realPath, { withFileTypes: true })).sort(
+    (left, right) => compareCodeUnits(left.name, right.name)
+  );
+  const fontEntries = entries.filter(
+    (entry) => supportedExtensions.has(extname(entry.name).toLowerCase())
+  );
+  if (fontEntries.length > maximumFontFilesPerDirectory) {
+    issues.push({
+      message: `At most ${maximumFontFilesPerDirectory} font files are allowed in one directory`,
+      path: directory.configPath
+    });
+  }
+  const licenseEntry = entries.find((entry) => entry.name === "LICENSE.txt");
+  let license;
+  if (fontEntries.length > 0) {
+    if (!licenseEntry?.isFile()) {
+      issues.push({
+        message: "Every directory containing fonts must include the regular file LICENSE.txt",
+        path: `${directory.configPath}.LICENSE.txt`
+      });
+    } else {
+      license = await readContainedFile(directory, licenseEntry.name, maximumLicenseBytes, issues);
+      if (license && !isValidLicense(license)) {
+        issues.push({
+          message: "LICENSE.txt must be non-empty UTF-8 text without NUL bytes",
+          path: `${directory.configPath}.LICENSE.txt`
+        });
+        license = void 0;
+      }
+    }
+  }
+  const faces = [];
+  const namesInDirectory = /* @__PURE__ */ new Set();
+  for (const entry of fontEntries.slice(0, maximumFontFilesPerDirectory)) {
+    const path = `${directory.configPath}.${entry.name}`;
+    const extension = extname(entry.name);
+    if (!supportedExtensions.has(extension)) {
+      issues.push({ message: "Font file extensions must be lowercase", path });
+      continue;
+    }
+    if (!entry.isFile()) {
+      issues.push({ message: "Font inputs must be regular files", path });
+      continue;
+    }
+    const source = await readContainedFile(directory, entry.name, maximumFontFileBytes, issues);
+    if (!source || !license) continue;
+    try {
+      assertFontSignature(source, extension);
+      const metadata = readFontMetadata(source);
+      if (namesInDirectory.has(metadata.canonicalName)) {
+        issues.push({
+          message: `Directory declares canonical face "${metadata.canonicalName}" more than once`,
+          path
+        });
+        continue;
+      }
+      namesInDirectory.add(metadata.canonicalName);
+      faces.push({
+        ...metadata,
+        directory,
+        extension,
+        fileName: entry.name,
+        license,
+        source
+      });
+    } catch (error) {
+      issues.push({
+        message: error instanceof Error ? error.message : "Font metadata could not be read",
+        path
+      });
+    }
+  }
+  return { faces };
+}
+async function readContainedFile(directory, fileName, maximumBytes, issues) {
+  const configuredPath = join(directory.realPath, fileName);
+  const issuePath = `${directory.configPath}.${fileName}`;
+  try {
+    if (!(await lstat(configuredPath)).isFile()) throw new Error("Asset must be a regular file");
+    const realPath = await realpath(configuredPath);
+    if (!isPathWithin(directory.realPath, realPath)) {
+      throw new Error("Asset file escapes its declared directory");
+    }
+    const metadata = await stat(realPath);
+    if (metadata.size === 0) throw new Error("Asset file may not be empty");
+    if (metadata.size > maximumBytes) {
+      throw new Error(`Asset file exceeds the ${maximumBytes}-byte limit`);
+    }
+    return await readFile(realPath);
+  } catch (error) {
+    issues.push({
+      message: error instanceof Error ? error.message : "Asset file could not be read",
+      path: issuePath
+    });
+    return void 0;
+  }
+}
+function readFontMetadata(source) {
+  let font;
+  try {
+    font = fontkit.create(source);
+  } catch (error) {
+    throw new Error(
+      `Unable to parse OpenType font${error instanceof Error && error.message ? `: ${error.message}` : ""}`
+    );
+  }
+  if (!font || typeof font !== "object") throw new Error("Expected one OpenType font face");
+  const canonicalName = normalizeCanonicalFontName(font.fullName);
+  if (!canonicalName) {
+    throw new Error("OpenType fullName must be a canonical name of 1 to 100 characters");
+  }
+  const os2 = font["OS/2"];
+  const rawWeight = os2?.usWeightClass;
+  if (!Number.isInteger(rawWeight) || rawWeight < 100 || rawWeight > 900 || rawWeight % 100 !== 0) {
+    throw new Error("OpenType OS/2.usWeightClass must be one of 100, 200, ..., 900");
+  }
+  const italicAngle = font.italicAngle;
+  if (italicAngle !== void 0 && (typeof italicAngle !== "number" || !Number.isFinite(italicAngle))) {
+    throw new Error("OpenType italicAngle is invalid");
+  }
+  const style = os2?.fsSelection?.oblique ? "oblique" : os2?.fsSelection?.italic || typeof italicAngle === "number" && italicAngle !== 0 ? "italic" : "normal";
+  const weight = String(rawWeight);
+  return { canonicalName, fontFace: { family: canonicalName, style, weight } };
+}
+function normalizeCanonicalFontName(input) {
+  if (typeof input !== "string" || input !== input.trim()) return void 0;
+  const value = input.normalize("NFC");
+  if (!value || value.length > 100 || /[\p{Cc}\\]/u.test(value)) return void 0;
+  return value;
+}
+function collectPrimaryTextFonts(style, mapName, issues) {
+  const result = /* @__PURE__ */ new Set();
+  for (const [index, layer] of style.layers.entries()) {
+    if (!layer || typeof layer !== "object" || Array.isArray(layer)) continue;
+    const layout = layer.layout;
+    if (!layout || typeof layout !== "object" || Array.isArray(layout)) continue;
+    const textFont = layout["text-font"];
+    if (textFont === void 0) continue;
+    const layerId = typeof layer.id === "string" ? layer.id : String(index);
+    const primary = readStaticPrimaryFont(textFont);
+    if (primary === void 0) {
+      issues.push({
+        message: "Local font providers require a static non-empty text-font stack",
+        path: `styles.${mapName}.layers.${layerId}.layout.text-font`
+      });
+      continue;
+    }
+    const canonical = normalizeCanonicalFontName(primary);
+    if (!canonical) {
+      issues.push({
+        message: "Primary text-font must be a canonical name of 1 to 100 characters",
+        path: `styles.${mapName}.layers.${layerId}.layout.text-font.0`
+      });
+      continue;
+    }
+    result.add(canonical);
+  }
+  return result;
+}
+function readStaticPrimaryFont(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  if (value.length === 2 && value[0] === "literal") return readStaticPrimaryFont(value[1]);
+  if (value.every((entry) => typeof entry === "string") && !expressionOperators.has(value[0])) {
+    return value[0];
+  }
+  return void 0;
+}
+function withFontFaces(style, fontFaces) {
+  const metadata = { ...style.metadata };
+  if (fontFaces.length === 0) delete metadata[tileflowStyleFontFacesMetadataKey];
+  else metadata[tileflowStyleFontFacesMetadataKey] = fontFaces;
+  return { ...style, metadata };
+}
+function addAsset(assets, asset) {
+  const previous = assets.get(asset.fileName);
+  if (!previous) {
+    assets.set(asset.fileName, asset);
+    return;
+  }
+  if (previous.contentType !== asset.contentType || !equalBytes(toBytes(previous.source), toBytes(asset.source))) {
+    throw new Error(`Conflicting generated font asset: ${asset.fileName}`);
+  }
+}
+function assertFontSignature(source, extension) {
+  if (source.byteLength < 4) throw new Error("Font file is too small");
+  const signature = String.fromCharCode(source[0], source[1], source[2], source[3]);
+  const trueType = source[0] === 0 && source[1] === 1 && source[2] === 0 && source[3] === 0;
+  const supported = extension === ".woff2" ? signature === "wOF2" : extension === ".otf" ? signature === "OTTO" : trueType || signature === "true";
+  if (!supported) throw new Error(`File bytes do not match the ${extension} format`);
+}
+function isValidLicense(source) {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(source);
+    return text.trim().length > 0 && !text.includes("\0");
+  } catch {
+    return false;
+  }
+}
+function contentTypeForExtension(extension) {
+  if (extension === ".otf") return "font/otf";
+  if (extension === ".ttf") return "font/ttf";
+  return "font/woff2";
+}
+function slugifyFontName(name) {
+  const slug = name.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return slug || "font";
+}
+function sha256(source) {
+  return createHash("sha256").update(source).digest("hex");
+}
+function toBytes(source) {
+  return typeof source === "string" ? new TextEncoder().encode(source) : source;
+}
+function equalBytes(left, right) {
+  if (left.byteLength !== right.byteLength) return false;
+  return left.every((value, index) => value === right[index]);
+}
+function fontFaceIdentity(face) {
+  return `${face.family}\0${face.style ?? "normal"}\0${face.weight ?? "400"}`;
+}
+
+export {
+  normalizeTileflowBasePath,
+  joinTileflowPublicUrl,
+  resolveTileflowArtifactPublicUrls,
+  getTileflowAssetBasePath,
+  getTileflowAssetFileName,
+  TileflowFontCompilationError,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  bindTileflowStyleFontBundle,
+  replaceTileflowStyleFontSources
+};