styled-map-package 2.2.1 → 3.0.0

package/dist/utils/mapbox.cjs

@@ -0,0 +1,121 @@
+"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 mapbox_exports = {};
+__export(mapbox_exports, {
+  API_URL: () => API_URL,
+  isMapboxURL: () => isMapboxURL,
+  normalizeGlyphsURL: () => normalizeGlyphsURL,
+  normalizeSourceURL: () => normalizeSourceURL,
+  normalizeSpriteURL: () => normalizeSpriteURL,
+  normalizeStyleURL: () => normalizeStyleURL,
+  normalizeTileURL: () => normalizeTileURL
+});
+module.exports = __toCommonJS(mapbox_exports);
+const API_URL = "https://api.mapbox.com";
+const HELP = "See https://www.mapbox.com/api-documentation/#access-tokens";
+function makeAPIURL(urlObject, accessToken) {
+  const apiUrlObject = parseUrl(API_URL);
+  urlObject.protocol = apiUrlObject.protocol;
+  urlObject.authority = apiUrlObject.authority;
+  if (!accessToken) {
+    throw new Error(
+      `An API access token is required to use a Mapbox style. ${HELP}`
+    );
+  }
+  if (accessToken[0] === "s") {
+    throw new Error(
+      `Use a public access token (pk.*) not a secret access token (sk.*). ${HELP}`
+    );
+  }
+  urlObject.params.push(`access_token=${accessToken}`);
+  return formatUrl(urlObject);
+}
+function isMapboxURL(url) {
+  return url.indexOf("mapbox:") === 0;
+}
+function normalizeStyleURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/styles/v1${urlObject.path}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeGlyphsURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/fonts/v1${urlObject.path}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeSourceURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/v4/${urlObject.authority}.json`;
+  urlObject.params.push("secure");
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeSpriteURL(url, format, extension, accessToken) {
+  const urlObject = parseUrl(url);
+  if (!isMapboxURL(url)) {
+    urlObject.path += `${format}${extension}`;
+    return formatUrl(urlObject);
+  }
+  urlObject.path = `/styles/v1${urlObject.path}/sprite${format}${extension}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+const imageExtensionRe = /(\.(png|jpg)\d*)(?=$)/;
+function normalizeTileURL(tileURL, sourceURL, tileSize, { devicePixelRatio = 1, supportsWebp = false } = {}) {
+  if (!sourceURL || !isMapboxURL(sourceURL)) return tileURL;
+  const urlObject = parseUrl(tileURL);
+  const suffix = devicePixelRatio >= 2 || tileSize === 512 ? "@2x" : "";
+  const extension = supportsWebp ? ".webp" : "$1";
+  urlObject.path = urlObject.path.replace(
+    imageExtensionRe,
+    `${suffix}${extension}`
+  );
+  return formatUrl(urlObject);
+}
+const urlRe = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+function parseUrl(url) {
+  const parts = url.match(urlRe);
+  if (!parts) {
+    throw new Error("Unable to parse URL object");
+  }
+  return {
+    protocol: parts[1],
+    authority: parts[2],
+    path: parts[3] || "/",
+    params: parts[4] ? parts[4].split("&") : []
+  };
+}
+function formatUrl(obj) {
+  const params = obj.params.length ? `?${obj.params.join("&")}` : "";
+  return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_URL,
+  isMapboxURL,
+  normalizeGlyphsURL,
+  normalizeSourceURL,
+  normalizeSpriteURL,
+  normalizeStyleURL,
+  normalizeTileURL
+});

package/dist/utils/mapbox.d.cts

@@ -0,0 +1,43 @@
+/** @param {string} url */
+declare function isMapboxURL(url: string): boolean;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeStyleURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeGlyphsURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeSourceURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {'' | '@2x'} format
+ * @param {'.png' | '.json'} extension
+ * @param {string} [accessToken]
+ */
+declare function normalizeSpriteURL(url: string, format: "" | "@2x", extension: ".png" | ".json", accessToken?: string): string;
+/**
+ * @param {any} tileURL
+ * @param {string} sourceURL
+ * @param {256 | 512} [tileSize]
+ * @param {{ devicePixelRatio?: number; supportsWebp?: boolean; }} [opts]
+ */
+declare function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
+    devicePixelRatio?: number;
+    supportsWebp?: boolean;
+}): any;
+declare const API_URL: "https://api.mapbox.com";
+type URLObject = {
+    protocol: string;
+    authority: string;
+    path: string;
+    params: string[];
+};
+
+export { API_URL, type URLObject, isMapboxURL, normalizeGlyphsURL, normalizeSourceURL, normalizeSpriteURL, normalizeStyleURL, normalizeTileURL };

package/dist/utils/mapbox.d.ts

@@ -0,0 +1,43 @@
+/** @param {string} url */
+declare function isMapboxURL(url: string): boolean;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeStyleURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeGlyphsURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {string} [accessToken]
+ */
+declare function normalizeSourceURL(url: string, accessToken?: string): string;
+/**
+ * @param {string} url
+ * @param {'' | '@2x'} format
+ * @param {'.png' | '.json'} extension
+ * @param {string} [accessToken]
+ */
+declare function normalizeSpriteURL(url: string, format: "" | "@2x", extension: ".png" | ".json", accessToken?: string): string;
+/**
+ * @param {any} tileURL
+ * @param {string} sourceURL
+ * @param {256 | 512} [tileSize]
+ * @param {{ devicePixelRatio?: number; supportsWebp?: boolean; }} [opts]
+ */
+declare function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
+    devicePixelRatio?: number;
+    supportsWebp?: boolean;
+}): any;
+declare const API_URL: "https://api.mapbox.com";
+type URLObject = {
+    protocol: string;
+    authority: string;
+    path: string;
+    params: string[];
+};
+
+export { API_URL, type URLObject, isMapboxURL, normalizeGlyphsURL, normalizeSourceURL, normalizeSpriteURL, normalizeStyleURL, normalizeTileURL };

package/dist/utils/mapbox.js

@@ -0,0 +1,91 @@
+const API_URL = "https://api.mapbox.com";
+const HELP = "See https://www.mapbox.com/api-documentation/#access-tokens";
+function makeAPIURL(urlObject, accessToken) {
+  const apiUrlObject = parseUrl(API_URL);
+  urlObject.protocol = apiUrlObject.protocol;
+  urlObject.authority = apiUrlObject.authority;
+  if (!accessToken) {
+    throw new Error(
+      `An API access token is required to use a Mapbox style. ${HELP}`
+    );
+  }
+  if (accessToken[0] === "s") {
+    throw new Error(
+      `Use a public access token (pk.*) not a secret access token (sk.*). ${HELP}`
+    );
+  }
+  urlObject.params.push(`access_token=${accessToken}`);
+  return formatUrl(urlObject);
+}
+function isMapboxURL(url) {
+  return url.indexOf("mapbox:") === 0;
+}
+function normalizeStyleURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/styles/v1${urlObject.path}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeGlyphsURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/fonts/v1${urlObject.path}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeSourceURL(url, accessToken) {
+  if (!isMapboxURL(url)) return url;
+  if (!accessToken) throw new Error("Mapbox styles require an access token");
+  const urlObject = parseUrl(url);
+  urlObject.path = `/v4/${urlObject.authority}.json`;
+  urlObject.params.push("secure");
+  return makeAPIURL(urlObject, accessToken);
+}
+function normalizeSpriteURL(url, format, extension, accessToken) {
+  const urlObject = parseUrl(url);
+  if (!isMapboxURL(url)) {
+    urlObject.path += `${format}${extension}`;
+    return formatUrl(urlObject);
+  }
+  urlObject.path = `/styles/v1${urlObject.path}/sprite${format}${extension}`;
+  return makeAPIURL(urlObject, accessToken);
+}
+const imageExtensionRe = /(\.(png|jpg)\d*)(?=$)/;
+function normalizeTileURL(tileURL, sourceURL, tileSize, { devicePixelRatio = 1, supportsWebp = false } = {}) {
+  if (!sourceURL || !isMapboxURL(sourceURL)) return tileURL;
+  const urlObject = parseUrl(tileURL);
+  const suffix = devicePixelRatio >= 2 || tileSize === 512 ? "@2x" : "";
+  const extension = supportsWebp ? ".webp" : "$1";
+  urlObject.path = urlObject.path.replace(
+    imageExtensionRe,
+    `${suffix}${extension}`
+  );
+  return formatUrl(urlObject);
+}
+const urlRe = /^(\w+):\/\/([^/?]*)(\/[^?]+)?\??(.+)?/;
+function parseUrl(url) {
+  const parts = url.match(urlRe);
+  if (!parts) {
+    throw new Error("Unable to parse URL object");
+  }
+  return {
+    protocol: parts[1],
+    authority: parts[2],
+    path: parts[3] || "/",
+    params: parts[4] ? parts[4].split("&") : []
+  };
+}
+function formatUrl(obj) {
+  const params = obj.params.length ? `?${obj.params.join("&")}` : "";
+  return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
+}
+export {
+  API_URL,
+  isMapboxURL,
+  normalizeGlyphsURL,
+  normalizeSourceURL,
+  normalizeSpriteURL,
+  normalizeStyleURL,
+  normalizeTileURL
+};

package/dist/utils/misc.cjs

@@ -0,0 +1,39 @@
+"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 misc_exports = {};
+__export(misc_exports, {
+  clone: () => clone,
+  hasOwn: () => hasOwn,
+  noop: () => noop
+});
+module.exports = __toCommonJS(misc_exports);
+function clone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function noop() {
+}
+function hasOwn(obj, key) {
+  return Object.hasOwn(obj, key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clone,
+  hasOwn,
+  noop
+});

package/{lib/utils/misc.js → dist/utils/misc.d.cts}

@@ -7,12 +7,8 @@
  * @param {T} obj
  * @returns {T}
  */
-export function clone(obj) {
-  return JSON.parse(JSON.stringify(obj))
-}
-
-export function noop() {}
-
+declare function clone<T>(obj: T): T;
+declare function noop(): void;
 /**
  * Like `Object.hasOwn`, but refines the type of `key`.
  *
@@ -21,6 +17,6 @@ export function noop() {}
  * @param {string} key
  * @returns {key is (keyof T)}
  */
-export function hasOwn(obj, key) {
-  return Object.hasOwn(obj, key)
-}
+declare function hasOwn<T extends Record<string, unknown>>(obj: T, key: string): key is (keyof T);
+
+export { clone, hasOwn, noop };

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

@@ -7,8 +7,8 @@
  * @param {T} obj
  * @returns {T}
  */
-export function clone<T>(obj: T): T;
-export function noop(): void;
+declare function clone<T>(obj: T): T;
+declare function noop(): void;
 /**
  * Like `Object.hasOwn`, but refines the type of `key`.
  *
@@ -17,4 +17,6 @@ export function noop(): void;
  * @param {string} key
  * @returns {key is (keyof T)}
  */
-export function hasOwn<T extends Record<string, unknown>>(obj: T, key: string): key is (keyof T);
+declare function hasOwn<T extends Record<string, unknown>>(obj: T, key: string): key is (keyof T);
+
+export { clone, hasOwn, noop };

package/dist/utils/misc.js

@@ -0,0 +1,13 @@
+function clone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function noop() {
+}
+function hasOwn(obj, key) {
+  return Object.hasOwn(obj, key);
+}
+export {
+  clone,
+  hasOwn,
+  noop
+};

package/dist/utils/streams.cjs

@@ -0,0 +1,130 @@
+"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 streams_exports = {};
+__export(streams_exports, {
+  ProgressStream: () => ProgressStream,
+  fromWebReadableStream: () => fromWebReadableStream,
+  isWebReadableStream: () => isWebReadableStream,
+  writeStreamFromAsync: () => writeStreamFromAsync
+});
+module.exports = __toCommonJS(streams_exports);
+var import_readable_stream = require("readable-stream");
+function writeStreamFromAsync(fn, { concurrency = 16 } = {}) {
+  return new import_readable_stream.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 import_readable_stream.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 import_readable_stream.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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProgressStream,
+  fromWebReadableStream,
+  isWebReadableStream,
+  writeStreamFromAsync
+});

package/dist/utils/streams.d.cts

@@ -0,0 +1,73 @@
+import * as stream from 'stream';
+import * as readable_stream from 'readable-stream';
+import { Transform, TransformOptions } from 'readable-stream';
+
+/** @import { TransformOptions } from 'readable-stream' */
+/**
+ * Create a writable stream from an async function. Default concurrecy is 16 -
+ * this is the number of parallel functions that will be pending before
+ * backpressure is applied on the stream.
+ *
+ * @template {(...args: any[]) => Promise<void>} T
+ * @param {T} fn
+ * @returns {import('readable-stream').Writable}
+ */
+declare function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>>(fn: T, { concurrency }?: {
+    concurrency?: number | undefined;
+}): readable_stream.Writable;
+/**
+ * From https://github.com/nodejs/node/blob/430c0269/lib/internal/webstreams/adapters.js#L509
+ *
+ * @param {ReadableStream} readableStream
+ * @param {{
+ *   highWaterMark? : number,
+ *   encoding? : string,
+ *   objectMode? : boolean,
+ *   signal? : AbortSignal,
+ * }} [options]
+ * @returns {import('stream').Readable}
+ */
+declare function fromWebReadableStream(readableStream: ReadableStream, options?: {
+    highWaterMark?: number;
+    encoding?: string;
+    objectMode?: boolean;
+    signal?: AbortSignal;
+}): stream.Readable;
+/**
+ * @param {unknown} obj
+ * @returns {obj is ReadableStream}
+ */
+declare function isWebReadableStream(obj: unknown): obj is ReadableStream;
+/** @typedef {(opts: { totalBytes: number, chunkBytes: number }) => void} ProgressCallback */
+/** @typedef {TransformOptions & { onprogress?: ProgressCallback }} ProgressStreamOptions */
+/**
+ * Passthrough stream that counts the bytes passing through it. Pass an optional
+ * `onprogress` callback that will be called with the accumulated total byte
+ * count and the chunk byte count after each chunk.
+ * @extends {Transform}
+ */
+declare class ProgressStream extends Transform {
+    /**
+     * @param {ProgressStreamOptions} [opts]
+     */
+    constructor({ onprogress, ...opts }?: ProgressStreamOptions);
+    /** Total bytes that have passed through this stream */
+    get byteLength(): number;
+    /**
+     * @override
+     * @param {Buffer | Uint8Array} chunk
+     * @param {Parameters<Transform['_transform']>[1]} encoding
+     * @param {Parameters<Transform['_transform']>[2]} callback
+     */
+    override _transform(chunk: Buffer | Uint8Array, encoding: Parameters<Transform["_transform"]>[1], callback: Parameters<Transform["_transform"]>[2]): void;
+    #private;
+}
+type ProgressCallback = (opts: {
+    totalBytes: number;
+    chunkBytes: number;
+}) => void;
+type ProgressStreamOptions = TransformOptions & {
+    onprogress?: ProgressCallback;
+};
+
+export { type ProgressCallback, ProgressStream, type ProgressStreamOptions, fromWebReadableStream, isWebReadableStream, writeStreamFromAsync };

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

@@ -1,3 +1,7 @@
+import * as stream from 'stream';
+import * as readable_stream from 'readable-stream';
+import { Transform, TransformOptions } from 'readable-stream';
+
 /** @import { TransformOptions } from 'readable-stream' */
 /**
  * Create a writable stream from an async function. Default concurrecy is 16 -
@@ -8,9 +12,9 @@
  * @param {T} fn
  * @returns {import('readable-stream').Writable}
  */
-export function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>>(fn: T, { concurrency }?: {
+declare function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>>(fn: T, { concurrency }?: {
     concurrency?: number | undefined;
-}): import("readable-stream").Writable;
+}): readable_stream.Writable;
 /**
  * From https://github.com/nodejs/node/blob/430c0269/lib/internal/webstreams/adapters.js#L509
  *
@@ -23,17 +27,17 @@ export function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>
  * }} [options]
  * @returns {import('stream').Readable}
  */
-export function fromWebReadableStream(readableStream: ReadableStream, options?: {
+declare function fromWebReadableStream(readableStream: ReadableStream, options?: {
     highWaterMark?: number;
     encoding?: string;
     objectMode?: boolean;
     signal?: AbortSignal;
-}): import("stream").Readable;
+}): stream.Readable;
 /**
  * @param {unknown} obj
  * @returns {obj is ReadableStream}
  */
-export function isWebReadableStream(obj: unknown): obj is ReadableStream;
+declare function isWebReadableStream(obj: unknown): obj is ReadableStream;
 /** @typedef {(opts: { totalBytes: number, chunkBytes: number }) => void} ProgressCallback */
 /** @typedef {TransformOptions & { onprogress?: ProgressCallback }} ProgressStreamOptions */
 /**
@@ -42,7 +46,7 @@ export function isWebReadableStream(obj: unknown): obj is ReadableStream;
  * count and the chunk byte count after each chunk.
  * @extends {Transform}
  */
-export class ProgressStream extends Transform {
+declare class ProgressStream extends Transform {
     /**
      * @param {ProgressStreamOptions} [opts]
      */
@@ -58,12 +62,12 @@ export class ProgressStream extends Transform {
     override _transform(chunk: Buffer | Uint8Array, encoding: Parameters<Transform["_transform"]>[1], callback: Parameters<Transform["_transform"]>[2]): void;
     #private;
 }
-export type ProgressCallback = (opts: {
+type ProgressCallback = (opts: {
     totalBytes: number;
     chunkBytes: number;
 }) => void;
-export type ProgressStreamOptions = TransformOptions & {
+type ProgressStreamOptions = TransformOptions & {
     onprogress?: ProgressCallback;
 };
-import { Transform } from 'readable-stream';
-import type { TransformOptions } from 'readable-stream';
+
+export { type ProgressCallback, ProgressStream, type ProgressStreamOptions, fromWebReadableStream, isWebReadableStream, writeStreamFromAsync };