@tileflow/dev 0.1.0-alpha.31 → 0.1.0-alpha.33

package/dist/devtools-observer.js

@@ -0,0 +1,95 @@
+// src/devtools/observer.ts
+function resourceAddress(input, base = "http://localhost") {
+  try {
+    const url = new URL(input.replace(/^(?:tileflow-pmtiles|pmtiles):\/\//u, ""), base);
+    if (!["http:", "https:"].includes(url.protocol)) return url.protocol;
+    return `${url.origin}${url.pathname}`.slice(0, 2048);
+  } catch {
+    return "(unavailable URL)";
+  }
+}
+function resourceKind(url, initiator = "") {
+  if (/\.(?:pbf|mvt|mlt)(?:$|\?)/iu.test(url)) return /glyph|font/iu.test(url) ? "Font" : "Tile";
+  if (/\.pmtiles(?:$|\?)/iu.test(url)) return "Archive";
+  if (/\/(?:\d+)\/(?:\d+)\/(?:\d+)(?:\.[a-z]+)?(?:$|\?)/iu.test(url)) return "Tile";
+  if (/sprite/iu.test(url)) return "Sprite";
+  if (/\.(?:woff2?|ttf|otf)(?:$|\?)/iu.test(url)) return "Font";
+  if (/\.(?:glb|gltf)(?:$|\?)/iu.test(url)) return "Model";
+  if (/\.json(?:$|\?)/iu.test(url)) return "JSON";
+  return initiator === "script" || /\.m?js(?:$|\?)/iu.test(url) ? "Script" : "Other";
+}
+function createPreviewObserver() {
+  let nextId = 0;
+  const seen = /* @__PURE__ */ new Set();
+  const limit = 2e3;
+  let map;
+  const observer = {
+    records: [],
+    revision: 0,
+    dropped: 0,
+    recording: true,
+    attach(value) {
+      map = value;
+      map.on("data", onData);
+      if (!map.loaded()) map.once("load", onLoad);
+    },
+    clear() {
+      observer.records.length = 0;
+      observer.dropped = 0;
+      observer.revision++;
+    },
+    dispose() {
+      performanceObserver?.disconnect();
+      map?.off("data", onData);
+      map?.off("load", onLoad);
+      seen.clear();
+    }
+  };
+  function onLoad() {
+    observer.mapReadyMs = performance.now();
+  }
+  function record(entry) {
+    if (!observer.recording) return;
+    const key = `${entry.name}|${entry.startTime}|${entry.duration}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    if (seen.size > limit * 2) seen.delete(seen.values().next().value);
+    const url = resourceAddress(entry.name, location.href);
+    if (/\/__(?:status|events|workbench|inspection)/u.test(url)) return;
+    const sizesAvailable = entry.decodedBodySize > 0 || entry.encodedBodySize > 0;
+    const status = entry.responseStatus;
+    const item = {
+      id: ++nextId,
+      url,
+      name: /\/\d+\/\d+\/\d+(?:\.[a-z]+)?$/iu.exec(url)?.[0].slice(1) || url.split("/").pop() || url,
+      kind: resourceKind(url, entry.initiatorType),
+      transport: "resource",
+      start: Number.isFinite(entry.startTime) ? Math.max(0, entry.startTime) : 0,
+      duration: Number.isFinite(entry.duration) && entry.duration >= 0 ? entry.duration : void 0,
+      status: status ? String(status) : "\u2014",
+      ...sizesAvailable ? { bytes: entry.encodedBodySize, transferred: entry.transferSize } : {}
+    };
+    if (entry.transferSize === 0 && sizesAvailable) item.status = "Cached";
+    observer.records.push(item);
+    if (observer.records.length > limit) {
+      observer.records.shift();
+      observer.dropped++;
+    }
+    observer.revision++;
+  }
+  function onData(event) {
+    const timings = event.resourceTiming;
+    for (const timing of timings || []) record(timing);
+  }
+  const performanceObserver = typeof PerformanceObserver === "undefined" ? void 0 : new PerformanceObserver((list) => {
+    for (const entry of list.getEntries()) record(entry);
+  });
+  performanceObserver?.observe({ type: "resource", buffered: true });
+  addEventListener("pagehide", observer.dispose, { once: true });
+  return observer;
+}
+export {
+  createPreviewObserver,
+  resourceAddress,
+  resourceKind
+};

package/dist/fonts.d.ts

@@ -1,6 +1,6 @@
 import { TileflowFontBundleManifest, MapLibreStyle } from '@tileflow/core';
 import { TileflowEffectiveFontSourceIdentity, TileflowBuildStyles, TileflowBuildCatalog } from '@tileflow/core/build';
-import { TileflowBuildAsset } from './icons.js';
+import { T as TileflowBuildAsset } from './icons-BdOehQmB.js';
 
 type TileflowFontCompilationTarget = 'hosted' | 'local';
 type TileflowFontCompilationIssue = {

package/dist/icons-BdOehQmB.d.ts

@@ -0,0 +1,424 @@
+import { TileflowIconAppearance, TileflowIconLayoutMetadata, TileflowIconSetPin, TileflowLandmarkRegion, TileflowModelBundleManifest, TileflowModelDirectory, TileflowTreeModel, TileflowIconSpriteIndex, TileflowIconSource, TileflowIconsLockfileV1, TileflowIconCompositionV1, TileflowIconPackageFileName, TileflowIconPackageManifest, TileflowIconDirectory } from '@tileflow/core';
+import { TileflowEffectiveModelSourceIdentity, TileflowEffectiveIconSourceIdentity, TileflowBuildCatalog, TileflowPreparedMapAssets } from '@tileflow/core/build';
+
+type TileflowRenderedIconCell = {
+    height: number;
+    width: number;
+    rgba: Uint8Array;
+};
+type TileflowRenderedIcon = {
+    id: string;
+    appearance?: TileflowIconAppearance;
+    layout?: TileflowIconLayoutMetadata;
+    oneX: TileflowRenderedIconCell;
+    twoX: TileflowRenderedIconCell;
+};
+/** Pack independently rendered densities without scaling or re-rasterizing either input. */
+declare function packTileflowRenderedIcons(input: readonly TileflowRenderedIcon[]): Promise<CompiledTileflowIconPackage>;
+
+type VerifiedTileflowIconArtifact = {
+    package: CompiledTileflowIconPackage;
+    icons: TileflowRenderedIcon[];
+};
+/** Verify exact compressed bytes and independently decode/hash every cell at both densities. */
+declare function verifyTileflowIconArtifact(input: CompiledTileflowIconPackage): Promise<VerifiedTileflowIconArtifact>;
+
+type TileflowIconCacheOptions = {
+    /** Parent of the versioned tileflow/icons/v1 cache, not a serialized lock setting. */
+    cacheRoot?: string;
+    offline?: boolean;
+    /** Trusted application configuration. A lock cannot extend this allowlist. */
+    deliveryOrigins?: readonly string[];
+    fetch?: typeof globalThis.fetch;
+    signal?: AbortSignal;
+};
+declare function getTileflowIconCacheDirectory(options?: Pick<TileflowIconCacheOptions, 'cacheRoot'>): string;
+/** Read and verify an exact pin; a cache miss never resolves a newer version. */
+declare function loadTileflowIconSetArtifact(input: TileflowIconSetPin, options?: TileflowIconCacheOptions): Promise<VerifiedTileflowIconArtifact>;
+/** Seed or repair a disposable cache using verified generated bytes, never original artwork. */
+declare function storeTileflowIconSetArtifact(input: TileflowIconSetPin, artifact: CompiledTileflowIconPackage, options?: Pick<TileflowIconCacheOptions, 'cacheRoot'>): Promise<VerifiedTileflowIconArtifact>;
+
+/** A building model file, prepared for the build to write beside the style. */
+type PreparedTileflowBuildingModel = {
+    /** Its file name, content-addressed: `<id>-<first 16 hex of its SHA-256>.glb`. */
+    fileName: string;
+    bytes: Uint8Array;
+    sha256: string;
+};
+/** A building model's glTF binaries, nearest level first. */
+type TileflowBuildingModelLevels = Readonly<{
+    near: Uint8Array;
+    mid?: Uint8Array;
+    far?: Uint8Array;
+}>;
+/**
+ * Prepares one building model from its glTF binaries into the file a build writes beside the
+ * style: a glTF binary compressed with meshoptimizer. Its footprint is the near level's `footprint`
+ * mesh, or else its outline on the ground. Throws `TileflowGltfError` or `RangeError` with words an
+ * author can act on.
+ */
+declare function prepareTileflowBuildingModel(id: string, levels: TileflowBuildingModelLevels): Promise<{
+    bytes: Uint8Array;
+    sha256: string;
+}>;
+/** A landmark to package: a building model and where it stands. */
+type TileflowLandmarkSource = Readonly<{
+    id: string;
+    /** Longitude and latitude of its origin. */
+    at: readonly [number, number];
+    /** Degrees clockwise from north its own north is turned to, from 0 to 360. */
+    heading: number;
+    levels: TileflowBuildingModelLevels;
+}>;
+/**
+ * Packages the landmarks standing in one tile of a landmarks tileset into that tile's prepared
+ * model file, the landmarks in the order of their ids. Every landmark's origin must fall in the
+ * same zoom-14 tile. The result depends only on its input.
+ */
+declare function packageTileflowLandmarkTile(landmarks: readonly TileflowLandmarkSource[]): Promise<{
+    x: number;
+    y: number;
+    bytes: Uint8Array;
+    sha256: string;
+}>;
+/**
+ * Writes the index of one region of a landmarks tileset, `{region: [x, y], tiles: [[x, y,
+ * sha256], ...]}`, as the bytes the tileset serves, with their SHA-256.
+ */
+declare function encodeTileflowLandmarkRegion(region: TileflowLandmarkRegion): {
+    bytes: Uint8Array;
+    sha256: string;
+};
+/** A map's building models as the model bundle a hosted deploy uploads before its styles. */
+type TileflowModelBundle = {
+    /** The SHA-256 of the manifest's canonical JSON. */
+    contentHash: string;
+    manifest: TileflowModelBundleManifest;
+    /** Each model's prepared file, named as the manifest names it. */
+    files: {
+        contentType: string;
+        fileName: string;
+        source: Uint8Array;
+    }[];
+};
+/**
+ * Bundles a map's prepared building models, or returns undefined when it has none. Throws a
+ * `RangeError` an author can act on when the models together are too large to host.
+ */
+declare function createTileflowModelBundle(buildings: Readonly<Record<string, PreparedTileflowBuildingModel>>): Promise<TileflowModelBundle | undefined>;
+type PreparedTileflowTreeModels = {
+    /** The prepared tree models by id. */
+    models: Record<string, TileflowTreeModel>;
+    /** The prepared building models by id. */
+    buildings: Record<string, PreparedTileflowBuildingModel>;
+    identities: TileflowEffectiveModelSourceIdentity[];
+    /** Directories to watch for changes. */
+    watchPaths: string[];
+};
+/** Reads, checks and prepares one map's model directories. */
+declare function prepareTileflowMapTreeModels(directories: readonly TileflowModelDirectory[], options: {
+    baseDirectory: string;
+    configPath: string;
+    cwd: string;
+    target: 'hosted' | 'local';
+}): Promise<PreparedTileflowTreeModels>;
+
+/** Render a report image without changing the immutable generated sprite. */
+declare function renderTileflowIconAtlasPreview(source: Uint8Array, index: TileflowIconSpriteIndex): Promise<Uint8Array>;
+
+/**
+ * Read the exact current lock bytes for a compare-and-swap update.
+ *
+ * `null` means no lock exists yet. The returned text is the only valid `expectedContents` for a
+ * later `writeTileflowIconsLockfile` call, so a concurrent writer can never be silently lost.
+ */
+declare function readTileflowIconsLockfileText(baseDirectory: string): Promise<string | null>;
+declare function readTileflowIconsLockfile(baseDirectory: string, sources?: readonly TileflowIconSource[]): Promise<TileflowIconsLockfileV1>;
+/** Compare-and-swap the whole lock. Never rewrite executable config or lose another writer's pin. */
+declare function writeTileflowIconsLockfile(baseDirectory: string, input: TileflowIconsLockfileV1, expectedContents: string | null): Promise<void>;
+
+type ComposeTileflowIconSourcesOptions = TileflowIconCacheOptions & {
+    cwd: string;
+    baseDirectory?: string;
+    /** Trusted caller-owned diagnostic prefix, such as `maps.main.icons`. */
+    configPath?: string;
+    lock?: unknown;
+    target?: TileflowIconCompilationTarget;
+};
+/** One declared contributor, retained even when later contributors shadow all of its exports. */
+type TileflowComposedIconContributor = {
+    /** Ordered declared entries, before later contributors replace any of them. */
+    entries: readonly TileflowIconDirectoryEntry[];
+    iconIds: readonly string[];
+    insideWorkingTree: boolean;
+    kind: 'local' | 'package';
+    label: string;
+} | {
+    iconIds: readonly string[];
+    kind: 'icon-set';
+    /** Canonical `@team/set` reference; the exact revision lives in the receipt. */
+    label: string;
+    packageId: string;
+    reference: string;
+    setId: string;
+    version: number;
+    versionId: string;
+};
+/** One effective icon after ordered last-wins replacement has completed. */
+type TileflowComposedIconWinner = {
+    contributor: number;
+    id: string;
+    identity: TileflowEffectiveIconSourceIdentity;
+    /** Present only for filesystem-backed winners; verified shared cells expose no original. */
+    source: TileflowIconDirectorySourceFile | null;
+};
+type TileflowComposedIconSources = {
+    package: CompiledTileflowIconPackage | null;
+    composition: TileflowIconCompositionV1 | null;
+    contributors: TileflowComposedIconContributor[];
+    sourceIdentities: TileflowEffectiveIconSourceIdentity[];
+    replacements: Array<{
+        id: string;
+        replaced: number;
+        winner: number;
+    }>;
+    /** Exact files whose contents select this composition, such as the icon lock. */
+    watchFiles: string[];
+    /** Local directories whose children can change the composition without a config edit. */
+    watchPaths: string[];
+    winners: TileflowComposedIconWinner[];
+};
+/** The single normal icon-preparation path for declared local, package and shared contributors. */
+declare function composeTileflowIconSources(input: readonly TileflowIconSource[], options: ComposeTileflowIconSourcesOptions): Promise<TileflowComposedIconSources>;
+
+type TileflowBuildAsset = {
+    contentType: string;
+    fileName: string;
+    source: string | Uint8Array;
+};
+/** Executable authoring input before local sources have been resolved into runtime URLs. */
+type TileflowSourceCatalog = TileflowBuildCatalog;
+declare const preparedTileflowBuildCatalog: unique symbol;
+/** A validated catalog paired with build-owned portable assets. */
+type PreparedTileflowBuildCatalog = TileflowBuildCatalog & {
+    readonly [preparedTileflowBuildCatalog]: true;
+};
+type PreparedTileflowCatalog = {
+    assets: TileflowBuildAsset[];
+    baseDirectory: string;
+    cwd: string;
+    mapAssets: Record<string, TileflowPreparedMapAssets>;
+    /** Ordered shared dependency receipts, present only for maps that declare an Icon Set. */
+    mapIconCompositions: Record<string, TileflowIconCompositionV1>;
+    mapIconSources: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    /** The files of each map's own 3D models, for its revision. */
+    mapModelSources?: Record<string, readonly TileflowEffectiveModelSourceIdentity[]>;
+    project: PreparedTileflowBuildCatalog;
+    sourceProject: TileflowSourceCatalog;
+    /** Exact files whose contents select the composition, such as the icon lock. */
+    watchFiles: string[];
+    watchPaths: string[];
+};
+/**
+ * Explicit, trusted resolution settings for declared shared Icon Sets.
+ *
+ * These are supplied by the calling command or adapter. A lock file can never widen them, and no
+ * ambient process state selects a cache, an origin, or a transport.
+ */
+type TileflowIconResolutionOptions = TileflowIconCacheOptions;
+type TileflowIconCompilationTarget = 'hosted' | 'local';
+type TileflowIconCompilationIssue = {
+    message: string;
+    path: string;
+};
+type CompiledTileflowIconPackageFile = {
+    contentType: 'application/json' | 'image/png';
+    fileName: TileflowIconPackageFileName;
+    source: Uint8Array;
+};
+type CompiledTileflowIconPackage = {
+    contentHash: string;
+    files: CompiledTileflowIconPackageFile[];
+    manifest: TileflowIconPackageManifest;
+};
+type TileflowMapIconPackageBinding = {
+    appearances?: Record<string, TileflowIconAppearance>;
+    iconIds: readonly string[];
+    label: string;
+    mapName: string;
+    packageHash: string;
+};
+type CompileTileflowIconPackagesOptions = {
+    baseDirectory?: string;
+    cwd: string;
+    /** Trusted shared-set resolution settings; omitted means the default verified cache. */
+    icons?: TileflowIconResolutionOptions;
+    target: TileflowIconCompilationTarget;
+};
+type CompileTileflowIconPackagesResult = {
+    bindings: TileflowMapIconPackageBinding[];
+    /** Exact ordered dependency receipts, keyed by map, for maps that declare an Icon Set. */
+    compositions: Record<string, TileflowIconCompositionV1>;
+    packages: CompiledTileflowIconPackage[];
+    sourceIdentities: Record<string, readonly TileflowEffectiveIconSourceIdentity[]>;
+    /** Exact files whose contents select the composition, such as the icon lock. */
+    watchFiles: string[];
+    watchPaths: string[];
+};
+type InspectTileflowIconCatalogsOptions = {
+    baseDirectory?: string;
+    cwd: string;
+    icons?: TileflowIconResolutionOptions;
+    mapNames?: readonly string[];
+};
+type TileflowIconCatalogSourceFormat = 'jpeg' | 'png' | 'svg' | 'webp';
+type TileflowIconCatalogAtlasRectangle = {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type TileflowIconCatalogRenderedDensity = {
+    atlas: TileflowIconCatalogAtlasRectangle;
+    height: number;
+    pixelRatio: 1 | 2;
+    pixelSha256: string;
+    width: number;
+};
+/** One winning icon's origin: a repository/package original, or an exact shared revision cell. */
+type TileflowIconCatalogIconSource = {
+    byteLength: number;
+    contributor: number;
+    dimensions: {
+        height: number;
+        width: number;
+    } | null;
+    format: TileflowIconCatalogSourceFormat;
+    kind: 'file';
+    path: string;
+} | {
+    contributor: number;
+    kind: 'icon-set';
+    reference: string;
+    version: number;
+};
+type TileflowIconCatalogIcon = {
+    appearance?: TileflowIconAppearance;
+    layout?: TileflowIconLayoutMetadata;
+    id: string;
+    rendered: {
+        oneX: TileflowIconCatalogRenderedDensity;
+        twoX: TileflowIconCatalogRenderedDensity;
+    };
+    source: TileflowIconCatalogIconSource;
+};
+/** One declared contributor in authoring order, retained even when fully shadowed. */
+type TileflowIconCatalogContributor = {
+    iconIds: string[];
+    insideWorkingTree: boolean;
+    kind: 'local' | 'package';
+    label: string;
+} | {
+    iconIds: string[];
+    kind: 'icon-set';
+    label: string;
+    reference: string;
+    version: number;
+};
+type TileflowIconCatalog = {
+    compiledPackage: CompiledTileflowIconPackage;
+    composition: TileflowIconCompositionV1 | null;
+    contributors: TileflowIconCatalogContributor[];
+    icons: TileflowIconCatalogIcon[];
+    insideWorkingTree: boolean;
+    replacements: TileflowIconReplacement[];
+};
+type TileflowIconReplacement = {
+    id: string;
+    replaced: string;
+    winner: string;
+};
+type TileflowIconCatalogMap = {
+    name: string;
+    icons: {
+        composition: TileflowIconCompositionV1 | null;
+        contributors: TileflowIconCatalogContributor[];
+        iconIds: string[];
+        kind: 'sources';
+        label: string;
+        packageHash: string;
+    } | {
+        kind: 'none';
+    };
+};
+type TileflowIconCatalogInspection = {
+    catalogs: TileflowIconCatalog[];
+    maps: TileflowIconCatalogMap[];
+};
+declare class TileflowIconCompilationError extends Error {
+    readonly code: "ICON_INVALID";
+    readonly issues: TileflowIconCompilationIssue[];
+    readonly phase: "icon-compilation";
+    constructor(issues: TileflowIconCompilationIssue[]);
+}
+type DecodedIconDimensions = {
+    height: number;
+    width: number;
+};
+declare const iconFileExtensions: Set<string>;
+declare function compileTileflowIconPackages(project: TileflowBuildCatalog, options: CompileTileflowIconPackagesOptions): Promise<CompileTileflowIconPackagesResult>;
+declare function inspectTileflowIconCatalogs(project: TileflowBuildCatalog, options: InspectTileflowIconCatalogsOptions): Promise<TileflowIconCatalogInspection>;
+declare function prepareTileflowCatalogIcons(project: TileflowBuildCatalog, options: {
+    assetBaseUrl: string;
+    baseDirectory?: string;
+    cwd: string;
+    icons?: TileflowIconResolutionOptions;
+}): Promise<PreparedTileflowCatalog>;
+/**
+ * Report the exact filesystem inputs that can change the composed sprite.
+ *
+ * The lock beside the selected config is one of them; a lock edit rebuilds from its new exact
+ * pins. Catalog heads are never polled, so a newly published revision changes nothing here.
+ */
+declare function getTileflowIconWatchPaths(project: TileflowBuildCatalog, cwd: string, baseDirectory?: string): Promise<string[]>;
+
+/** One declared icon file, including entries a later contributor eventually replaces. */
+type TileflowIconDirectoryEntry = {
+    byteLength: number;
+    format: TileflowIconCatalogSourceFormat;
+    id: string;
+    kind: 'icon' | 'pattern';
+    /** Authoring-relative display path. Absolute filesystem paths never leave this module. */
+    path: string;
+};
+/** The decoded original behind one effective local winner. */
+type TileflowIconDirectorySourceFile = TileflowIconDirectoryEntry & {
+    dimensions: DecodedIconDimensions;
+};
+type ReadTileflowIconDirectoryResult = {
+    containmentRoot: string;
+    entries: TileflowIconDirectoryEntry[];
+    iconIds: string[];
+    /** Authoring label: a config-relative directory or a safe `npm:<package>/<path>` descriptor. */
+    label: string;
+    realPath: string;
+    render: (ids: readonly string[]) => Promise<Array<{
+        icon: TileflowRenderedIcon;
+        identity: TileflowEffectiveIconSourceIdentity;
+        source: TileflowIconDirectorySourceFile;
+        sourceBytes: number;
+    }>>;
+    watchPath?: string;
+};
+/** A bounded local source snapshot used by the explicit shared-composition build port. */
+declare function readTileflowIconDirectory(source: TileflowIconDirectory, options: {
+    baseDirectory: string;
+    /** Trusted caller-owned diagnostic prefix, such as `maps.main.icons`. */
+    configPath?: string;
+    cwd: string;
+    /** Ordinal of this directory inside the declared contributor sequence. */
+    ordinal?: number;
+    target: TileflowIconCompilationTarget;
+}): Promise<ReadTileflowIconDirectoryResult>;
+
+export { readTileflowIconDirectory as $, TileflowIconCompilationError as A, type TileflowIconCompilationIssue as B, type CompileTileflowIconPackagesOptions as C, type TileflowIconCompilationTarget as D, type TileflowIconDirectoryEntry as E, type TileflowIconDirectorySourceFile as F, type TileflowIconReplacement as G, type TileflowMapIconPackageBinding as H, type InspectTileflowIconCatalogsOptions as I, type TileflowModelBundle as J, type TileflowRenderedIcon as K, type TileflowRenderedIconCell as L, compileTileflowIconPackages as M, composeTileflowIconSources as N, createTileflowModelBundle as O, type PreparedTileflowBuildCatalog as P, getTileflowIconCacheDirectory as Q, type ReadTileflowIconDirectoryResult as R, getTileflowIconWatchPaths as S, type TileflowBuildAsset as T, iconFileExtensions as U, type VerifiedTileflowIconArtifact as V, inspectTileflowIconCatalogs as W, loadTileflowIconSetArtifact as X, packTileflowRenderedIcons as Y, prepareTileflowCatalogIcons as Z, prepareTileflowMapTreeModels as _, type TileflowIconResolutionOptions as a, readTileflowIconsLockfile as a0, readTileflowIconsLockfileText as a1, renderTileflowIconAtlasPreview as a2, storeTileflowIconSetArtifact as a3, verifyTileflowIconArtifact as a4, writeTileflowIconsLockfile as a5, type TileflowSourceCatalog as b, type PreparedTileflowCatalog as c, type TileflowBuildingModelLevels as d, type TileflowLandmarkSource as e, encodeTileflowLandmarkRegion as f, prepareTileflowBuildingModel as g, type CompileTileflowIconPackagesResult as h, type CompiledTileflowIconPackage as i, type CompiledTileflowIconPackageFile as j, type ComposeTileflowIconSourcesOptions as k, type PreparedTileflowBuildingModel as l, type TileflowComposedIconContributor as m, type TileflowComposedIconSources as n, type TileflowComposedIconWinner as o, packageTileflowLandmarkTile as p, type TileflowIconCacheOptions as q, type TileflowIconCatalog as r, type TileflowIconCatalogAtlasRectangle as s, type TileflowIconCatalogContributor as t, type TileflowIconCatalogIcon as u, type TileflowIconCatalogIconSource as v, type TileflowIconCatalogInspection as w, type TileflowIconCatalogMap as x, type TileflowIconCatalogRenderedDensity as y, type TileflowIconCatalogSourceFormat as z };