styled-map-package-api 5.0.0-pre.3 → 5.0.0-pre.4

package/dist/utils/templates.d.cts

@@ -1,79 +0,0 @@
-import * as type_fest from 'type-fest';
-import { d as GlyphRange, T as TileInfo, c as TileFormat } from '../types-Bhn0-Ldk.cjs';
-import '@maplibre/maplibre-gl-style-spec';
-import 'geojson';
-
-/**
- * @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 VERSION_FILE: "VERSION";
-declare const FORMAT_VERSION: "1.0";
-declare const STYLE_FILE: "style.json";
-declare const SOURCES_FOLDER: "s";
-declare const FONTS_FOLDER: "fonts";
-declare const GLYPH_URI: string;
-
-export { FONTS_FOLDER, FORMAT_VERSION, GLYPH_URI, SOURCES_FOLDER, STYLE_FILE, URI_BASE, URI_SCHEME, VERSION_FILE, getContentType, getGlyphFilename, getResourceType, getSpriteFilename, getSpriteUri, getTileFilename, getTileUri, replaceVariables };

package/dist/utils/templates.js

@@ -1,85 +0,0 @@
-const URI_SCHEME = "smp";
-const URI_BASE = URI_SCHEME + "://maps.v1/";
-const VERSION_FILE = "VERSION";
-const FORMAT_VERSION = "1.0";
-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;
-  });
-}
-export {
-  FONTS_FOLDER,
-  FORMAT_VERSION,
-  GLYPH_URI,
-  SOURCES_FOLDER,
-  STYLE_FILE,
-  URI_BASE,
-  URI_SCHEME,
-  VERSION_FILE,
-  getContentType,
-  getGlyphFilename,
-  getResourceType,
-  getSpriteFilename,
-  getSpriteUri,
-  getTileFilename,
-  getTileUri,
-  replaceVariables
-};

package/dist/writer.cjs

@@ -1,539 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var writer_exports = {};
-__export(writer_exports, {
-  SUPPORTED_SOURCE_TYPES: () => SUPPORTED_SOURCE_TYPES,
-  Writer: () => Writer
-});
-module.exports = __toCommonJS(writer_exports);
-var import_maplibre_gl_style_spec = require("@maplibre/maplibre-gl-style-spec");
-var import_bbox = require("@turf/bbox");
-var import_filter_obj = require("filter-obj");
-var import_zip_writer = require("zip-writer");
-var import_file_formats = require('./utils/file-formats.cjs');
-var import_geo = require('./utils/geo.cjs');
-var import_misc = require('./utils/misc.cjs');
-var import_streams = require('./utils/streams.cjs');
-var import_style = require('./utils/style.cjs');
-var import_templates = require('./utils/templates.cjs');
-const SUPPORTED_SOURCE_TYPES = (
-  /** @type {const} */
-  [
-    "raster",
-    "vector",
-    "geojson"
-  ]
-);
-class Writer {
-  #zipWriter = new import_zip_writer.ZipWriter();
-  /** @type {Set<string>} */
-  #addedFiles = /* @__PURE__ */ new Set();
-  /** @type {Set<string>} */
-  #fonts = /* @__PURE__ */ new Set();
-  /** @type {Set<string>} */
-  #addedSpriteIds = /* @__PURE__ */ new Set();
-  /** @type {Map<string, SourceInfo>} */
-  #sources = /* @__PURE__ */ new Map();
-  /** @type {StyleSpecification} */
-  #style;
-  /** @type {ReadableStream<Uint8Array>} */
-  #outputStream;
-  /** @type {ReadableStreamDefaultController<Uint8Array>} */
-  #outputController;
-  /** @type {boolean} */
-  #dedupe;
-  /** @type {Map<string, string>} hash → first entry name */
-  #tileHashes = /* @__PURE__ */ new Map();
-  /** @type {Array<{ name: string, originalName: string }>} */
-  #duplicateEntries = [];
-  static SUPPORTED_SOURCE_TYPES = SUPPORTED_SOURCE_TYPES;
-  /**
-   * @param {any} style A v7 or v8 MapLibre style. v7 styles will be migrated to
-   * v8. (There are currently no typescript declarations for v7 styles, hence
-   * this is typed as `any` and validated internally)
-   * @param {WriterOptions} [options]
-   */
-  constructor(style, { dedupe = false } = {}) {
-    if (!style || !("version" in style)) {
-      throw new Error("Invalid style");
-    }
-    if (style.version !== 7 && style.version !== 8) {
-      throw new Error(`Invalid style: Unsupported version v${style.version}`);
-    }
-    if (!Array.isArray(style.layers)) {
-      throw new Error("Invalid style: missing layers property");
-    }
-    const styleCopy = (0, import_misc.clone)(style);
-    (0, import_maplibre_gl_style_spec.migrate)(styleCopy);
-    const errors = (0, import_maplibre_gl_style_spec.validateStyleMin)(styleCopy);
-    if (errors.length) {
-      throw new AggregateError(errors, "Invalid style");
-    }
-    this.#style = styleCopy;
-    this.#dedupe = dedupe;
-    for (const [sourceId, source] of Object.entries(this.#style.sources)) {
-      if (source.type !== "geojson") continue;
-      this.#addSource(sourceId, source);
-    }
-    const zipReader = this.#zipWriter.readable.getReader();
-    let outputController;
-    this.#outputStream = new ReadableStream({
-      start(controller) {
-        outputController = controller;
-      },
-      async pull(controller) {
-        try {
-          const { done, value } = await zipReader.read();
-          if (done) {
-            controller.close();
-          } else {
-            controller.enqueue(
-              /** @type {Uint8Array} */
-              value
-            );
-          }
-        } catch (err) {
-          controller.error(err);
-        }
-      },
-      cancel(reason) {
-        zipReader.cancel(reason);
-      }
-    });
-    this.#outputController = outputController;
-  }
-  /**
-   * @returns {ReadableStream<Uint8Array>} Readable stream of the styled map package
-   */
-  get outputStream() {
-    return this.#outputStream;
-  }
-  /**
-   * Abort the output stream with an error. Call this if an error occurs during
-   * writing to propagate the error to consumers of `outputStream`.
-   *
-   * @param {Error} reason
-   */
-  abort(reason) {
-    this.#outputController.error(reason);
-  }
-  #getBounds() {
-    let bounds;
-    let maxzoom = 0;
-    for (const { source } of this.#sources.values()) {
-      if (source.type === "geojson") {
-        if (isEmptyFeatureCollection(source.data)) continue;
-        const bbox2 = get2DBBox(source.data.bbox);
-        bounds = bounds ? (0, import_geo.unionBBox)([bounds, bbox2]) : [...bbox2];
-      } else {
-        if (source.maxzoom < maxzoom) continue;
-        if (source.maxzoom === maxzoom) {
-          bounds = bounds ? (0, import_geo.unionBBox)([bounds, source.bounds]) : source.bounds;
-        } else {
-          bounds = source.bounds;
-          maxzoom = source.maxzoom;
-        }
-      }
-    }
-    return bounds;
-  }
-  #getMaxZoom() {
-    let maxzoom = 0;
-    for (const { source } of this.#sources.values()) {
-      const sourceMaxzoom = (
-        // For GeoJSON sources, the maxzoom is 16 unless otherwise set
-        source.type === "geojson" ? source.maxzoom || 16 : source.maxzoom
-      );
-      maxzoom = Math.max(maxzoom, sourceMaxzoom);
-    }
-    return maxzoom;
-  }
-  /**
-   * Add a source definition to the styled map package
-   *
-   * @param {string} sourceId
-   * @param {InputSource} source
-   * @returns {SourceInfo}
-   */
-  #addSource(sourceId, source) {
-    const encodedSourceId = encodeSourceId(this.#sources.size);
-    const tileSourceOverrides = {
-      minzoom: 0,
-      maxzoom: 0,
-      bounds: (
-        /** @type {import('./utils/geo.js').BBox} */
-        [...import_geo.MAX_BOUNDS]
-      ),
-      tiles: (
-        /** @type {string[]} */
-        []
-      )
-    };
-    let smpSource;
-    switch (source.type) {
-      case "raster":
-      case "vector":
-        smpSource = {
-          ...(0, import_filter_obj.excludeKeys)(source, ["tiles", "url"]),
-          ...tileSourceOverrides
-        };
-        break;
-      case "geojson":
-        smpSource = {
-          ...source,
-          maxzoom: 0,
-          data: typeof source.data !== "string" ? (
-            // Add a bbox property to the GeoJSON data if it doesn't already have one
-            { ...source.data, bbox: source.data.bbox || (0, import_bbox.bbox)(source.data) }
-          ) : (
-            // If GeoJSON data is referenced by a URL, start with an empty FeatureCollection
-            {
-              type: "FeatureCollection",
-              features: [],
-              bbox: [0, 0, 0, 0]
-            }
-          )
-        };
-        break;
-    }
-    const sourceInfo = {
-      source: smpSource,
-      encodedSourceId
-    };
-    this.#sources.set(sourceId, sourceInfo);
-    return sourceInfo;
-  }
-  /**
-   * Add a tile to the styled map package
-   *
-   * @param {Source} tileData
-   * @param {TileInfo} opts
-   */
-  async addTile(tileData, { z, x, y, sourceId, format }) {
-    let sourceInfo = this.#sources.get(sourceId);
-    if (!sourceInfo) {
-      const source2 = this.#style.sources[sourceId];
-      if (!source2) {
-        throw new Error(`Source not referenced in style.json: ${sourceId}`);
-      }
-      if (source2.type !== "raster" && source2.type !== "vector") {
-        throw new Error(`Unsupported source type: ${source2.type}`);
-      }
-      sourceInfo = this.#addSource(sourceId, source2);
-    }
-    const { source, encodedSourceId } = sourceInfo;
-    if (source.type !== "raster" && source.type !== "vector") {
-      throw new Error(`Unsupported source type: ${source.type}`);
-    }
-    if (!format) {
-      ;
-      [format, tileData] = await (0, import_file_formats.getTileFormatFromStream)(toWebStream(tileData));
-    }
-    if (!sourceInfo.format) {
-      sourceInfo.format = format;
-    } else if (sourceInfo.format !== format) {
-      throw new Error(
-        `Tile format mismatch for source ${sourceId}: expected ${sourceInfo.format}, got ${format}`
-      );
-    }
-    const bbox2 = (0, import_geo.tileToBBox)({ z, x, y });
-    if (z > source.maxzoom) {
-      source.maxzoom = z;
-      source.bounds = bbox2;
-    } else if (z === source.maxzoom) {
-      source.bounds = (0, import_geo.unionBBox)([source.bounds, bbox2]);
-    }
-    const name = (0, import_templates.getTileFilename)({ sourceId: encodedSourceId, z, x, y, format });
-    if (this.#dedupe) {
-      const data = await toUint8Array(tileData);
-      const hash = await hashData(data);
-      if (this.#addedFiles.has(name)) {
-        throw new Error(`${name} already added`);
-      }
-      this.#addedFiles.add(name);
-      const existingName = this.#tileHashes.get(hash);
-      if (existingName) {
-        this.#duplicateEntries.push({ name, originalName: existingName });
-        return;
-      }
-      this.#tileHashes.set(hash, name);
-      const readable = toWebStream(data);
-      await this.#zipWriter.addEntry({ readable, name, store: true });
-      return;
-    }
-    return this.#append(tileData, { name, store: true });
-  }
-  /**
-   * Create a write stream for adding tiles to the styled map package
-   *
-   * @param {object} opts
-   * @param {number} [opts.concurrency=16] The number of concurrent writes
-   *
-   * @returns
-   */
-  createTileWriteStream({ concurrency = 16 } = {}) {
-    return (0, import_streams.writeStreamFromAsync)(this.addTile.bind(this), { concurrency });
-  }
-  /**
-   * Add a sprite to the styled map package
-   *
-   * @param {object} options
-   * @param {Source} options.json
-   * @param {Source} options.png
-   * @param {number} [options.pixelRatio]
-   * @param {string} [options.id='default']
-   * @returns {Promise<void>}
-   */
-  async addSprite({ json, png, pixelRatio = 1, id = "default" }) {
-    this.#addedSpriteIds.add(id);
-    const jsonName = (0, import_templates.getSpriteFilename)({ id, pixelRatio, ext: ".json" });
-    const pngName = (0, import_templates.getSpriteFilename)({ id, pixelRatio, ext: ".png" });
-    await Promise.all([
-      this.#append(json, { name: jsonName }),
-      this.#append(png, { name: pngName })
-    ]);
-  }
-  /**
-   * Add glyphs to the styled map package
-   *
-   * @param {Source} glyphData
-   * @param {GlyphInfo} glyphInfo
-   * @returns {Promise<void>}
-   */
-  addGlyphs(glyphData, { font: fontName, range }) {
-    this.#fonts.add(fontName);
-    const name = (0, import_templates.getGlyphFilename)({ fontstack: fontName, range });
-    return this.#append(glyphData, { name });
-  }
-  /**
-   * Create a write stream for adding glyphs to the styled map package
-   *
-   * @param {object} opts
-   * @param {number} [opts.concurrency=16] The number of concurrent writes
-   * @returns
-   */
-  createGlyphWriteStream({ concurrency = 16 } = {}) {
-    return (0, import_streams.writeStreamFromAsync)(this.addGlyphs.bind(this), { concurrency });
-  }
-  /**
-   * Finalize the styled map package and write the style to the archive.
-   * This method must be called to complete the archive.
-   * You must wait for your destination write stream to 'finish' before using the output.
-   */
-  async finish() {
-    await this.#append(import_templates.FORMAT_VERSION, { name: import_templates.VERSION_FILE });
-    this.#prepareStyle();
-    const style = JSON.stringify(this.#style);
-    await this.#append(style, { name: import_templates.STYLE_FILE });
-    let entries = await this.#zipWriter.entries();
-    if (this.#duplicateEntries.length > 0) {
-      const entriesByName = new Map(entries.map((e) => [e.name, e]));
-      for (const { name, originalName } of this.#duplicateEntries) {
-        const original = entriesByName.get(originalName);
-        if (!original) {
-          throw new Error(`Original entry ${originalName} not found`);
-        }
-        entries.push({ ...original, name });
-      }
-    }
-    const sortedEntries = sortEntries(entries);
-    await this.#zipWriter.finalize({ entries: sortedEntries });
-  }
-  /**
-   * Mutates the style object to prepare it for writing to the archive.
-   * Deterministic: can be run more than once with the same result.
-   */
-  #prepareStyle() {
-    if (this.#sources.size === 0) {
-      throw new Error("Missing sources: add at least one source");
-    }
-    if (this.#style.glyphs && this.#fonts.size === 0) {
-      throw new Error(
-        "Missing fonts: style references glyphs but no fonts added"
-      );
-    }
-    (0, import_style.replaceFontStacks)(this.#style, [...this.#fonts]);
-    if (this.#style.glyphs) {
-      this.#style.glyphs = import_templates.GLYPH_URI;
-    }
-    if (typeof this.#style.sprite === "string") {
-      if (!this.#addedSpriteIds.has("default")) {
-        throw new Error(
-          "Missing sprite: style references sprite but none added"
-        );
-      }
-      this.#style.sprite = (0, import_templates.getSpriteUri)();
-    } else if (Array.isArray(this.#style.sprite)) {
-      this.#style.sprite = this.#style.sprite.map(({ id }) => {
-        if (!this.#addedSpriteIds.has(id)) {
-          throw new Error(
-            `Missing sprite: style references sprite ${id} but none added`
-          );
-        }
-        return { id, url: (0, import_templates.getSpriteUri)(id) };
-      });
-    }
-    this.#style.sources = {};
-    for (const [sourceId, { source, encodedSourceId, format = "mvt" }] of this.#sources) {
-      if (source.type === "geojson" && isEmptyFeatureCollection(source.data)) {
-        continue;
-      }
-      this.#style.sources[sourceId] = source;
-      if (!("tiles" in source)) continue;
-      source.tiles = [(0, import_templates.getTileUri)({ sourceId: encodedSourceId, format })];
-    }
-    this.#style.layers = this.#style.layers.filter(
-      (layer) => !("source" in layer) || !!this.#style.sources[layer.source]
-    );
-    const metadata = this.#style.metadata || (this.#style.metadata = {});
-    const bounds = this.#getBounds();
-    if (bounds) {
-      metadata["smp:bounds"] = bounds;
-      const [w, s, e, n] = bounds;
-      this.#style.center = [w + (e - w) / 2, s + (n - s) / 2];
-    }
-    metadata["smp:maxzoom"] = this.#getMaxZoom();
-    metadata["smp:sourceFolders"] = {};
-    for (const [sourceId, { encodedSourceId }] of this.#sources) {
-      metadata["smp:sourceFolders"][sourceId] = encodedSourceId;
-    }
-    this.#style.zoom = Math.max(0, this.#getMaxZoom() - 2);
-  }
-  /**
-   *
-   * @param {Source} source
-   * @param {{ name: string, store?: boolean }} options
-   * @returns {Promise<void>}
-   */
-  async #append(source, { name, store = false }) {
-    if (this.#addedFiles.has(name)) {
-      throw new Error(`${name} already added`);
-    }
-    this.#addedFiles.add(name);
-    const readable = toWebStream(source);
-    await this.#zipWriter.addEntry({ readable, name, store });
-  }
-}
-function encodeSourceId(sourceIndex) {
-  return sourceIndex.toString(36);
-}
-function toWebStream(source) {
-  if (typeof source === "string") {
-    const bytes = new TextEncoder().encode(source);
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(bytes);
-        controller.close();
-      }
-    });
-  }
-  if (source instanceof Uint8Array) {
-    return new ReadableStream({
-      start(controller) {
-        controller.enqueue(
-          new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
-        );
-        controller.close();
-      }
-    });
-  }
-  return (
-    /** @type {ReadableStream<Uint8Array>} */
-    source
-  );
-}
-function isEmptyFeatureCollection(data) {
-  return data.type === "FeatureCollection" && data.features.length === 0;
-}
-function get2DBBox(bbox2) {
-  if (bbox2.length === 4) return bbox2;
-  return [bbox2[0], bbox2[1], bbox2[3], bbox2[4]];
-}
-async function toUint8Array(source) {
-  if (source instanceof Uint8Array) return source;
-  if (typeof source === "string") return new TextEncoder().encode(source);
-  const reader = (
-    /** @type {ReadableStream<Uint8Array>} */
-    source.getReader()
-  );
-  const chunks = [];
-  let totalLength = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-    totalLength += value.byteLength;
-  }
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return result;
-}
-async function hashData(data) {
-  let c = globalThis.crypto;
-  if (!c) {
-    c = (await import("node:crypto")).webcrypto;
-  }
-  const buf = await c.subtle.digest("SHA-256", data);
-  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function sortEntries(entries) {
-  return [...entries].sort((a, b) => {
-    if (a.name === import_templates.VERSION_FILE) return -1;
-    if (b.name === import_templates.VERSION_FILE) return 1;
-    if (a.name === import_templates.STYLE_FILE) return -1;
-    if (b.name === import_templates.STYLE_FILE) return 1;
-    const foldersA = a.name.split("/");
-    const foldersB = b.name.split("/");
-    const aIsFirst = foldersA[0] === import_templates.FONTS_FOLDER && foldersA[2] === "0-255.pbf.gz";
-    const bIsFirst = foldersB[0] === import_templates.FONTS_FOLDER && foldersB[2] === "0-255.pbf.gz";
-    if (aIsFirst && bIsFirst)
-      return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-    if (aIsFirst) return -1;
-    if (bIsFirst) return 1;
-    if (foldersA[0] === import_templates.SOURCES_FOLDER && foldersB[0] !== import_templates.SOURCES_FOLDER)
-      return -1;
-    if (foldersB[0] === import_templates.SOURCES_FOLDER && foldersA[0] !== import_templates.SOURCES_FOLDER)
-      return 1;
-    if (foldersA[0] === import_templates.SOURCES_FOLDER && foldersB[0] === import_templates.SOURCES_FOLDER) {
-      const zoomA = +foldersA[2];
-      const zoomB = +foldersB[2];
-      return zoomA - zoomB;
-    }
-    return 0;
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SUPPORTED_SOURCE_TYPES,
-  Writer
-});