@tileflow/dev 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/chunk-RTU7TD4M.js

@@ -0,0 +1,172 @@
+// src/asset-directories.ts
+import { realpath, stat } from "fs/promises";
+import { createRequire } from "module";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+import {
+  isTileflowLocalDirectory,
+  tileflowLocalDirectoryMessage
+} from "@tileflow/core";
+var TileflowAssetDirectoryError = class extends Error {
+  code = "ASSET_DIRECTORY_INVALID";
+  issues;
+  phase = "asset-directory-resolution";
+  constructor(kind, issues) {
+    super(
+      [
+        `Invalid Tileflow ${kind} directories`,
+        ...issues.map((issue) => `- ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+    this.name = "TileflowAssetDirectoryError";
+    this.issues = issues;
+  }
+};
+async function resolveTileflowAssetDirectories(directories, options) {
+  const issues = [];
+  let realCwd;
+  let realBaseDirectory;
+  try {
+    realCwd = await realpath(options.cwd);
+    if (!(await stat(realCwd)).isDirectory()) throw new Error("Working tree is not a directory");
+  } catch (error) {
+    throw new TileflowAssetDirectoryError(options.kind, [
+      { message: filesystemMessage(error, "Selected working tree was not found"), path: "cwd" }
+    ]);
+  }
+  try {
+    realBaseDirectory = await realpath(options.baseDirectory ?? options.cwd);
+    if (!(await stat(realBaseDirectory)).isDirectory()) {
+      throw new Error("Config base is not a directory");
+    }
+    if (!isPathInside(realCwd, realBaseDirectory)) {
+      throw new Error("Config base directory escapes the selected working tree");
+    }
+  } catch (error) {
+    throw new TileflowAssetDirectoryError(options.kind, [
+      {
+        message: filesystemMessage(error, "Config base directory was not found"),
+        path: "baseDirectory"
+      }
+    ]);
+  }
+  const result = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, directory] of directories.entries()) {
+    const configPath = `${options.configPath}.${index + (options.ordinalOffset ?? 0)}`;
+    let candidate;
+    let containmentRoot;
+    let packageOwned = false;
+    if (typeof directory === "string") {
+      if (!isTileflowLocalDirectory(directory)) {
+        issues.push({
+          message: tileflowLocalDirectoryMessage,
+          path: configPath
+        });
+        continue;
+      }
+      candidate = resolve(realBaseDirectory, directory);
+      containmentRoot = realCwd;
+    } else if (isPackageDirectory(directory)) {
+      packageOwned = true;
+      let packageRoot;
+      try {
+        validatePackageDirectory(directory);
+        const requireFromProject = createRequire(
+          resolve(realBaseDirectory, "__tileflow_config__.cjs")
+        );
+        let packageJson;
+        try {
+          packageJson = requireFromProject.resolve(`${directory.package}/package.json`);
+        } catch {
+          packageJson = createRequire(import.meta.url).resolve(`${directory.package}/package.json`);
+        }
+        packageRoot = dirname(packageJson);
+        containmentRoot = await realpath(packageRoot);
+        candidate = resolve(containmentRoot, ...directory.path.split("/"));
+      } catch (error) {
+        issues.push({
+          message: error instanceof Error ? error.message : "Package directory could not be resolved",
+          path: configPath
+        });
+        continue;
+      }
+    } else {
+      issues.push({
+        message: "Expected a relative directory or imported package-directory descriptor",
+        path: configPath
+      });
+      continue;
+    }
+    try {
+      const realCandidate = await realpath(candidate);
+      if (!(await stat(realCandidate)).isDirectory()) {
+        throw new Error("Asset source must be a directory");
+      }
+      if (!isPathInside(containmentRoot, realCandidate)) {
+        throw new Error(
+          packageOwned ? "Package asset directory escapes its installed package" : "Asset directory escapes the selected working tree"
+        );
+      }
+      if (options.target === "hosted" && !packageOwned && !isPathInside(realCwd, realCandidate)) {
+        throw new Error("Hosted asset directories must remain inside the selected working tree");
+      }
+      const previous = seen.get(realCandidate);
+      if (previous) {
+        issues.push({ message: `Directory duplicates ${previous}`, path: configPath });
+        continue;
+      }
+      seen.set(realCandidate, configPath);
+      result.push({
+        authoring: directory,
+        configPath,
+        containmentRoot,
+        packageOwned,
+        realPath: realCandidate,
+        watch: !packageOwned || isPathInside(realCwd, realCandidate) && !realCandidate.split(/[\\/]/u).includes("node_modules")
+      });
+    } catch (error) {
+      issues.push({
+        message: filesystemMessage(error, "Asset directory was not found"),
+        path: configPath
+      });
+    }
+  }
+  if (issues.length > 0) throw new TileflowAssetDirectoryError(options.kind, issues);
+  return result;
+}
+function isPackageDirectory(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && value.kind === "package-directory"
+  );
+}
+function validatePackageDirectory(directory) {
+  const keys = Object.keys(directory).sort();
+  if (keys.join(",") !== "kind,package,path") {
+    throw new Error("Package directory accepts exactly kind, package, and path");
+  }
+  if (!/^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/u.test(
+    directory.package
+  )) {
+    throw new Error("Package directory has an invalid npm package name");
+  }
+  if (!directory.path || directory.path.startsWith("/") || directory.path.includes("\\") || directory.path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error("Package directory path must be a portable package-relative path");
+  }
+}
+function isPathInside(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
+}
+function filesystemMessage(error, fallback) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = String(error.code ?? "");
+    if (code === "ENOENT") return fallback;
+    if (code === "EACCES" || code === "EPERM") return "Asset directory is not readable";
+  }
+  return error instanceof Error && error.message ? error.message : fallback;
+}
+
+export {
+  TileflowAssetDirectoryError,
+  resolveTileflowAssetDirectories
+};

package/dist/chunk-XHJBCVBB.js

@@ -0,0 +1,241 @@
+import {
+  sanitizeDiagnosticSecrets
+} from "./chunk-KDFTE4Q5.js";
+
+// src/validation.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep, win32 } from "path";
+import { compareCodeUnits } from "@tileflow/core";
+import { TileflowNativeCompatibilityError } from "@tileflow/core/native-profile";
+var tileflowCommandDocumentSchemaVersion = 1;
+function createTileflowCommandSummary(input) {
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(input.command, "command"),
+    ok: input.ok,
+    phase: normalizePhase(input.phase, "command"),
+    code: normalizeCode(input.code, input.ok ? "COMMAND_OK" : "COMMAND_FAILED"),
+    path: boundText(input.path ?? "", 300),
+    severity: input.severity,
+    message: boundText(input.message.replace(/[\r\n]+/gu, " ").trim(), 300),
+    suggestion: boundText(input.suggestion.replace(/[\r\n]+/gu, " ").trim(), 300)
+  };
+}
+function createTileflowStructuredDiagnostics(error, cwd, defaults) {
+  if (error instanceof TileflowNativeCompatibilityError) {
+    return error.issues.map((issue) => ({ ...issue }));
+  }
+  const inheritedCode = optionalField(error, "code");
+  const inheritedDomain = optionalField(error, "domain") ?? optionalField(error, "owner") ?? optionalNestedField(error, "domain") ?? optionalNestedField(error, "owner");
+  const inheritedLevel = optionalField(error, "level") ?? optionalNestedField(error, "level");
+  const inheritedMessage = optionalField(error, "message") ?? optionalNestedField(error, "message");
+  const inheritedPath = optionalField(error, "path") ?? optionalNestedField(error, "path");
+  const inheritedPhase = optionalField(error, "phase") ?? optionalNestedField(error, "phase");
+  const inheritedSeverity = optionalField(error, "severity") ?? optionalNestedField(error, "severity");
+  const inheritedSuggestion = optionalField(error, "suggestion") ?? optionalNestedField(error, "suggestion");
+  const inheritedTarget = optionalField(error, "target") ?? optionalNestedField(error, "target");
+  const issues = getIssues(error);
+  const candidates = issues.length ? issues : [
+    {
+      message: inheritedMessage ?? (error instanceof Error ? error.message : "The Tileflow command failed."),
+      path: inheritedPath ?? ""
+    }
+  ];
+  const diagnostics = candidates.map((issue) => {
+    const phase = normalizePhase(issue.phase ?? inheritedPhase, defaults.phase);
+    const code = normalizeCode(issue.code ?? inheritedCode, defaults.code);
+    const severity = normalizeSeverity(
+      issue.severity ?? issue.level ?? inheritedSeverity ?? inheritedLevel,
+      defaults.severity ?? "error"
+    );
+    const domain = sanitizeDiagnosticContext(issue.domain ?? issue.owner ?? inheritedDomain, cwd);
+    const target = sanitizeDiagnosticContext(issue.target ?? inheritedTarget, cwd);
+    const suggestion = issue.suggestion ?? inheritedSuggestion;
+    return {
+      phase,
+      code,
+      ...domain ? { domain } : {},
+      path: boundText(sanitizePath(issue.path ?? inheritedPath ?? "", cwd), 300),
+      ...target ? { target } : {},
+      severity,
+      message: boundText(sanitizeMessage(issue.message, cwd), 300),
+      suggestion: suggestion ? boundText(sanitizeMessage(suggestion, cwd), 300) : suggestionForDiagnostic(code, phase)
+    };
+  });
+  diagnostics.sort(compareDiagnostics);
+  return diagnostics.filter(
+    (diagnostic, index) => index === 0 || JSON.stringify(diagnostic) !== JSON.stringify(diagnostics[index - 1])
+  ).slice(0, 32);
+}
+function createTileflowCommandFailureDocument(command, error, cwd, defaults) {
+  const diagnostics = createTileflowStructuredDiagnostics(error, cwd, defaults);
+  const primary = diagnostics[0] ?? {
+    phase: normalizePhase(defaults.phase, "command"),
+    code: normalizeCode(defaults.code, "COMMAND_FAILED"),
+    path: "",
+    severity: defaults.severity ?? "error",
+    message: "The Tileflow command failed.",
+    suggestion: "Review the command input and run it again."
+  };
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(command, "command"),
+    ok: false,
+    phase: primary.phase,
+    code: primary.code,
+    ...primary.domain ? { domain: primary.domain } : {},
+    path: primary.path,
+    ...primary.target ? { target: primary.target } : {},
+    severity: primary.severity,
+    message: primary.message,
+    suggestion: primary.suggestion,
+    diagnostics,
+    ...primary.renderer ? { renderer: primary.renderer, profile: primary.profile } : {}
+  };
+}
+function serializeTileflowCommandDocument(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function getIssues(error) {
+  if (!error || typeof error !== "object") return [];
+  const containers = [];
+  for (const key of ["diagnostics", "messages", "issues"]) {
+    const value = error[key];
+    if (Array.isArray(value)) containers.push(value);
+  }
+  const details = error.details;
+  if (details && typeof details === "object") {
+    const diagnostics = details.diagnostics;
+    if (Array.isArray(diagnostics)) containers.push(diagnostics);
+  }
+  return containers.flatMap(
+    (container) => container.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const candidate = entry;
+      if (typeof candidate.message !== "string") return [];
+      return [
+        {
+          ...typeof candidate.code === "string" ? { code: candidate.code } : {},
+          ...typeof candidate.domain === "string" ? { domain: candidate.domain } : {},
+          ...typeof candidate.level === "string" ? { level: candidate.level } : {},
+          message: candidate.message,
+          ...typeof candidate.owner === "string" ? { owner: candidate.owner } : {},
+          ...typeof candidate.path === "string" ? { path: candidate.path } : {},
+          ...typeof candidate.phase === "string" ? { phase: candidate.phase } : {},
+          ...typeof candidate.severity === "string" ? { severity: candidate.severity } : {},
+          ...typeof candidate.suggestion === "string" ? { suggestion: candidate.suggestion } : {},
+          ...typeof candidate.target === "string" ? { target: candidate.target } : {}
+        }
+      ];
+    })
+  );
+}
+function sanitizeMessage(value, cwd) {
+  let sanitized = value;
+  for (const root of localPathAliases(cwd)) sanitized = sanitized.replaceAll(root, ".");
+  sanitized = sanitized.replace(/[\r\n]+/gu, " ").trim();
+  sanitized = sanitized.replace(/https?:\/\/[^\s'")<>]+/giu, (url) => {
+    try {
+      return new URL(url.replace(/[),.;]+$/u, "")).origin;
+    } catch {
+      return "(resource URL)";
+    }
+  });
+  sanitized = sanitized.replace(/(^|[\s'"(])[A-Za-z]:[\\/][^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])(?:\\\\|\/\/)[^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])\/[^\s'")]+/gu, "$1(external path)");
+  return sanitizeDiagnosticSecrets(sanitized);
+}
+function sanitizePath(value, cwd) {
+  if (!value) return "";
+  if (win32.isAbsolute(value) && !isAbsolute(value)) return "(external)";
+  if (!isAbsolute(value)) return sanitizeDiagnosticSecrets(value.replaceAll("\\", "/"));
+  const local = relative(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep, "/");
+  return local.startsWith("../") || local === ".." ? "(external)" : local || ".";
+}
+function sanitizeDiagnosticContext(value, cwd) {
+  if (!value) return void 0;
+  const sanitized = boundText(sanitizeMessage(value, cwd), 300);
+  return sanitized || void 0;
+}
+function localPathAliases(path) {
+  return [.../* @__PURE__ */ new Set([resolve(path), canonicalPath(path)])].sort(
+    (left, right) => right.length - left.length
+  );
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function suggestionForDiagnostic(code, phase) {
+  if (code === "INVALID_TARGET" || phase === "command-validation") {
+    return "Use a documented command option and run the command again.";
+  }
+  if (phase === "config-load") {
+    return "Check the config path and its installed imports, then run the command again.";
+  }
+  if (phase === "config-validation" || code === "CONFIG_INVALID") {
+    return "Edit the reported config path to match the Tileflow config reference, then validate again.";
+  }
+  if (phase.includes("icon") || code.includes("ICON")) {
+    return "Fix the reported icon input and run validation again.";
+  }
+  if (phase.includes("font") || code.includes("FONT") || code.includes("GLYPH")) {
+    return "Fix the reported font or glyph input and run validation again.";
+  }
+  if (phase === "style-validation" || code === "STYLE_INVALID") {
+    return "Adjust the reported semantic map value and run validation again.";
+  }
+  if (phase === "hosted-validation" || code === "HOSTED_INCOMPATIBLE") {
+    return "Use a supported Hosted input or validate with the local target.";
+  }
+  if (phase === "config-inspection") {
+    return "Resolve the reported config diagnostic before inspecting the map again.";
+  }
+  return "Review the reported path and run the command again.";
+}
+function compareDiagnostics(left, right) {
+  return diagnosticSeverityRank(left.severity) - diagnosticSeverityRank(right.severity) || compareCodeUnits(left.path, right.path) || compareCodeUnits(left.domain ?? "", right.domain ?? "") || compareCodeUnits(left.target ?? "", right.target ?? "") || compareCodeUnits(left.phase, right.phase) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message) || compareCodeUnits(left.suggestion, right.suggestion);
+}
+function diagnosticSeverityRank(severity) {
+  return severity === "error" ? 0 : severity === "warning" ? 1 : 2;
+}
+function normalizeSeverity(value, fallback) {
+  return value === "error" || value === "info" || value === "warning" ? value : fallback;
+}
+function normalizeCode(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toUpperCase().replace(/[^A-Z0-9_]/gu, "_").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizePhase(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toLowerCase().replace(/[^a-z0-9-]/gu, "-").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizeCommandField(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value).toLowerCase().replace(/[^a-z0-9 ._-]/gu, "").trim().slice(0, 64);
+  return normalized || fallback;
+}
+function optionalField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  const field = value[key];
+  return typeof field === "string" && field.trim() ? field : void 0;
+}
+function optionalNestedField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  return optionalField(value.details, key);
+}
+function boundText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+export {
+  tileflowCommandDocumentSchemaVersion,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  createTileflowCommandFailureDocument,
+  serializeTileflowCommandDocument
+};

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import { TileflowMap, ValidationMessage } from '@tileflow/core';
+import { TileflowBuildCatalog } from '@tileflow/core/build';
+
+declare const defaultTileflowApiUrl = "https://api.tileflow.dev";
+declare const defaultTileflowConfigPath = "tileflow.config.ts";
+declare const defaultTileflowManifestPath = "public/tileflow/manifest.json";
+type LoadTileflowConfigOptions = {
+    cwd?: string;
+    fresh?: boolean;
+};
+type LoadedTileflowConfig = {
+    /** Tooling-only authoring definitions retained for resolved-config provenance. Never serialize. */
+    authoringMaps: Record<string, TileflowMap>;
+    /** Absolute executable config path. Asset directories resolve from its parent directory. */
+    configFile: string;
+    inputFiles: string[];
+    project: TileflowBuildCatalog;
+};
+declare class TileflowValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly messages: ValidationMessage[];
+    readonly phase: "config-validation";
+    constructor(messages: ValidationMessage[]);
+}
+declare function loadTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function loadValidTileflowConfig(configPath?: string, options?: LoadTileflowConfigOptions): Promise<TileflowBuildCatalog>;
+declare function loadValidTileflowConfigWithInputs(configPath?: string, options?: LoadTileflowConfigOptions): Promise<LoadedTileflowConfig>;
+declare function assertValidTileflowConfig(project: TileflowBuildCatalog): void;
+declare function getTileflowMapNames(project: TileflowBuildCatalog): string[];
+declare function getFirstTileflowMapName(project: TileflowBuildCatalog): string;
+
+export { type LoadTileflowConfigOptions, type LoadedTileflowConfig, TileflowValidationError, assertValidTileflowConfig, defaultTileflowApiUrl, defaultTileflowConfigPath, defaultTileflowManifestPath, getFirstTileflowMapName, getTileflowMapNames, loadTileflowConfig, loadTileflowConfigWithInputs, loadValidTileflowConfig, loadValidTileflowConfigWithInputs };

package/dist/config.js

@@ -0,0 +1,27 @@
+import {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-AQUGMUZW.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowValidationError,
+  assertValidTileflowConfig,
+  defaultTileflowApiUrl,
+  defaultTileflowConfigPath,
+  defaultTileflowManifestPath,
+  getFirstTileflowMapName,
+  getTileflowMapNames,
+  loadTileflowConfig,
+  loadTileflowConfigWithInputs,
+  loadValidTileflowConfig,
+  loadValidTileflowConfigWithInputs
+};

package/dist/fonts.d.ts

@@ -0,0 +1,47 @@
+import { TileflowFontBundleManifest, MapLibreStyle } from '@tileflow/core';
+import { TileflowEffectiveFontSourceIdentity, TileflowBuildStyles, TileflowBuildCatalog } from '@tileflow/core/build';
+import { T as TileflowBuildAsset } from './icons-BIHpw5Zy.js';
+
+type TileflowFontCompilationTarget = 'hosted' | 'local';
+type TileflowFontCompilationIssue = {
+    message: string;
+    path: string;
+};
+declare class TileflowFontCompilationError extends Error {
+    readonly code: "FONT_INVALID";
+    readonly issues: readonly TileflowFontCompilationIssue[];
+    readonly phase: "font-compilation";
+    constructor(issues: readonly TileflowFontCompilationIssue[]);
+}
+type PreparedTileflowStyleFonts = {
+    assets: TileflowBuildAsset[];
+    bundles: Record<string, CompiledTileflowFontBundle>;
+    sourceIdentities: Record<string, TileflowEffectiveFontSourceIdentity[]>;
+    styles: TileflowBuildStyles;
+    watchPaths: string[];
+};
+type CompiledTileflowFontBundle = {
+    contentHash: string;
+    files: TileflowBuildAsset[];
+    manifest: TileflowFontBundleManifest;
+};
+type PrepareTileflowStyleFontsOptions = {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+    target: TileflowFontCompilationTarget;
+};
+/** Resolve only mutable local font directories so failed builds can still be watched. */
+declare function getTileflowFontWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+/**
+ * Prepare every map's ordered local font provider.
+ *
+ * OpenType full names are the canonical IDs consumed by `text-font`. Directories are applied from
+ * left to right, so a later directory replaces an earlier face only when that exact ID matches.
+ */
+declare function prepareTileflowStyleFonts(project: TileflowBuildCatalog, inputStyles: Readonly<Record<string, Readonly<Record<string, MapLibreStyle>>>>, options: PrepareTileflowStyleFontsOptions): Promise<PreparedTileflowStyleFonts>;
+/** Replace provisional local/preflight URLs with one exact Hosted bundle base URL. */
+declare function bindTileflowStyleFontBundle(style: MapLibreStyle, bundle: CompiledTileflowFontBundle, publicBaseUrl: string): MapLibreStyle;
+declare function replaceTileflowStyleFontSources(style: MapLibreStyle, replace: (source: string) => string): MapLibreStyle;
+
+export { type CompiledTileflowFontBundle, type PrepareTileflowStyleFontsOptions, type PreparedTileflowStyleFonts, TileflowFontCompilationError, type TileflowFontCompilationIssue, type TileflowFontCompilationTarget, bindTileflowStyleFontBundle, getTileflowFontWatchPaths, prepareTileflowStyleFonts, replaceTileflowStyleFontSources };

package/dist/fonts.js

@@ -0,0 +1,16 @@
+import {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+} from "./chunk-FOMTSCOP.js";
+import "./chunk-RTU7TD4M.js";
+import "./chunk-D4OE4ITL.js";
+export {
+  TileflowFontCompilationError,
+  bindTileflowStyleFontBundle,
+  getTileflowFontWatchPaths,
+  prepareTileflowStyleFonts,
+  replaceTileflowStyleFontSources
+};