styled-map-package 2.2.0 → 3.0.0

package/dist/utils/streams.js

@@ -0,0 +1,103 @@
+import { Readable, Writable, Transform } from "readable-stream";
+function writeStreamFromAsync(fn, { concurrency = 16 } = {}) {
+  return new Writable({
+    highWaterMark: concurrency,
+    objectMode: true,
+    write(chunk, encoding, callback) {
+      fn.apply(null, chunk).then(() => callback(), callback);
+    }
+  });
+}
+function fromWebReadableStream(readableStream, options = {}) {
+  if (!isWebReadableStream(readableStream)) {
+    throw new Error("First argument must be a ReadableStream");
+  }
+  const { highWaterMark, encoding, objectMode = false, signal } = options;
+  if (encoding !== void 0 && !Buffer.isEncoding(encoding))
+    throw new Error("Invalid encoding");
+  const reader = readableStream.getReader();
+  let closed = false;
+  const readable = new Readable({
+    objectMode,
+    highWaterMark,
+    encoding,
+    // @ts-ignore
+    signal,
+    read() {
+      reader.read().then(
+        (chunk) => {
+          if (chunk.done) {
+            readable.push(null);
+          } else {
+            readable.push(chunk.value);
+          }
+        },
+        (error) => readable.destroy(error)
+      );
+    },
+    destroy(error, callback) {
+      function done() {
+        try {
+          callback(error);
+        } catch (error2) {
+          process.nextTick(() => {
+            throw error2;
+          });
+        }
+      }
+      if (!closed) {
+        reader.cancel(error).then(done, done);
+        return;
+      }
+      done();
+    }
+  });
+  reader.closed.then(
+    () => {
+      closed = true;
+    },
+    (error) => {
+      closed = true;
+      readable.destroy(error);
+    }
+  );
+  return readable;
+}
+function isWebReadableStream(obj) {
+  return !!(typeof obj === "object" && obj !== null && "pipeThrough" in obj && typeof obj.pipeThrough === "function" && "getReader" in obj && typeof obj.getReader === "function" && "cancel" in obj && typeof obj.cancel === "function");
+}
+class ProgressStream extends Transform {
+  #onprogress;
+  #byteLength = 0;
+  /**
+   * @param {ProgressStreamOptions} [opts]
+   */
+  constructor({ onprogress, ...opts } = {}) {
+    super(opts);
+    this.#onprogress = onprogress;
+  }
+  /** Total bytes that have passed through this stream */
+  get byteLength() {
+    return this.#byteLength;
+  }
+  /**
+   * @override
+   * @param {Buffer | Uint8Array} chunk
+   * @param {Parameters<Transform['_transform']>[1]} encoding
+   * @param {Parameters<Transform['_transform']>[2]} callback
+   */
+  _transform(chunk, encoding, callback) {
+    this.#byteLength += chunk.length;
+    this.#onprogress?.({
+      totalBytes: this.#byteLength,
+      chunkBytes: chunk.length
+    });
+    callback(null, chunk);
+  }
+}
+export {
+  ProgressStream,
+  fromWebReadableStream,
+  isWebReadableStream,
+  writeStreamFromAsync
+};

package/dist/utils/style.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var style_exports = {};
+__export(style_exports, {
+  assertTileJSON: () => assertTileJSON,
+  isInlinedSource: () => isInlinedSource,
+  mapFontStacks: () => mapFontStacks,
+  replaceFontStacks: () => replaceFontStacks,
+  validateStyle: () => validateStyle
+});
+module.exports = __toCommonJS(style_exports);
+var import_maplibre_gl_style_spec = require("@maplibre/maplibre-gl-style-spec");
+function replaceFontStacks(style, fonts) {
+  const mappedLayers = mapFontStacks(style.layers, (fontStack) => {
+    let match;
+    for (const font of fontStack) {
+      if (fonts.includes(font)) {
+        match = font;
+        break;
+      }
+    }
+    return [match || fonts[0]];
+  });
+  style.layers = mappedLayers;
+  return style;
+}
+function mapFontStacks(layers, callbackFn) {
+  return layers.map((layer) => {
+    if (layer.type !== "symbol" || !layer.layout || !layer.layout["text-font"])
+      return layer;
+    const textFont = layer.layout["text-font"];
+    let mappedValue;
+    if (isExpression(textFont)) {
+      mappedValue = mapArrayExpressionValue(textFont, callbackFn);
+    } else if (Array.isArray(textFont)) {
+      mappedValue = callbackFn(textFont);
+    } else {
+      console.warn(
+        "Deprecated function definitions are not supported, font stack has not been transformed."
+      );
+      console.dir(textFont, { depth: null });
+      return layer;
+    }
+    return {
+      ...layer,
+      layout: {
+        ...layer.layout,
+        "text-font": mappedValue
+      }
+    };
+  });
+}
+function isExpression(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0] === "string" && value[0] in import_maplibre_gl_style_spec.expressions;
+}
+function mapArrayExpressionValue(expression, callbackFn) {
+  if (expression[0] === "literal" && Array.isArray(expression[1])) {
+    return ["literal", callbackFn(expression[1])];
+  } else {
+    return [
+      expression[0],
+      ...expression.slice(1).map(
+        // @ts-ignore
+        (x) => {
+          if (isExpression(x)) {
+            return mapArrayExpressionValue(x, callbackFn);
+          } else {
+            return x;
+          }
+        }
+      )
+    ];
+  }
+}
+function assertTileJSON(tilejson) {
+  if (typeof tilejson !== "object" || tilejson === null) {
+    throw new Error("Invalid TileJSON");
+  }
+  if (!("tiles" in tilejson) || !Array.isArray(tilejson.tiles) || tilejson.tiles.length === 0 || tilejson.tiles.some((tile) => typeof tile !== "string")) {
+    throw new Error("Invalid TileJSON: missing or invalid tiles property");
+  }
+}
+const validateStyle = (
+  /** @type {{ (style: unknown): style is StyleSpecification, errors: ValidationError[] }} */
+  (style) => {
+    validateStyle.errors = (0, import_maplibre_gl_style_spec.validateStyleMin)(
+      /** @type {StyleSpecification} */
+      style
+    );
+    if (validateStyle.errors.length) return false;
+    return true;
+  }
+);
+function isInlinedSource(source) {
+  if (source.type === "geojson") {
+    return typeof source.data === "object";
+  } else if (source.type === "vector" || source.type === "raster" || source.type === "raster-dem") {
+    return "tiles" in source;
+  } else {
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertTileJSON,
+  isInlinedSource,
+  mapFontStacks,
+  replaceFontStacks,
+  validateStyle
+});

package/dist/utils/style.d.cts

@@ -0,0 +1,69 @@
+import { BBox } from './geo.cjs';
+import { I as InlinedSource } from '../types-B4Xn1F9K.cjs';
+import * as _maplibre_maplibre_gl_style_spec from '@maplibre/maplibre-gl-style-spec';
+import { StyleSpecification, ValidationError } from '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
+/** @import {StyleSpecification, ExpressionSpecification, ValidationError} from '@maplibre/maplibre-gl-style-spec' */
+/**
+ * For a given style, replace all font stacks (`text-field` properties) with the
+ * provided fonts. If no matching font is found, the first font in the stack is
+ * used.
+ *
+ * *Modifies the input style object*
+ *
+ * @param {StyleSpecification} style
+ * @param {string[]} fonts
+ */
+declare function replaceFontStacks(style: StyleSpecification, fonts: string[]): StyleSpecification;
+/**
+ * From given style layers, create a new style by calling the provided callback
+ * function on every font stack defined in the style.
+ *
+ * @param {StyleSpecification['layers']} layers
+ * @param {(fontStack: string[]) => string[]} callbackFn
+ * @returns {StyleSpecification['layers']}
+ */
+declare function mapFontStacks(layers: StyleSpecification["layers"], callbackFn: (fontStack: string[]) => string[]): StyleSpecification["layers"];
+/**
+ * @typedef {object} TileJSONPartial
+ * @property {string[]} tiles
+ * @property {string} [description]
+ * @property {string} [attribution]
+ * @property {object[]} [vector_layers]
+ * @property {import('./geo.js').BBox} [bounds]
+ * @property {number} [maxzoom]
+ * @property {number} [minzoom]
+ */
+/**
+ *
+ * @param {unknown} tilejson
+ * @returns {asserts tilejson is TileJSONPartial}
+ */
+declare function assertTileJSON(tilejson: unknown): asserts tilejson is TileJSONPartial;
+/**
+ * Check whether a source is already inlined (e.g. does not reference a TileJSON or GeoJSON url)
+ *
+ * @param {import('@maplibre/maplibre-gl-style-spec').SourceSpecification} source
+ * @returns {source is import('../types.js').InlinedSource}
+ */
+declare function isInlinedSource(source: _maplibre_maplibre_gl_style_spec.SourceSpecification): source is InlinedSource;
+declare const validateStyle: {
+    (style: unknown): style is StyleSpecification;
+    errors: ValidationError[];
+};
+type TileJSONPartial = {
+    tiles: string[];
+    description?: string | undefined;
+    attribution?: string | undefined;
+    vector_layers?: object[] | undefined;
+    bounds?: BBox | undefined;
+    maxzoom?: number | undefined;
+    minzoom?: number | undefined;
+};
+
+export { type TileJSONPartial, assertTileJSON, isInlinedSource, mapFontStacks, replaceFontStacks, validateStyle };

package/dist/{lib/utils → utils}/style.d.ts

@@ -1,3 +1,13 @@
+import { BBox } from './geo.js';
+import { I as InlinedSource } from '../types-B4Xn1F9K.js';
+import * as _maplibre_maplibre_gl_style_spec from '@maplibre/maplibre-gl-style-spec';
+import { StyleSpecification, ValidationError } from '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
 /** @import {StyleSpecification, ExpressionSpecification, ValidationError} from '@maplibre/maplibre-gl-style-spec' */
 /**
  * For a given style, replace all font stacks (`text-field` properties) with the
@@ -9,7 +19,7 @@
  * @param {StyleSpecification} style
  * @param {string[]} fonts
  */
-export function replaceFontStacks(style: StyleSpecification, fonts: string[]): StyleSpecification;
+declare function replaceFontStacks(style: StyleSpecification, fonts: string[]): StyleSpecification;
 /**
  * From given style layers, create a new style by calling the provided callback
  * function on every font stack defined in the style.
@@ -18,7 +28,7 @@ export function replaceFontStacks(style: StyleSpecification, fonts: string[]): S
  * @param {(fontStack: string[]) => string[]} callbackFn
  * @returns {StyleSpecification['layers']}
  */
-export function mapFontStacks(layers: StyleSpecification["layers"], callbackFn: (fontStack: string[]) => string[]): StyleSpecification["layers"];
+declare function mapFontStacks(layers: StyleSpecification["layers"], callbackFn: (fontStack: string[]) => string[]): StyleSpecification["layers"];
 /**
  * @typedef {object} TileJSONPartial
  * @property {string[]} tiles
@@ -34,26 +44,26 @@ export function mapFontStacks(layers: StyleSpecification["layers"], callbackFn:
  * @param {unknown} tilejson
  * @returns {asserts tilejson is TileJSONPartial}
  */
-export function assertTileJSON(tilejson: unknown): asserts tilejson is TileJSONPartial;
+declare function assertTileJSON(tilejson: unknown): asserts tilejson is TileJSONPartial;
 /**
  * Check whether a source is already inlined (e.g. does not reference a TileJSON or GeoJSON url)
  *
  * @param {import('@maplibre/maplibre-gl-style-spec').SourceSpecification} source
  * @returns {source is import('../types.js').InlinedSource}
  */
-export function isInlinedSource(source: import("@maplibre/maplibre-gl-style-spec").SourceSpecification): source is import("../types.js").InlinedSource;
-export const validateStyle: {
+declare function isInlinedSource(source: _maplibre_maplibre_gl_style_spec.SourceSpecification): source is InlinedSource;
+declare const validateStyle: {
     (style: unknown): style is StyleSpecification;
     errors: ValidationError[];
 };
-export type TileJSONPartial = {
+type TileJSONPartial = {
     tiles: string[];
     description?: string | undefined;
     attribution?: string | undefined;
     vector_layers?: object[] | undefined;
-    bounds?: import("./geo.js").BBox | undefined;
+    bounds?: BBox | undefined;
     maxzoom?: number | undefined;
     minzoom?: number | undefined;
 };
-import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
-import type { ValidationError } from '@maplibre/maplibre-gl-style-spec';
+
+export { type TileJSONPartial, assertTileJSON, isInlinedSource, mapFontStacks, replaceFontStacks, validateStyle };

package/dist/utils/style.js

@@ -0,0 +1,98 @@
+import { expressions, validateStyleMin } from "@maplibre/maplibre-gl-style-spec";
+function replaceFontStacks(style, fonts) {
+  const mappedLayers = mapFontStacks(style.layers, (fontStack) => {
+    let match;
+    for (const font of fontStack) {
+      if (fonts.includes(font)) {
+        match = font;
+        break;
+      }
+    }
+    return [match || fonts[0]];
+  });
+  style.layers = mappedLayers;
+  return style;
+}
+function mapFontStacks(layers, callbackFn) {
+  return layers.map((layer) => {
+    if (layer.type !== "symbol" || !layer.layout || !layer.layout["text-font"])
+      return layer;
+    const textFont = layer.layout["text-font"];
+    let mappedValue;
+    if (isExpression(textFont)) {
+      mappedValue = mapArrayExpressionValue(textFont, callbackFn);
+    } else if (Array.isArray(textFont)) {
+      mappedValue = callbackFn(textFont);
+    } else {
+      console.warn(
+        "Deprecated function definitions are not supported, font stack has not been transformed."
+      );
+      console.dir(textFont, { depth: null });
+      return layer;
+    }
+    return {
+      ...layer,
+      layout: {
+        ...layer.layout,
+        "text-font": mappedValue
+      }
+    };
+  });
+}
+function isExpression(value) {
+  return Array.isArray(value) && value.length > 0 && typeof value[0] === "string" && value[0] in expressions;
+}
+function mapArrayExpressionValue(expression, callbackFn) {
+  if (expression[0] === "literal" && Array.isArray(expression[1])) {
+    return ["literal", callbackFn(expression[1])];
+  } else {
+    return [
+      expression[0],
+      ...expression.slice(1).map(
+        // @ts-ignore
+        (x) => {
+          if (isExpression(x)) {
+            return mapArrayExpressionValue(x, callbackFn);
+          } else {
+            return x;
+          }
+        }
+      )
+    ];
+  }
+}
+function assertTileJSON(tilejson) {
+  if (typeof tilejson !== "object" || tilejson === null) {
+    throw new Error("Invalid TileJSON");
+  }
+  if (!("tiles" in tilejson) || !Array.isArray(tilejson.tiles) || tilejson.tiles.length === 0 || tilejson.tiles.some((tile) => typeof tile !== "string")) {
+    throw new Error("Invalid TileJSON: missing or invalid tiles property");
+  }
+}
+const validateStyle = (
+  /** @type {{ (style: unknown): style is StyleSpecification, errors: ValidationError[] }} */
+  (style) => {
+    validateStyle.errors = validateStyleMin(
+      /** @type {StyleSpecification} */
+      style
+    );
+    if (validateStyle.errors.length) return false;
+    return true;
+  }
+);
+function isInlinedSource(source) {
+  if (source.type === "geojson") {
+    return typeof source.data === "object";
+  } else if (source.type === "vector" || source.type === "raster" || source.type === "raster-dem") {
+    return "tiles" in source;
+  } else {
+    return true;
+  }
+}
+export {
+  assertTileJSON,
+  isInlinedSource,
+  mapFontStacks,
+  replaceFontStacks,
+  validateStyle
+};

package/dist/utils/templates.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var templates_exports = {};
+__export(templates_exports, {
+  GLYPH_URI: () => GLYPH_URI,
+  STYLE_FILE: () => STYLE_FILE,
+  URI_BASE: () => URI_BASE,
+  URI_SCHEME: () => URI_SCHEME,
+  getContentType: () => getContentType,
+  getGlyphFilename: () => getGlyphFilename,
+  getResourceType: () => getResourceType,
+  getSpriteFilename: () => getSpriteFilename,
+  getSpriteUri: () => getSpriteUri,
+  getTileFilename: () => getTileFilename,
+  getTileUri: () => getTileUri,
+  replaceVariables: () => replaceVariables
+});
+module.exports = __toCommonJS(templates_exports);
+const URI_SCHEME = "smp";
+const URI_BASE = URI_SCHEME + "://maps.v1/";
+const STYLE_FILE = "style.json";
+const SOURCES_FOLDER = "s";
+const SPRITES_FOLDER = "sprites";
+const FONTS_FOLDER = "fonts";
+const TILE_FILE = SOURCES_FOLDER + "/{sourceId}/{z}/{x}/{y}{ext}";
+const SPRITE_FILE = SPRITES_FOLDER + "/{id}/sprite{pixelRatio}{ext}";
+const GLYPH_FILE = FONTS_FOLDER + "/{fontstack}/{range}.pbf.gz";
+const GLYPH_URI = URI_BASE + GLYPH_FILE;
+const pathToResouceType = (
+  /** @type {const} */
+  {
+    [TILE_FILE.split("/")[0] + "/"]: "tile",
+    [SPRITE_FILE.split("/")[0] + "/"]: "sprite",
+    [GLYPH_FILE.split("/")[0] + "/"]: "glyph"
+  }
+);
+function getResourceType(path) {
+  if (path === "style.json") return "style";
+  for (const [prefix, type] of Object.entries(pathToResouceType)) {
+    if (path.startsWith(prefix)) return type;
+  }
+  throw new Error(`Unknown resource type for path: ${path}`);
+}
+function getContentType(path) {
+  if (path.endsWith(".json")) return "application/json; charset=utf-8";
+  if (path.endsWith(".pbf.gz") || path.endsWith(".pbf"))
+    return "application/x-protobuf";
+  if (path.endsWith(".png")) return "image/png";
+  if (path.endsWith(".jpg")) return "image/jpeg";
+  if (path.endsWith(".webp")) return "image/webp";
+  if (path.endsWith(".mvt.gz") || path.endsWith(".mvt"))
+    return "application/vnd.mapbox-vector-tile";
+  throw new Error(`Unknown content type for path: ${path}`);
+}
+function getTileFilename({ sourceId, z, x, y, format }) {
+  const ext = "." + format + (format === "mvt" ? ".gz" : "");
+  return replaceVariables(TILE_FILE, { sourceId, z, x, y, ext });
+}
+function getSpriteFilename({ id, pixelRatio, ext }) {
+  return replaceVariables(SPRITE_FILE, {
+    id,
+    pixelRatio: getPixelRatioString(pixelRatio),
+    ext
+  });
+}
+function getGlyphFilename({ fontstack, range }) {
+  return replaceVariables(GLYPH_FILE, { fontstack, range });
+}
+function getSpriteUri(id = "default") {
+  return URI_BASE + replaceVariables(SPRITE_FILE, { id, pixelRatio: "", ext: "" });
+}
+function getTileUri({ sourceId, format }) {
+  const ext = "." + format + (format === "mvt" ? ".gz" : "");
+  return URI_BASE + TILE_FILE.replace("{sourceId}", sourceId).replace("{ext}", ext);
+}
+function getPixelRatioString(pixelRatio) {
+  return pixelRatio === 1 ? "" : `@${pixelRatio}x`;
+}
+function replaceVariables(template, variables) {
+  return template.replace(/{(.*?)}/g, (match, varName) => {
+    return varName in variables ? String(variables[varName]) : match;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLYPH_URI,
+  STYLE_FILE,
+  URI_BASE,
+  URI_SCHEME,
+  getContentType,
+  getGlyphFilename,
+  getResourceType,
+  getSpriteFilename,
+  getSpriteUri,
+  getTileFilename,
+  getTileUri,
+  replaceVariables
+});

package/dist/utils/templates.d.cts

@@ -0,0 +1,78 @@
+import * as type_fest from 'type-fest';
+import { T as TileInfo, d as GlyphRange, c as TileFormat } from '../types-B4Xn1F9K.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'readable-stream';
+import 'events';
+
+/**
+ * @param {string} path
+ * @returns
+ */
+declare function getResourceType(path: string): "sprite" | "style" | "tile" | "glyph";
+/**
+ * Determine the content type of a file based on its extension.
+ *
+ * @param {string} path
+ */
+declare function getContentType(path: string): "application/json; charset=utf-8" | "application/x-protobuf" | "image/png" | "image/jpeg" | "image/webp" | "application/vnd.mapbox-vector-tile";
+/**
+ * Get the filename for a tile, given the TileInfo
+ *
+ * @param {import("type-fest").SetRequired<import("../writer.js").TileInfo, 'format'>} tileInfo
+ * @returns
+ */
+declare function getTileFilename({ sourceId, z, x, y, format }: type_fest.SetRequired<TileInfo, "format">): string;
+/**
+ * Get a filename for a sprite file, given the sprite id, pixel ratio and extension
+ *
+ * @param {{ id: string, pixelRatio: number, ext: '.json' | '.png'}} spriteInfo
+ */
+declare function getSpriteFilename({ id, pixelRatio, ext }: {
+    id: string;
+    pixelRatio: number;
+    ext: ".json" | ".png";
+}): string;
+/**
+ * Get the filename for a glyph file, given the fontstack and range
+ *
+ * @param {object} options
+ * @param {string} options.fontstack
+ * @param {import("../writer.js").GlyphRange} options.range
+ */
+declare function getGlyphFilename({ fontstack, range }: {
+    fontstack: string;
+    range: GlyphRange;
+}): string;
+/**
+ * Get the URI template for the sprites in the style
+ */
+declare function getSpriteUri(id?: string): string;
+/**
+ * Get the URI template for tiles in the style
+ *
+ * @param {object} opts
+ * @param {string} opts.sourceId
+ * @param {import("../writer.js").TileFormat} opts.format
+ * @returns
+ */
+declare function getTileUri({ sourceId, format }: {
+    sourceId: string;
+    format: TileFormat;
+}): string;
+/**
+ * Replaces variables in a string with values provided in an object. Variables
+ * in the string are denoted by curly braces, e.g., {variableName}.
+ *
+ * @param {string} template - The string containing variables wrapped in curly braces.
+ * @param {Record<string, string | number>} variables - An object where the keys correspond to variable names and values correspond to the replacement values.
+ * @returns {string} The string with the variables replaced by their corresponding values.
+ */
+declare function replaceVariables(template: string, variables: Record<string, string | number>): string;
+declare const URI_SCHEME: "smp";
+declare const URI_BASE: string;
+declare const STYLE_FILE: "style.json";
+declare const GLYPH_URI: string;
+
+export { GLYPH_URI, STYLE_FILE, URI_BASE, URI_SCHEME, getContentType, getGlyphFilename, getResourceType, getSpriteFilename, getSpriteUri, getTileFilename, getTileUri, replaceVariables };