styled-map-package 2.2.1 → 4.0.0

package/dist/tile-downloader.js

@@ -0,0 +1,126 @@
+import SphericalMercator from "@mapbox/sphericalmercator";
+import Queue from "yocto-queue";
+import zlib from "zlib";
+import { FetchQueue } from "./utils/fetch.js";
+import {
+  getFormatFromMimeType,
+  getTileFormatFromStream
+} from "./utils/file-formats.js";
+import { getTileUrl, MAX_BOUNDS } from "./utils/geo.js";
+import { noop } from "./utils/misc.js";
+function downloadTiles({
+  tileUrls,
+  bounds,
+  maxzoom,
+  onprogress = noop,
+  trackErrors = false,
+  sourceBounds = MAX_BOUNDS,
+  boundsBuffer = false,
+  minzoom = 0,
+  concurrency = 8,
+  fetchQueue = new FetchQueue(concurrency),
+  scheme = "xyz"
+}) {
+  const skipped = [];
+  let completed = 0;
+  let stats = {
+    total: 0,
+    downloaded: 0,
+    skipped: 0,
+    totalBytes: 0
+  };
+  function onDownloadProgress({ chunkBytes }) {
+    stats.totalBytes += chunkBytes;
+    onprogress(stats);
+  }
+  function onDownloadError(error, tileInfo) {
+    if (trackErrors) {
+      skipped.push({ ...tileInfo, error });
+    } else {
+      skipped.push(tileInfo);
+    }
+    onprogress(stats);
+  }
+  function onDownloadComplete() {
+    stats.downloaded = ++completed - skipped.length;
+    stats.skipped = skipped.length;
+    onprogress(stats);
+  }
+  const tiles = async function* () {
+    const queue = new Queue();
+    const tiles2 = tileIterator({
+      bounds,
+      minzoom,
+      maxzoom,
+      sourceBounds,
+      boundsBuffer
+    });
+    for (const { x, y, z } of tiles2) {
+      const tileURL = getTileUrl(tileUrls, { x, y, z, scheme });
+      const tileInfo = { z, x, y };
+      const result = fetchQueue.fetch(tileURL, { onprogress: onDownloadProgress }).catch((err) => onDownloadError(err, tileInfo));
+      queue.enqueue([result, tileInfo]);
+    }
+    stats.total = queue.size;
+    if (onprogress) onprogress(stats);
+    for (const [result, tileInfo] of queue) {
+      const downloadResponse = await result.catch(noop);
+      if (!downloadResponse) continue;
+      let { body, mimeType } = downloadResponse;
+      body.on("end", onDownloadComplete);
+      body.on("error", (err) => onDownloadError(err, tileInfo));
+      let format;
+      if (mimeType) {
+        format = getFormatFromMimeType(mimeType);
+      } else {
+        ;
+        [format, body] = await getTileFormatFromStream(body);
+      }
+      let stream = body;
+      if (format === "mvt") {
+        const gzipStream = zlib.createGzip();
+        stream = body.pipe(gzipStream);
+        stream.on("error", (err) => gzipStream.destroy(err));
+      }
+      yield [stream, { ...tileInfo, format }];
+    }
+  }();
+  Object.defineProperty(tiles, "skipped", {
+    get() {
+      return skipped;
+    }
+  });
+  Object.defineProperty(tiles, "stats", {
+    get() {
+      return stats;
+    }
+  });
+  return tiles;
+}
+function* tileIterator({
+  bounds = [...MAX_BOUNDS],
+  minzoom = 0,
+  maxzoom,
+  sourceBounds,
+  boundsBuffer = false
+}) {
+  const sm = new SphericalMercator({ size: 256 });
+  for (let z = minzoom; z <= maxzoom; z++) {
+    let { minX, minY, maxX, maxY } = sm.xyz([...bounds], z);
+    let sourceXYBounds = sourceBounds ? sm.xyz([...sourceBounds], z) : { minX, minY, maxX, maxY };
+    const buffer = boundsBuffer ? 1 : 0;
+    minX = Math.max(0, minX - buffer, sourceXYBounds.minX);
+    minY = Math.max(0, minY - buffer, sourceXYBounds.minY);
+    maxX = Math.min(Math.pow(2, z) - 1, maxX + buffer, sourceXYBounds.maxX);
+    maxY = Math.min(Math.pow(2, z) - 1, maxY + buffer, sourceXYBounds.maxY);
+    for (let x = minX; x <= maxX; x++) {
+      for (let y = minY; y <= maxY; y++) {
+        yield { x, y, z };
+      }
+    }
+  }
+}
+export {
+  downloadTiles,
+  tileIterator
+};

package/dist/{lib/writer.d.ts → types-B4Xn1F9K.d.cts}

@@ -1,3 +1,11 @@
+import { SourceSpecification, GeoJSONSourceSpecification, VectorSourceSpecification, RasterSourceSpecification, RasterDEMSourceSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import { GeoJSON, BBox } from 'geojson';
+import * as stream from 'stream';
+import { Readable } from 'stream';
+import { SetRequired } from 'type-fest';
+import * as readable_stream from 'readable-stream';
+import { EventEmitter } from 'events';
+
 /** @typedef {string | Buffer | Uint8Array | import('stream').Readable } Source */
 /** @typedef {string | Buffer | import('stream').Readable} SourceInternal */
 /** @typedef {`${number}-${number}`} GlyphRange */
@@ -23,14 +31,14 @@
  */
 /** @import { StyleSpecification } from '@maplibre/maplibre-gl-style-spec' */
 /** @import { InputSource, SMPSource } from './types.js' */
-export const SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
+declare const SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
 /**
  * Write a styled map package to a stream. Stream `writer.outputStream` to a
  * destination, e.g. `fs.createWriteStream('my-map.styledmap')`. You must call
  * `witer.finish()` and then wait for your writable stream to `finish` before
  * using the output.
  */
-export default class Writer extends EventEmitter<[never]> {
+declare class Writer extends EventEmitter<[never]> {
     static SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
     /**
      * @param {any} style A v7 or v8 MapLibre style. v7 styles will be migrated to
@@ -45,7 +53,7 @@ export default class Writer extends EventEmitter<[never]> {
     /**
      * @returns {import('stream').Readable} Readable stream of the styled map package
      */
-    get outputStream(): import("stream").Readable;
+    get outputStream(): stream.Readable;
     /**
      * Add a tile to the styled map package
      *
@@ -63,7 +71,7 @@ export default class Writer extends EventEmitter<[never]> {
      */
     createTileWriteStream({ concurrency }?: {
         concurrency?: number | undefined;
-    }): import("readable-stream").Writable;
+    }): readable_stream.Writable;
     /**
      * Add a sprite to the styled map package
      *
@@ -97,7 +105,7 @@ export default class Writer extends EventEmitter<[never]> {
      */
     createGlyphWriteStream({ concurrency }?: {
         concurrency?: number | undefined;
-    }): import("readable-stream").Writable;
+    }): readable_stream.Writable;
     /**
      * Finalize the styled map package and write the style to the archive.
      * This method must be called to complete the archive.
@@ -106,24 +114,76 @@ export default class Writer extends EventEmitter<[never]> {
     finish(): void;
     #private;
 }
-export type Source = string | Buffer | Uint8Array | import("stream").Readable;
-export type SourceInternal = string | Buffer | import("stream").Readable;
-export type GlyphRange = `${number}-${number}`;
-export type TileFormat = "png" | "mvt" | "jpg" | "webp";
-export type SourceInfo = {
-    source: import("./types.js").SMPSource;
+type Source = string | Buffer | Uint8Array | stream.Readable;
+type SourceInternal = string | Buffer | stream.Readable;
+type GlyphRange = `${number}-${number}`;
+type TileFormat = "png" | "mvt" | "jpg" | "webp";
+type SourceInfo = {
+    source: SMPSource;
     encodedSourceId: string;
     format?: TileFormat | undefined;
 };
-export type TileInfo = {
+type TileInfo = {
     z: number;
     x: number;
     y: number;
     sourceId: string;
     format?: TileFormat | undefined;
 };
-export type GlyphInfo = {
+type GlyphInfo = {
     font: string;
     range: GlyphRange;
 };
-import { EventEmitter } from 'events';
+
+type TransformInlinedSource<T extends SourceSpecification> = T extends GeoJSONSourceSpecification ? OmitUnion<T, 'data'> & {
+    data: GeoJSON;
+} : T extends VectorSourceSpecification | RasterSourceSpecification | RasterDEMSourceSpecification ? SetRequired<OmitUnion<T, 'url'>, 'tiles'> : T;
+/**
+ * This is a slightly stricter version of SourceSpecification that requires
+ * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
+ */
+type InlinedSource = TransformInlinedSource<SourceSpecification>;
+type SupportedInlinedSource = Extract<InlinedSource, {
+    type: (typeof SUPPORTED_SOURCE_TYPES)[number];
+}>;
+/**
+ * This is a slightly stricter version of StyleSpecification that requires
+ * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
+ */
+type StyleInlinedSources = Omit<StyleSpecification, 'sources'> & {
+    sources: {
+        [_: string]: InlinedSource;
+    };
+};
+type SMPSource = TransformSMPInputSource<SupportedInlinedSource>;
+/**
+ * This is a slightly stricter version of StyleSpecification that is provided in
+ * a Styled Map Package. Tile sources must have tile URLs inlined (they cannot
+ * refer to a TileJSON url), and they must have bounds, minzoom, and maxzoom.
+ * GeoJSON sources must have inlined GeoJSON (not a URL to a GeoJSON file).
+ */
+type SMPStyle = TransformSMPStyle<StyleSpecification>;
+type TransformSMPInputSource<T extends SupportedInlinedSource> = T extends GeoJSONSourceSpecification ? T & {
+    data: {
+        bbox: BBox;
+    };
+} : T extends RasterSourceSpecification | VectorSourceSpecification ? SetRequired<T, 'bounds' | 'minzoom' | 'maxzoom'> : T;
+type TransformSMPStyle<T extends StyleSpecification> = Omit<T, 'sources'> & {
+    metadata: {
+        'smp:bounds': [number, number, number, number];
+        'smp:maxzoom': 0;
+        'smp:sourceFolders': {
+            [_: string]: string;
+        };
+    };
+    sources: {
+        [_: string]: SMPSource;
+    };
+};
+interface DownloadStream extends Readable {
+    iterator(...args: Parameters<Readable['iterator']>): AsyncIterableIterator<Buffer>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Buffer>;
+}
+type OmitUnion<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never;
+
+export { type DownloadStream as D, type GlyphInfo as G, type InlinedSource as I, type SMPSource as S, type TileInfo as T, Writer as W, type SMPStyle as a, type StyleInlinedSources as b, type TileFormat as c, type GlyphRange as d, SUPPORTED_SOURCE_TYPES as e, type Source as f, type SourceInternal as g, type SourceInfo as h };

package/dist/types-B4Xn1F9K.d.ts

@@ -0,0 +1,189 @@
+import { SourceSpecification, GeoJSONSourceSpecification, VectorSourceSpecification, RasterSourceSpecification, RasterDEMSourceSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import { GeoJSON, BBox } from 'geojson';
+import * as stream from 'stream';
+import { Readable } from 'stream';
+import { SetRequired } from 'type-fest';
+import * as readable_stream from 'readable-stream';
+import { EventEmitter } from 'events';
+
+/** @typedef {string | Buffer | Uint8Array | import('stream').Readable } Source */
+/** @typedef {string | Buffer | import('stream').Readable} SourceInternal */
+/** @typedef {`${number}-${number}`} GlyphRange */
+/** @typedef {'png' | 'mvt' | 'jpg' | 'webp'} TileFormat */
+/**
+ * @typedef {object} SourceInfo
+ * @property {import('./types.js').SMPSource} source
+ * @property {string} encodedSourceId
+ * @property {TileFormat} [format]
+ */
+/**
+ * @typedef {object} TileInfo
+ * @property {number} z
+ * @property {number} x
+ * @property {number} y
+ * @property {string} sourceId
+ * @property {TileFormat} [format]
+ */
+/**
+ * @typedef {object} GlyphInfo
+ * @property {string} font
+ * @property {GlyphRange} range
+ */
+/** @import { StyleSpecification } from '@maplibre/maplibre-gl-style-spec' */
+/** @import { InputSource, SMPSource } from './types.js' */
+declare const SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
+/**
+ * Write a styled map package to a stream. Stream `writer.outputStream` to a
+ * destination, e.g. `fs.createWriteStream('my-map.styledmap')`. You must call
+ * `witer.finish()` and then wait for your writable stream to `finish` before
+ * using the output.
+ */
+declare class Writer extends EventEmitter<[never]> {
+    static SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
+    /**
+     * @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 {object} opts
+     * @param {number} [opts.highWaterMark=1048576] The maximum number of bytes to buffer during write
+     */
+    constructor(style: any, { highWaterMark }?: {
+        highWaterMark?: number | undefined;
+    });
+    /**
+     * @returns {import('stream').Readable} Readable stream of the styled map package
+     */
+    get outputStream(): stream.Readable;
+    /**
+     * Add a tile to the styled map package
+     *
+     * @param {Source} tileData
+     * @param {TileInfo} opts
+     */
+    addTile(tileData: Source, { z, x, y, sourceId, format }: TileInfo): Promise<void>;
+    /**
+     * 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 }?: {
+        concurrency?: number | undefined;
+    }): readable_stream.Writable;
+    /**
+     * 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>}
+     */
+    addSprite({ json, png, pixelRatio, id }: {
+        json: Source;
+        png: Source;
+        pixelRatio?: number | undefined;
+        id?: string | undefined;
+    }): Promise<void>;
+    /**
+     * Add glyphs to the styled map package
+     *
+     * @param {Source} glyphData
+     * @param {GlyphInfo} glyphInfo
+     * @returns {Promise<void>}
+     */
+    addGlyphs(glyphData: Source, { font: fontName, range }: GlyphInfo): Promise<void>;
+    /**
+     * 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 }?: {
+        concurrency?: number | undefined;
+    }): readable_stream.Writable;
+    /**
+     * 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.
+     */
+    finish(): void;
+    #private;
+}
+type Source = string | Buffer | Uint8Array | stream.Readable;
+type SourceInternal = string | Buffer | stream.Readable;
+type GlyphRange = `${number}-${number}`;
+type TileFormat = "png" | "mvt" | "jpg" | "webp";
+type SourceInfo = {
+    source: SMPSource;
+    encodedSourceId: string;
+    format?: TileFormat | undefined;
+};
+type TileInfo = {
+    z: number;
+    x: number;
+    y: number;
+    sourceId: string;
+    format?: TileFormat | undefined;
+};
+type GlyphInfo = {
+    font: string;
+    range: GlyphRange;
+};
+
+type TransformInlinedSource<T extends SourceSpecification> = T extends GeoJSONSourceSpecification ? OmitUnion<T, 'data'> & {
+    data: GeoJSON;
+} : T extends VectorSourceSpecification | RasterSourceSpecification | RasterDEMSourceSpecification ? SetRequired<OmitUnion<T, 'url'>, 'tiles'> : T;
+/**
+ * This is a slightly stricter version of SourceSpecification that requires
+ * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
+ */
+type InlinedSource = TransformInlinedSource<SourceSpecification>;
+type SupportedInlinedSource = Extract<InlinedSource, {
+    type: (typeof SUPPORTED_SOURCE_TYPES)[number];
+}>;
+/**
+ * This is a slightly stricter version of StyleSpecification that requires
+ * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
+ */
+type StyleInlinedSources = Omit<StyleSpecification, 'sources'> & {
+    sources: {
+        [_: string]: InlinedSource;
+    };
+};
+type SMPSource = TransformSMPInputSource<SupportedInlinedSource>;
+/**
+ * This is a slightly stricter version of StyleSpecification that is provided in
+ * a Styled Map Package. Tile sources must have tile URLs inlined (they cannot
+ * refer to a TileJSON url), and they must have bounds, minzoom, and maxzoom.
+ * GeoJSON sources must have inlined GeoJSON (not a URL to a GeoJSON file).
+ */
+type SMPStyle = TransformSMPStyle<StyleSpecification>;
+type TransformSMPInputSource<T extends SupportedInlinedSource> = T extends GeoJSONSourceSpecification ? T & {
+    data: {
+        bbox: BBox;
+    };
+} : T extends RasterSourceSpecification | VectorSourceSpecification ? SetRequired<T, 'bounds' | 'minzoom' | 'maxzoom'> : T;
+type TransformSMPStyle<T extends StyleSpecification> = Omit<T, 'sources'> & {
+    metadata: {
+        'smp:bounds': [number, number, number, number];
+        'smp:maxzoom': 0;
+        'smp:sourceFolders': {
+            [_: string]: string;
+        };
+    };
+    sources: {
+        [_: string]: SMPSource;
+    };
+};
+interface DownloadStream extends Readable {
+    iterator(...args: Parameters<Readable['iterator']>): AsyncIterableIterator<Buffer>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Buffer>;
+}
+type OmitUnion<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never;
+
+export { type DownloadStream as D, type GlyphInfo as G, type InlinedSource as I, type SMPSource as S, type TileInfo as T, Writer as W, type SMPStyle as a, type StyleInlinedSources as b, type TileFormat as c, type GlyphRange as d, SUPPORTED_SOURCE_TYPES as e, type Source as f, type SourceInternal as g, type SourceInfo as h };

package/dist/utils/errors.cjs

@@ -0,0 +1,41 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  ENOENT: () => ENOENT,
+  isFileNotThereError: () => isFileNotThereError
+});
+module.exports = __toCommonJS(errors_exports);
+class ENOENT extends Error {
+  code = "ENOENT";
+  /** @param {string} path */
+  constructor(path) {
+    const message = `ENOENT: no such file or directory, open '${path}'`;
+    super(message);
+    this.path = path;
+  }
+}
+function isFileNotThereError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EPERM");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENOENT,
+  isFileNotThereError
+});

package/dist/utils/errors.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the error if because a file is not found. On Windows, some
+ * operations like fs.watch() throw an EPERM error rather than ENOENT.
+ *
+ * @param {unknown} error
+ * @returns {error is Error & { code: 'ENOENT' | 'EPERM' }}
+ */
+declare function isFileNotThereError(error: unknown): error is Error & {
+    code: "ENOENT" | "EPERM";
+};
+declare class ENOENT extends Error {
+    /** @param {string} path */
+    constructor(path: string);
+    code: string;
+    path: string;
+}
+
+export { ENOENT, isFileNotThereError };

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

@@ -5,12 +5,14 @@
  * @param {unknown} error
  * @returns {error is Error & { code: 'ENOENT' | 'EPERM' }}
  */
-export function isFileNotThereError(error: unknown): error is Error & {
+declare function isFileNotThereError(error: unknown): error is Error & {
     code: "ENOENT" | "EPERM";
 };
-export class ENOENT extends Error {
+declare class ENOENT extends Error {
     /** @param {string} path */
     constructor(path: string);
     code: string;
     path: string;
 }
+
+export { ENOENT, isFileNotThereError };

package/dist/utils/errors.js

@@ -0,0 +1,16 @@
+class ENOENT extends Error {
+  code = "ENOENT";
+  /** @param {string} path */
+  constructor(path) {
+    const message = `ENOENT: no such file or directory, open '${path}'`;
+    super(message);
+    this.path = path;
+  }
+}
+function isFileNotThereError(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EPERM");
+}
+export {
+  ENOENT,
+  isFileNotThereError
+};

package/dist/utils/fetch.cjs

@@ -0,0 +1,96 @@
+"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 fetch_exports = {};
+__export(fetch_exports, {
+  FetchQueue: () => FetchQueue
+});
+module.exports = __toCommonJS(fetch_exports);
+var import_ky = __toESM(require("ky"), 1);
+var import_p_event = require("p-event");
+var import_p_limit = __toESM(require("p-limit"), 1);
+var import_streams = require('./streams.cjs');
+class FetchQueue {
+  /** @type {import('p-limit').LimitFunction} */
+  #limit;
+  /** @param {number} concurrency */
+  constructor(concurrency) {
+    this.#limit = (0, import_p_limit.default)(concurrency);
+  }
+  get activeCount() {
+    return this.#limit.activeCount;
+  }
+  /**
+   * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+   * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+   * with `body` as a Node readable stream, and the MIME type and content length
+   * of the response.
+   *
+   * NB: The response body stream must be consumed to the end, otherwise the
+   * queue will never be emptied.
+   *
+   * @param {string} url
+   * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+   * @returns {Promise<DownloadResponse>}
+   */
+  fetch(url, { onprogress } = {}) {
+    return new Promise((resolveResponse, rejectResponse) => {
+      this.#limit(fetchStream, {
+        url,
+        onresponse: resolveResponse,
+        onerror: rejectResponse,
+        onprogress
+      });
+    });
+  }
+}
+async function fetchStream({ url, onresponse, onerror, onprogress }) {
+  try {
+    const response = await (0, import_ky.default)(url, { retry: 3 });
+    if (!response.body) {
+      throw new Error("No body in response");
+    }
+    const body = (0, import_streams.fromWebReadableStream)(response.body);
+    const contentType = response.headers.get("content-type");
+    const mimeType = typeof contentType === "string" ? contentType.split(";")[0] : null;
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader === null ? null : parseInt(contentLengthHeader, 10);
+    onresponse({
+      body: onprogress ? body.pipe(new import_streams.ProgressStream({ onprogress })) : body,
+      mimeType,
+      contentLength
+    });
+    await (0, import_p_event.pEvent)(body, "end");
+  } catch (err) {
+    onerror(err instanceof Error ? err : new Error("Unknown error"));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FetchQueue
+});