styled-map-package-api 5.0.0-pre.0

package/dist/tile-downloader.d.ts

@@ -0,0 +1,83 @@
+import { T as TileInfo$1 } from './types-CJq90eOB.js';
+import { BBox } from './utils/geo.js';
+import { FetchQueue } from './utils/fetch.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'events';
+import './utils/streams.js';
+import 'stream/web';
+
+/** @typedef {Omit<import('./writer.js').TileInfo, 'sourceId'>} TileInfo */
+/**
+ * @typedef {object} TileDownloadStats
+ * @property {number} total
+ * @property {number} downloaded
+ * @property {number} skipped
+ * @property {number} totalBytes
+ */
+/**
+ * Download tiles from a list of tile URLs within a bounding box and zoom range.
+ * Returns an async generator of tile data as readable streams and tile info objects.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.tileUrls Array of tile URL templates. Use `{x}`, `{y}`, `{z}` placeholders, and optional `{scheme}` placeholder which can be `xyz` or `tms`.
+ * @param {import('./utils/geo.js').BBox} opts.bounds Bounding box of the area to download
+ * @param {number} opts.maxzoom Maximum zoom level to download
+ * @param {(progress: TileDownloadStats) => void} [opts.onprogress] Callback to report download progress
+ * @param {boolean} [opts.trackErrors=false] Include errors in the returned array of skipped tiles - this has memory overhead so should only be used for debugging.
+ * @param {import('./utils/geo.js').BBox} [opts.sourceBounds=MAX_BOUNDS] Bounding box of source data.
+ * @param {boolean} [opts.boundsBuffer=false] Buffer the bounds by one tile at each zoom level to ensure no tiles are missed at the edges. With this set to false, in most instances the map will appear incomplete when viewed because the downloaded tiles at lower zoom levels will not cover the map view area.
+ * @param {number} [opts.minzoom=0] Minimum zoom level to download (for most cases this should be left as `0` - the size overhead is minimal, because each zoom level has 4x as many tiles)
+ * @param {number} [opts.concurrency=8] Number of concurrent downloads (ignored if `fetchQueue` is provided)
+ * @param {FetchQueue} [opts.fetchQueue=new FetchQueue(concurrency)] Optional fetch queue to use for downloading tiles
+ * @param {'xyz' | 'tms'} [opts.scheme='xyz'] Tile scheme to use for tile URLs
+ * @returns {AsyncGenerator<[ReadableStream<Uint8Array>, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
+ */
+declare function downloadTiles({ tileUrls, bounds, maxzoom, onprogress, trackErrors, sourceBounds, boundsBuffer, minzoom, concurrency, fetchQueue, scheme, }: {
+    tileUrls: string[];
+    bounds: BBox;
+    maxzoom: number;
+    onprogress?: ((progress: TileDownloadStats) => void) | undefined;
+    trackErrors?: boolean | undefined;
+    sourceBounds?: BBox | undefined;
+    boundsBuffer?: boolean | undefined;
+    minzoom?: number | undefined;
+    concurrency?: number | undefined;
+    fetchQueue?: FetchQueue | undefined;
+    scheme?: "xyz" | "tms" | undefined;
+}): AsyncGenerator<[ReadableStream<Uint8Array>, TileInfo]> & {
+    readonly skipped: Array<TileInfo & {
+        error?: Error;
+    }>;
+    readonly stats: TileDownloadStats;
+};
+/**
+ *
+ * @param {object} opts
+ * @param {import('./utils/geo.js').BBox} [opts.bounds]
+ * @param {import('./utils/geo.js').BBox} [opts.sourceBounds]
+ * @param {boolean} [opts.boundsBuffer]
+ * @param {number} [opts.minzoom]
+ * @param {number} opts.maxzoom
+ */
+declare function tileIterator({ bounds, minzoom, maxzoom, sourceBounds, boundsBuffer, }: {
+    bounds?: BBox | undefined;
+    sourceBounds?: BBox | undefined;
+    boundsBuffer?: boolean | undefined;
+    minzoom?: number | undefined;
+    maxzoom: number;
+}): Generator<{
+    x: number;
+    y: number;
+    z: number;
+}, void, unknown>;
+type TileInfo = Omit<TileInfo$1, "sourceId">;
+type TileDownloadStats = {
+    total: number;
+    downloaded: number;
+    skipped: number;
+    totalBytes: number;
+};
+
+export { type TileDownloadStats, type TileInfo, downloadTiles, tileIterator };

package/dist/tile-downloader.js

@@ -0,0 +1,124 @@
+import SphericalMercator from "@mapbox/sphericalmercator";
+import Queue from "yocto-queue";
+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;
+      let format;
+      if (mimeType) {
+        format = getFormatFromMimeType(mimeType);
+      } else {
+        ;
+        [format, body] = await getTileFormatFromStream(body);
+      }
+      let stream = body;
+      const transform = (
+        /** @type {TransformStream<Uint8Array, Uint8Array>} */
+        format === "mvt" ? new CompressionStream("gzip") : new TransformStream()
+      );
+      body.pipeTo(transform.writable).then(onDownloadComplete, (err) => onDownloadError(err, tileInfo));
+      stream = transform.readable;
+      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/types-CJq90eOB.d.cts

@@ -0,0 +1,184 @@
+import { StyleSpecification, SourceSpecification, GeoJSONSourceSpecification, VectorSourceSpecification, RasterSourceSpecification, RasterDEMSourceSpecification } from '@maplibre/maplibre-gl-style-spec';
+import { GeoJSON, BBox } from 'geojson';
+import { SetRequired } from 'type-fest';
+import { EventEmitter } from 'events';
+
+/** @typedef {string | Uint8Array | ReadableStream } Source */
+/** @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)
+     */
+    constructor(style: any);
+    /**
+     * @returns {ReadableStream<Uint8Array>} Readable stream of the styled map package
+     */
+    get outputStream(): ReadableStream<Uint8Array>;
+    /**
+     * 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: Error): void;
+    /**
+     * 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;
+    }): WritableStream<any>;
+    /**
+     * 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;
+    }): WritableStream<any>;
+    /**
+     * 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(): Promise<void>;
+    #private;
+}
+type Source = string | Uint8Array | ReadableStream;
+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;
+    };
+};
+type DownloadStream = ReadableStream<Uint8Array>;
+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 SourceInfo as g };

package/dist/types-CJq90eOB.d.ts

@@ -0,0 +1,184 @@
+import { StyleSpecification, SourceSpecification, GeoJSONSourceSpecification, VectorSourceSpecification, RasterSourceSpecification, RasterDEMSourceSpecification } from '@maplibre/maplibre-gl-style-spec';
+import { GeoJSON, BBox } from 'geojson';
+import { SetRequired } from 'type-fest';
+import { EventEmitter } from 'events';
+
+/** @typedef {string | Uint8Array | ReadableStream } Source */
+/** @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)
+     */
+    constructor(style: any);
+    /**
+     * @returns {ReadableStream<Uint8Array>} Readable stream of the styled map package
+     */
+    get outputStream(): ReadableStream<Uint8Array>;
+    /**
+     * 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: Error): void;
+    /**
+     * 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;
+    }): WritableStream<any>;
+    /**
+     * 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;
+    }): WritableStream<any>;
+    /**
+     * 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(): Promise<void>;
+    #private;
+}
+type Source = string | Uint8Array | ReadableStream;
+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;
+    };
+};
+type DownloadStream = ReadableStream<Uint8Array>;
+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 SourceInfo as g };

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/utils/errors.d.ts

@@ -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/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
+};