commit e40e28d9e43209bc08f3014b375c97ceb4f2b253
Author: kura <kura@sina.com>
Date:   Wed Nov 6 11:40:07 2024 +0800

    init

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000..0dacc95
Binary files /dev/null and b/.DS_Store differ
diff --git a/convert_image_to_webp.cpp b/convert_image_to_webp.cpp
new file mode 100644
index 0000000..104f117
--- /dev/null
+++ b/convert_image_to_webp.cpp
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "webp/encode.h" // WebP 头文件，用于编码 WebP
+#include "stb_image.h"   // stb_image 头文件，用于解码 PNG/JPG
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#include "stb_image_resize.h"
+
+extern "C" {
+
+    // 将输入的 JPG/PNG 数据转换为 WebP，并返回 WebP 数据
+    unsigned char *convert_image_to_webp(const uint8_t *input_data, size_t input_size, int target_width, int target_height, float quality_factor, size_t *output_size) {
+        int width, height, channels;
+
+
+        // 使用 stb_image 解码输入图像（强制加载为 RGB 而非 RGBA）
+        unsigned char *decoded_data = stbi_load_from_memory(input_data, input_size, &width, &height, &channels, 3); // 强制加载为 RGB
+
+        if (!decoded_data) {
+            return nullptr; // 图像解码失败
+        }
+
+        // 如果需要调整尺寸，则进行调整
+        unsigned char *resized_data = decoded_data;
+        if (target_width > 0 && target_height > 0) {
+            // 分配用于存储调整大小后图像的缓冲区
+            resized_data = (unsigned char *)malloc(target_width * target_height * 3); // RGB 3 通道
+
+            if (!resized_data) {
+                // 内存分配失败的处理
+                fprintf(stderr, "Failed to allocate memory for resized image.\n");
+                stbi_image_free(decoded_data); // 释放原始解码数据
+                return NULL;
+            }
+
+            // 使用 stb_image_resize 调整图像大小
+            int result = stbir_resize_uint8(decoded_data, width, height, 0,
+                                            resized_data, target_width, target_height, 0, 3);
+
+            if (!result) {
+                // 如果调整大小失败，释放已分配的内存
+                fprintf(stderr, "Image resizing failed.\n");
+                free(resized_data);
+                stbi_image_free(decoded_data);
+                return NULL;
+            }
+        } else {
+            target_width = width;
+            target_height = height;
+        }
+
+        // 使用 libwebp 的有损编码函数（WebPEncodeRGB）将 RGB 图像编码为 WebP
+        unsigned char *webp_output = NULL;
+        *output_size = WebPEncodeRGB(resized_data, target_width, target_height, target_width * 3, quality_factor, &webp_output);
+
+        // 释放解码后的图像内存
+        stbi_image_free(decoded_data);
+        if (resized_data != decoded_data) {
+            free(resized_data); // 如果调整了大小，则释放调整大小后的数据
+        }
+
+        return webp_output; // 返回 WebP 编码后的数据
+    }
+}
\ No newline at end of file
diff --git a/index_ffmpeg.html b/index_ffmpeg.html
new file mode 100644
index 0000000..e02c7a5
--- /dev/null
+++ b/index_ffmpeg.html
@@ -0,0 +1,3 @@
+<script src="./node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js"></script>
+<script>
+</script>
\ No newline at end of file
diff --git a/libsharpyuv.a b/libsharpyuv.a
new file mode 100644
index 0000000..66e2cf2
Binary files /dev/null and b/libsharpyuv.a differ
diff --git a/libwebp.a b/libwebp.a
new file mode 100644
index 0000000..5e8b1cb
Binary files /dev/null and b/libwebp.a differ
diff --git a/libwebpdecoder.a b/libwebpdecoder.a
new file mode 100644
index 0000000..df6a1ce
Binary files /dev/null and b/libwebpdecoder.a differ
diff --git a/libwebpdemux.a b/libwebpdemux.a
new file mode 100644
index 0000000..6b2da15
Binary files /dev/null and b/libwebpdemux.a differ
diff --git a/libwebpmux.a b/libwebpmux.a
new file mode 100644
index 0000000..87b7d95
Binary files /dev/null and b/libwebpmux.a differ
diff --git a/node_modules/.bin/esbuild b/node_modules/.bin/esbuild
new file mode 120000
index 0000000..c83ac07
--- /dev/null
+++ b/node_modules/.bin/esbuild
@@ -0,0 +1 @@
+../esbuild/bin/esbuild
\ No newline at end of file
diff --git a/node_modules/.bin/nanoid b/node_modules/.bin/nanoid
new file mode 120000
index 0000000..e2be547
--- /dev/null
+++ b/node_modules/.bin/nanoid
@@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs
\ No newline at end of file
diff --git a/node_modules/.bin/rollup b/node_modules/.bin/rollup
new file mode 120000
index 0000000..5939621
--- /dev/null
+++ b/node_modules/.bin/rollup
@@ -0,0 +1 @@
+../rollup/dist/bin/rollup
\ No newline at end of file
diff --git a/node_modules/.bin/vite b/node_modules/.bin/vite
new file mode 120000
index 0000000..6d1e3be
--- /dev/null
+++ b/node_modules/.bin/vite
@@ -0,0 +1 @@
+../vite/bin/vite.js
\ No newline at end of file
diff --git a/node_modules/.yarn-integrity b/node_modules/.yarn-integrity
new file mode 100644
index 0000000..535990f
--- /dev/null
+++ b/node_modules/.yarn-integrity
@@ -0,0 +1,69 @@
+{
+  "systemParams": "darwin-arm64-108",
+  "modulesFolders": [
+    "node_modules"
+  ],
+  "flags": [],
+  "linkedModules": [],
+  "topLevelPatterns": [
+    "@ffmpeg/ffmpeg@^0.12.10",
+    "@ffmpeg/util@^0.12.1",
+    "vite@^5.4.8"
+  ],
+  "lockfileEntries": {
+    "@esbuild/aix-ppc64@0.21.5": "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f",
+    "@esbuild/android-arm64@0.21.5": "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052",
+    "@esbuild/android-arm@0.21.5": "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28",
+    "@esbuild/android-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e",
+    "@esbuild/darwin-arm64@0.21.5": "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a",
+    "@esbuild/darwin-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22",
+    "@esbuild/freebsd-arm64@0.21.5": "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e",
+    "@esbuild/freebsd-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261",
+    "@esbuild/linux-arm64@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b",
+    "@esbuild/linux-arm@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9",
+    "@esbuild/linux-ia32@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2",
+    "@esbuild/linux-loong64@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df",
+    "@esbuild/linux-mips64el@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe",
+    "@esbuild/linux-ppc64@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4",
+    "@esbuild/linux-riscv64@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc",
+    "@esbuild/linux-s390x@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de",
+    "@esbuild/linux-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0",
+    "@esbuild/netbsd-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047",
+    "@esbuild/openbsd-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70",
+    "@esbuild/sunos-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b",
+    "@esbuild/win32-arm64@0.21.5": "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d",
+    "@esbuild/win32-ia32@0.21.5": "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b",
+    "@esbuild/win32-x64@0.21.5": "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c",
+    "@ffmpeg/ffmpeg@^0.12.10": "https://registry.yarnpkg.com/@ffmpeg/ffmpeg/-/ffmpeg-0.12.10.tgz#e3cce21f21f11f33dfc1ec1d5ad5694f4a3073c9",
+    "@ffmpeg/types@^0.12.2": "https://registry.yarnpkg.com/@ffmpeg/types/-/types-0.12.2.tgz#bc7eef321ae50225c247091f1f23fd3087c6aa1d",
+    "@ffmpeg/util@^0.12.1": "https://registry.yarnpkg.com/@ffmpeg/util/-/util-0.12.1.tgz#98afa20d7b4c0821eebdb205ddcfa5d07b0a4f53",
+    "@rollup/rollup-android-arm-eabi@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.24.0.tgz#1661ff5ea9beb362795304cb916049aba7ac9c54",
+    "@rollup/rollup-android-arm64@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.24.0.tgz#2ffaa91f1b55a0082b8a722525741aadcbd3971e",
+    "@rollup/rollup-darwin-arm64@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.24.0.tgz#627007221b24b8cc3063703eee0b9177edf49c1f",
+    "@rollup/rollup-darwin-x64@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.24.0.tgz#0605506142b9e796c370d59c5984ae95b9758724",
+    "@rollup/rollup-linux-arm-gnueabihf@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.24.0.tgz#62dfd196d4b10c0c2db833897164d2d319ee0cbb",
+    "@rollup/rollup-linux-arm-musleabihf@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.24.0.tgz#53ce72aeb982f1f34b58b380baafaf6a240fddb3",
+    "@rollup/rollup-linux-arm64-gnu@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.24.0.tgz#1632990f62a75c74f43e4b14ab3597d7ed416496",
+    "@rollup/rollup-linux-arm64-musl@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.24.0.tgz#8c03a996efb41e257b414b2e0560b7a21f2d9065",
+    "@rollup/rollup-linux-powerpc64le-gnu@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.24.0.tgz#5b98729628d5bcc8f7f37b58b04d6845f85c7b5d",
+    "@rollup/rollup-linux-riscv64-gnu@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.24.0.tgz#48e42e41f4cabf3573cfefcb448599c512e22983",
+    "@rollup/rollup-linux-s390x-gnu@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.24.0.tgz#e0b4f9a966872cb7d3e21b9e412a4b7efd7f0b58",
+    "@rollup/rollup-linux-x64-gnu@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.24.0.tgz#78144741993100f47bd3da72fce215e077ae036b",
+    "@rollup/rollup-linux-x64-musl@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.24.0.tgz#d9fe32971883cd1bd858336bd33a1c3ca6146127",
+    "@rollup/rollup-win32-arm64-msvc@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.24.0.tgz#71fa3ea369316db703a909c790743972e98afae5",
+    "@rollup/rollup-win32-ia32-msvc@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.24.0.tgz#653f5989a60658e17d7576a3996deb3902e342e2",
+    "@rollup/rollup-win32-x64-msvc@4.24.0": "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.24.0.tgz#0574d7e87b44ee8511d08cc7f914bcb802b70818",
+    "@types/estree@1.0.6": "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.6.tgz#628effeeae2064a1b4e79f78e81d87b7e5fc7b50",
+    "esbuild@^0.21.3": "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d",
+    "fsevents@~2.3.2": "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6",
+    "fsevents@~2.3.3": "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6",
+    "nanoid@^3.3.7": "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8",
+    "picocolors@^1.1.0": "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.0.tgz#5358b76a78cde483ba5cef6a9dc9671440b27d59",
+    "postcss@^8.4.43": "https://registry.yarnpkg.com/postcss/-/postcss-8.4.47.tgz#5bf6c9a010f3e724c503bf03ef7947dcb0fea365",
+    "rollup@^4.20.0": "https://registry.yarnpkg.com/rollup/-/rollup-4.24.0.tgz#c14a3576f20622ea6a5c9cad7caca5e6e9555d05",
+    "source-map-js@^1.2.1": "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46",
+    "vite@^5.4.8": "https://registry.yarnpkg.com/vite/-/vite-5.4.8.tgz#af548ce1c211b2785478d3ba3e8da51e39a287e8"
+  },
+  "files": [],
+  "artifacts": {}
+}
\ No newline at end of file
diff --git a/node_modules/@esbuild/darwin-arm64/README.md b/node_modules/@esbuild/darwin-arm64/README.md
new file mode 100644
index 0000000..c2c0398
--- /dev/null
+++ b/node_modules/@esbuild/darwin-arm64/README.md
@@ -0,0 +1,3 @@
+# esbuild
+
+This is the macOS ARM 64-bit binary for esbuild, a JavaScript bundler and minifier. See https://github.com/evanw/esbuild for details.
diff --git a/node_modules/@esbuild/darwin-arm64/bin/esbuild b/node_modules/@esbuild/darwin-arm64/bin/esbuild
new file mode 100755
index 0000000..e81b7da
Binary files /dev/null and b/node_modules/@esbuild/darwin-arm64/bin/esbuild differ
diff --git a/node_modules/@esbuild/darwin-arm64/package.json b/node_modules/@esbuild/darwin-arm64/package.json
new file mode 100644
index 0000000..6eea7ea
--- /dev/null
+++ b/node_modules/@esbuild/darwin-arm64/package.json
@@ -0,0 +1,20 @@
+{
+  "name": "@esbuild/darwin-arm64",
+  "version": "0.21.5",
+  "description": "The macOS ARM 64-bit binary for esbuild, a JavaScript bundler.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "license": "MIT",
+  "preferUnplugged": true,
+  "engines": {
+    "node": ">=12"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ]
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.d.ts
new file mode 100644
index 0000000..205c94e
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.d.ts
@@ -0,0 +1,145 @@
+import { FSNode, FFMessageLoadConfig, OK, IsFirst, LogEventCallback, ProgressEventCallback, FileData, FFFSType, FFFSMountOptions, FFFSPath } from "./types.js";
+type FFMessageOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * Provides APIs to interact with ffmpeg web worker.
+ *
+ * @example
+ * ```ts
+ * const ffmpeg = new FFmpeg();
+ * ```
+ */
+export declare class FFmpeg {
+    #private;
+    loaded: boolean;
+    /**
+     * Listen to log or prgress events from `ffmpeg.exec()`.
+     *
+     * @example
+     * ```ts
+     * ffmpeg.on("log", ({ type, message }) => {
+     *   // ...
+     * })
+     * ```
+     *
+     * @example
+     * ```ts
+     * ffmpeg.on("progress", ({ progress, time }) => {
+     *   // ...
+     * })
+     * ```
+     *
+     * @remarks
+     * - log includes output to stdout and stderr.
+     * - The progress events are accurate only when the length of
+     * input and output video/audio file are the same.
+     *
+     * @category FFmpeg
+     */
+    on(event: "log", callback: LogEventCallback): void;
+    on(event: "progress", callback: ProgressEventCallback): void;
+    /**
+     * Unlisten to log or prgress events from `ffmpeg.exec()`.
+     *
+     * @category FFmpeg
+     */
+    off(event: "log", callback: LogEventCallback): void;
+    off(event: "progress", callback: ProgressEventCallback): void;
+    /**
+     * Loads ffmpeg-core inside web worker. It is required to call this method first
+     * as it initializes WebAssembly and other essential variables.
+     *
+     * @category FFmpeg
+     * @returns `true` if ffmpeg core is loaded for the first time.
+     */
+    load: ({ classWorkerURL, ...config }?: FFMessageLoadConfig, { signal }?: FFMessageOptions) => Promise<IsFirst>;
+    /**
+     * Execute ffmpeg command.
+     *
+     * @remarks
+     * To avoid common I/O issues, ["-nostdin", "-y"] are prepended to the args
+     * by default.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", ...);
+     * // ffmpeg -i video.avi video.mp4
+     * await ffmpeg.exec(["-i", "video.avi", "video.mp4"]);
+     * const data = ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @returns `0` if no error, `!= 0` if timeout (1) or error.
+     * @category FFmpeg
+     */
+    exec: (args: string[], timeout?: number, { signal }?: FFMessageOptions) => Promise<number>;
+    /**
+     * Terminate all ongoing API calls and terminate web worker.
+     * `FFmpeg.load()` must be called again before calling any other APIs.
+     *
+     * @category FFmpeg
+     */
+    terminate: () => void;
+    /**
+     * Write data to ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", await fetchFile("../video.avi"));
+     * await ffmpeg.writeFile("text.txt", "hello world");
+     * ```
+     *
+     * @category File System
+     */
+    writeFile: (path: string, data: FileData, { signal }?: FFMessageOptions) => Promise<OK>;
+    mount: (fsType: FFFSType, options: FFFSMountOptions, mountPoint: FFFSPath) => Promise<OK>;
+    unmount: (mountPoint: FFFSPath) => Promise<OK>;
+    /**
+     * Read data from ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * const data = await ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @category File System
+     */
+    readFile: (path: string, encoding?: string, { signal }?: FFMessageOptions) => Promise<FileData>;
+    /**
+     * Delete a file.
+     *
+     * @category File System
+     */
+    deleteFile: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * Rename a file or directory.
+     *
+     * @category File System
+     */
+    rename: (oldPath: string, newPath: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * Create a directory.
+     *
+     * @category File System
+     */
+    createDir: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+    /**
+     * List directory contents.
+     *
+     * @category File System
+     */
+    listDir: (path: string, { signal }?: FFMessageOptions) => Promise<FSNode[]>;
+    /**
+     * Delete an empty directory.
+     *
+     * @category File System
+     */
+    deleteDir: (path: string, { signal }?: FFMessageOptions) => Promise<OK>;
+}
+export {};
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.js
new file mode 100644
index 0000000..e490b7a
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/classes.js
@@ -0,0 +1,277 @@
+import { FFMessageType } from "./const.js";
+import { getMessageID } from "./utils.js";
+import { ERROR_TERMINATED, ERROR_NOT_LOADED } from "./errors.js";
+/**
+ * Provides APIs to interact with ffmpeg web worker.
+ *
+ * @example
+ * ```ts
+ * const ffmpeg = new FFmpeg();
+ * ```
+ */
+export class FFmpeg {
+    #worker = null;
+    /**
+     * #resolves and #rejects tracks Promise resolves and rejects to
+     * be called when we receive message from web worker.
+     */
+    #resolves = {};
+    #rejects = {};
+    #logEventCallbacks = [];
+    #progressEventCallbacks = [];
+    loaded = false;
+    /**
+     * register worker message event handlers.
+     */
+    #registerHandlers = () => {
+        if (this.#worker) {
+            this.#worker.onmessage = ({ data: { id, type, data }, }) => {
+                switch (type) {
+                    case FFMessageType.LOAD:
+                        this.loaded = true;
+                        this.#resolves[id](data);
+                        break;
+                    case FFMessageType.MOUNT:
+                    case FFMessageType.UNMOUNT:
+                    case FFMessageType.EXEC:
+                    case FFMessageType.WRITE_FILE:
+                    case FFMessageType.READ_FILE:
+                    case FFMessageType.DELETE_FILE:
+                    case FFMessageType.RENAME:
+                    case FFMessageType.CREATE_DIR:
+                    case FFMessageType.LIST_DIR:
+                    case FFMessageType.DELETE_DIR:
+                        this.#resolves[id](data);
+                        break;
+                    case FFMessageType.LOG:
+                        this.#logEventCallbacks.forEach((f) => f(data));
+                        break;
+                    case FFMessageType.PROGRESS:
+                        this.#progressEventCallbacks.forEach((f) => f(data));
+                        break;
+                    case FFMessageType.ERROR:
+                        this.#rejects[id](data);
+                        break;
+                }
+                delete this.#resolves[id];
+                delete this.#rejects[id];
+            };
+        }
+    };
+    /**
+     * Generic function to send messages to web worker.
+     */
+    #send = ({ type, data }, trans = [], signal) => {
+        if (!this.#worker) {
+            return Promise.reject(ERROR_NOT_LOADED);
+        }
+        return new Promise((resolve, reject) => {
+            const id = getMessageID();
+            this.#worker && this.#worker.postMessage({ id, type, data }, trans);
+            this.#resolves[id] = resolve;
+            this.#rejects[id] = reject;
+            signal?.addEventListener("abort", () => {
+                reject(new DOMException(`Message # ${id} was aborted`, "AbortError"));
+            }, { once: true });
+        });
+    };
+    on(event, callback) {
+        if (event === "log") {
+            this.#logEventCallbacks.push(callback);
+        }
+        else if (event === "progress") {
+            this.#progressEventCallbacks.push(callback);
+        }
+    }
+    off(event, callback) {
+        if (event === "log") {
+            this.#logEventCallbacks = this.#logEventCallbacks.filter((f) => f !== callback);
+        }
+        else if (event === "progress") {
+            this.#progressEventCallbacks = this.#progressEventCallbacks.filter((f) => f !== callback);
+        }
+    }
+    /**
+     * Loads ffmpeg-core inside web worker. It is required to call this method first
+     * as it initializes WebAssembly and other essential variables.
+     *
+     * @category FFmpeg
+     * @returns `true` if ffmpeg core is loaded for the first time.
+     */
+    load = ({ classWorkerURL, ...config } = {}, { signal } = {}) => {
+        if (!this.#worker) {
+            this.#worker = classWorkerURL ?
+                new Worker(new URL(classWorkerURL, import.meta.url), {
+                    type: "module",
+                }) :
+                // We need to duplicated the code here to enable webpack
+                // to bundle worekr.js here.
+                new Worker(new URL("./worker.js", import.meta.url), {
+                    type: "module",
+                });
+            this.#registerHandlers();
+        }
+        return this.#send({
+            type: FFMessageType.LOAD,
+            data: config,
+        }, undefined, signal);
+    };
+    /**
+     * Execute ffmpeg command.
+     *
+     * @remarks
+     * To avoid common I/O issues, ["-nostdin", "-y"] are prepended to the args
+     * by default.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", ...);
+     * // ffmpeg -i video.avi video.mp4
+     * await ffmpeg.exec(["-i", "video.avi", "video.mp4"]);
+     * const data = ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @returns `0` if no error, `!= 0` if timeout (1) or error.
+     * @category FFmpeg
+     */
+    exec = (
+    /** ffmpeg command line args */
+    args, 
+    /**
+     * milliseconds to wait before stopping the command execution.
+     *
+     * @defaultValue -1
+     */
+    timeout = -1, { signal } = {}) => this.#send({
+        type: FFMessageType.EXEC,
+        data: { args, timeout },
+    }, undefined, signal);
+    /**
+     * Terminate all ongoing API calls and terminate web worker.
+     * `FFmpeg.load()` must be called again before calling any other APIs.
+     *
+     * @category FFmpeg
+     */
+    terminate = () => {
+        const ids = Object.keys(this.#rejects);
+        // rejects all incomplete Promises.
+        for (const id of ids) {
+            this.#rejects[id](ERROR_TERMINATED);
+            delete this.#rejects[id];
+            delete this.#resolves[id];
+        }
+        if (this.#worker) {
+            this.#worker.terminate();
+            this.#worker = null;
+            this.loaded = false;
+        }
+    };
+    /**
+     * Write data to ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * await ffmpeg.writeFile("video.avi", await fetchFile("../video.avi"));
+     * await ffmpeg.writeFile("text.txt", "hello world");
+     * ```
+     *
+     * @category File System
+     */
+    writeFile = (path, data, { signal } = {}) => {
+        const trans = [];
+        if (data instanceof Uint8Array) {
+            trans.push(data.buffer);
+        }
+        return this.#send({
+            type: FFMessageType.WRITE_FILE,
+            data: { path, data },
+        }, trans, signal);
+    };
+    mount = (fsType, options, mountPoint) => {
+        const trans = [];
+        return this.#send({
+            type: FFMessageType.MOUNT,
+            data: { fsType, options, mountPoint },
+        }, trans);
+    };
+    unmount = (mountPoint) => {
+        const trans = [];
+        return this.#send({
+            type: FFMessageType.UNMOUNT,
+            data: { mountPoint },
+        }, trans);
+    };
+    /**
+     * Read data from ffmpeg.wasm.
+     *
+     * @example
+     * ```ts
+     * const ffmpeg = new FFmpeg();
+     * await ffmpeg.load();
+     * const data = await ffmpeg.readFile("video.mp4");
+     * ```
+     *
+     * @category File System
+     */
+    readFile = (path, 
+    /**
+     * File content encoding, supports two encodings:
+     * - utf8: read file as text file, return data in string type.
+     * - binary: read file as binary file, return data in Uint8Array type.
+     *
+     * @defaultValue binary
+     */
+    encoding = "binary", { signal } = {}) => this.#send({
+        type: FFMessageType.READ_FILE,
+        data: { path, encoding },
+    }, undefined, signal);
+    /**
+     * Delete a file.
+     *
+     * @category File System
+     */
+    deleteFile = (path, { signal } = {}) => this.#send({
+        type: FFMessageType.DELETE_FILE,
+        data: { path },
+    }, undefined, signal);
+    /**
+     * Rename a file or directory.
+     *
+     * @category File System
+     */
+    rename = (oldPath, newPath, { signal } = {}) => this.#send({
+        type: FFMessageType.RENAME,
+        data: { oldPath, newPath },
+    }, undefined, signal);
+    /**
+     * Create a directory.
+     *
+     * @category File System
+     */
+    createDir = (path, { signal } = {}) => this.#send({
+        type: FFMessageType.CREATE_DIR,
+        data: { path },
+    }, undefined, signal);
+    /**
+     * List directory contents.
+     *
+     * @category File System
+     */
+    listDir = (path, { signal } = {}) => this.#send({
+        type: FFMessageType.LIST_DIR,
+        data: { path },
+    }, undefined, signal);
+    /**
+     * Delete an empty directory.
+     *
+     * @category File System
+     */
+    deleteDir = (path, { signal } = {}) => this.#send({
+        type: FFMessageType.DELETE_DIR,
+        data: { path },
+    }, undefined, signal);
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/const.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/const.d.ts
new file mode 100644
index 0000000..97978fb
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/const.d.ts
@@ -0,0 +1,21 @@
+export declare const MIME_TYPE_JAVASCRIPT = "text/javascript";
+export declare const MIME_TYPE_WASM = "application/wasm";
+export declare const CORE_VERSION = "0.12.6";
+export declare const CORE_URL: string;
+export declare enum FFMessageType {
+    LOAD = "LOAD",
+    EXEC = "EXEC",
+    WRITE_FILE = "WRITE_FILE",
+    READ_FILE = "READ_FILE",
+    DELETE_FILE = "DELETE_FILE",
+    RENAME = "RENAME",
+    CREATE_DIR = "CREATE_DIR",
+    LIST_DIR = "LIST_DIR",
+    DELETE_DIR = "DELETE_DIR",
+    ERROR = "ERROR",
+    DOWNLOAD = "DOWNLOAD",
+    PROGRESS = "PROGRESS",
+    LOG = "LOG",
+    MOUNT = "MOUNT",
+    UNMOUNT = "UNMOUNT"
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/const.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/const.js
new file mode 100644
index 0000000..35cc93f
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/const.js
@@ -0,0 +1,22 @@
+export const MIME_TYPE_JAVASCRIPT = "text/javascript";
+export const MIME_TYPE_WASM = "application/wasm";
+export const CORE_VERSION = "0.12.6";
+export const CORE_URL = `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.js`;
+export var FFMessageType;
+(function (FFMessageType) {
+    FFMessageType["LOAD"] = "LOAD";
+    FFMessageType["EXEC"] = "EXEC";
+    FFMessageType["WRITE_FILE"] = "WRITE_FILE";
+    FFMessageType["READ_FILE"] = "READ_FILE";
+    FFMessageType["DELETE_FILE"] = "DELETE_FILE";
+    FFMessageType["RENAME"] = "RENAME";
+    FFMessageType["CREATE_DIR"] = "CREATE_DIR";
+    FFMessageType["LIST_DIR"] = "LIST_DIR";
+    FFMessageType["DELETE_DIR"] = "DELETE_DIR";
+    FFMessageType["ERROR"] = "ERROR";
+    FFMessageType["DOWNLOAD"] = "DOWNLOAD";
+    FFMessageType["PROGRESS"] = "PROGRESS";
+    FFMessageType["LOG"] = "LOG";
+    FFMessageType["MOUNT"] = "MOUNT";
+    FFMessageType["UNMOUNT"] = "UNMOUNT";
+})(FFMessageType || (FFMessageType = {}));
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.d.mts b/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.d.mts
new file mode 100644
index 0000000..1b5f8f2
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.d.mts
@@ -0,0 +1,3 @@
+export declare class FFmpeg {
+    constructor();
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.mjs b/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.mjs
new file mode 100644
index 0000000..b16b65c
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/empty.mjs
@@ -0,0 +1,6 @@
+// File to be imported in node enviroments
+export class FFmpeg {
+    constructor() {
+        throw new Error("ffmpeg.wasm does not support nodejs");
+    }
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.d.ts
new file mode 100644
index 0000000..e8ee0d9
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.d.ts
@@ -0,0 +1,4 @@
+export declare const ERROR_UNKNOWN_MESSAGE_TYPE: Error;
+export declare const ERROR_NOT_LOADED: Error;
+export declare const ERROR_TERMINATED: Error;
+export declare const ERROR_IMPORT_FAILURE: Error;
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.js
new file mode 100644
index 0000000..409f515
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/errors.js
@@ -0,0 +1,4 @@
+export const ERROR_UNKNOWN_MESSAGE_TYPE = new Error("unknown message type");
+export const ERROR_NOT_LOADED = new Error("ffmpeg is not loaded, call `await ffmpeg.load()` first");
+export const ERROR_TERMINATED = new Error("called FFmpeg.terminate()");
+export const ERROR_IMPORT_FAILURE = new Error("failed to import ffmpeg-core.js");
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/index.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/index.d.ts
new file mode 100644
index 0000000..b84e9db
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/index.d.ts
@@ -0,0 +1 @@
+export * from "./classes.js";
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/index.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/index.js
new file mode 100644
index 0000000..b84e9db
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/index.js
@@ -0,0 +1 @@
+export * from "./classes.js";
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/types.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/types.d.ts
new file mode 100644
index 0000000..8b0eda3
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/types.d.ts
@@ -0,0 +1,131 @@
+export type FFFSPath = string;
+/**
+ * ffmpeg-core loading configuration.
+ */
+export interface FFMessageLoadConfig {
+    /**
+     * `ffmpeg-core.js` URL.
+     *
+     * @defaultValue `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.js`;
+     */
+    coreURL?: string;
+    /**
+     * `ffmpeg-core.wasm` URL.
+     *
+     * @defaultValue `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.wasm`;
+     */
+    wasmURL?: string;
+    /**
+     * `ffmpeg-core.worker.js` URL. This worker is spawned when using multithread version of ffmpeg-core.
+     *
+     * @ref: https://ffmpegwasm.netlify.app/docs/overview#architecture
+     * @defaultValue `https://unpkg.com/@ffmpeg/core-mt@${CORE_VERSION}/dist/umd/ffmpeg-core.worker.js`;
+     */
+    workerURL?: string;
+    /**
+     * `ffmpeg.worker.js` URL. This worker is spawned when FFmpeg.load() is called, it is an essential worker and usually you don't need to update this config.
+     *
+     * @ref: https://ffmpegwasm.netlify.app/docs/overview#architecture
+     * @defaultValue `./worker.js`
+     */
+    classWorkerURL?: string;
+}
+export interface FFMessageExecData {
+    args: string[];
+    timeout?: number;
+}
+export interface FFMessageWriteFileData {
+    path: FFFSPath;
+    data: FileData;
+}
+export interface FFMessageReadFileData {
+    path: FFFSPath;
+    encoding: string;
+}
+export interface FFMessageDeleteFileData {
+    path: FFFSPath;
+}
+export interface FFMessageRenameData {
+    oldPath: FFFSPath;
+    newPath: FFFSPath;
+}
+export interface FFMessageCreateDirData {
+    path: FFFSPath;
+}
+export interface FFMessageListDirData {
+    path: FFFSPath;
+}
+/**
+ * @remarks
+ * Only deletes empty directory.
+ */
+export interface FFMessageDeleteDirData {
+    path: FFFSPath;
+}
+export declare enum FFFSType {
+    MEMFS = "MEMFS",
+    NODEFS = "NODEFS",
+    NODERAWFS = "NODERAWFS",
+    IDBFS = "IDBFS",
+    WORKERFS = "WORKERFS",
+    PROXYFS = "PROXYFS"
+}
+export type WorkerFSFileEntry = File;
+export interface WorkerFSBlobEntry {
+    name: string;
+    data: Blob;
+}
+export interface WorkerFSMountData {
+    blobs?: WorkerFSBlobEntry[];
+    files?: WorkerFSFileEntry[];
+}
+export type FFFSMountOptions = WorkerFSMountData;
+export interface FFMessageMountData {
+    fsType: FFFSType;
+    options: FFFSMountOptions;
+    mountPoint: FFFSPath;
+}
+export interface FFMessageUnmountData {
+    mountPoint: FFFSPath;
+}
+export type FFMessageData = FFMessageLoadConfig | FFMessageExecData | FFMessageWriteFileData | FFMessageReadFileData | FFMessageDeleteFileData | FFMessageRenameData | FFMessageCreateDirData | FFMessageListDirData | FFMessageDeleteDirData | FFMessageMountData | FFMessageUnmountData;
+export interface Message {
+    type: string;
+    data?: FFMessageData;
+}
+export interface FFMessage extends Message {
+    id: number;
+}
+export interface FFMessageEvent extends MessageEvent {
+    data: FFMessage;
+}
+export interface LogEvent {
+    type: string;
+    message: string;
+}
+export interface ProgressEvent {
+    progress: number;
+    time: number;
+}
+export type ExitCode = number;
+export type ErrorMessage = string;
+export type FileData = Uint8Array | string;
+export type IsFirst = boolean;
+export type OK = boolean;
+export interface FSNode {
+    name: string;
+    isDir: boolean;
+}
+export type CallbackData = FileData | ExitCode | ErrorMessage | LogEvent | ProgressEvent | IsFirst | OK | Error | FSNode[] | undefined;
+export interface Callbacks {
+    [id: number | string]: (data: CallbackData) => void;
+}
+export type LogEventCallback = (event: LogEvent) => void;
+export type ProgressEventCallback = (event: ProgressEvent) => void;
+export interface FFMessageEventCallback {
+    data: {
+        id: number;
+        type: string;
+        data: CallbackData;
+    };
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/types.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/types.js
new file mode 100644
index 0000000..76a0690
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/types.js
@@ -0,0 +1,9 @@
+export var FFFSType;
+(function (FFFSType) {
+    FFFSType["MEMFS"] = "MEMFS";
+    FFFSType["NODEFS"] = "NODEFS";
+    FFFSType["NODERAWFS"] = "NODERAWFS";
+    FFFSType["IDBFS"] = "IDBFS";
+    FFFSType["WORKERFS"] = "WORKERFS";
+    FFFSType["PROXYFS"] = "PROXYFS";
+})(FFFSType || (FFFSType = {}));
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.d.ts
new file mode 100644
index 0000000..a980fe6
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.d.ts
@@ -0,0 +1,4 @@
+/**
+ * Generate an unique message ID.
+ */
+export declare const getMessageID: () => number;
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.js
new file mode 100644
index 0000000..7dd12b0
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/utils.js
@@ -0,0 +1,7 @@
+/**
+ * Generate an unique message ID.
+ */
+export const getMessageID = (() => {
+    let messageID = 0;
+    return () => messageID++;
+})();
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.d.ts b/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.d.ts
new file mode 100644
index 0000000..1f14e35
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.d.ts
@@ -0,0 +1,9 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+import type { FFmpegCoreModuleFactory } from "@ffmpeg/types";
+declare global {
+    interface WorkerGlobalScope {
+        createFFmpegCore: FFmpegCoreModuleFactory;
+    }
+}
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.js b/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.js
new file mode 100644
index 0000000..57bd90c
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/esm/worker.js
@@ -0,0 +1,151 @@
+/// <reference no-default-lib="true" />
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+import { CORE_URL, FFMessageType } from "./const.js";
+import { ERROR_UNKNOWN_MESSAGE_TYPE, ERROR_NOT_LOADED, ERROR_IMPORT_FAILURE, } from "./errors.js";
+let ffmpeg;
+const load = async ({ coreURL: _coreURL, wasmURL: _wasmURL, workerURL: _workerURL, }) => {
+    const first = !ffmpeg;
+    try {
+        if (!_coreURL)
+            _coreURL = CORE_URL;
+        // when web worker type is `classic`.
+        importScripts(_coreURL);
+    }
+    catch {
+        if (!_coreURL)
+            _coreURL = CORE_URL.replace('/umd/', '/esm/');
+        // when web worker type is `module`.
+        self.createFFmpegCore = (await import(
+        /* webpackIgnore: true */ /* @vite-ignore */ _coreURL)).default;
+        if (!self.createFFmpegCore) {
+            throw ERROR_IMPORT_FAILURE;
+        }
+    }
+    const coreURL = _coreURL;
+    const wasmURL = _wasmURL ? _wasmURL : _coreURL.replace(/.js$/g, ".wasm");
+    const workerURL = _workerURL
+        ? _workerURL
+        : _coreURL.replace(/.js$/g, ".worker.js");
+    ffmpeg = await self.createFFmpegCore({
+        // Fix `Overload resolution failed.` when using multi-threaded ffmpeg-core.
+        // Encoded wasmURL and workerURL in the URL as a hack to fix locateFile issue.
+        mainScriptUrlOrBlob: `${coreURL}#${btoa(JSON.stringify({ wasmURL, workerURL }))}`,
+    });
+    ffmpeg.setLogger((data) => self.postMessage({ type: FFMessageType.LOG, data }));
+    ffmpeg.setProgress((data) => self.postMessage({
+        type: FFMessageType.PROGRESS,
+        data,
+    }));
+    return first;
+};
+const exec = ({ args, timeout = -1 }) => {
+    ffmpeg.setTimeout(timeout);
+    ffmpeg.exec(...args);
+    const ret = ffmpeg.ret;
+    ffmpeg.reset();
+    return ret;
+};
+const writeFile = ({ path, data }) => {
+    ffmpeg.FS.writeFile(path, data);
+    return true;
+};
+const readFile = ({ path, encoding }) => ffmpeg.FS.readFile(path, { encoding });
+// TODO: check if deletion works.
+const deleteFile = ({ path }) => {
+    ffmpeg.FS.unlink(path);
+    return true;
+};
+const rename = ({ oldPath, newPath }) => {
+    ffmpeg.FS.rename(oldPath, newPath);
+    return true;
+};
+// TODO: check if creation works.
+const createDir = ({ path }) => {
+    ffmpeg.FS.mkdir(path);
+    return true;
+};
+const listDir = ({ path }) => {
+    const names = ffmpeg.FS.readdir(path);
+    const nodes = [];
+    for (const name of names) {
+        const stat = ffmpeg.FS.stat(`${path}/${name}`);
+        const isDir = ffmpeg.FS.isDir(stat.mode);
+        nodes.push({ name, isDir });
+    }
+    return nodes;
+};
+// TODO: check if deletion works.
+const deleteDir = ({ path }) => {
+    ffmpeg.FS.rmdir(path);
+    return true;
+};
+const mount = ({ fsType, options, mountPoint }) => {
+    const str = fsType;
+    const fs = ffmpeg.FS.filesystems[str];
+    if (!fs)
+        return false;
+    ffmpeg.FS.mount(fs, options, mountPoint);
+    return true;
+};
+const unmount = ({ mountPoint }) => {
+    ffmpeg.FS.unmount(mountPoint);
+    return true;
+};
+self.onmessage = async ({ data: { id, type, data: _data }, }) => {
+    const trans = [];
+    let data;
+    try {
+        if (type !== FFMessageType.LOAD && !ffmpeg)
+            throw ERROR_NOT_LOADED; // eslint-disable-line
+        switch (type) {
+            case FFMessageType.LOAD:
+                data = await load(_data);
+                break;
+            case FFMessageType.EXEC:
+                data = exec(_data);
+                break;
+            case FFMessageType.WRITE_FILE:
+                data = writeFile(_data);
+                break;
+            case FFMessageType.READ_FILE:
+                data = readFile(_data);
+                break;
+            case FFMessageType.DELETE_FILE:
+                data = deleteFile(_data);
+                break;
+            case FFMessageType.RENAME:
+                data = rename(_data);
+                break;
+            case FFMessageType.CREATE_DIR:
+                data = createDir(_data);
+                break;
+            case FFMessageType.LIST_DIR:
+                data = listDir(_data);
+                break;
+            case FFMessageType.DELETE_DIR:
+                data = deleteDir(_data);
+                break;
+            case FFMessageType.MOUNT:
+                data = mount(_data);
+                break;
+            case FFMessageType.UNMOUNT:
+                data = unmount(_data);
+                break;
+            default:
+                throw ERROR_UNKNOWN_MESSAGE_TYPE;
+        }
+    }
+    catch (e) {
+        self.postMessage({
+            id,
+            type: FFMessageType.ERROR,
+            data: e.toString(),
+        });
+        return;
+    }
+    if (data instanceof Uint8Array) {
+        trans.push(data.buffer);
+    }
+    self.postMessage({ id, type, data }, trans);
+};
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js b/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js
new file mode 100644
index 0000000..a82c120
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js
@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FFmpegWASM=t():e.FFmpegWASM=t()}(self,(()=>(()=>{"use strict";const e="https://unpkg.com/@ffmpeg/core@0.12.6/dist/umd/ffmpeg-core.js";var t;!function(e){e.LOAD="LOAD",e.EXEC="EXEC",e.WRITE_FILE="WRITE_FILE",e.READ_FILE="READ_FILE",e.DELETE_FILE="DELETE_FILE",e.RENAME="RENAME",e.CREATE_DIR="CREATE_DIR",e.LIST_DIR="LIST_DIR",e.DELETE_DIR="DELETE_DIR",e.ERROR="ERROR",e.DOWNLOAD="DOWNLOAD",e.PROGRESS="PROGRESS",e.LOG="LOG",e.MOUNT="MOUNT",e.UNMOUNT="UNMOUNT"}(t||(t={}));const r=new Error("unknown message type"),a=new Error("ffmpeg is not loaded, call `await ffmpeg.load()` first"),s=(new Error("called FFmpeg.terminate()"),new Error("failed to import ffmpeg-core.js"));let o;return self.onmessage=async({data:{id:n,type:E,data:c}})=>{const i=[];let p;try{if(E!==t.LOAD&&!o)throw a;switch(E){case t.LOAD:p=await(async({coreURL:r,wasmURL:a,workerURL:n})=>{const E=!o;try{r||(r=e),importScripts(r)}catch{if(r||(r=e.replace("/umd/","/esm/")),self.createFFmpegCore=(await import(r)).default,!self.createFFmpegCore)throw s}const c=r,i=a||r.replace(/.js$/g,".wasm"),p=n||r.replace(/.js$/g,".worker.js");return o=await self.createFFmpegCore({mainScriptUrlOrBlob:`${c}#${btoa(JSON.stringify({wasmURL:i,workerURL:p}))}`}),o.setLogger((e=>self.postMessage({type:t.LOG,data:e}))),o.setProgress((e=>self.postMessage({type:t.PROGRESS,data:e}))),E})(c);break;case t.EXEC:p=(({args:e,timeout:t=-1})=>{o.setTimeout(t),o.exec(...e);const r=o.ret;return o.reset(),r})(c);break;case t.WRITE_FILE:p=(({path:e,data:t})=>(o.FS.writeFile(e,t),!0))(c);break;case t.READ_FILE:p=(({path:e,encoding:t})=>o.FS.readFile(e,{encoding:t}))(c);break;case t.DELETE_FILE:p=(({path:e})=>(o.FS.unlink(e),!0))(c);break;case t.RENAME:p=(({oldPath:e,newPath:t})=>(o.FS.rename(e,t),!0))(c);break;case t.CREATE_DIR:p=(({path:e})=>(o.FS.mkdir(e),!0))(c);break;case t.LIST_DIR:p=(({path:e})=>{const t=o.FS.readdir(e),r=[];for(const a of t){const t=o.FS.stat(`${e}/${a}`),s=o.FS.isDir(t.mode);r.push({name:a,isDir:s})}return r})(c);break;case t.DELETE_DIR:p=(({path:e})=>(o.FS.rmdir(e),!0))(c);break;case t.MOUNT:p=(({fsType:e,options:t,mountPoint:r})=>{const a=e,s=o.FS.filesystems[a];return!!s&&(o.FS.mount(s,t,r),!0)})(c);break;case t.UNMOUNT:p=(({mountPoint:e})=>(o.FS.unmount(e),!0))(c);break;default:throw r}}catch(e){return void self.postMessage({id:n,type:t.ERROR,data:e.toString()})}p instanceof Uint8Array&&i.push(p.buffer),self.postMessage({id:n,type:E,data:p},i)},{}})()));
+//# sourceMappingURL=814.ffmpeg.js.map
\ No newline at end of file
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js.map b/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js.map
new file mode 100644
index 0000000..192de85
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/umd/814.ffmpeg.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"814.ffmpeg.js","mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAoB,WAAID,IAExBD,EAAiB,WAAIC,GACtB,CATD,CASGK,MAAM,I,mBCTF,MAGMC,EAAW,gEACjB,IAAIC,GACX,SAAWA,GACPA,EAAoB,KAAI,OACxBA,EAAoB,KAAI,OACxBA,EAA0B,WAAI,aAC9BA,EAAyB,UAAI,YAC7BA,EAA2B,YAAI,cAC/BA,EAAsB,OAAI,SAC1BA,EAA0B,WAAI,aAC9BA,EAAwB,SAAI,WAC5BA,EAA0B,WAAI,aAC9BA,EAAqB,MAAI,QACzBA,EAAwB,SAAI,WAC5BA,EAAwB,SAAI,WAC5BA,EAAmB,IAAI,MACvBA,EAAqB,MAAI,QACzBA,EAAuB,QAAI,SAC9B,CAhBD,CAgBGA,IAAkBA,EAAgB,CAAC,ICrB/B,MAAMC,EAA6B,IAAIC,MAAM,wBACvCC,EAAmB,IAAID,MAAM,0DAE7BE,GADmB,IAAIF,MAAM,6BACN,IAAIA,MAAM,oCCE9C,IAAIG,E,OAyFJP,KAAKQ,UAAYC,OAASC,MAAQC,KAAIC,OAAMF,KAAMG,OAC9C,MAAMC,EAAQ,GACd,IAAIJ,EACJ,IACI,GAAIE,IAASV,EAAca,OAASR,EAChC,MAAMF,EACV,OAAQO,GACJ,KAAKV,EAAca,KACfL,OAhGHD,QAASO,QAASC,EAAUC,QAASC,EAAUC,UAAWC,MACnE,MAAMC,GAASf,EACf,IACSU,IACDA,EAAWhB,GAEfsB,cAAcN,EAClB,CACA,MAMI,GALKA,IACDA,EAAWhB,EAASuB,QAAQ,QAAS,UAEzCxB,KAAKyB,wBAA0BC,OACcT,IAAWU,SACnD3B,KAAKyB,iBACN,MAAMnB,CAEd,CACA,MAAMU,EAAUC,EACVC,EAAUC,GAAsBF,EAASO,QAAQ,QAAS,SAC1DJ,EAAYC,GAEZJ,EAASO,QAAQ,QAAS,cAWhC,OAVAjB,QAAeP,KAAKyB,iBAAiB,CAGjCG,oBAAqB,GAAGZ,KAAWa,KAAKC,KAAKC,UAAU,CAAEb,UAASE,mBAEtEb,EAAOyB,WAAWtB,GAASV,KAAKiC,YAAY,CAAErB,KAAMV,EAAcgC,IAAKxB,WACvEH,EAAO4B,aAAazB,GAASV,KAAKiC,YAAY,CAC1CrB,KAAMV,EAAckC,SACpB1B,WAEGY,CAAK,EA+Dae,CAAKxB,GAClB,MACJ,KAAKX,EAAcoC,KACf5B,EAhEH,GAAG6B,OAAMC,WAAU,MAC5BjC,EAAOkC,WAAWD,GAClBjC,EAAOmC,QAAQH,GACf,MAAMI,EAAMpC,EAAOoC,IAEnB,OADApC,EAAOqC,QACAD,CAAG,EA2DSD,CAAK7B,GACZ,MACJ,KAAKX,EAAc2C,WACfnC,EA5DE,GAAGoC,OAAMpC,WACvBH,EAAOwC,GAAGC,UAAUF,EAAMpC,IACnB,GA0DYsC,CAAUnC,GACjB,MACJ,KAAKX,EAAc+C,UACfvC,EA3DC,GAAGoC,OAAMI,cAAe3C,EAAOwC,GAAGI,SAASL,EAAM,CAAEI,aA2D7CC,CAAStC,GAChB,MACJ,KAAKX,EAAckD,YACf1C,EA5DG,GAAGoC,WAClBvC,EAAOwC,GAAGM,OAAOP,IACV,GA0DYQ,CAAWzC,GAClB,MACJ,KAAKX,EAAcqD,OACf7C,EA3DD,GAAG8C,UAASC,cACvBlD,EAAOwC,GAAGW,OAAOF,EAASC,IACnB,GAyDYC,CAAO7C,GACd,MACJ,KAAKX,EAAcyD,WACfjD,EAzDE,GAAGoC,WACjBvC,EAAOwC,GAAGa,MAAMd,IACT,GAuDYe,CAAUhD,GACjB,MACJ,KAAKX,EAAc4D,SACfpD,EAxDA,GAAGoC,WACf,MAAMiB,EAAQxD,EAAOwC,GAAGiB,QAAQlB,GAC1BmB,EAAQ,GACd,IAAK,MAAMC,KAAQH,EAAO,CACtB,MAAMI,EAAO5D,EAAOwC,GAAGoB,KAAK,GAAGrB,KAAQoB,KACjCE,EAAQ7D,EAAOwC,GAAGqB,MAAMD,EAAKE,MACnCJ,EAAMK,KAAK,CAAEJ,OAAME,SACvB,CACA,OAAOH,CAAK,EAgDOM,CAAQ1D,GACf,MACJ,KAAKX,EAAcsE,WACf9D,EAhDE,GAAGoC,WACjBvC,EAAOwC,GAAG0B,MAAM3B,IACT,GA8CY4B,CAAU7D,GACjB,MACJ,KAAKX,EAAcyE,MACfjE,EA/CF,GAAGkE,SAAQC,UAASC,iBAC9B,MAAMC,EAAMH,EACNI,EAAKzE,EAAOwC,GAAGkC,YAAYF,GACjC,QAAKC,IAELzE,EAAOwC,GAAGmC,MAAMF,EAAIH,EAASC,IACtB,EAAI,EAyCQI,CAAMrE,GACb,MACJ,KAAKX,EAAciF,QACfzE,EA1CA,GAAGoE,iBACfvE,EAAOwC,GAAGqC,QAAQN,IACX,GAwCYM,CAAQvE,GACf,MACJ,QACI,MAAMV,EAElB,CACA,MAAOkF,GAMH,YALArF,KAAKiC,YAAY,CACbtB,KACAC,KAAMV,EAAcoF,MACpB5E,KAAM2E,EAAEE,YAGhB,CACI7E,aAAgB8E,YAChB1E,EAAMwD,KAAK5D,EAAK+E,QAEpBzF,KAAKiC,YAAY,CAAEtB,KAAIC,OAAMF,QAAQI,EAAM,E","sources":["webpack://FFmpegWASM/webpack/universalModuleDefinition","webpack://FFmpegWASM/./dist/esm/const.js","webpack://FFmpegWASM/./dist/esm/errors.js","webpack://FFmpegWASM/./dist/esm/worker.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FFmpegWASM\"] = factory();\n\telse\n\t\troot[\"FFmpegWASM\"] = factory();\n})(self, () => {\nreturn ","export const MIME_TYPE_JAVASCRIPT = \"text/javascript\";\nexport const MIME_TYPE_WASM = \"application/wasm\";\nexport const CORE_VERSION = \"0.12.6\";\nexport const CORE_URL = `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.js`;\nexport var FFMessageType;\n(function (FFMessageType) {\n    FFMessageType[\"LOAD\"] = \"LOAD\";\n    FFMessageType[\"EXEC\"] = \"EXEC\";\n    FFMessageType[\"WRITE_FILE\"] = \"WRITE_FILE\";\n    FFMessageType[\"READ_FILE\"] = \"READ_FILE\";\n    FFMessageType[\"DELETE_FILE\"] = \"DELETE_FILE\";\n    FFMessageType[\"RENAME\"] = \"RENAME\";\n    FFMessageType[\"CREATE_DIR\"] = \"CREATE_DIR\";\n    FFMessageType[\"LIST_DIR\"] = \"LIST_DIR\";\n    FFMessageType[\"DELETE_DIR\"] = \"DELETE_DIR\";\n    FFMessageType[\"ERROR\"] = \"ERROR\";\n    FFMessageType[\"DOWNLOAD\"] = \"DOWNLOAD\";\n    FFMessageType[\"PROGRESS\"] = \"PROGRESS\";\n    FFMessageType[\"LOG\"] = \"LOG\";\n    FFMessageType[\"MOUNT\"] = \"MOUNT\";\n    FFMessageType[\"UNMOUNT\"] = \"UNMOUNT\";\n})(FFMessageType || (FFMessageType = {}));\n","export const ERROR_UNKNOWN_MESSAGE_TYPE = new Error(\"unknown message type\");\nexport const ERROR_NOT_LOADED = new Error(\"ffmpeg is not loaded, call `await ffmpeg.load()` first\");\nexport const ERROR_TERMINATED = new Error(\"called FFmpeg.terminate()\");\nexport const ERROR_IMPORT_FAILURE = new Error(\"failed to import ffmpeg-core.js\");\n","/// <reference no-default-lib=\"true\" />\n/// <reference lib=\"esnext\" />\n/// <reference lib=\"webworker\" />\nimport { CORE_URL, FFMessageType } from \"./const.js\";\nimport { ERROR_UNKNOWN_MESSAGE_TYPE, ERROR_NOT_LOADED, ERROR_IMPORT_FAILURE, } from \"./errors.js\";\nlet ffmpeg;\nconst load = async ({ coreURL: _coreURL, wasmURL: _wasmURL, workerURL: _workerURL, }) => {\n    const first = !ffmpeg;\n    try {\n        if (!_coreURL)\n            _coreURL = CORE_URL;\n        // when web worker type is `classic`.\n        importScripts(_coreURL);\n    }\n    catch {\n        if (!_coreURL)\n            _coreURL = CORE_URL.replace('/umd/', '/esm/');\n        // when web worker type is `module`.\n        self.createFFmpegCore = (await import(\n        /* webpackIgnore: true */ /* @vite-ignore */ _coreURL)).default;\n        if (!self.createFFmpegCore) {\n            throw ERROR_IMPORT_FAILURE;\n        }\n    }\n    const coreURL = _coreURL;\n    const wasmURL = _wasmURL ? _wasmURL : _coreURL.replace(/.js$/g, \".wasm\");\n    const workerURL = _workerURL\n        ? _workerURL\n        : _coreURL.replace(/.js$/g, \".worker.js\");\n    ffmpeg = await self.createFFmpegCore({\n        // Fix `Overload resolution failed.` when using multi-threaded ffmpeg-core.\n        // Encoded wasmURL and workerURL in the URL as a hack to fix locateFile issue.\n        mainScriptUrlOrBlob: `${coreURL}#${btoa(JSON.stringify({ wasmURL, workerURL }))}`,\n    });\n    ffmpeg.setLogger((data) => self.postMessage({ type: FFMessageType.LOG, data }));\n    ffmpeg.setProgress((data) => self.postMessage({\n        type: FFMessageType.PROGRESS,\n        data,\n    }));\n    return first;\n};\nconst exec = ({ args, timeout = -1 }) => {\n    ffmpeg.setTimeout(timeout);\n    ffmpeg.exec(...args);\n    const ret = ffmpeg.ret;\n    ffmpeg.reset();\n    return ret;\n};\nconst writeFile = ({ path, data }) => {\n    ffmpeg.FS.writeFile(path, data);\n    return true;\n};\nconst readFile = ({ path, encoding }) => ffmpeg.FS.readFile(path, { encoding });\n// TODO: check if deletion works.\nconst deleteFile = ({ path }) => {\n    ffmpeg.FS.unlink(path);\n    return true;\n};\nconst rename = ({ oldPath, newPath }) => {\n    ffmpeg.FS.rename(oldPath, newPath);\n    return true;\n};\n// TODO: check if creation works.\nconst createDir = ({ path }) => {\n    ffmpeg.FS.mkdir(path);\n    return true;\n};\nconst listDir = ({ path }) => {\n    const names = ffmpeg.FS.readdir(path);\n    const nodes = [];\n    for (const name of names) {\n        const stat = ffmpeg.FS.stat(`${path}/${name}`);\n        const isDir = ffmpeg.FS.isDir(stat.mode);\n        nodes.push({ name, isDir });\n    }\n    return nodes;\n};\n// TODO: check if deletion works.\nconst deleteDir = ({ path }) => {\n    ffmpeg.FS.rmdir(path);\n    return true;\n};\nconst mount = ({ fsType, options, mountPoint }) => {\n    const str = fsType;\n    const fs = ffmpeg.FS.filesystems[str];\n    if (!fs)\n        return false;\n    ffmpeg.FS.mount(fs, options, mountPoint);\n    return true;\n};\nconst unmount = ({ mountPoint }) => {\n    ffmpeg.FS.unmount(mountPoint);\n    return true;\n};\nself.onmessage = async ({ data: { id, type, data: _data }, }) => {\n    const trans = [];\n    let data;\n    try {\n        if (type !== FFMessageType.LOAD && !ffmpeg)\n            throw ERROR_NOT_LOADED; // eslint-disable-line\n        switch (type) {\n            case FFMessageType.LOAD:\n                data = await load(_data);\n                break;\n            case FFMessageType.EXEC:\n                data = exec(_data);\n                break;\n            case FFMessageType.WRITE_FILE:\n                data = writeFile(_data);\n                break;\n            case FFMessageType.READ_FILE:\n                data = readFile(_data);\n                break;\n            case FFMessageType.DELETE_FILE:\n                data = deleteFile(_data);\n                break;\n            case FFMessageType.RENAME:\n                data = rename(_data);\n                break;\n            case FFMessageType.CREATE_DIR:\n                data = createDir(_data);\n                break;\n            case FFMessageType.LIST_DIR:\n                data = listDir(_data);\n                break;\n            case FFMessageType.DELETE_DIR:\n                data = deleteDir(_data);\n                break;\n            case FFMessageType.MOUNT:\n                data = mount(_data);\n                break;\n            case FFMessageType.UNMOUNT:\n                data = unmount(_data);\n                break;\n            default:\n                throw ERROR_UNKNOWN_MESSAGE_TYPE;\n        }\n    }\n    catch (e) {\n        self.postMessage({\n            id,\n            type: FFMessageType.ERROR,\n            data: e.toString(),\n        });\n        return;\n    }\n    if (data instanceof Uint8Array) {\n        trans.push(data.buffer);\n    }\n    self.postMessage({ id, type, data }, trans);\n};\n"],"names":["root","factory","exports","module","define","amd","self","CORE_URL","FFMessageType","ERROR_UNKNOWN_MESSAGE_TYPE","Error","ERROR_NOT_LOADED","ERROR_IMPORT_FAILURE","ffmpeg","onmessage","async","data","id","type","_data","trans","LOAD","coreURL","_coreURL","wasmURL","_wasmURL","workerURL","_workerURL","first","importScripts","replace","createFFmpegCore","import","default","mainScriptUrlOrBlob","btoa","JSON","stringify","setLogger","postMessage","LOG","setProgress","PROGRESS","load","EXEC","args","timeout","setTimeout","exec","ret","reset","WRITE_FILE","path","FS","writeFile","READ_FILE","encoding","readFile","DELETE_FILE","unlink","deleteFile","RENAME","oldPath","newPath","rename","CREATE_DIR","mkdir","createDir","LIST_DIR","names","readdir","nodes","name","stat","isDir","mode","push","listDir","DELETE_DIR","rmdir","deleteDir","MOUNT","fsType","options","mountPoint","str","fs","filesystems","mount","UNMOUNT","unmount","e","ERROR","toString","Uint8Array","buffer"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js b/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js
new file mode 100644
index 0000000..05cdf7a
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js
@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FFmpegWASM=t():e.FFmpegWASM=t()}(self,(()=>(()=>{"use strict";var e={m:{},d:(t,s)=>{for(var r in s)e.o(s,r)&&!e.o(t,r)&&Object.defineProperty(t,r,{enumerable:!0,get:s[r]})},u:e=>e+".ffmpeg.js"};e.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),e.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),e.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},(()=>{var t;e.g.importScripts&&(t=e.g.location+"");var s=e.g.document;if(!t&&s&&(s.currentScript&&(t=s.currentScript.src),!t)){var r=s.getElementsByTagName("script");if(r.length)for(var a=r.length-1;a>-1&&!t;)t=r[a--].src}if(!t)throw new Error("Automatic publicPath is not supported in this browser");t=t.replace(/#.*$/,"").replace(/\?.*$/,"").replace(/\/[^\/]+$/,"/"),e.p=t})(),e.b=document.baseURI||self.location.href;var t,s={};e.r(s),e.d(s,{FFmpeg:()=>i}),function(e){e.LOAD="LOAD",e.EXEC="EXEC",e.WRITE_FILE="WRITE_FILE",e.READ_FILE="READ_FILE",e.DELETE_FILE="DELETE_FILE",e.RENAME="RENAME",e.CREATE_DIR="CREATE_DIR",e.LIST_DIR="LIST_DIR",e.DELETE_DIR="DELETE_DIR",e.ERROR="ERROR",e.DOWNLOAD="DOWNLOAD",e.PROGRESS="PROGRESS",e.LOG="LOG",e.MOUNT="MOUNT",e.UNMOUNT="UNMOUNT"}(t||(t={}));const r=(()=>{let e=0;return()=>e++})(),a=(new Error("unknown message type"),new Error("ffmpeg is not loaded, call `await ffmpeg.load()` first")),o=new Error("called FFmpeg.terminate()");new Error("failed to import ffmpeg-core.js");class i{#e=null;#t={};#s={};#r=[];#a=[];loaded=!1;#o=()=>{this.#e&&(this.#e.onmessage=({data:{id:e,type:s,data:r}})=>{switch(s){case t.LOAD:this.loaded=!0,this.#t[e](r);break;case t.MOUNT:case t.UNMOUNT:case t.EXEC:case t.WRITE_FILE:case t.READ_FILE:case t.DELETE_FILE:case t.RENAME:case t.CREATE_DIR:case t.LIST_DIR:case t.DELETE_DIR:this.#t[e](r);break;case t.LOG:this.#r.forEach((e=>e(r)));break;case t.PROGRESS:this.#a.forEach((e=>e(r)));break;case t.ERROR:this.#s[e](r)}delete this.#t[e],delete this.#s[e]})};#i=({type:e,data:t},s=[],o)=>this.#e?new Promise(((a,i)=>{const n=r();this.#e&&this.#e.postMessage({id:n,type:e,data:t},s),this.#t[n]=a,this.#s[n]=i,o?.addEventListener("abort",(()=>{i(new DOMException(`Message # ${n} was aborted`,"AbortError"))}),{once:!0})})):Promise.reject(a);on(e,t){"log"===e?this.#r.push(t):"progress"===e&&this.#a.push(t)}off(e,t){"log"===e?this.#r=this.#r.filter((e=>e!==t)):"progress"===e&&(this.#a=this.#a.filter((e=>e!==t)))}load=({classWorkerURL:s,...r}={},{signal:a}={})=>(this.#e||(this.#e=s?new Worker(new URL(s,"file:///home/jeromewu/ffmpeg.wasm/packages/ffmpeg/dist/esm/classes.js"),{type:"module"}):new Worker(new URL(e.p+e.u(814),e.b),{type:void 0}),this.#o()),this.#i({type:t.LOAD,data:r},void 0,a));exec=(e,s=-1,{signal:r}={})=>this.#i({type:t.EXEC,data:{args:e,timeout:s}},void 0,r);terminate=()=>{const e=Object.keys(this.#s);for(const t of e)this.#s[t](o),delete this.#s[t],delete this.#t[t];this.#e&&(this.#e.terminate(),this.#e=null,this.loaded=!1)};writeFile=(e,s,{signal:r}={})=>{const a=[];return s instanceof Uint8Array&&a.push(s.buffer),this.#i({type:t.WRITE_FILE,data:{path:e,data:s}},a,r)};mount=(e,s,r)=>this.#i({type:t.MOUNT,data:{fsType:e,options:s,mountPoint:r}},[]);unmount=e=>this.#i({type:t.UNMOUNT,data:{mountPoint:e}},[]);readFile=(e,s="binary",{signal:r}={})=>this.#i({type:t.READ_FILE,data:{path:e,encoding:s}},void 0,r);deleteFile=(e,{signal:s}={})=>this.#i({type:t.DELETE_FILE,data:{path:e}},void 0,s);rename=(e,s,{signal:r}={})=>this.#i({type:t.RENAME,data:{oldPath:e,newPath:s}},void 0,r);createDir=(e,{signal:s}={})=>this.#i({type:t.CREATE_DIR,data:{path:e}},void 0,s);listDir=(e,{signal:s}={})=>this.#i({type:t.LIST_DIR,data:{path:e}},void 0,s);deleteDir=(e,{signal:s}={})=>this.#i({type:t.DELETE_DIR,data:{path:e}},void 0,s)}return s})()));
+//# sourceMappingURL=ffmpeg.js.map
\ No newline at end of file
diff --git a/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js.map b/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js.map
new file mode 100644
index 0000000..d328f05
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/dist/umd/ffmpeg.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"ffmpeg.js","mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAoB,WAAID,IAExBD,EAAiB,WAAIC,GACtB,CATD,CASGK,MAAM,I,uBCRLC,EAAsB,CAG1BA,E,GCHAA,EAAwB,CAACL,EAASM,KACjC,IAAI,IAAIC,KAAOD,EACXD,EAAoBG,EAAEF,EAAYC,KAASF,EAAoBG,EAAER,EAASO,IAC5EE,OAAOC,eAAeV,EAASO,EAAK,CAAEI,YAAY,EAAMC,IAAKN,EAAWC,IAE1E,ECLDF,EAAyBQ,GAEZA,EAAU,cCHvBR,EAAoBS,EAAI,WACvB,GAA0B,iBAAfC,WAAyB,OAAOA,WAC3C,IACC,OAAOC,MAAQ,IAAIC,SAAS,cAAb,EAChB,CAAE,MAAOC,GACR,GAAsB,iBAAXC,OAAqB,OAAOA,MACxC,CACA,CAPuB,GCAxBd,EAAoBG,EAAI,CAACY,EAAKC,IAAUZ,OAAOa,UAAUC,eAAeC,KAAKJ,EAAKC,GCClFhB,EAAoBoB,EAAKzB,IACH,oBAAX0B,QAA0BA,OAAOC,aAC1ClB,OAAOC,eAAeV,EAAS0B,OAAOC,YAAa,CAAEC,MAAO,WAE7DnB,OAAOC,eAAeV,EAAS,aAAc,CAAE4B,OAAO,GAAO,E,MCL9D,IAAIC,EACAxB,EAAoBS,EAAEgB,gBAAeD,EAAYxB,EAAoBS,EAAEiB,SAAW,IACtF,IAAIC,EAAW3B,EAAoBS,EAAEkB,SACrC,IAAKH,GAAaG,IACbA,EAASC,gBACZJ,EAAYG,EAASC,cAAcC,MAC/BL,GAAW,CACf,IAAIM,EAAUH,EAASI,qBAAqB,UAC5C,GAAGD,EAAQE,OAEV,IADA,IAAIC,EAAIH,EAAQE,OAAS,EAClBC,GAAK,IAAMT,GAAWA,EAAYM,EAAQG,KAAKJ,GAExD,CAID,IAAKL,EAAW,MAAM,IAAIU,MAAM,yDAChCV,EAAYA,EAAUW,QAAQ,OAAQ,IAAIA,QAAQ,QAAS,IAAIA,QAAQ,YAAa,KACpFnC,EAAoBoC,EAAIZ,C,KClBxBxB,EAAoBqC,EAAIV,SAASW,SAAWvC,KAAK2B,SAASa,K,ICI/CC,E,kCACX,SAAWA,GACPA,EAAoB,KAAI,OACxBA,EAAoB,KAAI,OACxBA,EAA0B,WAAI,aAC9BA,EAAyB,UAAI,YAC7BA,EAA2B,YAAI,cAC/BA,EAAsB,OAAI,SAC1BA,EAA0B,WAAI,aAC9BA,EAAwB,SAAI,WAC5BA,EAA0B,WAAI,aAC9BA,EAAqB,MAAI,QACzBA,EAAwB,SAAI,WAC5BA,EAAwB,SAAI,WAC5BA,EAAmB,IAAI,MACvBA,EAAqB,MAAI,QACzBA,EAAuB,QAAI,SAC9B,CAhBD,CAgBGA,IAAkBA,EAAgB,CAAC,IClB/B,MAAMC,EAAe,MACxB,IAAIC,EAAY,EAChB,MAAO,IAAMA,GAChB,EAH2B,GCFfC,GAD6B,IAAIT,MAAM,wBACpB,IAAIA,MAAM,2DAC7BU,EAAmB,IAAIV,MAAM,6BACN,IAAIA,MAAM,mCCQvC,MAAMW,EACT,GAAU,KAKV,GAAY,CAAC,EACb,GAAW,CAAC,EACZ,GAAqB,GACrB,GAA0B,GAC1BC,QAAS,EAIT,GAAoB,KACZnC,MAAK,IACLA,MAAK,EAAQoC,UAAY,EAAGC,MAAQC,KAAIC,OAAMF,YAC1C,OAAQE,GACJ,KAAKV,EAAcW,KACfxC,KAAKmC,QAAS,EACdnC,MAAK,EAAUsC,GAAID,GACnB,MACJ,KAAKR,EAAcY,MACnB,KAAKZ,EAAca,QACnB,KAAKb,EAAcc,KACnB,KAAKd,EAAce,WACnB,KAAKf,EAAcgB,UACnB,KAAKhB,EAAciB,YACnB,KAAKjB,EAAckB,OACnB,KAAKlB,EAAcmB,WACnB,KAAKnB,EAAcoB,SACnB,KAAKpB,EAAcqB,WACflD,MAAK,EAAUsC,GAAID,GACnB,MACJ,KAAKR,EAAcsB,IACfnD,MAAK,EAAmBoD,SAASC,GAAMA,EAAEhB,KACzC,MACJ,KAAKR,EAAcyB,SACftD,MAAK,EAAwBoD,SAASC,GAAMA,EAAEhB,KAC9C,MACJ,KAAKR,EAAc0B,MACfvD,MAAK,EAASsC,GAAID,UAGnBrC,MAAK,EAAUsC,UACftC,MAAK,EAASsC,EAAG,EAEhC,EAKJ,GAAQ,EAAGC,OAAMF,QAAQmB,EAAQ,GAAIC,IAC5BzD,MAAK,EAGH,IAAI0D,SAAQ,CAACC,EAASC,KACzB,MAAMtB,EAAKR,IACX9B,MAAK,GAAWA,MAAK,EAAQ6D,YAAY,CAAEvB,KAAIC,OAAMF,QAAQmB,GAC7DxD,MAAK,EAAUsC,GAAMqB,EACrB3D,MAAK,EAASsC,GAAMsB,EACpBH,GAAQK,iBAAiB,SAAS,KAC9BF,EAAO,IAAIG,aAAa,aAAazB,gBAAkB,cAAc,GACtE,CAAE0B,MAAM,GAAO,IATXN,QAAQE,OAAO5B,GAY9B,EAAAiC,CAAGC,EAAOC,GACQ,QAAVD,EACAlE,MAAK,EAAmBoE,KAAKD,GAEd,aAAVD,GACLlE,MAAK,EAAwBoE,KAAKD,EAE1C,CACA,GAAAE,CAAIH,EAAOC,GACO,QAAVD,EACAlE,MAAK,EAAqBA,MAAK,EAAmBsE,QAAQjB,GAAMA,IAAMc,IAEvD,aAAVD,IACLlE,MAAK,EAA0BA,MAAK,EAAwBsE,QAAQjB,GAAMA,IAAMc,IAExF,CAQAI,KAAO,EAAGC,oBAAmBC,GAAW,CAAC,GAAKhB,UAAW,CAAC,KACjDzD,MAAK,IACNA,MAAK,EAAUwE,EACX,IAAIE,OAAO,IAAIC,IAAIH,EAAgB,yEAAkB,CACjDjC,KAAM,WAIV,IAAImC,OAAO,IAAIC,IAAI,kBAAiC,CAChDpC,UAAM,IAEdvC,MAAK,KAEFA,MAAK,EAAM,CACduC,KAAMV,EAAcW,KACpBH,KAAMoC,QACPG,EAAWnB,IAsBlBoB,KAAO,CAEPC,EAMAC,GAAU,GAAMtB,UAAW,CAAC,IAAMzD,MAAK,EAAM,CACzCuC,KAAMV,EAAcc,KACpBN,KAAM,CAAEyC,OAAMC,iBACfH,EAAWnB,GAOduB,UAAY,KACR,MAAMC,EAAMxF,OAAOyF,KAAKlF,MAAK,GAE7B,IAAK,MAAMsC,KAAM2C,EACbjF,MAAK,EAASsC,GAAIL,UACXjC,MAAK,EAASsC,UACdtC,MAAK,EAAUsC,GAEtBtC,MAAK,IACLA,MAAK,EAAQgF,YACbhF,MAAK,EAAU,KACfA,KAAKmC,QAAS,EAClB,EAeJgD,UAAY,CAACC,EAAM/C,GAAQoB,UAAW,CAAC,KACnC,MAAMD,EAAQ,GAId,OAHInB,aAAgBgD,YAChB7B,EAAMY,KAAK/B,EAAKiD,QAEbtF,MAAK,EAAM,CACduC,KAAMV,EAAce,WACpBP,KAAM,CAAE+C,OAAM/C,SACfmB,EAAOC,EAAO,EAErB8B,MAAQ,CAACC,EAAQC,EAASC,IAEf1F,MAAK,EAAM,CACduC,KAAMV,EAAcY,MACpBJ,KAAM,CAAEmD,SAAQC,UAASC,eAHf,IAMlBC,QAAWD,GAEA1F,MAAK,EAAM,CACduC,KAAMV,EAAca,QACpBL,KAAM,CAAEqD,eAHE,IAkBlBE,SAAW,CAACR,EAQZS,EAAW,UAAYpC,UAAW,CAAC,IAAMzD,MAAK,EAAM,CAChDuC,KAAMV,EAAcgB,UACpBR,KAAM,CAAE+C,OAAMS,kBACfjB,EAAWnB,GAMdqC,WAAa,CAACV,GAAQ3B,UAAW,CAAC,IAAMzD,MAAK,EAAM,CAC/CuC,KAAMV,EAAciB,YACpBT,KAAM,CAAE+C,cACTR,EAAWnB,GAMdsC,OAAS,CAACC,EAASC,GAAWxC,UAAW,CAAC,IAAMzD,MAAK,EAAM,CACvDuC,KAAMV,EAAckB,OACpBV,KAAM,CAAE2D,UAASC,iBAClBrB,EAAWnB,GAMdyC,UAAY,CAACd,GAAQ3B,UAAW,CAAC,IAAMzD,MAAK,EAAM,CAC9CuC,KAAMV,EAAcmB,WACpBX,KAAM,CAAE+C,cACTR,EAAWnB,GAMd0C,QAAU,CAACf,GAAQ3B,UAAW,CAAC,IAAMzD,MAAK,EAAM,CAC5CuC,KAAMV,EAAcoB,SACpBZ,KAAM,CAAE+C,cACTR,EAAWnB,GAMd2C,UAAY,CAAChB,GAAQ3B,UAAW,CAAC,IAAMzD,MAAK,EAAM,CAC9CuC,KAAMV,EAAcqB,WACpBb,KAAM,CAAE+C,cACTR,EAAWnB,G","sources":["webpack://FFmpegWASM/webpack/universalModuleDefinition","webpack://FFmpegWASM/webpack/bootstrap","webpack://FFmpegWASM/webpack/runtime/define property getters","webpack://FFmpegWASM/webpack/runtime/get javascript chunk filename","webpack://FFmpegWASM/webpack/runtime/global","webpack://FFmpegWASM/webpack/runtime/hasOwnProperty shorthand","webpack://FFmpegWASM/webpack/runtime/make namespace object","webpack://FFmpegWASM/webpack/runtime/publicPath","webpack://FFmpegWASM/webpack/runtime/jsonp chunk loading","webpack://FFmpegWASM/./dist/esm/const.js","webpack://FFmpegWASM/./dist/esm/utils.js","webpack://FFmpegWASM/./dist/esm/errors.js","webpack://FFmpegWASM/./dist/esm/classes.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FFmpegWASM\"] = factory();\n\telse\n\t\troot[\"FFmpegWASM\"] = factory();\n})(self, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".ffmpeg.js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t179: 0\n};\n\n// no chunk on demand loading\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// no jsonp function","export const MIME_TYPE_JAVASCRIPT = \"text/javascript\";\nexport const MIME_TYPE_WASM = \"application/wasm\";\nexport const CORE_VERSION = \"0.12.6\";\nexport const CORE_URL = `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/umd/ffmpeg-core.js`;\nexport var FFMessageType;\n(function (FFMessageType) {\n    FFMessageType[\"LOAD\"] = \"LOAD\";\n    FFMessageType[\"EXEC\"] = \"EXEC\";\n    FFMessageType[\"WRITE_FILE\"] = \"WRITE_FILE\";\n    FFMessageType[\"READ_FILE\"] = \"READ_FILE\";\n    FFMessageType[\"DELETE_FILE\"] = \"DELETE_FILE\";\n    FFMessageType[\"RENAME\"] = \"RENAME\";\n    FFMessageType[\"CREATE_DIR\"] = \"CREATE_DIR\";\n    FFMessageType[\"LIST_DIR\"] = \"LIST_DIR\";\n    FFMessageType[\"DELETE_DIR\"] = \"DELETE_DIR\";\n    FFMessageType[\"ERROR\"] = \"ERROR\";\n    FFMessageType[\"DOWNLOAD\"] = \"DOWNLOAD\";\n    FFMessageType[\"PROGRESS\"] = \"PROGRESS\";\n    FFMessageType[\"LOG\"] = \"LOG\";\n    FFMessageType[\"MOUNT\"] = \"MOUNT\";\n    FFMessageType[\"UNMOUNT\"] = \"UNMOUNT\";\n})(FFMessageType || (FFMessageType = {}));\n","/**\n * Generate an unique message ID.\n */\nexport const getMessageID = (() => {\n    let messageID = 0;\n    return () => messageID++;\n})();\n","export const ERROR_UNKNOWN_MESSAGE_TYPE = new Error(\"unknown message type\");\nexport const ERROR_NOT_LOADED = new Error(\"ffmpeg is not loaded, call `await ffmpeg.load()` first\");\nexport const ERROR_TERMINATED = new Error(\"called FFmpeg.terminate()\");\nexport const ERROR_IMPORT_FAILURE = new Error(\"failed to import ffmpeg-core.js\");\n","import { FFMessageType } from \"./const.js\";\nimport { getMessageID } from \"./utils.js\";\nimport { ERROR_TERMINATED, ERROR_NOT_LOADED } from \"./errors.js\";\n/**\n * Provides APIs to interact with ffmpeg web worker.\n *\n * @example\n * ```ts\n * const ffmpeg = new FFmpeg();\n * ```\n */\nexport class FFmpeg {\n    #worker = null;\n    /**\n     * #resolves and #rejects tracks Promise resolves and rejects to\n     * be called when we receive message from web worker.\n     */\n    #resolves = {};\n    #rejects = {};\n    #logEventCallbacks = [];\n    #progressEventCallbacks = [];\n    loaded = false;\n    /**\n     * register worker message event handlers.\n     */\n    #registerHandlers = () => {\n        if (this.#worker) {\n            this.#worker.onmessage = ({ data: { id, type, data }, }) => {\n                switch (type) {\n                    case FFMessageType.LOAD:\n                        this.loaded = true;\n                        this.#resolves[id](data);\n                        break;\n                    case FFMessageType.MOUNT:\n                    case FFMessageType.UNMOUNT:\n                    case FFMessageType.EXEC:\n                    case FFMessageType.WRITE_FILE:\n                    case FFMessageType.READ_FILE:\n                    case FFMessageType.DELETE_FILE:\n                    case FFMessageType.RENAME:\n                    case FFMessageType.CREATE_DIR:\n                    case FFMessageType.LIST_DIR:\n                    case FFMessageType.DELETE_DIR:\n                        this.#resolves[id](data);\n                        break;\n                    case FFMessageType.LOG:\n                        this.#logEventCallbacks.forEach((f) => f(data));\n                        break;\n                    case FFMessageType.PROGRESS:\n                        this.#progressEventCallbacks.forEach((f) => f(data));\n                        break;\n                    case FFMessageType.ERROR:\n                        this.#rejects[id](data);\n                        break;\n                }\n                delete this.#resolves[id];\n                delete this.#rejects[id];\n            };\n        }\n    };\n    /**\n     * Generic function to send messages to web worker.\n     */\n    #send = ({ type, data }, trans = [], signal) => {\n        if (!this.#worker) {\n            return Promise.reject(ERROR_NOT_LOADED);\n        }\n        return new Promise((resolve, reject) => {\n            const id = getMessageID();\n            this.#worker && this.#worker.postMessage({ id, type, data }, trans);\n            this.#resolves[id] = resolve;\n            this.#rejects[id] = reject;\n            signal?.addEventListener(\"abort\", () => {\n                reject(new DOMException(`Message # ${id} was aborted`, \"AbortError\"));\n            }, { once: true });\n        });\n    };\n    on(event, callback) {\n        if (event === \"log\") {\n            this.#logEventCallbacks.push(callback);\n        }\n        else if (event === \"progress\") {\n            this.#progressEventCallbacks.push(callback);\n        }\n    }\n    off(event, callback) {\n        if (event === \"log\") {\n            this.#logEventCallbacks = this.#logEventCallbacks.filter((f) => f !== callback);\n        }\n        else if (event === \"progress\") {\n            this.#progressEventCallbacks = this.#progressEventCallbacks.filter((f) => f !== callback);\n        }\n    }\n    /**\n     * Loads ffmpeg-core inside web worker. It is required to call this method first\n     * as it initializes WebAssembly and other essential variables.\n     *\n     * @category FFmpeg\n     * @returns `true` if ffmpeg core is loaded for the first time.\n     */\n    load = ({ classWorkerURL, ...config } = {}, { signal } = {}) => {\n        if (!this.#worker) {\n            this.#worker = classWorkerURL ?\n                new Worker(new URL(classWorkerURL, import.meta.url), {\n                    type: \"module\",\n                }) :\n                // We need to duplicated the code here to enable webpack\n                // to bundle worekr.js here.\n                new Worker(new URL(\"./worker.js\", import.meta.url), {\n                    type: \"module\",\n                });\n            this.#registerHandlers();\n        }\n        return this.#send({\n            type: FFMessageType.LOAD,\n            data: config,\n        }, undefined, signal);\n    };\n    /**\n     * Execute ffmpeg command.\n     *\n     * @remarks\n     * To avoid common I/O issues, [\"-nostdin\", \"-y\"] are prepended to the args\n     * by default.\n     *\n     * @example\n     * ```ts\n     * const ffmpeg = new FFmpeg();\n     * await ffmpeg.load();\n     * await ffmpeg.writeFile(\"video.avi\", ...);\n     * // ffmpeg -i video.avi video.mp4\n     * await ffmpeg.exec([\"-i\", \"video.avi\", \"video.mp4\"]);\n     * const data = ffmpeg.readFile(\"video.mp4\");\n     * ```\n     *\n     * @returns `0` if no error, `!= 0` if timeout (1) or error.\n     * @category FFmpeg\n     */\n    exec = (\n    /** ffmpeg command line args */\n    args, \n    /**\n     * milliseconds to wait before stopping the command execution.\n     *\n     * @defaultValue -1\n     */\n    timeout = -1, { signal } = {}) => this.#send({\n        type: FFMessageType.EXEC,\n        data: { args, timeout },\n    }, undefined, signal);\n    /**\n     * Terminate all ongoing API calls and terminate web worker.\n     * `FFmpeg.load()` must be called again before calling any other APIs.\n     *\n     * @category FFmpeg\n     */\n    terminate = () => {\n        const ids = Object.keys(this.#rejects);\n        // rejects all incomplete Promises.\n        for (const id of ids) {\n            this.#rejects[id](ERROR_TERMINATED);\n            delete this.#rejects[id];\n            delete this.#resolves[id];\n        }\n        if (this.#worker) {\n            this.#worker.terminate();\n            this.#worker = null;\n            this.loaded = false;\n        }\n    };\n    /**\n     * Write data to ffmpeg.wasm.\n     *\n     * @example\n     * ```ts\n     * const ffmpeg = new FFmpeg();\n     * await ffmpeg.load();\n     * await ffmpeg.writeFile(\"video.avi\", await fetchFile(\"../video.avi\"));\n     * await ffmpeg.writeFile(\"text.txt\", \"hello world\");\n     * ```\n     *\n     * @category File System\n     */\n    writeFile = (path, data, { signal } = {}) => {\n        const trans = [];\n        if (data instanceof Uint8Array) {\n            trans.push(data.buffer);\n        }\n        return this.#send({\n            type: FFMessageType.WRITE_FILE,\n            data: { path, data },\n        }, trans, signal);\n    };\n    mount = (fsType, options, mountPoint) => {\n        const trans = [];\n        return this.#send({\n            type: FFMessageType.MOUNT,\n            data: { fsType, options, mountPoint },\n        }, trans);\n    };\n    unmount = (mountPoint) => {\n        const trans = [];\n        return this.#send({\n            type: FFMessageType.UNMOUNT,\n            data: { mountPoint },\n        }, trans);\n    };\n    /**\n     * Read data from ffmpeg.wasm.\n     *\n     * @example\n     * ```ts\n     * const ffmpeg = new FFmpeg();\n     * await ffmpeg.load();\n     * const data = await ffmpeg.readFile(\"video.mp4\");\n     * ```\n     *\n     * @category File System\n     */\n    readFile = (path, \n    /**\n     * File content encoding, supports two encodings:\n     * - utf8: read file as text file, return data in string type.\n     * - binary: read file as binary file, return data in Uint8Array type.\n     *\n     * @defaultValue binary\n     */\n    encoding = \"binary\", { signal } = {}) => this.#send({\n        type: FFMessageType.READ_FILE,\n        data: { path, encoding },\n    }, undefined, signal);\n    /**\n     * Delete a file.\n     *\n     * @category File System\n     */\n    deleteFile = (path, { signal } = {}) => this.#send({\n        type: FFMessageType.DELETE_FILE,\n        data: { path },\n    }, undefined, signal);\n    /**\n     * Rename a file or directory.\n     *\n     * @category File System\n     */\n    rename = (oldPath, newPath, { signal } = {}) => this.#send({\n        type: FFMessageType.RENAME,\n        data: { oldPath, newPath },\n    }, undefined, signal);\n    /**\n     * Create a directory.\n     *\n     * @category File System\n     */\n    createDir = (path, { signal } = {}) => this.#send({\n        type: FFMessageType.CREATE_DIR,\n        data: { path },\n    }, undefined, signal);\n    /**\n     * List directory contents.\n     *\n     * @category File System\n     */\n    listDir = (path, { signal } = {}) => this.#send({\n        type: FFMessageType.LIST_DIR,\n        data: { path },\n    }, undefined, signal);\n    /**\n     * Delete an empty directory.\n     *\n     * @category File System\n     */\n    deleteDir = (path, { signal } = {}) => this.#send({\n        type: FFMessageType.DELETE_DIR,\n        data: { path },\n    }, undefined, signal);\n}\n"],"names":["root","factory","exports","module","define","amd","self","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","chunkId","g","globalThis","this","Function","e","window","obj","prop","prototype","hasOwnProperty","call","r","Symbol","toStringTag","value","scriptUrl","importScripts","location","document","currentScript","src","scripts","getElementsByTagName","length","i","Error","replace","p","b","baseURI","href","FFMessageType","getMessageID","messageID","ERROR_NOT_LOADED","ERROR_TERMINATED","FFmpeg","loaded","onmessage","data","id","type","LOAD","MOUNT","UNMOUNT","EXEC","WRITE_FILE","READ_FILE","DELETE_FILE","RENAME","CREATE_DIR","LIST_DIR","DELETE_DIR","LOG","forEach","f","PROGRESS","ERROR","trans","signal","Promise","resolve","reject","postMessage","addEventListener","DOMException","once","on","event","callback","push","off","filter","load","classWorkerURL","config","Worker","URL","undefined","exec","args","timeout","terminate","ids","keys","writeFile","path","Uint8Array","buffer","mount","fsType","options","mountPoint","unmount","readFile","encoding","deleteFile","rename","oldPath","newPath","createDir","listDir","deleteDir"],"sourceRoot":""}
\ No newline at end of file
diff --git a/node_modules/@ffmpeg/ffmpeg/package.json b/node_modules/@ffmpeg/ffmpeg/package.json
new file mode 100644
index 0000000..8dbc8c0
--- /dev/null
+++ b/node_modules/@ffmpeg/ffmpeg/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "@ffmpeg/ffmpeg",
+  "version": "0.12.10",
+  "description": "FFmpeg WebAssembly version for browser",
+  "main": "./dist/umd/ffmpeg.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "node": "./dist/esm/empty.mjs",
+      "default": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/umd/ffmpeg.js"
+      }
+    }
+  },
+  "scripts": {
+    "dev": "webpack -w --mode development",
+    "lint": "eslint src",
+    "clean": "rimraf dist",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:umd": "webpack",
+    "build": "npm run clean && npm run build:esm && npm run build:umd",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "types/ffmpeg.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ffmpegwasm/ffmpeg.wasm.git"
+  },
+  "keywords": [
+    "ffmpeg",
+    "WebAssembly",
+    "video",
+    "audio",
+    "transcode"
+  ],
+  "author": "Jerome Wu <jeromewus@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ffmpegwasm/ffmpeg.wasm/issues"
+  },
+  "engines": {
+    "node": ">=18.x"
+  },
+  "homepage": "https://github.com/ffmpegwasm/ffmpeg.wasm#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.1.0",
+    "@typescript-eslint/parser": "^6.1.0",
+    "eslint": "^8.45.0",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.1.6",
+    "webpack-cli": "^5.1.4"
+  },
+  "dependencies": {
+    "@ffmpeg/types": "^0.12.2"
+  }
+}
diff --git a/node_modules/@ffmpeg/types/package.json b/node_modules/@ffmpeg/types/package.json
new file mode 100644
index 0000000..65397a3
--- /dev/null
+++ b/node_modules/@ffmpeg/types/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "@ffmpeg/types",
+  "version": "0.12.2",
+  "description": "ffmpeg.wasm types",
+  "types": "types",
+  "files": [
+    "types"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ffmpegwasm/ffmpeg.wasm.git"
+  },
+  "keywords": [
+    "ffmpeg",
+    "WebAssembly",
+    "video",
+    "audio",
+    "transcode"
+  ],
+  "author": "Jerome Wu <jeromewus@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ffmpegwasm/ffmpeg.wasm/issues"
+  },
+  "engines": {
+    "node": ">=16.x"
+  },
+  "homepage": "https://github.com/ffmpegwasm/ffmpeg.wasm#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/node_modules/@ffmpeg/types/types/index.d.ts b/node_modules/@ffmpeg/types/types/index.d.ts
new file mode 100644
index 0000000..d3cd4fb
--- /dev/null
+++ b/node_modules/@ffmpeg/types/types/index.d.ts
@@ -0,0 +1,131 @@
+// TODO: Add lint and test.
+
+export type Pointer = number;
+
+export type StringPointer = Pointer;
+export type StringArrayPointer = Pointer;
+export type DateString = string;
+
+/**
+ * Options for readFile.
+ *
+ * @see [Emscripten File System API](https://emscripten.org/docs/api_reference/Filesystem-API.html#FS.readFile)
+ * @category File System
+ */
+export interface ReadFileOptions {
+  /** encoding of the file, must be `binary` or `utf8` */
+  encdoing: string;
+}
+
+/**
+ * Describes attributes of a node. (a.k.a file, directory)
+ *
+ * @see [Emscripten File System API](https://emscripten.org/docs/api_reference/Filesystem-API.html#FS.stat)
+ * @category File System
+ */
+export interface Stat {
+  dev: number;
+  ino: number;
+  mode: number;
+  nlink: number;
+  uid: number;
+  gid: number;
+  rdev: number;
+  size: number;
+  atime: DateString;
+  mtime: DateString;
+  ctime: DateString;
+  blksize: number;
+  blocks: number;
+}
+
+export interface FSFilesystemWORKERFS {
+  
+}
+
+export interface FSFilesystemMEMFS {
+  
+}
+
+export interface FSFilesystems {
+  WORKERFS: FSFilesystemWORKERFS;
+  MEMFS: FSFilesystemMEMFS;
+}
+
+export type FSFilesystem =
+| FSFilesystemWORKERFS
+| FSFilesystemMEMFS;
+
+/**
+ * Functions to interact with Emscripten FS library.
+ *
+ * @see [Emscripten File System API](https://emscripten.org/docs/api_reference/Filesystem-API.html)
+ * @category File System
+ */
+export interface FS {
+  mkdir: (path: string) => void;
+  rmdir: (path: string) => void;
+  rename: (oldPath: string, newPath: string) => void;
+  writeFile: (path: string, data: Uint8Array | string) => void;
+  readFile: (path: string, opts: OptionReadFile) => Uint8Array | string;
+  readdir: (path: string) => string[];
+  unlink: (path: string) => void;
+  stat: (path: string) => Stat;
+  /** mode is a numeric notation of permission, @see [Numeric Notation](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation) */
+  isFile: (mode: number) => boolean;
+  /** mode is a numeric notation of permission, @see [Numeric Notation](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation) */
+  isDir: (mode: number) => boolean;
+  mount: (fileSystemType: FSFilesystem, data: WorkerFSMountConfig, path: string) => void;
+  unmount: (path: string) => void;
+  filesystems: FSFilesystems;
+}
+
+/**
+ * Arguments passed to setLogger callback function.
+ */
+export interface Log {
+  /** file descriptor of the log, must be `stdout` or `stderr` */
+  type: string;
+  message: string;
+}
+
+/**
+ * Arguments passed to setProgress callback function.
+ */
+export interface Progress {
+  /** progress of the operation, interval = [0, 1] */
+  progress: number;
+  /** time of transcoded media in microseconds, ex: if a video is 10 seconds long, when time is 1000000 means 1 second of the video is transcoded already. */
+  time: number;
+}
+
+/**
+ * FFmpeg core module, an object to interact with ffmpeg.
+ */
+export interface FFmpegCoreModule {
+  /** default arguments prepend when running exec() */
+  DEFAULT_ARGS: string[];
+  FS: FS;
+  NULL: Pointer;
+  SIZE_I32: number;
+
+  /** return code of the ffmpeg exec, error when ret != 0 */
+  ret: number;
+  timeout: number;
+  mainScriptUrlOrBlob: string;
+
+  exec: (...args: string[]) => number;
+  reset: () => void;
+  setLogger: (logger: (log: Log) => void) => void;
+  setTimeout: (timeout: number) => void;
+  setProgress: (handler: (progress: Progress) => void) => void;
+
+  locateFile: (path: string, prefix: string) => string;
+}
+
+/**
+ * Factory of FFmpegCoreModule.
+ */
+export type FFmpegCoreModuleFactory = (
+  moduleOverrides?: Partial<FFmpegCoreModule>
+) => Promise<FFmpegCoreModule>;
diff --git a/node_modules/@ffmpeg/util/dist/cjs/const.d.ts b/node_modules/@ffmpeg/util/dist/cjs/const.d.ts
new file mode 100644
index 0000000..e4a71b1
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/const.d.ts
@@ -0,0 +1 @@
+export declare const HeaderContentLength = "Content-Length";
diff --git a/node_modules/@ffmpeg/util/dist/cjs/const.js b/node_modules/@ffmpeg/util/dist/cjs/const.js
new file mode 100644
index 0000000..9acb10e
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/const.js
@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeaderContentLength = void 0;
+exports.HeaderContentLength = "Content-Length";
diff --git a/node_modules/@ffmpeg/util/dist/cjs/errors.d.ts b/node_modules/@ffmpeg/util/dist/cjs/errors.d.ts
new file mode 100644
index 0000000..1cc685f
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/errors.d.ts
@@ -0,0 +1,2 @@
+export declare const ERROR_RESPONSE_BODY_READER: Error;
+export declare const ERROR_INCOMPLETED_DOWNLOAD: Error;
diff --git a/node_modules/@ffmpeg/util/dist/cjs/errors.js b/node_modules/@ffmpeg/util/dist/cjs/errors.js
new file mode 100644
index 0000000..e4a5fff
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/errors.js
@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_INCOMPLETED_DOWNLOAD = exports.ERROR_RESPONSE_BODY_READER = void 0;
+exports.ERROR_RESPONSE_BODY_READER = new Error("failed to get response body reader");
+exports.ERROR_INCOMPLETED_DOWNLOAD = new Error("failed to complete download");
diff --git a/node_modules/@ffmpeg/util/dist/cjs/index.d.ts b/node_modules/@ffmpeg/util/dist/cjs/index.d.ts
new file mode 100644
index 0000000..fb0ed59
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/index.d.ts
@@ -0,0 +1,50 @@
+import { ProgressCallback } from "./types.js";
+/**
+ * An util function to fetch data from url string, base64, URL, File or Blob format.
+ *
+ * Examples:
+ * ```ts
+ * // URL
+ * await fetchFile("http://localhost:3000/video.mp4");
+ * // base64
+ * await fetchFile("data:<type>;base64,wL2dvYWwgbW9yZ...");
+ * // URL
+ * await fetchFile(new URL("video.mp4", import.meta.url));
+ * // File
+ * fileInput.addEventListener('change', (e) => {
+ *   await fetchFile(e.target.files[0]);
+ * });
+ * // Blob
+ * const blob = new Blob(...);
+ * await fetchFile(blob);
+ * ```
+ */
+export declare const fetchFile: (file?: string | File | Blob) => Promise<Uint8Array>;
+/**
+ * importScript dynamically import a script, useful when you
+ * want to use different versions of ffmpeg.wasm based on environment.
+ *
+ * Example:
+ *
+ * ```ts
+ * await importScript("http://localhost:3000/ffmpeg.js");
+ * ```
+ */
+export declare const importScript: (url: string) => Promise<void>;
+/**
+ * Download content of a URL with progress.
+ *
+ * Progress only works when Content-Length is provided by the server.
+ *
+ */
+export declare const downloadWithProgress: (url: string | URL, cb?: ProgressCallback) => Promise<ArrayBuffer>;
+/**
+ * toBlobURL fetches data from an URL and return a blob URL.
+ *
+ * Example:
+ *
+ * ```ts
+ * await toBlobURL("http://localhost:3000/ffmpeg.js", "text/javascript");
+ * ```
+ */
+export declare const toBlobURL: (url: string, mimeType: string, progress?: boolean, cb?: ProgressCallback) => Promise<string>;
diff --git a/node_modules/@ffmpeg/util/dist/cjs/index.js b/node_modules/@ffmpeg/util/dist/cjs/index.js
new file mode 100644
index 0000000..59f01cf
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/index.js
@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBlobURL = exports.downloadWithProgress = exports.importScript = exports.fetchFile = void 0;
+const errors_js_1 = require("./errors.js");
+const const_js_1 = require("./const.js");
+const readFromBlobOrFile = (blob) => new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onload = () => {
+        const { result } = fileReader;
+        if (result instanceof ArrayBuffer) {
+            resolve(new Uint8Array(result));
+        }
+        else {
+            resolve(new Uint8Array());
+        }
+    };
+    fileReader.onerror = (event) => {
+        var _a, _b;
+        reject(Error(`File could not be read! Code=${((_b = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code) || -1}`));
+    };
+    fileReader.readAsArrayBuffer(blob);
+});
+/**
+ * An util function to fetch data from url string, base64, URL, File or Blob format.
+ *
+ * Examples:
+ * ```ts
+ * // URL
+ * await fetchFile("http://localhost:3000/video.mp4");
+ * // base64
+ * await fetchFile("data:<type>;base64,wL2dvYWwgbW9yZ...");
+ * // URL
+ * await fetchFile(new URL("video.mp4", import.meta.url));
+ * // File
+ * fileInput.addEventListener('change', (e) => {
+ *   await fetchFile(e.target.files[0]);
+ * });
+ * // Blob
+ * const blob = new Blob(...);
+ * await fetchFile(blob);
+ * ```
+ */
+const fetchFile = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    let data;
+    if (typeof file === "string") {
+        /* From base64 format */
+        if (/data:_data\/([a-zA-Z]*);base64,([^"]*)/.test(file)) {
+            data = atob(file.split(",")[1])
+                .split("")
+                .map((c) => c.charCodeAt(0));
+            /* From remote server/URL */
+        }
+        else {
+            data = yield (yield fetch(file)).arrayBuffer();
+        }
+    }
+    else if (file instanceof URL) {
+        data = yield (yield fetch(file)).arrayBuffer();
+    }
+    else if (file instanceof File || file instanceof Blob) {
+        data = yield readFromBlobOrFile(file);
+    }
+    else {
+        return new Uint8Array();
+    }
+    return new Uint8Array(data);
+});
+exports.fetchFile = fetchFile;
+/**
+ * importScript dynamically import a script, useful when you
+ * want to use different versions of ffmpeg.wasm based on environment.
+ *
+ * Example:
+ *
+ * ```ts
+ * await importScript("http://localhost:3000/ffmpeg.js");
+ * ```
+ */
+const importScript = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        const script = document.createElement("script");
+        const eventHandler = () => {
+            script.removeEventListener("load", eventHandler);
+            resolve();
+        };
+        script.src = url;
+        script.type = "text/javascript";
+        script.addEventListener("load", eventHandler);
+        document.getElementsByTagName("head")[0].appendChild(script);
+    });
+});
+exports.importScript = importScript;
+/**
+ * Download content of a URL with progress.
+ *
+ * Progress only works when Content-Length is provided by the server.
+ *
+ */
+const downloadWithProgress = (url, cb) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const resp = yield fetch(url);
+    let buf;
+    try {
+        // Set total to -1 to indicate that there is not Content-Type Header.
+        const total = parseInt(resp.headers.get(const_js_1.HeaderContentLength) || "-1");
+        const reader = (_a = resp.body) === null || _a === void 0 ? void 0 : _a.getReader();
+        if (!reader)
+            throw errors_js_1.ERROR_RESPONSE_BODY_READER;
+        const chunks = [];
+        let received = 0;
+        for (;;) {
+            const { done, value } = yield reader.read();
+            const delta = value ? value.length : 0;
+            if (done) {
+                if (total != -1 && total !== received)
+                    throw errors_js_1.ERROR_INCOMPLETED_DOWNLOAD;
+                cb && cb({ url, total, received, delta, done });
+                break;
+            }
+            chunks.push(value);
+            received += delta;
+            cb && cb({ url, total, received, delta, done });
+        }
+        const data = new Uint8Array(received);
+        let position = 0;
+        for (const chunk of chunks) {
+            data.set(chunk, position);
+            position += chunk.length;
+        }
+        buf = data.buffer;
+    }
+    catch (e) {
+        console.log(`failed to send download progress event: `, e);
+        // Fetch arrayBuffer directly when it is not possible to get progress.
+        buf = yield resp.arrayBuffer();
+        cb &&
+            cb({
+                url,
+                total: buf.byteLength,
+                received: buf.byteLength,
+                delta: 0,
+                done: true,
+            });
+    }
+    return buf;
+});
+exports.downloadWithProgress = downloadWithProgress;
+/**
+ * toBlobURL fetches data from an URL and return a blob URL.
+ *
+ * Example:
+ *
+ * ```ts
+ * await toBlobURL("http://localhost:3000/ffmpeg.js", "text/javascript");
+ * ```
+ */
+const toBlobURL = (url, mimeType, progress = false, cb) => __awaiter(void 0, void 0, void 0, function* () {
+    const buf = progress
+        ? yield (0, exports.downloadWithProgress)(url, cb)
+        : yield (yield fetch(url)).arrayBuffer();
+    const blob = new Blob([buf], { type: mimeType });
+    return URL.createObjectURL(blob);
+});
+exports.toBlobURL = toBlobURL;
diff --git a/node_modules/@ffmpeg/util/dist/cjs/types.d.ts b/node_modules/@ffmpeg/util/dist/cjs/types.d.ts
new file mode 100644
index 0000000..4d420ef
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/types.d.ts
@@ -0,0 +1,8 @@
+export interface DownloadProgressEvent {
+    url: string | URL;
+    total: number;
+    received: number;
+    delta: number;
+    done: boolean;
+}
+export type ProgressCallback = (event: DownloadProgressEvent) => void;
diff --git a/node_modules/@ffmpeg/util/dist/cjs/types.js b/node_modules/@ffmpeg/util/dist/cjs/types.js
new file mode 100644
index 0000000..c8ad2e5
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/cjs/types.js
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
diff --git a/node_modules/@ffmpeg/util/dist/esm/const.d.ts b/node_modules/@ffmpeg/util/dist/esm/const.d.ts
new file mode 100644
index 0000000..e4a71b1
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/const.d.ts
@@ -0,0 +1 @@
+export declare const HeaderContentLength = "Content-Length";
diff --git a/node_modules/@ffmpeg/util/dist/esm/const.js b/node_modules/@ffmpeg/util/dist/esm/const.js
new file mode 100644
index 0000000..5d0cd85
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/const.js
@@ -0,0 +1 @@
+export const HeaderContentLength = "Content-Length";
diff --git a/node_modules/@ffmpeg/util/dist/esm/errors.d.ts b/node_modules/@ffmpeg/util/dist/esm/errors.d.ts
new file mode 100644
index 0000000..1cc685f
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/errors.d.ts
@@ -0,0 +1,2 @@
+export declare const ERROR_RESPONSE_BODY_READER: Error;
+export declare const ERROR_INCOMPLETED_DOWNLOAD: Error;
diff --git a/node_modules/@ffmpeg/util/dist/esm/errors.js b/node_modules/@ffmpeg/util/dist/esm/errors.js
new file mode 100644
index 0000000..57250d8
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/errors.js
@@ -0,0 +1,2 @@
+export const ERROR_RESPONSE_BODY_READER = new Error("failed to get response body reader");
+export const ERROR_INCOMPLETED_DOWNLOAD = new Error("failed to complete download");
diff --git a/node_modules/@ffmpeg/util/dist/esm/index.d.ts b/node_modules/@ffmpeg/util/dist/esm/index.d.ts
new file mode 100644
index 0000000..fb0ed59
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/index.d.ts
@@ -0,0 +1,50 @@
+import { ProgressCallback } from "./types.js";
+/**
+ * An util function to fetch data from url string, base64, URL, File or Blob format.
+ *
+ * Examples:
+ * ```ts
+ * // URL
+ * await fetchFile("http://localhost:3000/video.mp4");
+ * // base64
+ * await fetchFile("data:<type>;base64,wL2dvYWwgbW9yZ...");
+ * // URL
+ * await fetchFile(new URL("video.mp4", import.meta.url));
+ * // File
+ * fileInput.addEventListener('change', (e) => {
+ *   await fetchFile(e.target.files[0]);
+ * });
+ * // Blob
+ * const blob = new Blob(...);
+ * await fetchFile(blob);
+ * ```
+ */
+export declare const fetchFile: (file?: string | File | Blob) => Promise<Uint8Array>;
+/**
+ * importScript dynamically import a script, useful when you
+ * want to use different versions of ffmpeg.wasm based on environment.
+ *
+ * Example:
+ *
+ * ```ts
+ * await importScript("http://localhost:3000/ffmpeg.js");
+ * ```
+ */
+export declare const importScript: (url: string) => Promise<void>;
+/**
+ * Download content of a URL with progress.
+ *
+ * Progress only works when Content-Length is provided by the server.
+ *
+ */
+export declare const downloadWithProgress: (url: string | URL, cb?: ProgressCallback) => Promise<ArrayBuffer>;
+/**
+ * toBlobURL fetches data from an URL and return a blob URL.
+ *
+ * Example:
+ *
+ * ```ts
+ * await toBlobURL("http://localhost:3000/ffmpeg.js", "text/javascript");
+ * ```
+ */
+export declare const toBlobURL: (url: string, mimeType: string, progress?: boolean, cb?: ProgressCallback) => Promise<string>;
diff --git a/node_modules/@ffmpeg/util/dist/esm/index.js b/node_modules/@ffmpeg/util/dist/esm/index.js
new file mode 100644
index 0000000..d96a383
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/index.js
@@ -0,0 +1,153 @@
+import { ERROR_RESPONSE_BODY_READER, ERROR_INCOMPLETED_DOWNLOAD, } from "./errors.js";
+import { HeaderContentLength } from "./const.js";
+const readFromBlobOrFile = (blob) => new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onload = () => {
+        const { result } = fileReader;
+        if (result instanceof ArrayBuffer) {
+            resolve(new Uint8Array(result));
+        }
+        else {
+            resolve(new Uint8Array());
+        }
+    };
+    fileReader.onerror = (event) => {
+        reject(Error(`File could not be read! Code=${event?.target?.error?.code || -1}`));
+    };
+    fileReader.readAsArrayBuffer(blob);
+});
+/**
+ * An util function to fetch data from url string, base64, URL, File or Blob format.
+ *
+ * Examples:
+ * ```ts
+ * // URL
+ * await fetchFile("http://localhost:3000/video.mp4");
+ * // base64
+ * await fetchFile("data:<type>;base64,wL2dvYWwgbW9yZ...");
+ * // URL
+ * await fetchFile(new URL("video.mp4", import.meta.url));
+ * // File
+ * fileInput.addEventListener('change', (e) => {
+ *   await fetchFile(e.target.files[0]);
+ * });
+ * // Blob
+ * const blob = new Blob(...);
+ * await fetchFile(blob);
+ * ```
+ */
+export const fetchFile = async (file) => {
+    let data;
+    if (typeof file === "string") {
+        /* From base64 format */
+        if (/data:_data\/([a-zA-Z]*);base64,([^"]*)/.test(file)) {
+            data = atob(file.split(",")[1])
+                .split("")
+                .map((c) => c.charCodeAt(0));
+            /* From remote server/URL */
+        }
+        else {
+            data = await (await fetch(file)).arrayBuffer();
+        }
+    }
+    else if (file instanceof URL) {
+        data = await (await fetch(file)).arrayBuffer();
+    }
+    else if (file instanceof File || file instanceof Blob) {
+        data = await readFromBlobOrFile(file);
+    }
+    else {
+        return new Uint8Array();
+    }
+    return new Uint8Array(data);
+};
+/**
+ * importScript dynamically import a script, useful when you
+ * want to use different versions of ffmpeg.wasm based on environment.
+ *
+ * Example:
+ *
+ * ```ts
+ * await importScript("http://localhost:3000/ffmpeg.js");
+ * ```
+ */
+export const importScript = async (url) => new Promise((resolve) => {
+    const script = document.createElement("script");
+    const eventHandler = () => {
+        script.removeEventListener("load", eventHandler);
+        resolve();
+    };
+    script.src = url;
+    script.type = "text/javascript";
+    script.addEventListener("load", eventHandler);
+    document.getElementsByTagName("head")[0].appendChild(script);
+});
+/**
+ * Download content of a URL with progress.
+ *
+ * Progress only works when Content-Length is provided by the server.
+ *
+ */
+export const downloadWithProgress = async (url, cb) => {
+    const resp = await fetch(url);
+    let buf;
+    try {
+        // Set total to -1 to indicate that there is not Content-Type Header.
+        const total = parseInt(resp.headers.get(HeaderContentLength) || "-1");
+        const reader = resp.body?.getReader();
+        if (!reader)
+            throw ERROR_RESPONSE_BODY_READER;
+        const chunks = [];
+        let received = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            const delta = value ? value.length : 0;
+            if (done) {
+                if (total != -1 && total !== received)
+                    throw ERROR_INCOMPLETED_DOWNLOAD;
+                cb && cb({ url, total, received, delta, done });
+                break;
+            }
+            chunks.push(value);
+            received += delta;
+            cb && cb({ url, total, received, delta, done });
+        }
+        const data = new Uint8Array(received);
+        let position = 0;
+        for (const chunk of chunks) {
+            data.set(chunk, position);
+            position += chunk.length;
+        }
+        buf = data.buffer;
+    }
+    catch (e) {
+        console.log(`failed to send download progress event: `, e);
+        // Fetch arrayBuffer directly when it is not possible to get progress.
+        buf = await resp.arrayBuffer();
+        cb &&
+            cb({
+                url,
+                total: buf.byteLength,
+                received: buf.byteLength,
+                delta: 0,
+                done: true,
+            });
+    }
+    return buf;
+};
+/**
+ * toBlobURL fetches data from an URL and return a blob URL.
+ *
+ * Example:
+ *
+ * ```ts
+ * await toBlobURL("http://localhost:3000/ffmpeg.js", "text/javascript");
+ * ```
+ */
+export const toBlobURL = async (url, mimeType, progress = false, cb) => {
+    const buf = progress
+        ? await downloadWithProgress(url, cb)
+        : await (await fetch(url)).arrayBuffer();
+    const blob = new Blob([buf], { type: mimeType });
+    return URL.createObjectURL(blob);
+};
diff --git a/node_modules/@ffmpeg/util/dist/esm/types.d.ts b/node_modules/@ffmpeg/util/dist/esm/types.d.ts
new file mode 100644
index 0000000..4d420ef
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/types.d.ts
@@ -0,0 +1,8 @@
+export interface DownloadProgressEvent {
+    url: string | URL;
+    total: number;
+    received: number;
+    delta: number;
+    done: boolean;
+}
+export type ProgressCallback = (event: DownloadProgressEvent) => void;
diff --git a/node_modules/@ffmpeg/util/dist/esm/types.js b/node_modules/@ffmpeg/util/dist/esm/types.js
new file mode 100644
index 0000000..cb0ff5c
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/esm/types.js
@@ -0,0 +1 @@
+export {};
diff --git a/node_modules/@ffmpeg/util/dist/umd/index.js b/node_modules/@ffmpeg/util/dist/umd/index.js
new file mode 100644
index 0000000..e3fae0b
--- /dev/null
+++ b/node_modules/@ffmpeg/util/dist/umd/index.js
@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FFmpegUtil=t():e.FFmpegUtil=t()}(self,(()=>(()=>{"use strict";var e={591:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.HeaderContentLength=void 0,t.HeaderContentLength="Content-Length"},431:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.ERROR_INCOMPLETED_DOWNLOAD=t.ERROR_RESPONSE_BODY_READER=void 0,t.ERROR_RESPONSE_BODY_READER=new Error("failed to get response body reader"),t.ERROR_INCOMPLETED_DOWNLOAD=new Error("failed to complete download")},915:function(e,t,o){var r=this&&this.__awaiter||function(e,t,o,r){return new(o||(o=Promise))((function(n,i){function d(e){try{l(r.next(e))}catch(e){i(e)}}function a(e){try{l(r.throw(e))}catch(e){i(e)}}function l(e){var t;e.done?n(e.value):(t=e.value,t instanceof o?t:new o((function(e){e(t)}))).then(d,a)}l((r=r.apply(e,t||[])).next())}))};Object.defineProperty(t,"__esModule",{value:!0}),t.toBlobURL=t.downloadWithProgress=t.importScript=t.fetchFile=void 0;const n=o(431),i=o(591);t.fetchFile=e=>r(void 0,void 0,void 0,(function*(){let t;if("string"==typeof e)t=/data:_data\/([a-zA-Z]*);base64,([^"]*)/.test(e)?atob(e.split(",")[1]).split("").map((e=>e.charCodeAt(0))):yield(yield fetch(e)).arrayBuffer();else if(e instanceof URL)t=yield(yield fetch(e)).arrayBuffer();else{if(!(e instanceof File||e instanceof Blob))return new Uint8Array;t=yield(o=e,new Promise(((e,t)=>{const r=new FileReader;r.onload=()=>{const{result:t}=r;t instanceof ArrayBuffer?e(new Uint8Array(t)):e(new Uint8Array)},r.onerror=e=>{var o,r;t(Error(`File could not be read! Code=${(null===(r=null===(o=null==e?void 0:e.target)||void 0===o?void 0:o.error)||void 0===r?void 0:r.code)||-1}`))},r.readAsArrayBuffer(o)})))}var o;return new Uint8Array(t)})),t.importScript=e=>r(void 0,void 0,void 0,(function*(){return new Promise((t=>{const o=document.createElement("script"),r=()=>{o.removeEventListener("load",r),t()};o.src=e,o.type="text/javascript",o.addEventListener("load",r),document.getElementsByTagName("head")[0].appendChild(o)}))})),t.downloadWithProgress=(e,t)=>r(void 0,void 0,void 0,(function*(){var o;const r=yield fetch(e);let d;try{const a=parseInt(r.headers.get(i.HeaderContentLength)||"-1"),l=null===(o=r.body)||void 0===o?void 0:o.getReader();if(!l)throw n.ERROR_RESPONSE_BODY_READER;const c=[];let s=0;for(;;){const{done:o,value:r}=yield l.read(),i=r?r.length:0;if(o){if(-1!=a&&a!==s)throw n.ERROR_INCOMPLETED_DOWNLOAD;t&&t({url:e,total:a,received:s,delta:i,done:o});break}c.push(r),s+=i,t&&t({url:e,total:a,received:s,delta:i,done:o})}const f=new Uint8Array(s);let u=0;for(const e of c)f.set(e,u),u+=e.length;d=f.buffer}catch(o){console.log("failed to send download progress event: ",o),d=yield r.arrayBuffer(),t&&t({url:e,total:d.byteLength,received:d.byteLength,delta:0,done:!0})}return d})),t.toBlobURL=(e,o,n=!1,i)=>r(void 0,void 0,void 0,(function*(){const r=n?yield(0,t.downloadWithProgress)(e,i):yield(yield fetch(e)).arrayBuffer(),d=new Blob([r],{type:o});return URL.createObjectURL(d)}))}},t={};return function o(r){var n=t[r];if(void 0!==n)return n.exports;var i=t[r]={exports:{}};return e[r].call(i.exports,i,i.exports,o),i.exports}(915)})()));
\ No newline at end of file
diff --git a/node_modules/@ffmpeg/util/package.json b/node_modules/@ffmpeg/util/package.json
new file mode 100644
index 0000000..3afedb4
--- /dev/null
+++ b/node_modules/@ffmpeg/util/package.json
@@ -0,0 +1,56 @@
+{
+  "name": "@ffmpeg/util",
+  "version": "0.12.1",
+  "description": "browser utils for @ffmpeg/*",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cjs/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsc -p tsconfig-esm.json --watch",
+    "lint": "eslint src",
+    "clean": "rimraf dist",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:umd": "tsc -p tsconfig.cjs.json && webpack",
+    "build": "npm run clean && npm run build:esm && npm run build:umd",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ffmpegwasm/ffmpeg.wasm.git"
+  },
+  "keywords": [
+    "ffmpeg",
+    "video",
+    "audio",
+    "transcode"
+  ],
+  "author": "Jerome Wu <jeromewus@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ffmpegwasm/ffmpeg.wasm/issues"
+  },
+  "engines": {
+    "node": ">=18.x"
+  },
+  "homepage": "https://github.com/ffmpegwasm/ffmpeg.wasm#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.1.0",
+    "@typescript-eslint/parser": "^6.1.0",
+    "eslint": "^8.45.0",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.1.6",
+    "webpack-cli": "^5.1.4"
+  }
+}
diff --git a/node_modules/@rollup/rollup-darwin-arm64/README.md b/node_modules/@rollup/rollup-darwin-arm64/README.md
new file mode 100644
index 0000000..c29619c
--- /dev/null
+++ b/node_modules/@rollup/rollup-darwin-arm64/README.md
@@ -0,0 +1,3 @@
+# `@rollup/rollup-darwin-arm64`
+
+This is the **aarch64-apple-darwin** binary for `rollup`
diff --git a/node_modules/@rollup/rollup-darwin-arm64/package.json b/node_modules/@rollup/rollup-darwin-arm64/package.json
new file mode 100644
index 0000000..9f52e7e
--- /dev/null
+++ b/node_modules/@rollup/rollup-darwin-arm64/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "@rollup/rollup-darwin-arm64",
+  "version": "4.24.0",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "rollup.darwin-arm64.node"
+  ],
+  "description": "Native bindings for Rollup",
+  "author": "Lukas Taegert-Atkinson",
+  "homepage": "https://rollupjs.org/",
+  "license": "MIT",
+  "repository": "rollup/rollup",
+  "main": "./rollup.darwin-arm64.node"
+}
\ No newline at end of file
diff --git a/node_modules/@rollup/rollup-darwin-arm64/rollup.darwin-arm64.node b/node_modules/@rollup/rollup-darwin-arm64/rollup.darwin-arm64.node
new file mode 100644
index 0000000..dc16dfa
Binary files /dev/null and b/node_modules/@rollup/rollup-darwin-arm64/rollup.darwin-arm64.node differ
diff --git a/node_modules/@types/estree/LICENSE b/node_modules/@types/estree/LICENSE
new file mode 100644
index 0000000..9e841e7
--- /dev/null
+++ b/node_modules/@types/estree/LICENSE
@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE
diff --git a/node_modules/@types/estree/README.md b/node_modules/@types/estree/README.md
new file mode 100644
index 0000000..5a6f4c8
--- /dev/null
+++ b/node_modules/@types/estree/README.md
@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/estree`
+
+# Summary
+This package contains type definitions for estree (https://github.com/estree/estree).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.
+
+### Additional Details
+ * Last updated: Wed, 18 Sep 2024 09:37:00 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [RReverser](https://github.com/RReverser).
diff --git a/node_modules/@types/estree/flow.d.ts b/node_modules/@types/estree/flow.d.ts
new file mode 100644
index 0000000..9d001a9
--- /dev/null
+++ b/node_modules/@types/estree/flow.d.ts
@@ -0,0 +1,167 @@
+declare namespace ESTree {
+    interface FlowTypeAnnotation extends Node {}
+
+    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
+
+    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
+
+    interface FlowDeclaration extends Declaration {}
+
+    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
+        elementType: FlowTypeAnnotation;
+    }
+
+    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface ClassImplements extends Node {
+        id: Identifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface ClassProperty {
+        key: Expression;
+        value?: Expression | null;
+        typeAnnotation?: TypeAnnotation | null;
+        computed: boolean;
+        static: boolean;
+    }
+
+    interface DeclareClass extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        body: ObjectTypeAnnotation;
+        extends: InterfaceExtends[];
+    }
+
+    interface DeclareFunction extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface DeclareModule extends FlowDeclaration {
+        id: Literal | Identifier;
+        body: BlockStatement;
+    }
+
+    interface DeclareVariable extends FlowDeclaration {
+        id: Identifier;
+    }
+
+    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
+        params: FunctionTypeParam[];
+        returnType: FlowTypeAnnotation;
+        rest?: FunctionTypeParam | null;
+        typeParameters?: TypeParameterDeclaration | null;
+    }
+
+    interface FunctionTypeParam {
+        name: Identifier;
+        typeAnnotation: FlowTypeAnnotation;
+        optional: boolean;
+    }
+
+    interface GenericTypeAnnotation extends FlowTypeAnnotation {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceExtends extends Node {
+        id: Identifier | QualifiedTypeIdentifier;
+        typeParameters?: TypeParameterInstantiation | null;
+    }
+
+    interface InterfaceDeclaration extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        extends: InterfaceExtends[];
+        body: ObjectTypeAnnotation;
+    }
+
+    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface NullableTypeAnnotation extends FlowTypeAnnotation {
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
+
+    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
+
+    interface TupleTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
+        argument: FlowTypeAnnotation;
+    }
+
+    interface TypeAlias extends FlowDeclaration {
+        id: Identifier;
+        typeParameters?: TypeParameterDeclaration | null;
+        right: FlowTypeAnnotation;
+    }
+
+    interface TypeAnnotation extends Node {
+        typeAnnotation: FlowTypeAnnotation;
+    }
+
+    interface TypeCastExpression extends Expression {
+        expression: Expression;
+        typeAnnotation: TypeAnnotation;
+    }
+
+    interface TypeParameterDeclaration extends Node {
+        params: Identifier[];
+    }
+
+    interface TypeParameterInstantiation extends Node {
+        params: FlowTypeAnnotation[];
+    }
+
+    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
+        properties: ObjectTypeProperty[];
+        indexers: ObjectTypeIndexer[];
+        callProperties: ObjectTypeCallProperty[];
+    }
+
+    interface ObjectTypeCallProperty extends Node {
+        value: FunctionTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeIndexer extends Node {
+        id: Identifier;
+        key: FlowTypeAnnotation;
+        value: FlowTypeAnnotation;
+        static: boolean;
+    }
+
+    interface ObjectTypeProperty extends Node {
+        key: Expression;
+        value: FlowTypeAnnotation;
+        optional: boolean;
+        static: boolean;
+    }
+
+    interface QualifiedTypeIdentifier extends Node {
+        qualification: Identifier | QualifiedTypeIdentifier;
+        id: Identifier;
+    }
+
+    interface UnionTypeAnnotation extends FlowTypeAnnotation {
+        types: FlowTypeAnnotation[];
+    }
+
+    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
+}
diff --git a/node_modules/@types/estree/index.d.ts b/node_modules/@types/estree/index.d.ts
new file mode 100644
index 0000000..81a351f
--- /dev/null
+++ b/node_modules/@types/estree/index.d.ts
@@ -0,0 +1,684 @@
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+export interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+export interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+export interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+export type Node = NodeMap[keyof NodeMap];
+
+export interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+export interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+
+export interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+export interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+export interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
+}
+
+export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+export type Statement =
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
+
+export interface BaseStatement extends BaseNode {}
+
+export interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+export interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+export interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+export interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+export interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+export interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+export interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+export interface BaseDeclaration extends BaseStatement {}
+
+export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const";
+}
+
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+export interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+export type Expression = ExpressionMap[keyof ExpressionMap];
+
+export interface BaseExpression extends BaseNode {}
+
+export type ChainElement = SimpleCallExpression | MemberExpression;
+
+export interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+export interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+export interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+export interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+export interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression | PrivateIdentifier;
+    right: Expression;
+}
+
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+export interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+export type CallExpression = SimpleCallExpression | NewExpression;
+
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+export interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+export interface BasePattern extends BaseNode {}
+
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+export interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+
+export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+export interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+export interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+export interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type BinaryOperator =
+    | "=="
+    | "!="
+    | "==="
+    | "!=="
+    | "<"
+    | "<="
+    | ">"
+    | ">="
+    | "<<"
+    | ">>"
+    | ">>>"
+    | "+"
+    | "-"
+    | "*"
+    | "/"
+    | "%"
+    | "**"
+    | "|"
+    | "^"
+    | "&"
+    | "in"
+    | "instanceof";
+
+export type LogicalOperator = "||" | "&&" | "??";
+
+export type AssignmentOperator =
+    | "="
+    | "+="
+    | "-="
+    | "*="
+    | "/="
+    | "%="
+    | "**="
+    | "<<="
+    | ">>="
+    | ">>>="
+    | "|="
+    | "^="
+    | "&="
+    | "||="
+    | "&&="
+    | "??=";
+
+export type UpdateOperator = "++" | "--";
+
+export interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+export interface Super extends BaseNode {
+    type: "Super";
+}
+
+export interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+export interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+export interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+export interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+export interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+export interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean; // false
+}
+
+export interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+export interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+export interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+export interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+export type Class = ClassDeclaration | ClassExpression;
+export interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+export interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+export interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+export interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+export interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+export interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+export type ModuleDeclaration =
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+export interface BaseModuleDeclaration extends BaseNode {}
+
+export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+export interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+export interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    source: Literal;
+}
+
+export interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+}
+
+export interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+}
+
+export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+export interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    source?: Literal | null | undefined;
+}
+
+export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+}
+
+export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+export interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    source: Literal;
+}
+
+export interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
diff --git a/node_modules/@types/estree/package.json b/node_modules/@types/estree/package.json
new file mode 100644
index 0000000..f410761
--- /dev/null
+++ b/node_modules/@types/estree/package.json
@@ -0,0 +1,26 @@
+{
+    "name": "@types/estree",
+    "version": "1.0.6",
+    "description": "TypeScript definitions for estree",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "RReverser",
+            "githubUsername": "RReverser",
+            "url": "https://github.com/RReverser"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/estree"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "0310b41994a6f8d7530af6c53d47d8b227f32925e43718507fdb1178e05006b1",
+    "typeScriptVersion": "4.8",
+    "nonNpm": true
+}
\ No newline at end of file
diff --git a/node_modules/esbuild/LICENSE.md b/node_modules/esbuild/LICENSE.md
new file mode 100644
index 0000000..2027e8d
--- /dev/null
+++ b/node_modules/esbuild/LICENSE.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Evan Wallace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/esbuild/README.md b/node_modules/esbuild/README.md
new file mode 100644
index 0000000..93863d1
--- /dev/null
+++ b/node_modules/esbuild/README.md
@@ -0,0 +1,3 @@
+# esbuild
+
+This is a JavaScript bundler and minifier. See https://github.com/evanw/esbuild and the [JavaScript API documentation](https://esbuild.github.io/api/) for details.
diff --git a/node_modules/esbuild/bin/esbuild b/node_modules/esbuild/bin/esbuild
new file mode 100755
index 0000000..971ac09
--- /dev/null
+++ b/node_modules/esbuild/bin/esbuild
@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM2 = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM2 = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM: isWASM2 };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = require.resolve("esbuild");
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const unixKey in knownUnixlikePackages) {
+      try {
+        const pkg = knownUnixlikePackages[unixKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+    for (const windowsKey in knownWindowsPackages) {
+      try {
+        const pkg = knownWindowsPackages[windowsKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
+  }
+  const { pkg, subpath, isWASM: isWASM2 } = pkgAndSubpathForCurrentPlatform();
+  let binPath2;
+  try {
+    binPath2 = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath2 = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath2)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling esbuild. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          }
+          throw new Error(`
+You installed esbuild for another platform than the one you're currently using.
+This won't work because esbuild is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+Another alternative is to use the "esbuild-wasm" package instead, which works
+the same way on all platforms. But it comes with a heavy performance cost and
+can sometimes be 10x slower than the "esbuild" package, so you may also not
+want to do that.
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
+
+If you are installing esbuild with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by esbuild to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  if (/\.zip\//.test(binPath2)) {
+    let pnpapi;
+    try {
+      pnpapi = require("pnpapi");
+    } catch (e) {
+    }
+    if (pnpapi) {
+      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
+      const binTargetPath = path.join(
+        root,
+        "node_modules",
+        ".cache",
+        "esbuild",
+        `pnpapi-${pkg.replace("/", "-")}-${"0.21.5"}-${path.basename(subpath)}`
+      );
+      if (!fs.existsSync(binTargetPath)) {
+        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
+        fs.copyFileSync(binPath2, binTargetPath);
+        fs.chmodSync(binTargetPath, 493);
+      }
+      return { binPath: binTargetPath, isWASM: isWASM2 };
+    }
+  }
+  return { binPath: binPath2, isWASM: isWASM2 };
+}
+
+// lib/npm/node-shim.ts
+var { binPath, isWASM } = generateBinPath();
+if (isWASM) {
+  require("child_process").execFileSync("node", [binPath].concat(process.argv.slice(2)), { stdio: "inherit" });
+} else {
+  require("child_process").execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+}
diff --git a/node_modules/esbuild/install.js b/node_modules/esbuild/install.js
new file mode 100644
index 0000000..d97764e
--- /dev/null
+++ b/node_modules/esbuild/install.js
@@ -0,0 +1,285 @@
+"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 __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
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM };
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+
+// lib/npm/node-install.ts
+var fs2 = require("fs");
+var os2 = require("os");
+var path2 = require("path");
+var zlib = require("zlib");
+var https = require("https");
+var child_process = require("child_process");
+var versionFromPackageJSON = require(path2.join(__dirname, "package.json")).version;
+var toPath = path2.join(__dirname, "bin", "esbuild");
+var isToPathJS = true;
+function validateBinaryVersion(...command) {
+  command.push("--version");
+  let stdout;
+  try {
+    stdout = child_process.execFileSync(command.shift(), command, {
+      // Without this, this install script strangely crashes with the error
+      // "EACCES: permission denied, write" but only on Ubuntu Linux when node is
+      // installed from the Snap Store. This is not a problem when you download
+      // the official version of node. The problem appears to be that stderr
+      // (i.e. file descriptor 2) isn't writable?
+      //
+      // More info:
+      // - https://snapcraft.io/ (what the Snap Store is)
+      // - https://nodejs.org/dist/ (download the official version of node)
+      // - https://github.com/evanw/esbuild/issues/1711#issuecomment-1027554035
+      //
+      stdio: "pipe"
+    }).toString().trim();
+  } catch (err) {
+    if (os2.platform() === "darwin" && /_SecTrustEvaluateWithError/.test(err + "")) {
+      let os3 = "this version of macOS";
+      try {
+        os3 = "macOS " + child_process.execFileSync("sw_vers", ["-productVersion"]).toString().trim();
+      } catch {
+      }
+      throw new Error(`The "esbuild" package cannot be installed because ${os3} is too outdated.
+
+The Go compiler (which esbuild relies on) no longer supports ${os3},
+which means the "esbuild" binary executable can't be run. You can either:
+
+  * Update your version of macOS to one that the Go compiler supports
+  * Use the "esbuild-wasm" package instead of the "esbuild" package
+  * Build esbuild yourself using an older version of the Go compiler
+`);
+    }
+    throw err;
+  }
+  if (stdout !== versionFromPackageJSON) {
+    throw new Error(`Expected ${JSON.stringify(versionFromPackageJSON)} but got ${JSON.stringify(stdout)}`);
+  }
+}
+function isYarn() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    return /\byarn\//.test(npm_config_user_agent);
+  }
+  return false;
+}
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location)
+        return fetch(res.headers.location).then(resolve, reject);
+      if (res.statusCode !== 200)
+        return reject(new Error(`Server responded with ${res.statusCode}`));
+      let chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", reject);
+  });
+}
+function extractFileFromTarGzip(buffer, subpath) {
+  try {
+    buffer = zlib.unzipSync(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in archive: ${err && err.message || err}`);
+  }
+  let str = (i, n) => String.fromCharCode(...buffer.subarray(i, i + n)).replace(/\0.*$/, "");
+  let offset = 0;
+  subpath = `package/${subpath}`;
+  while (offset < buffer.length) {
+    let name = str(offset, 100);
+    let size = parseInt(str(offset + 124, 12), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) return buffer.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in archive`);
+}
+function installUsingNPM(pkg, subpath, binPath) {
+  const env = { ...process.env, npm_config_global: void 0 };
+  const esbuildLibDir = path2.dirname(require.resolve("esbuild"));
+  const installDir = path2.join(esbuildLibDir, "npm-install");
+  fs2.mkdirSync(installDir);
+  try {
+    fs2.writeFileSync(path2.join(installDir, "package.json"), "{}");
+    child_process.execSync(
+      `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${versionFromPackageJSON}`,
+      { cwd: installDir, stdio: "pipe", env }
+    );
+    const installedBinPath = path2.join(installDir, "node_modules", pkg, subpath);
+    fs2.renameSync(installedBinPath, binPath);
+  } finally {
+    try {
+      removeRecursive(installDir);
+    } catch {
+    }
+  }
+}
+function removeRecursive(dir) {
+  for (const entry of fs2.readdirSync(dir)) {
+    const entryPath = path2.join(dir, entry);
+    let stats;
+    try {
+      stats = fs2.lstatSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) removeRecursive(entryPath);
+    else fs2.unlinkSync(entryPath);
+  }
+  fs2.rmdirSync(dir);
+}
+function applyManualBinaryPathOverride(overridePath) {
+  const pathString = JSON.stringify(overridePath);
+  fs2.writeFileSync(toPath, `#!/usr/bin/env node
+require('child_process').execFileSync(${pathString}, process.argv.slice(2), { stdio: 'inherit' });
+`);
+  const libMain = path2.join(__dirname, "lib", "main.js");
+  const code = fs2.readFileSync(libMain, "utf8");
+  fs2.writeFileSync(libMain, `var ESBUILD_BINARY_PATH = ${pathString};
+${code}`);
+}
+function maybeOptimizePackage(binPath) {
+  if (os2.platform() !== "win32" && !isYarn()) {
+    const tempPath = path2.join(__dirname, "bin-esbuild");
+    try {
+      fs2.linkSync(binPath, tempPath);
+      fs2.renameSync(tempPath, toPath);
+      isToPathJS = false;
+      fs2.unlinkSync(tempPath);
+    } catch {
+    }
+  }
+}
+async function downloadDirectlyFromNPM(pkg, subpath, binPath) {
+  const url = `https://registry.npmjs.org/${pkg}/-/${pkg.replace("@esbuild/", "")}-${versionFromPackageJSON}.tgz`;
+  console.error(`[esbuild] Trying to download ${JSON.stringify(url)}`);
+  try {
+    fs2.writeFileSync(binPath, extractFileFromTarGzip(await fetch(url), subpath));
+    fs2.chmodSync(binPath, 493);
+  } catch (e) {
+    console.error(`[esbuild] Failed to download ${JSON.stringify(url)}: ${e && e.message || e}`);
+    throw e;
+  }
+}
+async function checkAndPreparePackage() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs2.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      applyManualBinaryPathOverride(ESBUILD_BINARY_PATH);
+      return;
+    }
+  }
+  const { pkg, subpath } = pkgAndSubpathForCurrentPlatform();
+  let binPath;
+  try {
+    binPath = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    console.error(`[esbuild] Failed to find package "${pkg}" on the file system
+
+This can happen if you use the "--no-optional" flag. The "optionalDependencies"
+package.json feature is used by esbuild to install the correct binary executable
+for your current platform. This install script will now attempt to work around
+this. If that fails, you need to remove the "--no-optional" flag to use esbuild.
+`);
+    binPath = downloadedBinPath(pkg, subpath);
+    try {
+      console.error(`[esbuild] Trying to install package "${pkg}" using npm`);
+      installUsingNPM(pkg, subpath, binPath);
+    } catch (e2) {
+      console.error(`[esbuild] Failed to install package "${pkg}" using npm: ${e2 && e2.message || e2}`);
+      try {
+        await downloadDirectlyFromNPM(pkg, subpath, binPath);
+      } catch (e3) {
+        throw new Error(`Failed to install package "${pkg}"`);
+      }
+    }
+  }
+  maybeOptimizePackage(binPath);
+}
+checkAndPreparePackage().then(() => {
+  if (isToPathJS) {
+    validateBinaryVersion(process.execPath, toPath);
+  } else {
+    validateBinaryVersion(toPath);
+  }
+});
diff --git a/node_modules/esbuild/lib/main.d.ts b/node_modules/esbuild/lib/main.d.ts
new file mode 100644
index 0000000..d5c6ac9
--- /dev/null
+++ b/node_modules/esbuild/lib/main.d.ts
@@ -0,0 +1,705 @@
+export type Platform = 'browser' | 'node' | 'neutral'
+export type Format = 'iife' | 'cjs' | 'esm'
+export type Loader = 'base64' | 'binary' | 'copy' | 'css' | 'dataurl' | 'default' | 'empty' | 'file' | 'js' | 'json' | 'jsx' | 'local-css' | 'text' | 'ts' | 'tsx'
+export type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent'
+export type Charset = 'ascii' | 'utf8'
+export type Drop = 'console' | 'debugger'
+
+interface CommonOptions {
+  /** Documentation: https://esbuild.github.io/api/#sourcemap */
+  sourcemap?: boolean | 'linked' | 'inline' | 'external' | 'both'
+  /** Documentation: https://esbuild.github.io/api/#legal-comments */
+  legalComments?: 'none' | 'inline' | 'eof' | 'linked' | 'external'
+  /** Documentation: https://esbuild.github.io/api/#source-root */
+  sourceRoot?: string
+  /** Documentation: https://esbuild.github.io/api/#sources-content */
+  sourcesContent?: boolean
+
+  /** Documentation: https://esbuild.github.io/api/#format */
+  format?: Format
+  /** Documentation: https://esbuild.github.io/api/#global-name */
+  globalName?: string
+  /** Documentation: https://esbuild.github.io/api/#target */
+  target?: string | string[]
+  /** Documentation: https://esbuild.github.io/api/#supported */
+  supported?: Record<string, boolean>
+  /** Documentation: https://esbuild.github.io/api/#platform */
+  platform?: Platform
+
+  /** Documentation: https://esbuild.github.io/api/#mangle-props */
+  mangleProps?: RegExp
+  /** Documentation: https://esbuild.github.io/api/#mangle-props */
+  reserveProps?: RegExp
+  /** Documentation: https://esbuild.github.io/api/#mangle-props */
+  mangleQuoted?: boolean
+  /** Documentation: https://esbuild.github.io/api/#mangle-props */
+  mangleCache?: Record<string, string | false>
+  /** Documentation: https://esbuild.github.io/api/#drop */
+  drop?: Drop[]
+  /** Documentation: https://esbuild.github.io/api/#drop-labels */
+  dropLabels?: string[]
+  /** Documentation: https://esbuild.github.io/api/#minify */
+  minify?: boolean
+  /** Documentation: https://esbuild.github.io/api/#minify */
+  minifyWhitespace?: boolean
+  /** Documentation: https://esbuild.github.io/api/#minify */
+  minifyIdentifiers?: boolean
+  /** Documentation: https://esbuild.github.io/api/#minify */
+  minifySyntax?: boolean
+  /** Documentation: https://esbuild.github.io/api/#line-limit */
+  lineLimit?: number
+  /** Documentation: https://esbuild.github.io/api/#charset */
+  charset?: Charset
+  /** Documentation: https://esbuild.github.io/api/#tree-shaking */
+  treeShaking?: boolean
+  /** Documentation: https://esbuild.github.io/api/#ignore-annotations */
+  ignoreAnnotations?: boolean
+
+  /** Documentation: https://esbuild.github.io/api/#jsx */
+  jsx?: 'transform' | 'preserve' | 'automatic'
+  /** Documentation: https://esbuild.github.io/api/#jsx-factory */
+  jsxFactory?: string
+  /** Documentation: https://esbuild.github.io/api/#jsx-fragment */
+  jsxFragment?: string
+  /** Documentation: https://esbuild.github.io/api/#jsx-import-source */
+  jsxImportSource?: string
+  /** Documentation: https://esbuild.github.io/api/#jsx-development */
+  jsxDev?: boolean
+  /** Documentation: https://esbuild.github.io/api/#jsx-side-effects */
+  jsxSideEffects?: boolean
+
+  /** Documentation: https://esbuild.github.io/api/#define */
+  define?: { [key: string]: string }
+  /** Documentation: https://esbuild.github.io/api/#pure */
+  pure?: string[]
+  /** Documentation: https://esbuild.github.io/api/#keep-names */
+  keepNames?: boolean
+
+  /** Documentation: https://esbuild.github.io/api/#color */
+  color?: boolean
+  /** Documentation: https://esbuild.github.io/api/#log-level */
+  logLevel?: LogLevel
+  /** Documentation: https://esbuild.github.io/api/#log-limit */
+  logLimit?: number
+  /** Documentation: https://esbuild.github.io/api/#log-override */
+  logOverride?: Record<string, LogLevel>
+
+  /** Documentation: https://esbuild.github.io/api/#tsconfig-raw */
+  tsconfigRaw?: string | TsconfigRaw
+}
+
+export interface TsconfigRaw {
+  compilerOptions?: {
+    alwaysStrict?: boolean
+    baseUrl?: string
+    experimentalDecorators?: boolean
+    importsNotUsedAsValues?: 'remove' | 'preserve' | 'error'
+    jsx?: 'preserve' | 'react-native' | 'react' | 'react-jsx' | 'react-jsxdev'
+    jsxFactory?: string
+    jsxFragmentFactory?: string
+    jsxImportSource?: string
+    paths?: Record<string, string[]>
+    preserveValueImports?: boolean
+    strict?: boolean
+    target?: string
+    useDefineForClassFields?: boolean
+    verbatimModuleSyntax?: boolean
+  }
+}
+
+export interface BuildOptions extends CommonOptions {
+  /** Documentation: https://esbuild.github.io/api/#bundle */
+  bundle?: boolean
+  /** Documentation: https://esbuild.github.io/api/#splitting */
+  splitting?: boolean
+  /** Documentation: https://esbuild.github.io/api/#preserve-symlinks */
+  preserveSymlinks?: boolean
+  /** Documentation: https://esbuild.github.io/api/#outfile */
+  outfile?: string
+  /** Documentation: https://esbuild.github.io/api/#metafile */
+  metafile?: boolean
+  /** Documentation: https://esbuild.github.io/api/#outdir */
+  outdir?: string
+  /** Documentation: https://esbuild.github.io/api/#outbase */
+  outbase?: string
+  /** Documentation: https://esbuild.github.io/api/#external */
+  external?: string[]
+  /** Documentation: https://esbuild.github.io/api/#packages */
+  packages?: 'external'
+  /** Documentation: https://esbuild.github.io/api/#alias */
+  alias?: Record<string, string>
+  /** Documentation: https://esbuild.github.io/api/#loader */
+  loader?: { [ext: string]: Loader }
+  /** Documentation: https://esbuild.github.io/api/#resolve-extensions */
+  resolveExtensions?: string[]
+  /** Documentation: https://esbuild.github.io/api/#main-fields */
+  mainFields?: string[]
+  /** Documentation: https://esbuild.github.io/api/#conditions */
+  conditions?: string[]
+  /** Documentation: https://esbuild.github.io/api/#write */
+  write?: boolean
+  /** Documentation: https://esbuild.github.io/api/#allow-overwrite */
+  allowOverwrite?: boolean
+  /** Documentation: https://esbuild.github.io/api/#tsconfig */
+  tsconfig?: string
+  /** Documentation: https://esbuild.github.io/api/#out-extension */
+  outExtension?: { [ext: string]: string }
+  /** Documentation: https://esbuild.github.io/api/#public-path */
+  publicPath?: string
+  /** Documentation: https://esbuild.github.io/api/#entry-names */
+  entryNames?: string
+  /** Documentation: https://esbuild.github.io/api/#chunk-names */
+  chunkNames?: string
+  /** Documentation: https://esbuild.github.io/api/#asset-names */
+  assetNames?: string
+  /** Documentation: https://esbuild.github.io/api/#inject */
+  inject?: string[]
+  /** Documentation: https://esbuild.github.io/api/#banner */
+  banner?: { [type: string]: string }
+  /** Documentation: https://esbuild.github.io/api/#footer */
+  footer?: { [type: string]: string }
+  /** Documentation: https://esbuild.github.io/api/#entry-points */
+  entryPoints?: string[] | Record<string, string> | { in: string, out: string }[]
+  /** Documentation: https://esbuild.github.io/api/#stdin */
+  stdin?: StdinOptions
+  /** Documentation: https://esbuild.github.io/plugins/ */
+  plugins?: Plugin[]
+  /** Documentation: https://esbuild.github.io/api/#working-directory */
+  absWorkingDir?: string
+  /** Documentation: https://esbuild.github.io/api/#node-paths */
+  nodePaths?: string[]; // The "NODE_PATH" variable from Node.js
+}
+
+export interface StdinOptions {
+  contents: string | Uint8Array
+  resolveDir?: string
+  sourcefile?: string
+  loader?: Loader
+}
+
+export interface Message {
+  id: string
+  pluginName: string
+  text: string
+  location: Location | null
+  notes: Note[]
+
+  /**
+   * Optional user-specified data that is passed through unmodified. You can
+   * use this to stash the original error, for example.
+   */
+  detail: any
+}
+
+export interface Note {
+  text: string
+  location: Location | null
+}
+
+export interface Location {
+  file: string
+  namespace: string
+  /** 1-based */
+  line: number
+  /** 0-based, in bytes */
+  column: number
+  /** in bytes */
+  length: number
+  lineText: string
+  suggestion: string
+}
+
+export interface OutputFile {
+  path: string
+  contents: Uint8Array
+  hash: string
+  /** "contents" as text (changes automatically with "contents") */
+  readonly text: string
+}
+
+export interface BuildResult<ProvidedOptions extends BuildOptions = BuildOptions> {
+  errors: Message[]
+  warnings: Message[]
+  /** Only when "write: false" */
+  outputFiles: OutputFile[] | (ProvidedOptions['write'] extends false ? never : undefined)
+  /** Only when "metafile: true" */
+  metafile: Metafile | (ProvidedOptions['metafile'] extends true ? never : undefined)
+  /** Only when "mangleCache" is present */
+  mangleCache: Record<string, string | false> | (ProvidedOptions['mangleCache'] extends Object ? never : undefined)
+}
+
+export interface BuildFailure extends Error {
+  errors: Message[]
+  warnings: Message[]
+}
+
+/** Documentation: https://esbuild.github.io/api/#serve-arguments */
+export interface ServeOptions {
+  port?: number
+  host?: string
+  servedir?: string
+  keyfile?: string
+  certfile?: string
+  fallback?: string
+  onRequest?: (args: ServeOnRequestArgs) => void
+}
+
+export interface ServeOnRequestArgs {
+  remoteAddress: string
+  method: string
+  path: string
+  status: number
+  /** The time to generate the response, not to send it */
+  timeInMS: number
+}
+
+/** Documentation: https://esbuild.github.io/api/#serve-return-values */
+export interface ServeResult {
+  port: number
+  host: string
+}
+
+export interface TransformOptions extends CommonOptions {
+  /** Documentation: https://esbuild.github.io/api/#sourcefile */
+  sourcefile?: string
+  /** Documentation: https://esbuild.github.io/api/#loader */
+  loader?: Loader
+  /** Documentation: https://esbuild.github.io/api/#banner */
+  banner?: string
+  /** Documentation: https://esbuild.github.io/api/#footer */
+  footer?: string
+}
+
+export interface TransformResult<ProvidedOptions extends TransformOptions = TransformOptions> {
+  code: string
+  map: string
+  warnings: Message[]
+  /** Only when "mangleCache" is present */
+  mangleCache: Record<string, string | false> | (ProvidedOptions['mangleCache'] extends Object ? never : undefined)
+  /** Only when "legalComments" is "external" */
+  legalComments: string | (ProvidedOptions['legalComments'] extends 'external' ? never : undefined)
+}
+
+export interface TransformFailure extends Error {
+  errors: Message[]
+  warnings: Message[]
+}
+
+export interface Plugin {
+  name: string
+  setup: (build: PluginBuild) => (void | Promise<void>)
+}
+
+export interface PluginBuild {
+  /** Documentation: https://esbuild.github.io/plugins/#build-options */
+  initialOptions: BuildOptions
+
+  /** Documentation: https://esbuild.github.io/plugins/#resolve */
+  resolve(path: string, options?: ResolveOptions): Promise<ResolveResult>
+
+  /** Documentation: https://esbuild.github.io/plugins/#on-start */
+  onStart(callback: () =>
+    (OnStartResult | null | void | Promise<OnStartResult | null | void>)): void
+
+  /** Documentation: https://esbuild.github.io/plugins/#on-end */
+  onEnd(callback: (result: BuildResult) =>
+    (OnEndResult | null | void | Promise<OnEndResult | null | void>)): void
+
+  /** Documentation: https://esbuild.github.io/plugins/#on-resolve */
+  onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) =>
+    (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void
+
+  /** Documentation: https://esbuild.github.io/plugins/#on-load */
+  onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) =>
+    (OnLoadResult | null | undefined | Promise<OnLoadResult | null | undefined>)): void
+
+  /** Documentation: https://esbuild.github.io/plugins/#on-dispose */
+  onDispose(callback: () => void): void
+
+  // This is a full copy of the esbuild library in case you need it
+  esbuild: {
+    context: typeof context,
+    build: typeof build,
+    buildSync: typeof buildSync,
+    transform: typeof transform,
+    transformSync: typeof transformSync,
+    formatMessages: typeof formatMessages,
+    formatMessagesSync: typeof formatMessagesSync,
+    analyzeMetafile: typeof analyzeMetafile,
+    analyzeMetafileSync: typeof analyzeMetafileSync,
+    initialize: typeof initialize,
+    version: typeof version,
+  }
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#resolve-options */
+export interface ResolveOptions {
+  pluginName?: string
+  importer?: string
+  namespace?: string
+  resolveDir?: string
+  kind?: ImportKind
+  pluginData?: any
+  with?: Record<string, string>
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#resolve-results */
+export interface ResolveResult {
+  errors: Message[]
+  warnings: Message[]
+
+  path: string
+  external: boolean
+  sideEffects: boolean
+  namespace: string
+  suffix: string
+  pluginData: any
+}
+
+export interface OnStartResult {
+  errors?: PartialMessage[]
+  warnings?: PartialMessage[]
+}
+
+export interface OnEndResult {
+  errors?: PartialMessage[]
+  warnings?: PartialMessage[]
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#on-resolve-options */
+export interface OnResolveOptions {
+  filter: RegExp
+  namespace?: string
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#on-resolve-arguments */
+export interface OnResolveArgs {
+  path: string
+  importer: string
+  namespace: string
+  resolveDir: string
+  kind: ImportKind
+  pluginData: any
+  with: Record<string, string>
+}
+
+export type ImportKind =
+  | 'entry-point'
+
+  // JS
+  | 'import-statement'
+  | 'require-call'
+  | 'dynamic-import'
+  | 'require-resolve'
+
+  // CSS
+  | 'import-rule'
+  | 'composes-from'
+  | 'url-token'
+
+/** Documentation: https://esbuild.github.io/plugins/#on-resolve-results */
+export interface OnResolveResult {
+  pluginName?: string
+
+  errors?: PartialMessage[]
+  warnings?: PartialMessage[]
+
+  path?: string
+  external?: boolean
+  sideEffects?: boolean
+  namespace?: string
+  suffix?: string
+  pluginData?: any
+
+  watchFiles?: string[]
+  watchDirs?: string[]
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#on-load-options */
+export interface OnLoadOptions {
+  filter: RegExp
+  namespace?: string
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#on-load-arguments */
+export interface OnLoadArgs {
+  path: string
+  namespace: string
+  suffix: string
+  pluginData: any
+  with: Record<string, string>
+}
+
+/** Documentation: https://esbuild.github.io/plugins/#on-load-results */
+export interface OnLoadResult {
+  pluginName?: string
+
+  errors?: PartialMessage[]
+  warnings?: PartialMessage[]
+
+  contents?: string | Uint8Array
+  resolveDir?: string
+  loader?: Loader
+  pluginData?: any
+
+  watchFiles?: string[]
+  watchDirs?: string[]
+}
+
+export interface PartialMessage {
+  id?: string
+  pluginName?: string
+  text?: string
+  location?: Partial<Location> | null
+  notes?: PartialNote[]
+  detail?: any
+}
+
+export interface PartialNote {
+  text?: string
+  location?: Partial<Location> | null
+}
+
+/** Documentation: https://esbuild.github.io/api/#metafile */
+export interface Metafile {
+  inputs: {
+    [path: string]: {
+      bytes: number
+      imports: {
+        path: string
+        kind: ImportKind
+        external?: boolean
+        original?: string
+        with?: Record<string, string>
+      }[]
+      format?: 'cjs' | 'esm'
+      with?: Record<string, string>
+    }
+  }
+  outputs: {
+    [path: string]: {
+      bytes: number
+      inputs: {
+        [path: string]: {
+          bytesInOutput: number
+        }
+      }
+      imports: {
+        path: string
+        kind: ImportKind | 'file-loader'
+        external?: boolean
+      }[]
+      exports: string[]
+      entryPoint?: string
+      cssBundle?: string
+    }
+  }
+}
+
+export interface FormatMessagesOptions {
+  kind: 'error' | 'warning'
+  color?: boolean
+  terminalWidth?: number
+}
+
+export interface AnalyzeMetafileOptions {
+  color?: boolean
+  verbose?: boolean
+}
+
+export interface WatchOptions {
+}
+
+export interface BuildContext<ProvidedOptions extends BuildOptions = BuildOptions> {
+  /** Documentation: https://esbuild.github.io/api/#rebuild */
+  rebuild(): Promise<BuildResult<ProvidedOptions>>
+
+  /** Documentation: https://esbuild.github.io/api/#watch */
+  watch(options?: WatchOptions): Promise<void>
+
+  /** Documentation: https://esbuild.github.io/api/#serve */
+  serve(options?: ServeOptions): Promise<ServeResult>
+
+  cancel(): Promise<void>
+  dispose(): Promise<void>
+}
+
+// This is a TypeScript type-level function which replaces any keys in "In"
+// that aren't in "Out" with "never". We use this to reject properties with
+// typos in object literals. See: https://stackoverflow.com/questions/49580725
+type SameShape<Out, In extends Out> = In & { [Key in Exclude<keyof In, keyof Out>]: never }
+
+/**
+ * This function invokes the "esbuild" command-line tool for you. It returns a
+ * promise that either resolves with a "BuildResult" object or rejects with a
+ * "BuildFailure" object.
+ *
+ * - Works in node: yes
+ * - Works in browser: yes
+ *
+ * Documentation: https://esbuild.github.io/api/#build
+ */
+export declare function build<T extends BuildOptions>(options: SameShape<BuildOptions, T>): Promise<BuildResult<T>>
+
+/**
+ * This is the advanced long-running form of "build" that supports additional
+ * features such as watch mode and a local development server.
+ *
+ * - Works in node: yes
+ * - Works in browser: no
+ *
+ * Documentation: https://esbuild.github.io/api/#build
+ */
+export declare function context<T extends BuildOptions>(options: SameShape<BuildOptions, T>): Promise<BuildContext<T>>
+
+/**
+ * This function transforms a single JavaScript file. It can be used to minify
+ * JavaScript, convert TypeScript/JSX to JavaScript, or convert newer JavaScript
+ * to older JavaScript. It returns a promise that is either resolved with a
+ * "TransformResult" object or rejected with a "TransformFailure" object.
+ *
+ * - Works in node: yes
+ * - Works in browser: yes
+ *
+ * Documentation: https://esbuild.github.io/api/#transform
+ */
+export declare function transform<T extends TransformOptions>(input: string | Uint8Array, options?: SameShape<TransformOptions, T>): Promise<TransformResult<T>>
+
+/**
+ * Converts log messages to formatted message strings suitable for printing in
+ * the terminal. This allows you to reuse the built-in behavior of esbuild's
+ * log message formatter. This is a batch-oriented API for efficiency.
+ *
+ * - Works in node: yes
+ * - Works in browser: yes
+ */
+export declare function formatMessages(messages: PartialMessage[], options: FormatMessagesOptions): Promise<string[]>
+
+/**
+ * Pretty-prints an analysis of the metafile JSON to a string. This is just for
+ * convenience to be able to match esbuild's pretty-printing exactly. If you want
+ * to customize it, you can just inspect the data in the metafile yourself.
+ *
+ * - Works in node: yes
+ * - Works in browser: yes
+ *
+ * Documentation: https://esbuild.github.io/api/#analyze
+ */
+export declare function analyzeMetafile(metafile: Metafile | string, options?: AnalyzeMetafileOptions): Promise<string>
+
+/**
+ * A synchronous version of "build".
+ *
+ * - Works in node: yes
+ * - Works in browser: no
+ *
+ * Documentation: https://esbuild.github.io/api/#build
+ */
+export declare function buildSync<T extends BuildOptions>(options: SameShape<BuildOptions, T>): BuildResult<T>
+
+/**
+ * A synchronous version of "transform".
+ *
+ * - Works in node: yes
+ * - Works in browser: no
+ *
+ * Documentation: https://esbuild.github.io/api/#transform
+ */
+export declare function transformSync<T extends TransformOptions>(input: string | Uint8Array, options?: SameShape<TransformOptions, T>): TransformResult<T>
+
+/**
+ * A synchronous version of "formatMessages".
+ *
+ * - Works in node: yes
+ * - Works in browser: no
+ */
+export declare function formatMessagesSync(messages: PartialMessage[], options: FormatMessagesOptions): string[]
+
+/**
+ * A synchronous version of "analyzeMetafile".
+ *
+ * - Works in node: yes
+ * - Works in browser: no
+ *
+ * Documentation: https://esbuild.github.io/api/#analyze
+ */
+export declare function analyzeMetafileSync(metafile: Metafile | string, options?: AnalyzeMetafileOptions): string
+
+/**
+ * This configures the browser-based version of esbuild. It is necessary to
+ * call this first and wait for the returned promise to be resolved before
+ * making other API calls when using esbuild in the browser.
+ *
+ * - Works in node: yes
+ * - Works in browser: yes ("options" is required)
+ *
+ * Documentation: https://esbuild.github.io/api/#browser
+ */
+export declare function initialize(options: InitializeOptions): Promise<void>
+
+export interface InitializeOptions {
+  /**
+   * The URL of the "esbuild.wasm" file. This must be provided when running
+   * esbuild in the browser.
+   */
+  wasmURL?: string | URL
+
+  /**
+   * The result of calling "new WebAssembly.Module(buffer)" where "buffer"
+   * is a typed array or ArrayBuffer containing the binary code of the
+   * "esbuild.wasm" file.
+   *
+   * You can use this as an alternative to "wasmURL" for environments where it's
+   * not possible to download the WebAssembly module.
+   */
+  wasmModule?: WebAssembly.Module
+
+  /**
+   * By default esbuild runs the WebAssembly-based browser API in a web worker
+   * to avoid blocking the UI thread. This can be disabled by setting "worker"
+   * to false.
+   */
+  worker?: boolean
+}
+
+export let version: string
+
+// Call this function to terminate esbuild's child process. The child process
+// is not terminated and re-created after each API call because it's more
+// efficient to keep it around when there are multiple API calls.
+//
+// In node this happens automatically before the parent node process exits. So
+// you only need to call this if you know you will not make any more esbuild
+// API calls and you want to clean up resources.
+//
+// Unlike node, Deno lacks the necessary APIs to clean up child processes
+// automatically. You must manually call stop() in Deno when you're done
+// using esbuild or Deno will continue running forever.
+//
+// Another reason you might want to call this is if you are using esbuild from
+// within a Deno test. Deno fails tests that create a child process without
+// killing it before the test ends, so you have to call this function (and
+// await the returned promise) in every Deno test that uses esbuild.
+export declare function stop(): Promise<void>
+
+// Note: These declarations exist to avoid type errors when you omit "dom" from
+// "lib" in your "tsconfig.json" file. TypeScript confusingly declares the
+// global "WebAssembly" type in "lib.dom.d.ts" even though it has nothing to do
+// with the browser DOM and is present in many non-browser JavaScript runtimes
+// (e.g. node and deno). Declaring it here allows esbuild's API to be used in
+// these scenarios.
+//
+// There's an open issue about getting this problem corrected (although these
+// declarations will need to remain even if this is fixed for backward
+// compatibility with older TypeScript versions):
+//
+//   https://github.com/microsoft/TypeScript-DOM-lib-generator/issues/826
+//
+declare global {
+  namespace WebAssembly {
+    interface Module {
+    }
+  }
+  interface URL {
+  }
+}
diff --git a/node_modules/esbuild/lib/main.js b/node_modules/esbuild/lib/main.js
new file mode 100644
index 0000000..555613c
--- /dev/null
+++ b/node_modules/esbuild/lib/main.js
@@ -0,0 +1,2239 @@
+"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);
+
+// lib/npm/node.ts
+var node_exports = {};
+__export(node_exports, {
+  analyzeMetafile: () => analyzeMetafile,
+  analyzeMetafileSync: () => analyzeMetafileSync,
+  build: () => build,
+  buildSync: () => buildSync,
+  context: () => context,
+  default: () => node_default,
+  formatMessages: () => formatMessages,
+  formatMessagesSync: () => formatMessagesSync,
+  initialize: () => initialize,
+  stop: () => stop,
+  transform: () => transform,
+  transformSync: () => transformSync,
+  version: () => version
+});
+module.exports = __toCommonJS(node_exports);
+
+// lib/shared/stdio_protocol.ts
+function encodePacket(packet) {
+  let visit = (value) => {
+    if (value === null) {
+      bb.write8(0);
+    } else if (typeof value === "boolean") {
+      bb.write8(1);
+      bb.write8(+value);
+    } else if (typeof value === "number") {
+      bb.write8(2);
+      bb.write32(value | 0);
+    } else if (typeof value === "string") {
+      bb.write8(3);
+      bb.write(encodeUTF8(value));
+    } else if (value instanceof Uint8Array) {
+      bb.write8(4);
+      bb.write(value);
+    } else if (value instanceof Array) {
+      bb.write8(5);
+      bb.write32(value.length);
+      for (let item of value) {
+        visit(item);
+      }
+    } else {
+      let keys = Object.keys(value);
+      bb.write8(6);
+      bb.write32(keys.length);
+      for (let key of keys) {
+        bb.write(encodeUTF8(key));
+        visit(value[key]);
+      }
+    }
+  };
+  let bb = new ByteBuffer();
+  bb.write32(0);
+  bb.write32(packet.id << 1 | +!packet.isRequest);
+  visit(packet.value);
+  writeUInt32LE(bb.buf, bb.len - 4, 0);
+  return bb.buf.subarray(0, bb.len);
+}
+function decodePacket(bytes) {
+  let visit = () => {
+    switch (bb.read8()) {
+      case 0:
+        return null;
+      case 1:
+        return !!bb.read8();
+      case 2:
+        return bb.read32();
+      case 3:
+        return decodeUTF8(bb.read());
+      case 4:
+        return bb.read();
+      case 5: {
+        let count = bb.read32();
+        let value2 = [];
+        for (let i = 0; i < count; i++) {
+          value2.push(visit());
+        }
+        return value2;
+      }
+      case 6: {
+        let count = bb.read32();
+        let value2 = {};
+        for (let i = 0; i < count; i++) {
+          value2[decodeUTF8(bb.read())] = visit();
+        }
+        return value2;
+      }
+      default:
+        throw new Error("Invalid packet");
+    }
+  };
+  let bb = new ByteBuffer(bytes);
+  let id = bb.read32();
+  let isRequest = (id & 1) === 0;
+  id >>>= 1;
+  let value = visit();
+  if (bb.ptr !== bytes.length) {
+    throw new Error("Invalid packet");
+  }
+  return { id, isRequest, value };
+}
+var ByteBuffer = class {
+  constructor(buf = new Uint8Array(1024)) {
+    this.buf = buf;
+    this.len = 0;
+    this.ptr = 0;
+  }
+  _write(delta) {
+    if (this.len + delta > this.buf.length) {
+      let clone = new Uint8Array((this.len + delta) * 2);
+      clone.set(this.buf);
+      this.buf = clone;
+    }
+    this.len += delta;
+    return this.len - delta;
+  }
+  write8(value) {
+    let offset = this._write(1);
+    this.buf[offset] = value;
+  }
+  write32(value) {
+    let offset = this._write(4);
+    writeUInt32LE(this.buf, value, offset);
+  }
+  write(bytes) {
+    let offset = this._write(4 + bytes.length);
+    writeUInt32LE(this.buf, bytes.length, offset);
+    this.buf.set(bytes, offset + 4);
+  }
+  _read(delta) {
+    if (this.ptr + delta > this.buf.length) {
+      throw new Error("Invalid packet");
+    }
+    this.ptr += delta;
+    return this.ptr - delta;
+  }
+  read8() {
+    return this.buf[this._read(1)];
+  }
+  read32() {
+    return readUInt32LE(this.buf, this._read(4));
+  }
+  read() {
+    let length = this.read32();
+    let bytes = new Uint8Array(length);
+    let ptr = this._read(bytes.length);
+    bytes.set(this.buf.subarray(ptr, ptr + length));
+    return bytes;
+  }
+};
+var encodeUTF8;
+var decodeUTF8;
+var encodeInvariant;
+if (typeof TextEncoder !== "undefined" && typeof TextDecoder !== "undefined") {
+  let encoder = new TextEncoder();
+  let decoder = new TextDecoder();
+  encodeUTF8 = (text) => encoder.encode(text);
+  decodeUTF8 = (bytes) => decoder.decode(bytes);
+  encodeInvariant = 'new TextEncoder().encode("")';
+} else if (typeof Buffer !== "undefined") {
+  encodeUTF8 = (text) => Buffer.from(text);
+  decodeUTF8 = (bytes) => {
+    let { buffer, byteOffset, byteLength } = bytes;
+    return Buffer.from(buffer, byteOffset, byteLength).toString();
+  };
+  encodeInvariant = 'Buffer.from("")';
+} else {
+  throw new Error("No UTF-8 codec found");
+}
+if (!(encodeUTF8("") instanceof Uint8Array))
+  throw new Error(`Invariant violation: "${encodeInvariant} instanceof Uint8Array" is incorrectly false
+
+This indicates that your JavaScript environment is broken. You cannot use
+esbuild in this environment because esbuild relies on this invariant. This
+is not a problem with esbuild. You need to fix your environment instead.
+`);
+function readUInt32LE(buffer, offset) {
+  return buffer[offset++] | buffer[offset++] << 8 | buffer[offset++] << 16 | buffer[offset++] << 24;
+}
+function writeUInt32LE(buffer, value, offset) {
+  buffer[offset++] = value;
+  buffer[offset++] = value >> 8;
+  buffer[offset++] = value >> 16;
+  buffer[offset++] = value >> 24;
+}
+
+// lib/shared/common.ts
+var quote = JSON.stringify;
+var buildLogLevelDefault = "warning";
+var transformLogLevelDefault = "silent";
+function validateTarget(target) {
+  validateStringValue(target, "target");
+  if (target.indexOf(",") >= 0) throw new Error(`Invalid target: ${target}`);
+  return target;
+}
+var canBeAnything = () => null;
+var mustBeBoolean = (value) => typeof value === "boolean" ? null : "a boolean";
+var mustBeString = (value) => typeof value === "string" ? null : "a string";
+var mustBeRegExp = (value) => value instanceof RegExp ? null : "a RegExp object";
+var mustBeInteger = (value) => typeof value === "number" && value === (value | 0) ? null : "an integer";
+var mustBeFunction = (value) => typeof value === "function" ? null : "a function";
+var mustBeArray = (value) => Array.isArray(value) ? null : "an array";
+var mustBeObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? null : "an object";
+var mustBeEntryPoints = (value) => typeof value === "object" && value !== null ? null : "an array or an object";
+var mustBeWebAssemblyModule = (value) => value instanceof WebAssembly.Module ? null : "a WebAssembly.Module";
+var mustBeObjectOrNull = (value) => typeof value === "object" && !Array.isArray(value) ? null : "an object or null";
+var mustBeStringOrBoolean = (value) => typeof value === "string" || typeof value === "boolean" ? null : "a string or a boolean";
+var mustBeStringOrObject = (value) => typeof value === "string" || typeof value === "object" && value !== null && !Array.isArray(value) ? null : "a string or an object";
+var mustBeStringOrArray = (value) => typeof value === "string" || Array.isArray(value) ? null : "a string or an array";
+var mustBeStringOrUint8Array = (value) => typeof value === "string" || value instanceof Uint8Array ? null : "a string or a Uint8Array";
+var mustBeStringOrURL = (value) => typeof value === "string" || value instanceof URL ? null : "a string or a URL";
+function getFlag(object, keys, key, mustBeFn) {
+  let value = object[key];
+  keys[key + ""] = true;
+  if (value === void 0) return void 0;
+  let mustBe = mustBeFn(value);
+  if (mustBe !== null) throw new Error(`${quote(key)} must be ${mustBe}`);
+  return value;
+}
+function checkForInvalidFlags(object, keys, where) {
+  for (let key in object) {
+    if (!(key in keys)) {
+      throw new Error(`Invalid option ${where}: ${quote(key)}`);
+    }
+  }
+}
+function validateInitializeOptions(options) {
+  let keys = /* @__PURE__ */ Object.create(null);
+  let wasmURL = getFlag(options, keys, "wasmURL", mustBeStringOrURL);
+  let wasmModule = getFlag(options, keys, "wasmModule", mustBeWebAssemblyModule);
+  let worker = getFlag(options, keys, "worker", mustBeBoolean);
+  checkForInvalidFlags(options, keys, "in initialize() call");
+  return {
+    wasmURL,
+    wasmModule,
+    worker
+  };
+}
+function validateMangleCache(mangleCache) {
+  let validated;
+  if (mangleCache !== void 0) {
+    validated = /* @__PURE__ */ Object.create(null);
+    for (let key in mangleCache) {
+      let value = mangleCache[key];
+      if (typeof value === "string" || value === false) {
+        validated[key] = value;
+      } else {
+        throw new Error(`Expected ${quote(key)} in mangle cache to map to either a string or false`);
+      }
+    }
+  }
+  return validated;
+}
+function pushLogFlags(flags, options, keys, isTTY2, logLevelDefault) {
+  let color = getFlag(options, keys, "color", mustBeBoolean);
+  let logLevel = getFlag(options, keys, "logLevel", mustBeString);
+  let logLimit = getFlag(options, keys, "logLimit", mustBeInteger);
+  if (color !== void 0) flags.push(`--color=${color}`);
+  else if (isTTY2) flags.push(`--color=true`);
+  flags.push(`--log-level=${logLevel || logLevelDefault}`);
+  flags.push(`--log-limit=${logLimit || 0}`);
+}
+function validateStringValue(value, what, key) {
+  if (typeof value !== "string") {
+    throw new Error(`Expected value for ${what}${key !== void 0 ? " " + quote(key) : ""} to be a string, got ${typeof value} instead`);
+  }
+  return value;
+}
+function pushCommonFlags(flags, options, keys) {
+  let legalComments = getFlag(options, keys, "legalComments", mustBeString);
+  let sourceRoot = getFlag(options, keys, "sourceRoot", mustBeString);
+  let sourcesContent = getFlag(options, keys, "sourcesContent", mustBeBoolean);
+  let target = getFlag(options, keys, "target", mustBeStringOrArray);
+  let format = getFlag(options, keys, "format", mustBeString);
+  let globalName = getFlag(options, keys, "globalName", mustBeString);
+  let mangleProps = getFlag(options, keys, "mangleProps", mustBeRegExp);
+  let reserveProps = getFlag(options, keys, "reserveProps", mustBeRegExp);
+  let mangleQuoted = getFlag(options, keys, "mangleQuoted", mustBeBoolean);
+  let minify = getFlag(options, keys, "minify", mustBeBoolean);
+  let minifySyntax = getFlag(options, keys, "minifySyntax", mustBeBoolean);
+  let minifyWhitespace = getFlag(options, keys, "minifyWhitespace", mustBeBoolean);
+  let minifyIdentifiers = getFlag(options, keys, "minifyIdentifiers", mustBeBoolean);
+  let lineLimit = getFlag(options, keys, "lineLimit", mustBeInteger);
+  let drop = getFlag(options, keys, "drop", mustBeArray);
+  let dropLabels = getFlag(options, keys, "dropLabels", mustBeArray);
+  let charset = getFlag(options, keys, "charset", mustBeString);
+  let treeShaking = getFlag(options, keys, "treeShaking", mustBeBoolean);
+  let ignoreAnnotations = getFlag(options, keys, "ignoreAnnotations", mustBeBoolean);
+  let jsx = getFlag(options, keys, "jsx", mustBeString);
+  let jsxFactory = getFlag(options, keys, "jsxFactory", mustBeString);
+  let jsxFragment = getFlag(options, keys, "jsxFragment", mustBeString);
+  let jsxImportSource = getFlag(options, keys, "jsxImportSource", mustBeString);
+  let jsxDev = getFlag(options, keys, "jsxDev", mustBeBoolean);
+  let jsxSideEffects = getFlag(options, keys, "jsxSideEffects", mustBeBoolean);
+  let define = getFlag(options, keys, "define", mustBeObject);
+  let logOverride = getFlag(options, keys, "logOverride", mustBeObject);
+  let supported = getFlag(options, keys, "supported", mustBeObject);
+  let pure = getFlag(options, keys, "pure", mustBeArray);
+  let keepNames = getFlag(options, keys, "keepNames", mustBeBoolean);
+  let platform = getFlag(options, keys, "platform", mustBeString);
+  let tsconfigRaw = getFlag(options, keys, "tsconfigRaw", mustBeStringOrObject);
+  if (legalComments) flags.push(`--legal-comments=${legalComments}`);
+  if (sourceRoot !== void 0) flags.push(`--source-root=${sourceRoot}`);
+  if (sourcesContent !== void 0) flags.push(`--sources-content=${sourcesContent}`);
+  if (target) {
+    if (Array.isArray(target)) flags.push(`--target=${Array.from(target).map(validateTarget).join(",")}`);
+    else flags.push(`--target=${validateTarget(target)}`);
+  }
+  if (format) flags.push(`--format=${format}`);
+  if (globalName) flags.push(`--global-name=${globalName}`);
+  if (platform) flags.push(`--platform=${platform}`);
+  if (tsconfigRaw) flags.push(`--tsconfig-raw=${typeof tsconfigRaw === "string" ? tsconfigRaw : JSON.stringify(tsconfigRaw)}`);
+  if (minify) flags.push("--minify");
+  if (minifySyntax) flags.push("--minify-syntax");
+  if (minifyWhitespace) flags.push("--minify-whitespace");
+  if (minifyIdentifiers) flags.push("--minify-identifiers");
+  if (lineLimit) flags.push(`--line-limit=${lineLimit}`);
+  if (charset) flags.push(`--charset=${charset}`);
+  if (treeShaking !== void 0) flags.push(`--tree-shaking=${treeShaking}`);
+  if (ignoreAnnotations) flags.push(`--ignore-annotations`);
+  if (drop) for (let what of drop) flags.push(`--drop:${validateStringValue(what, "drop")}`);
+  if (dropLabels) flags.push(`--drop-labels=${Array.from(dropLabels).map((what) => validateStringValue(what, "dropLabels")).join(",")}`);
+  if (mangleProps) flags.push(`--mangle-props=${mangleProps.source}`);
+  if (reserveProps) flags.push(`--reserve-props=${reserveProps.source}`);
+  if (mangleQuoted !== void 0) flags.push(`--mangle-quoted=${mangleQuoted}`);
+  if (jsx) flags.push(`--jsx=${jsx}`);
+  if (jsxFactory) flags.push(`--jsx-factory=${jsxFactory}`);
+  if (jsxFragment) flags.push(`--jsx-fragment=${jsxFragment}`);
+  if (jsxImportSource) flags.push(`--jsx-import-source=${jsxImportSource}`);
+  if (jsxDev) flags.push(`--jsx-dev`);
+  if (jsxSideEffects) flags.push(`--jsx-side-effects`);
+  if (define) {
+    for (let key in define) {
+      if (key.indexOf("=") >= 0) throw new Error(`Invalid define: ${key}`);
+      flags.push(`--define:${key}=${validateStringValue(define[key], "define", key)}`);
+    }
+  }
+  if (logOverride) {
+    for (let key in logOverride) {
+      if (key.indexOf("=") >= 0) throw new Error(`Invalid log override: ${key}`);
+      flags.push(`--log-override:${key}=${validateStringValue(logOverride[key], "log override", key)}`);
+    }
+  }
+  if (supported) {
+    for (let key in supported) {
+      if (key.indexOf("=") >= 0) throw new Error(`Invalid supported: ${key}`);
+      const value = supported[key];
+      if (typeof value !== "boolean") throw new Error(`Expected value for supported ${quote(key)} to be a boolean, got ${typeof value} instead`);
+      flags.push(`--supported:${key}=${value}`);
+    }
+  }
+  if (pure) for (let fn of pure) flags.push(`--pure:${validateStringValue(fn, "pure")}`);
+  if (keepNames) flags.push(`--keep-names`);
+}
+function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeDefault) {
+  var _a2;
+  let flags = [];
+  let entries = [];
+  let keys = /* @__PURE__ */ Object.create(null);
+  let stdinContents = null;
+  let stdinResolveDir = null;
+  pushLogFlags(flags, options, keys, isTTY2, logLevelDefault);
+  pushCommonFlags(flags, options, keys);
+  let sourcemap = getFlag(options, keys, "sourcemap", mustBeStringOrBoolean);
+  let bundle = getFlag(options, keys, "bundle", mustBeBoolean);
+  let splitting = getFlag(options, keys, "splitting", mustBeBoolean);
+  let preserveSymlinks = getFlag(options, keys, "preserveSymlinks", mustBeBoolean);
+  let metafile = getFlag(options, keys, "metafile", mustBeBoolean);
+  let outfile = getFlag(options, keys, "outfile", mustBeString);
+  let outdir = getFlag(options, keys, "outdir", mustBeString);
+  let outbase = getFlag(options, keys, "outbase", mustBeString);
+  let tsconfig = getFlag(options, keys, "tsconfig", mustBeString);
+  let resolveExtensions = getFlag(options, keys, "resolveExtensions", mustBeArray);
+  let nodePathsInput = getFlag(options, keys, "nodePaths", mustBeArray);
+  let mainFields = getFlag(options, keys, "mainFields", mustBeArray);
+  let conditions = getFlag(options, keys, "conditions", mustBeArray);
+  let external = getFlag(options, keys, "external", mustBeArray);
+  let packages = getFlag(options, keys, "packages", mustBeString);
+  let alias = getFlag(options, keys, "alias", mustBeObject);
+  let loader = getFlag(options, keys, "loader", mustBeObject);
+  let outExtension = getFlag(options, keys, "outExtension", mustBeObject);
+  let publicPath = getFlag(options, keys, "publicPath", mustBeString);
+  let entryNames = getFlag(options, keys, "entryNames", mustBeString);
+  let chunkNames = getFlag(options, keys, "chunkNames", mustBeString);
+  let assetNames = getFlag(options, keys, "assetNames", mustBeString);
+  let inject = getFlag(options, keys, "inject", mustBeArray);
+  let banner = getFlag(options, keys, "banner", mustBeObject);
+  let footer = getFlag(options, keys, "footer", mustBeObject);
+  let entryPoints = getFlag(options, keys, "entryPoints", mustBeEntryPoints);
+  let absWorkingDir = getFlag(options, keys, "absWorkingDir", mustBeString);
+  let stdin = getFlag(options, keys, "stdin", mustBeObject);
+  let write = (_a2 = getFlag(options, keys, "write", mustBeBoolean)) != null ? _a2 : writeDefault;
+  let allowOverwrite = getFlag(options, keys, "allowOverwrite", mustBeBoolean);
+  let mangleCache = getFlag(options, keys, "mangleCache", mustBeObject);
+  keys.plugins = true;
+  checkForInvalidFlags(options, keys, `in ${callName}() call`);
+  if (sourcemap) flags.push(`--sourcemap${sourcemap === true ? "" : `=${sourcemap}`}`);
+  if (bundle) flags.push("--bundle");
+  if (allowOverwrite) flags.push("--allow-overwrite");
+  if (splitting) flags.push("--splitting");
+  if (preserveSymlinks) flags.push("--preserve-symlinks");
+  if (metafile) flags.push(`--metafile`);
+  if (outfile) flags.push(`--outfile=${outfile}`);
+  if (outdir) flags.push(`--outdir=${outdir}`);
+  if (outbase) flags.push(`--outbase=${outbase}`);
+  if (tsconfig) flags.push(`--tsconfig=${tsconfig}`);
+  if (packages) flags.push(`--packages=${packages}`);
+  if (resolveExtensions) {
+    let values = [];
+    for (let value of resolveExtensions) {
+      validateStringValue(value, "resolve extension");
+      if (value.indexOf(",") >= 0) throw new Error(`Invalid resolve extension: ${value}`);
+      values.push(value);
+    }
+    flags.push(`--resolve-extensions=${values.join(",")}`);
+  }
+  if (publicPath) flags.push(`--public-path=${publicPath}`);
+  if (entryNames) flags.push(`--entry-names=${entryNames}`);
+  if (chunkNames) flags.push(`--chunk-names=${chunkNames}`);
+  if (assetNames) flags.push(`--asset-names=${assetNames}`);
+  if (mainFields) {
+    let values = [];
+    for (let value of mainFields) {
+      validateStringValue(value, "main field");
+      if (value.indexOf(",") >= 0) throw new Error(`Invalid main field: ${value}`);
+      values.push(value);
+    }
+    flags.push(`--main-fields=${values.join(",")}`);
+  }
+  if (conditions) {
+    let values = [];
+    for (let value of conditions) {
+      validateStringValue(value, "condition");
+      if (value.indexOf(",") >= 0) throw new Error(`Invalid condition: ${value}`);
+      values.push(value);
+    }
+    flags.push(`--conditions=${values.join(",")}`);
+  }
+  if (external) for (let name of external) flags.push(`--external:${validateStringValue(name, "external")}`);
+  if (alias) {
+    for (let old in alias) {
+      if (old.indexOf("=") >= 0) throw new Error(`Invalid package name in alias: ${old}`);
+      flags.push(`--alias:${old}=${validateStringValue(alias[old], "alias", old)}`);
+    }
+  }
+  if (banner) {
+    for (let type in banner) {
+      if (type.indexOf("=") >= 0) throw new Error(`Invalid banner file type: ${type}`);
+      flags.push(`--banner:${type}=${validateStringValue(banner[type], "banner", type)}`);
+    }
+  }
+  if (footer) {
+    for (let type in footer) {
+      if (type.indexOf("=") >= 0) throw new Error(`Invalid footer file type: ${type}`);
+      flags.push(`--footer:${type}=${validateStringValue(footer[type], "footer", type)}`);
+    }
+  }
+  if (inject) for (let path3 of inject) flags.push(`--inject:${validateStringValue(path3, "inject")}`);
+  if (loader) {
+    for (let ext in loader) {
+      if (ext.indexOf("=") >= 0) throw new Error(`Invalid loader extension: ${ext}`);
+      flags.push(`--loader:${ext}=${validateStringValue(loader[ext], "loader", ext)}`);
+    }
+  }
+  if (outExtension) {
+    for (let ext in outExtension) {
+      if (ext.indexOf("=") >= 0) throw new Error(`Invalid out extension: ${ext}`);
+      flags.push(`--out-extension:${ext}=${validateStringValue(outExtension[ext], "out extension", ext)}`);
+    }
+  }
+  if (entryPoints) {
+    if (Array.isArray(entryPoints)) {
+      for (let i = 0, n = entryPoints.length; i < n; i++) {
+        let entryPoint = entryPoints[i];
+        if (typeof entryPoint === "object" && entryPoint !== null) {
+          let entryPointKeys = /* @__PURE__ */ Object.create(null);
+          let input = getFlag(entryPoint, entryPointKeys, "in", mustBeString);
+          let output = getFlag(entryPoint, entryPointKeys, "out", mustBeString);
+          checkForInvalidFlags(entryPoint, entryPointKeys, "in entry point at index " + i);
+          if (input === void 0) throw new Error('Missing property "in" for entry point at index ' + i);
+          if (output === void 0) throw new Error('Missing property "out" for entry point at index ' + i);
+          entries.push([output, input]);
+        } else {
+          entries.push(["", validateStringValue(entryPoint, "entry point at index " + i)]);
+        }
+      }
+    } else {
+      for (let key in entryPoints) {
+        entries.push([key, validateStringValue(entryPoints[key], "entry point", key)]);
+      }
+    }
+  }
+  if (stdin) {
+    let stdinKeys = /* @__PURE__ */ Object.create(null);
+    let contents = getFlag(stdin, stdinKeys, "contents", mustBeStringOrUint8Array);
+    let resolveDir = getFlag(stdin, stdinKeys, "resolveDir", mustBeString);
+    let sourcefile = getFlag(stdin, stdinKeys, "sourcefile", mustBeString);
+    let loader2 = getFlag(stdin, stdinKeys, "loader", mustBeString);
+    checkForInvalidFlags(stdin, stdinKeys, 'in "stdin" object');
+    if (sourcefile) flags.push(`--sourcefile=${sourcefile}`);
+    if (loader2) flags.push(`--loader=${loader2}`);
+    if (resolveDir) stdinResolveDir = resolveDir;
+    if (typeof contents === "string") stdinContents = encodeUTF8(contents);
+    else if (contents instanceof Uint8Array) stdinContents = contents;
+  }
+  let nodePaths = [];
+  if (nodePathsInput) {
+    for (let value of nodePathsInput) {
+      value += "";
+      nodePaths.push(value);
+    }
+  }
+  return {
+    entries,
+    flags,
+    write,
+    stdinContents,
+    stdinResolveDir,
+    absWorkingDir,
+    nodePaths,
+    mangleCache: validateMangleCache(mangleCache)
+  };
+}
+function flagsForTransformOptions(callName, options, isTTY2, logLevelDefault) {
+  let flags = [];
+  let keys = /* @__PURE__ */ Object.create(null);
+  pushLogFlags(flags, options, keys, isTTY2, logLevelDefault);
+  pushCommonFlags(flags, options, keys);
+  let sourcemap = getFlag(options, keys, "sourcemap", mustBeStringOrBoolean);
+  let sourcefile = getFlag(options, keys, "sourcefile", mustBeString);
+  let loader = getFlag(options, keys, "loader", mustBeString);
+  let banner = getFlag(options, keys, "banner", mustBeString);
+  let footer = getFlag(options, keys, "footer", mustBeString);
+  let mangleCache = getFlag(options, keys, "mangleCache", mustBeObject);
+  checkForInvalidFlags(options, keys, `in ${callName}() call`);
+  if (sourcemap) flags.push(`--sourcemap=${sourcemap === true ? "external" : sourcemap}`);
+  if (sourcefile) flags.push(`--sourcefile=${sourcefile}`);
+  if (loader) flags.push(`--loader=${loader}`);
+  if (banner) flags.push(`--banner=${banner}`);
+  if (footer) flags.push(`--footer=${footer}`);
+  return {
+    flags,
+    mangleCache: validateMangleCache(mangleCache)
+  };
+}
+function createChannel(streamIn) {
+  const requestCallbacksByKey = {};
+  const closeData = { didClose: false, reason: "" };
+  let responseCallbacks = {};
+  let nextRequestID = 0;
+  let nextBuildKey = 0;
+  let stdout = new Uint8Array(16 * 1024);
+  let stdoutUsed = 0;
+  let readFromStdout = (chunk) => {
+    let limit = stdoutUsed + chunk.length;
+    if (limit > stdout.length) {
+      let swap = new Uint8Array(limit * 2);
+      swap.set(stdout);
+      stdout = swap;
+    }
+    stdout.set(chunk, stdoutUsed);
+    stdoutUsed += chunk.length;
+    let offset = 0;
+    while (offset + 4 <= stdoutUsed) {
+      let length = readUInt32LE(stdout, offset);
+      if (offset + 4 + length > stdoutUsed) {
+        break;
+      }
+      offset += 4;
+      handleIncomingPacket(stdout.subarray(offset, offset + length));
+      offset += length;
+    }
+    if (offset > 0) {
+      stdout.copyWithin(0, offset, stdoutUsed);
+      stdoutUsed -= offset;
+    }
+  };
+  let afterClose = (error) => {
+    closeData.didClose = true;
+    if (error) closeData.reason = ": " + (error.message || error);
+    const text = "The service was stopped" + closeData.reason;
+    for (let id in responseCallbacks) {
+      responseCallbacks[id](text, null);
+    }
+    responseCallbacks = {};
+  };
+  let sendRequest = (refs, value, callback) => {
+    if (closeData.didClose) return callback("The service is no longer running" + closeData.reason, null);
+    let id = nextRequestID++;
+    responseCallbacks[id] = (error, response) => {
+      try {
+        callback(error, response);
+      } finally {
+        if (refs) refs.unref();
+      }
+    };
+    if (refs) refs.ref();
+    streamIn.writeToStdin(encodePacket({ id, isRequest: true, value }));
+  };
+  let sendResponse = (id, value) => {
+    if (closeData.didClose) throw new Error("The service is no longer running" + closeData.reason);
+    streamIn.writeToStdin(encodePacket({ id, isRequest: false, value }));
+  };
+  let handleRequest = async (id, request) => {
+    try {
+      if (request.command === "ping") {
+        sendResponse(id, {});
+        return;
+      }
+      if (typeof request.key === "number") {
+        const requestCallbacks = requestCallbacksByKey[request.key];
+        if (!requestCallbacks) {
+          return;
+        }
+        const callback = requestCallbacks[request.command];
+        if (callback) {
+          await callback(id, request);
+          return;
+        }
+      }
+      throw new Error(`Invalid command: ` + request.command);
+    } catch (e) {
+      const errors = [extractErrorMessageV8(e, streamIn, null, void 0, "")];
+      try {
+        sendResponse(id, { errors });
+      } catch {
+      }
+    }
+  };
+  let isFirstPacket = true;
+  let handleIncomingPacket = (bytes) => {
+    if (isFirstPacket) {
+      isFirstPacket = false;
+      let binaryVersion = String.fromCharCode(...bytes);
+      if (binaryVersion !== "0.21.5") {
+        throw new Error(`Cannot start service: Host version "${"0.21.5"}" does not match binary version ${quote(binaryVersion)}`);
+      }
+      return;
+    }
+    let packet = decodePacket(bytes);
+    if (packet.isRequest) {
+      handleRequest(packet.id, packet.value);
+    } else {
+      let callback = responseCallbacks[packet.id];
+      delete responseCallbacks[packet.id];
+      if (packet.value.error) callback(packet.value.error, {});
+      else callback(null, packet.value);
+    }
+  };
+  let buildOrContext = ({ callName, refs, options, isTTY: isTTY2, defaultWD: defaultWD2, callback }) => {
+    let refCount = 0;
+    const buildKey = nextBuildKey++;
+    const requestCallbacks = {};
+    const buildRefs = {
+      ref() {
+        if (++refCount === 1) {
+          if (refs) refs.ref();
+        }
+      },
+      unref() {
+        if (--refCount === 0) {
+          delete requestCallbacksByKey[buildKey];
+          if (refs) refs.unref();
+        }
+      }
+    };
+    requestCallbacksByKey[buildKey] = requestCallbacks;
+    buildRefs.ref();
+    buildOrContextImpl(
+      callName,
+      buildKey,
+      sendRequest,
+      sendResponse,
+      buildRefs,
+      streamIn,
+      requestCallbacks,
+      options,
+      isTTY2,
+      defaultWD2,
+      (err, res) => {
+        try {
+          callback(err, res);
+        } finally {
+          buildRefs.unref();
+        }
+      }
+    );
+  };
+  let transform2 = ({ callName, refs, input, options, isTTY: isTTY2, fs: fs3, callback }) => {
+    const details = createObjectStash();
+    let start = (inputPath) => {
+      try {
+        if (typeof input !== "string" && !(input instanceof Uint8Array))
+          throw new Error('The input to "transform" must be a string or a Uint8Array');
+        let {
+          flags,
+          mangleCache
+        } = flagsForTransformOptions(callName, options, isTTY2, transformLogLevelDefault);
+        let request = {
+          command: "transform",
+          flags,
+          inputFS: inputPath !== null,
+          input: inputPath !== null ? encodeUTF8(inputPath) : typeof input === "string" ? encodeUTF8(input) : input
+        };
+        if (mangleCache) request.mangleCache = mangleCache;
+        sendRequest(refs, request, (error, response) => {
+          if (error) return callback(new Error(error), null);
+          let errors = replaceDetailsInMessages(response.errors, details);
+          let warnings = replaceDetailsInMessages(response.warnings, details);
+          let outstanding = 1;
+          let next = () => {
+            if (--outstanding === 0) {
+              let result = {
+                warnings,
+                code: response.code,
+                map: response.map,
+                mangleCache: void 0,
+                legalComments: void 0
+              };
+              if ("legalComments" in response) result.legalComments = response == null ? void 0 : response.legalComments;
+              if (response.mangleCache) result.mangleCache = response == null ? void 0 : response.mangleCache;
+              callback(null, result);
+            }
+          };
+          if (errors.length > 0) return callback(failureErrorWithLog("Transform failed", errors, warnings), null);
+          if (response.codeFS) {
+            outstanding++;
+            fs3.readFile(response.code, (err, contents) => {
+              if (err !== null) {
+                callback(err, null);
+              } else {
+                response.code = contents;
+                next();
+              }
+            });
+          }
+          if (response.mapFS) {
+            outstanding++;
+            fs3.readFile(response.map, (err, contents) => {
+              if (err !== null) {
+                callback(err, null);
+              } else {
+                response.map = contents;
+                next();
+              }
+            });
+          }
+          next();
+        });
+      } catch (e) {
+        let flags = [];
+        try {
+          pushLogFlags(flags, options, {}, isTTY2, transformLogLevelDefault);
+        } catch {
+        }
+        const error = extractErrorMessageV8(e, streamIn, details, void 0, "");
+        sendRequest(refs, { command: "error", flags, error }, () => {
+          error.detail = details.load(error.detail);
+          callback(failureErrorWithLog("Transform failed", [error], []), null);
+        });
+      }
+    };
+    if ((typeof input === "string" || input instanceof Uint8Array) && input.length > 1024 * 1024) {
+      let next = start;
+      start = () => fs3.writeFile(input, next);
+    }
+    start(null);
+  };
+  let formatMessages2 = ({ callName, refs, messages, options, callback }) => {
+    if (!options) throw new Error(`Missing second argument in ${callName}() call`);
+    let keys = {};
+    let kind = getFlag(options, keys, "kind", mustBeString);
+    let color = getFlag(options, keys, "color", mustBeBoolean);
+    let terminalWidth = getFlag(options, keys, "terminalWidth", mustBeInteger);
+    checkForInvalidFlags(options, keys, `in ${callName}() call`);
+    if (kind === void 0) throw new Error(`Missing "kind" in ${callName}() call`);
+    if (kind !== "error" && kind !== "warning") throw new Error(`Expected "kind" to be "error" or "warning" in ${callName}() call`);
+    let request = {
+      command: "format-msgs",
+      messages: sanitizeMessages(messages, "messages", null, "", terminalWidth),
+      isWarning: kind === "warning"
+    };
+    if (color !== void 0) request.color = color;
+    if (terminalWidth !== void 0) request.terminalWidth = terminalWidth;
+    sendRequest(refs, request, (error, response) => {
+      if (error) return callback(new Error(error), null);
+      callback(null, response.messages);
+    });
+  };
+  let analyzeMetafile2 = ({ callName, refs, metafile, options, callback }) => {
+    if (options === void 0) options = {};
+    let keys = {};
+    let color = getFlag(options, keys, "color", mustBeBoolean);
+    let verbose = getFlag(options, keys, "verbose", mustBeBoolean);
+    checkForInvalidFlags(options, keys, `in ${callName}() call`);
+    let request = {
+      command: "analyze-metafile",
+      metafile
+    };
+    if (color !== void 0) request.color = color;
+    if (verbose !== void 0) request.verbose = verbose;
+    sendRequest(refs, request, (error, response) => {
+      if (error) return callback(new Error(error), null);
+      callback(null, response.result);
+    });
+  };
+  return {
+    readFromStdout,
+    afterClose,
+    service: {
+      buildOrContext,
+      transform: transform2,
+      formatMessages: formatMessages2,
+      analyzeMetafile: analyzeMetafile2
+    }
+  };
+}
+function buildOrContextImpl(callName, buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, options, isTTY2, defaultWD2, callback) {
+  const details = createObjectStash();
+  const isContext = callName === "context";
+  const handleError = (e, pluginName) => {
+    const flags = [];
+    try {
+      pushLogFlags(flags, options, {}, isTTY2, buildLogLevelDefault);
+    } catch {
+    }
+    const message = extractErrorMessageV8(e, streamIn, details, void 0, pluginName);
+    sendRequest(refs, { command: "error", flags, error: message }, () => {
+      message.detail = details.load(message.detail);
+      callback(failureErrorWithLog(isContext ? "Context failed" : "Build failed", [message], []), null);
+    });
+  };
+  let plugins;
+  if (typeof options === "object") {
+    const value = options.plugins;
+    if (value !== void 0) {
+      if (!Array.isArray(value)) return handleError(new Error(`"plugins" must be an array`), "");
+      plugins = value;
+    }
+  }
+  if (plugins && plugins.length > 0) {
+    if (streamIn.isSync) return handleError(new Error("Cannot use plugins in synchronous API calls"), "");
+    handlePlugins(
+      buildKey,
+      sendRequest,
+      sendResponse,
+      refs,
+      streamIn,
+      requestCallbacks,
+      options,
+      plugins,
+      details
+    ).then(
+      (result) => {
+        if (!result.ok) return handleError(result.error, result.pluginName);
+        try {
+          buildOrContextContinue(result.requestPlugins, result.runOnEndCallbacks, result.scheduleOnDisposeCallbacks);
+        } catch (e) {
+          handleError(e, "");
+        }
+      },
+      (e) => handleError(e, "")
+    );
+    return;
+  }
+  try {
+    buildOrContextContinue(null, (result, done) => done([], []), () => {
+    });
+  } catch (e) {
+    handleError(e, "");
+  }
+  function buildOrContextContinue(requestPlugins, runOnEndCallbacks, scheduleOnDisposeCallbacks) {
+    const writeDefault = streamIn.hasFS;
+    const {
+      entries,
+      flags,
+      write,
+      stdinContents,
+      stdinResolveDir,
+      absWorkingDir,
+      nodePaths,
+      mangleCache
+    } = flagsForBuildOptions(callName, options, isTTY2, buildLogLevelDefault, writeDefault);
+    if (write && !streamIn.hasFS) throw new Error(`The "write" option is unavailable in this environment`);
+    const request = {
+      command: "build",
+      key: buildKey,
+      entries,
+      flags,
+      write,
+      stdinContents,
+      stdinResolveDir,
+      absWorkingDir: absWorkingDir || defaultWD2,
+      nodePaths,
+      context: isContext
+    };
+    if (requestPlugins) request.plugins = requestPlugins;
+    if (mangleCache) request.mangleCache = mangleCache;
+    const buildResponseToResult = (response, callback2) => {
+      const result = {
+        errors: replaceDetailsInMessages(response.errors, details),
+        warnings: replaceDetailsInMessages(response.warnings, details),
+        outputFiles: void 0,
+        metafile: void 0,
+        mangleCache: void 0
+      };
+      const originalErrors = result.errors.slice();
+      const originalWarnings = result.warnings.slice();
+      if (response.outputFiles) result.outputFiles = response.outputFiles.map(convertOutputFiles);
+      if (response.metafile) result.metafile = JSON.parse(response.metafile);
+      if (response.mangleCache) result.mangleCache = response.mangleCache;
+      if (response.writeToStdout !== void 0) console.log(decodeUTF8(response.writeToStdout).replace(/\n$/, ""));
+      runOnEndCallbacks(result, (onEndErrors, onEndWarnings) => {
+        if (originalErrors.length > 0 || onEndErrors.length > 0) {
+          const error = failureErrorWithLog("Build failed", originalErrors.concat(onEndErrors), originalWarnings.concat(onEndWarnings));
+          return callback2(error, null, onEndErrors, onEndWarnings);
+        }
+        callback2(null, result, onEndErrors, onEndWarnings);
+      });
+    };
+    let latestResultPromise;
+    let provideLatestResult;
+    if (isContext)
+      requestCallbacks["on-end"] = (id, request2) => new Promise((resolve) => {
+        buildResponseToResult(request2, (err, result, onEndErrors, onEndWarnings) => {
+          const response = {
+            errors: onEndErrors,
+            warnings: onEndWarnings
+          };
+          if (provideLatestResult) provideLatestResult(err, result);
+          latestResultPromise = void 0;
+          provideLatestResult = void 0;
+          sendResponse(id, response);
+          resolve();
+        });
+      });
+    sendRequest(refs, request, (error, response) => {
+      if (error) return callback(new Error(error), null);
+      if (!isContext) {
+        return buildResponseToResult(response, (err, res) => {
+          scheduleOnDisposeCallbacks();
+          return callback(err, res);
+        });
+      }
+      if (response.errors.length > 0) {
+        return callback(failureErrorWithLog("Context failed", response.errors, response.warnings), null);
+      }
+      let didDispose = false;
+      const result = {
+        rebuild: () => {
+          if (!latestResultPromise) latestResultPromise = new Promise((resolve, reject) => {
+            let settlePromise;
+            provideLatestResult = (err, result2) => {
+              if (!settlePromise) settlePromise = () => err ? reject(err) : resolve(result2);
+            };
+            const triggerAnotherBuild = () => {
+              const request2 = {
+                command: "rebuild",
+                key: buildKey
+              };
+              sendRequest(refs, request2, (error2, response2) => {
+                if (error2) {
+                  reject(new Error(error2));
+                } else if (settlePromise) {
+                  settlePromise();
+                } else {
+                  triggerAnotherBuild();
+                }
+              });
+            };
+            triggerAnotherBuild();
+          });
+          return latestResultPromise;
+        },
+        watch: (options2 = {}) => new Promise((resolve, reject) => {
+          if (!streamIn.hasFS) throw new Error(`Cannot use the "watch" API in this environment`);
+          const keys = {};
+          checkForInvalidFlags(options2, keys, `in watch() call`);
+          const request2 = {
+            command: "watch",
+            key: buildKey
+          };
+          sendRequest(refs, request2, (error2) => {
+            if (error2) reject(new Error(error2));
+            else resolve(void 0);
+          });
+        }),
+        serve: (options2 = {}) => new Promise((resolve, reject) => {
+          if (!streamIn.hasFS) throw new Error(`Cannot use the "serve" API in this environment`);
+          const keys = {};
+          const port = getFlag(options2, keys, "port", mustBeInteger);
+          const host = getFlag(options2, keys, "host", mustBeString);
+          const servedir = getFlag(options2, keys, "servedir", mustBeString);
+          const keyfile = getFlag(options2, keys, "keyfile", mustBeString);
+          const certfile = getFlag(options2, keys, "certfile", mustBeString);
+          const fallback = getFlag(options2, keys, "fallback", mustBeString);
+          const onRequest = getFlag(options2, keys, "onRequest", mustBeFunction);
+          checkForInvalidFlags(options2, keys, `in serve() call`);
+          const request2 = {
+            command: "serve",
+            key: buildKey,
+            onRequest: !!onRequest
+          };
+          if (port !== void 0) request2.port = port;
+          if (host !== void 0) request2.host = host;
+          if (servedir !== void 0) request2.servedir = servedir;
+          if (keyfile !== void 0) request2.keyfile = keyfile;
+          if (certfile !== void 0) request2.certfile = certfile;
+          if (fallback !== void 0) request2.fallback = fallback;
+          sendRequest(refs, request2, (error2, response2) => {
+            if (error2) return reject(new Error(error2));
+            if (onRequest) {
+              requestCallbacks["serve-request"] = (id, request3) => {
+                onRequest(request3.args);
+                sendResponse(id, {});
+              };
+            }
+            resolve(response2);
+          });
+        }),
+        cancel: () => new Promise((resolve) => {
+          if (didDispose) return resolve();
+          const request2 = {
+            command: "cancel",
+            key: buildKey
+          };
+          sendRequest(refs, request2, () => {
+            resolve();
+          });
+        }),
+        dispose: () => new Promise((resolve) => {
+          if (didDispose) return resolve();
+          didDispose = true;
+          const request2 = {
+            command: "dispose",
+            key: buildKey
+          };
+          sendRequest(refs, request2, () => {
+            resolve();
+            scheduleOnDisposeCallbacks();
+            refs.unref();
+          });
+        })
+      };
+      refs.ref();
+      callback(null, result);
+    });
+  }
+}
+var handlePlugins = async (buildKey, sendRequest, sendResponse, refs, streamIn, requestCallbacks, initialOptions, plugins, details) => {
+  let onStartCallbacks = [];
+  let onEndCallbacks = [];
+  let onResolveCallbacks = {};
+  let onLoadCallbacks = {};
+  let onDisposeCallbacks = [];
+  let nextCallbackID = 0;
+  let i = 0;
+  let requestPlugins = [];
+  let isSetupDone = false;
+  plugins = [...plugins];
+  for (let item of plugins) {
+    let keys = {};
+    if (typeof item !== "object") throw new Error(`Plugin at index ${i} must be an object`);
+    const name = getFlag(item, keys, "name", mustBeString);
+    if (typeof name !== "string" || name === "") throw new Error(`Plugin at index ${i} is missing a name`);
+    try {
+      let setup = getFlag(item, keys, "setup", mustBeFunction);
+      if (typeof setup !== "function") throw new Error(`Plugin is missing a setup function`);
+      checkForInvalidFlags(item, keys, `on plugin ${quote(name)}`);
+      let plugin = {
+        name,
+        onStart: false,
+        onEnd: false,
+        onResolve: [],
+        onLoad: []
+      };
+      i++;
+      let resolve = (path3, options = {}) => {
+        if (!isSetupDone) throw new Error('Cannot call "resolve" before plugin setup has completed');
+        if (typeof path3 !== "string") throw new Error(`The path to resolve must be a string`);
+        let keys2 = /* @__PURE__ */ Object.create(null);
+        let pluginName = getFlag(options, keys2, "pluginName", mustBeString);
+        let importer = getFlag(options, keys2, "importer", mustBeString);
+        let namespace = getFlag(options, keys2, "namespace", mustBeString);
+        let resolveDir = getFlag(options, keys2, "resolveDir", mustBeString);
+        let kind = getFlag(options, keys2, "kind", mustBeString);
+        let pluginData = getFlag(options, keys2, "pluginData", canBeAnything);
+        let importAttributes = getFlag(options, keys2, "with", mustBeObject);
+        checkForInvalidFlags(options, keys2, "in resolve() call");
+        return new Promise((resolve2, reject) => {
+          const request = {
+            command: "resolve",
+            path: path3,
+            key: buildKey,
+            pluginName: name
+          };
+          if (pluginName != null) request.pluginName = pluginName;
+          if (importer != null) request.importer = importer;
+          if (namespace != null) request.namespace = namespace;
+          if (resolveDir != null) request.resolveDir = resolveDir;
+          if (kind != null) request.kind = kind;
+          else throw new Error(`Must specify "kind" when calling "resolve"`);
+          if (pluginData != null) request.pluginData = details.store(pluginData);
+          if (importAttributes != null) request.with = sanitizeStringMap(importAttributes, "with");
+          sendRequest(refs, request, (error, response) => {
+            if (error !== null) reject(new Error(error));
+            else resolve2({
+              errors: replaceDetailsInMessages(response.errors, details),
+              warnings: replaceDetailsInMessages(response.warnings, details),
+              path: response.path,
+              external: response.external,
+              sideEffects: response.sideEffects,
+              namespace: response.namespace,
+              suffix: response.suffix,
+              pluginData: details.load(response.pluginData)
+            });
+          });
+        });
+      };
+      let promise = setup({
+        initialOptions,
+        resolve,
+        onStart(callback) {
+          let registeredText = `This error came from the "onStart" callback registered here:`;
+          let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
+          onStartCallbacks.push({ name, callback, note: registeredNote });
+          plugin.onStart = true;
+        },
+        onEnd(callback) {
+          let registeredText = `This error came from the "onEnd" callback registered here:`;
+          let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onEnd");
+          onEndCallbacks.push({ name, callback, note: registeredNote });
+          plugin.onEnd = true;
+        },
+        onResolve(options, callback) {
+          let registeredText = `This error came from the "onResolve" callback registered here:`;
+          let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onResolve");
+          let keys2 = {};
+          let filter = getFlag(options, keys2, "filter", mustBeRegExp);
+          let namespace = getFlag(options, keys2, "namespace", mustBeString);
+          checkForInvalidFlags(options, keys2, `in onResolve() call for plugin ${quote(name)}`);
+          if (filter == null) throw new Error(`onResolve() call is missing a filter`);
+          let id = nextCallbackID++;
+          onResolveCallbacks[id] = { name, callback, note: registeredNote };
+          plugin.onResolve.push({ id, filter: filter.source, namespace: namespace || "" });
+        },
+        onLoad(options, callback) {
+          let registeredText = `This error came from the "onLoad" callback registered here:`;
+          let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onLoad");
+          let keys2 = {};
+          let filter = getFlag(options, keys2, "filter", mustBeRegExp);
+          let namespace = getFlag(options, keys2, "namespace", mustBeString);
+          checkForInvalidFlags(options, keys2, `in onLoad() call for plugin ${quote(name)}`);
+          if (filter == null) throw new Error(`onLoad() call is missing a filter`);
+          let id = nextCallbackID++;
+          onLoadCallbacks[id] = { name, callback, note: registeredNote };
+          plugin.onLoad.push({ id, filter: filter.source, namespace: namespace || "" });
+        },
+        onDispose(callback) {
+          onDisposeCallbacks.push(callback);
+        },
+        esbuild: streamIn.esbuild
+      });
+      if (promise) await promise;
+      requestPlugins.push(plugin);
+    } catch (e) {
+      return { ok: false, error: e, pluginName: name };
+    }
+  }
+  requestCallbacks["on-start"] = async (id, request) => {
+    let response = { errors: [], warnings: [] };
+    await Promise.all(onStartCallbacks.map(async ({ name, callback, note }) => {
+      try {
+        let result = await callback();
+        if (result != null) {
+          if (typeof result !== "object") throw new Error(`Expected onStart() callback in plugin ${quote(name)} to return an object`);
+          let keys = {};
+          let errors = getFlag(result, keys, "errors", mustBeArray);
+          let warnings = getFlag(result, keys, "warnings", mustBeArray);
+          checkForInvalidFlags(result, keys, `from onStart() callback in plugin ${quote(name)}`);
+          if (errors != null) response.errors.push(...sanitizeMessages(errors, "errors", details, name, void 0));
+          if (warnings != null) response.warnings.push(...sanitizeMessages(warnings, "warnings", details, name, void 0));
+        }
+      } catch (e) {
+        response.errors.push(extractErrorMessageV8(e, streamIn, details, note && note(), name));
+      }
+    }));
+    sendResponse(id, response);
+  };
+  requestCallbacks["on-resolve"] = async (id, request) => {
+    let response = {}, name = "", callback, note;
+    for (let id2 of request.ids) {
+      try {
+        ({ name, callback, note } = onResolveCallbacks[id2]);
+        let result = await callback({
+          path: request.path,
+          importer: request.importer,
+          namespace: request.namespace,
+          resolveDir: request.resolveDir,
+          kind: request.kind,
+          pluginData: details.load(request.pluginData),
+          with: request.with
+        });
+        if (result != null) {
+          if (typeof result !== "object") throw new Error(`Expected onResolve() callback in plugin ${quote(name)} to return an object`);
+          let keys = {};
+          let pluginName = getFlag(result, keys, "pluginName", mustBeString);
+          let path3 = getFlag(result, keys, "path", mustBeString);
+          let namespace = getFlag(result, keys, "namespace", mustBeString);
+          let suffix = getFlag(result, keys, "suffix", mustBeString);
+          let external = getFlag(result, keys, "external", mustBeBoolean);
+          let sideEffects = getFlag(result, keys, "sideEffects", mustBeBoolean);
+          let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
+          let errors = getFlag(result, keys, "errors", mustBeArray);
+          let warnings = getFlag(result, keys, "warnings", mustBeArray);
+          let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
+          let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
+          checkForInvalidFlags(result, keys, `from onResolve() callback in plugin ${quote(name)}`);
+          response.id = id2;
+          if (pluginName != null) response.pluginName = pluginName;
+          if (path3 != null) response.path = path3;
+          if (namespace != null) response.namespace = namespace;
+          if (suffix != null) response.suffix = suffix;
+          if (external != null) response.external = external;
+          if (sideEffects != null) response.sideEffects = sideEffects;
+          if (pluginData != null) response.pluginData = details.store(pluginData);
+          if (errors != null) response.errors = sanitizeMessages(errors, "errors", details, name, void 0);
+          if (warnings != null) response.warnings = sanitizeMessages(warnings, "warnings", details, name, void 0);
+          if (watchFiles != null) response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
+          if (watchDirs != null) response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
+          break;
+        }
+      } catch (e) {
+        response = { id: id2, errors: [extractErrorMessageV8(e, streamIn, details, note && note(), name)] };
+        break;
+      }
+    }
+    sendResponse(id, response);
+  };
+  requestCallbacks["on-load"] = async (id, request) => {
+    let response = {}, name = "", callback, note;
+    for (let id2 of request.ids) {
+      try {
+        ({ name, callback, note } = onLoadCallbacks[id2]);
+        let result = await callback({
+          path: request.path,
+          namespace: request.namespace,
+          suffix: request.suffix,
+          pluginData: details.load(request.pluginData),
+          with: request.with
+        });
+        if (result != null) {
+          if (typeof result !== "object") throw new Error(`Expected onLoad() callback in plugin ${quote(name)} to return an object`);
+          let keys = {};
+          let pluginName = getFlag(result, keys, "pluginName", mustBeString);
+          let contents = getFlag(result, keys, "contents", mustBeStringOrUint8Array);
+          let resolveDir = getFlag(result, keys, "resolveDir", mustBeString);
+          let pluginData = getFlag(result, keys, "pluginData", canBeAnything);
+          let loader = getFlag(result, keys, "loader", mustBeString);
+          let errors = getFlag(result, keys, "errors", mustBeArray);
+          let warnings = getFlag(result, keys, "warnings", mustBeArray);
+          let watchFiles = getFlag(result, keys, "watchFiles", mustBeArray);
+          let watchDirs = getFlag(result, keys, "watchDirs", mustBeArray);
+          checkForInvalidFlags(result, keys, `from onLoad() callback in plugin ${quote(name)}`);
+          response.id = id2;
+          if (pluginName != null) response.pluginName = pluginName;
+          if (contents instanceof Uint8Array) response.contents = contents;
+          else if (contents != null) response.contents = encodeUTF8(contents);
+          if (resolveDir != null) response.resolveDir = resolveDir;
+          if (pluginData != null) response.pluginData = details.store(pluginData);
+          if (loader != null) response.loader = loader;
+          if (errors != null) response.errors = sanitizeMessages(errors, "errors", details, name, void 0);
+          if (warnings != null) response.warnings = sanitizeMessages(warnings, "warnings", details, name, void 0);
+          if (watchFiles != null) response.watchFiles = sanitizeStringArray(watchFiles, "watchFiles");
+          if (watchDirs != null) response.watchDirs = sanitizeStringArray(watchDirs, "watchDirs");
+          break;
+        }
+      } catch (e) {
+        response = { id: id2, errors: [extractErrorMessageV8(e, streamIn, details, note && note(), name)] };
+        break;
+      }
+    }
+    sendResponse(id, response);
+  };
+  let runOnEndCallbacks = (result, done) => done([], []);
+  if (onEndCallbacks.length > 0) {
+    runOnEndCallbacks = (result, done) => {
+      (async () => {
+        const onEndErrors = [];
+        const onEndWarnings = [];
+        for (const { name, callback, note } of onEndCallbacks) {
+          let newErrors;
+          let newWarnings;
+          try {
+            const value = await callback(result);
+            if (value != null) {
+              if (typeof value !== "object") throw new Error(`Expected onEnd() callback in plugin ${quote(name)} to return an object`);
+              let keys = {};
+              let errors = getFlag(value, keys, "errors", mustBeArray);
+              let warnings = getFlag(value, keys, "warnings", mustBeArray);
+              checkForInvalidFlags(value, keys, `from onEnd() callback in plugin ${quote(name)}`);
+              if (errors != null) newErrors = sanitizeMessages(errors, "errors", details, name, void 0);
+              if (warnings != null) newWarnings = sanitizeMessages(warnings, "warnings", details, name, void 0);
+            }
+          } catch (e) {
+            newErrors = [extractErrorMessageV8(e, streamIn, details, note && note(), name)];
+          }
+          if (newErrors) {
+            onEndErrors.push(...newErrors);
+            try {
+              result.errors.push(...newErrors);
+            } catch {
+            }
+          }
+          if (newWarnings) {
+            onEndWarnings.push(...newWarnings);
+            try {
+              result.warnings.push(...newWarnings);
+            } catch {
+            }
+          }
+        }
+        done(onEndErrors, onEndWarnings);
+      })();
+    };
+  }
+  let scheduleOnDisposeCallbacks = () => {
+    for (const cb of onDisposeCallbacks) {
+      setTimeout(() => cb(), 0);
+    }
+  };
+  isSetupDone = true;
+  return {
+    ok: true,
+    requestPlugins,
+    runOnEndCallbacks,
+    scheduleOnDisposeCallbacks
+  };
+};
+function createObjectStash() {
+  const map = /* @__PURE__ */ new Map();
+  let nextID = 0;
+  return {
+    load(id) {
+      return map.get(id);
+    },
+    store(value) {
+      if (value === void 0) return -1;
+      const id = nextID++;
+      map.set(id, value);
+      return id;
+    }
+  };
+}
+function extractCallerV8(e, streamIn, ident) {
+  let note;
+  let tried = false;
+  return () => {
+    if (tried) return note;
+    tried = true;
+    try {
+      let lines = (e.stack + "").split("\n");
+      lines.splice(1, 1);
+      let location = parseStackLinesV8(streamIn, lines, ident);
+      if (location) {
+        note = { text: e.message, location };
+        return note;
+      }
+    } catch {
+    }
+  };
+}
+function extractErrorMessageV8(e, streamIn, stash, note, pluginName) {
+  let text = "Internal error";
+  let location = null;
+  try {
+    text = (e && e.message || e) + "";
+  } catch {
+  }
+  try {
+    location = parseStackLinesV8(streamIn, (e.stack + "").split("\n"), "");
+  } catch {
+  }
+  return { id: "", pluginName, text, location, notes: note ? [note] : [], detail: stash ? stash.store(e) : -1 };
+}
+function parseStackLinesV8(streamIn, lines, ident) {
+  let at = "    at ";
+  if (streamIn.readFileSync && !lines[0].startsWith(at) && lines[1].startsWith(at)) {
+    for (let i = 1; i < lines.length; i++) {
+      let line = lines[i];
+      if (!line.startsWith(at)) continue;
+      line = line.slice(at.length);
+      while (true) {
+        let match = /^(?:new |async )?\S+ \((.*)\)$/.exec(line);
+        if (match) {
+          line = match[1];
+          continue;
+        }
+        match = /^eval at \S+ \((.*)\)(?:, \S+:\d+:\d+)?$/.exec(line);
+        if (match) {
+          line = match[1];
+          continue;
+        }
+        match = /^(\S+):(\d+):(\d+)$/.exec(line);
+        if (match) {
+          let contents;
+          try {
+            contents = streamIn.readFileSync(match[1], "utf8");
+          } catch {
+            break;
+          }
+          let lineText = contents.split(/\r\n|\r|\n|\u2028|\u2029/)[+match[2] - 1] || "";
+          let column = +match[3] - 1;
+          let length = lineText.slice(column, column + ident.length) === ident ? ident.length : 0;
+          return {
+            file: match[1],
+            namespace: "file",
+            line: +match[2],
+            column: encodeUTF8(lineText.slice(0, column)).length,
+            length: encodeUTF8(lineText.slice(column, column + length)).length,
+            lineText: lineText + "\n" + lines.slice(1).join("\n"),
+            suggestion: ""
+          };
+        }
+        break;
+      }
+    }
+  }
+  return null;
+}
+function failureErrorWithLog(text, errors, warnings) {
+  let limit = 5;
+  text += errors.length < 1 ? "" : ` with ${errors.length} error${errors.length < 2 ? "" : "s"}:` + errors.slice(0, limit + 1).map((e, i) => {
+    if (i === limit) return "\n...";
+    if (!e.location) return `
+error: ${e.text}`;
+    let { file, line, column } = e.location;
+    let pluginText = e.pluginName ? `[plugin: ${e.pluginName}] ` : "";
+    return `
+${file}:${line}:${column}: ERROR: ${pluginText}${e.text}`;
+  }).join("");
+  let error = new Error(text);
+  for (const [key, value] of [["errors", errors], ["warnings", warnings]]) {
+    Object.defineProperty(error, key, {
+      configurable: true,
+      enumerable: true,
+      get: () => value,
+      set: (value2) => Object.defineProperty(error, key, {
+        configurable: true,
+        enumerable: true,
+        value: value2
+      })
+    });
+  }
+  return error;
+}
+function replaceDetailsInMessages(messages, stash) {
+  for (const message of messages) {
+    message.detail = stash.load(message.detail);
+  }
+  return messages;
+}
+function sanitizeLocation(location, where, terminalWidth) {
+  if (location == null) return null;
+  let keys = {};
+  let file = getFlag(location, keys, "file", mustBeString);
+  let namespace = getFlag(location, keys, "namespace", mustBeString);
+  let line = getFlag(location, keys, "line", mustBeInteger);
+  let column = getFlag(location, keys, "column", mustBeInteger);
+  let length = getFlag(location, keys, "length", mustBeInteger);
+  let lineText = getFlag(location, keys, "lineText", mustBeString);
+  let suggestion = getFlag(location, keys, "suggestion", mustBeString);
+  checkForInvalidFlags(location, keys, where);
+  if (lineText) {
+    const relevantASCII = lineText.slice(
+      0,
+      (column && column > 0 ? column : 0) + (length && length > 0 ? length : 0) + (terminalWidth && terminalWidth > 0 ? terminalWidth : 80)
+    );
+    if (!/[\x7F-\uFFFF]/.test(relevantASCII) && !/\n/.test(lineText)) {
+      lineText = relevantASCII;
+    }
+  }
+  return {
+    file: file || "",
+    namespace: namespace || "",
+    line: line || 0,
+    column: column || 0,
+    length: length || 0,
+    lineText: lineText || "",
+    suggestion: suggestion || ""
+  };
+}
+function sanitizeMessages(messages, property, stash, fallbackPluginName, terminalWidth) {
+  let messagesClone = [];
+  let index = 0;
+  for (const message of messages) {
+    let keys = {};
+    let id = getFlag(message, keys, "id", mustBeString);
+    let pluginName = getFlag(message, keys, "pluginName", mustBeString);
+    let text = getFlag(message, keys, "text", mustBeString);
+    let location = getFlag(message, keys, "location", mustBeObjectOrNull);
+    let notes = getFlag(message, keys, "notes", mustBeArray);
+    let detail = getFlag(message, keys, "detail", canBeAnything);
+    let where = `in element ${index} of "${property}"`;
+    checkForInvalidFlags(message, keys, where);
+    let notesClone = [];
+    if (notes) {
+      for (const note of notes) {
+        let noteKeys = {};
+        let noteText = getFlag(note, noteKeys, "text", mustBeString);
+        let noteLocation = getFlag(note, noteKeys, "location", mustBeObjectOrNull);
+        checkForInvalidFlags(note, noteKeys, where);
+        notesClone.push({
+          text: noteText || "",
+          location: sanitizeLocation(noteLocation, where, terminalWidth)
+        });
+      }
+    }
+    messagesClone.push({
+      id: id || "",
+      pluginName: pluginName || fallbackPluginName,
+      text: text || "",
+      location: sanitizeLocation(location, where, terminalWidth),
+      notes: notesClone,
+      detail: stash ? stash.store(detail) : -1
+    });
+    index++;
+  }
+  return messagesClone;
+}
+function sanitizeStringArray(values, property) {
+  const result = [];
+  for (const value of values) {
+    if (typeof value !== "string") throw new Error(`${quote(property)} must be an array of strings`);
+    result.push(value);
+  }
+  return result;
+}
+function sanitizeStringMap(map, property) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key in map) {
+    const value = map[key];
+    if (typeof value !== "string") throw new Error(`key ${quote(key)} in object ${quote(property)} must be a string`);
+    result[key] = value;
+  }
+  return result;
+}
+function convertOutputFiles({ path: path3, contents, hash }) {
+  let text = null;
+  return {
+    path: path3,
+    contents,
+    hash,
+    get text() {
+      const binary = this.contents;
+      if (text === null || binary !== contents) {
+        contents = binary;
+        text = decodeUTF8(binary);
+      }
+      return text;
+    }
+  };
+}
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var ESBUILD_BINARY_PATH = process.env.ESBUILD_BINARY_PATH || ESBUILD_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && x !== "/usr/bin/esbuild";
+var packageDarwin_arm64 = "@esbuild/darwin-arm64";
+var packageDarwin_x64 = "@esbuild/darwin-x64";
+var knownWindowsPackages = {
+  "win32 arm64 LE": "@esbuild/win32-arm64",
+  "win32 ia32 LE": "@esbuild/win32-ia32",
+  "win32 x64 LE": "@esbuild/win32-x64"
+};
+var knownUnixlikePackages = {
+  "aix ppc64 BE": "@esbuild/aix-ppc64",
+  "android arm64 LE": "@esbuild/android-arm64",
+  "darwin arm64 LE": "@esbuild/darwin-arm64",
+  "darwin x64 LE": "@esbuild/darwin-x64",
+  "freebsd arm64 LE": "@esbuild/freebsd-arm64",
+  "freebsd x64 LE": "@esbuild/freebsd-x64",
+  "linux arm LE": "@esbuild/linux-arm",
+  "linux arm64 LE": "@esbuild/linux-arm64",
+  "linux ia32 LE": "@esbuild/linux-ia32",
+  "linux mips64el LE": "@esbuild/linux-mips64el",
+  "linux ppc64 LE": "@esbuild/linux-ppc64",
+  "linux riscv64 LE": "@esbuild/linux-riscv64",
+  "linux s390x BE": "@esbuild/linux-s390x",
+  "linux x64 LE": "@esbuild/linux-x64",
+  "linux loong64 LE": "@esbuild/linux-loong64",
+  "netbsd x64 LE": "@esbuild/netbsd-x64",
+  "openbsd x64 LE": "@esbuild/openbsd-x64",
+  "sunos x64 LE": "@esbuild/sunos-x64"
+};
+var knownWebAssemblyFallbackPackages = {
+  "android arm LE": "@esbuild/android-arm",
+  "android x64 LE": "@esbuild/android-x64"
+};
+function pkgAndSubpathForCurrentPlatform() {
+  let pkg;
+  let subpath;
+  let isWASM = false;
+  let platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  if (platformKey in knownWindowsPackages) {
+    pkg = knownWindowsPackages[platformKey];
+    subpath = "esbuild.exe";
+  } else if (platformKey in knownUnixlikePackages) {
+    pkg = knownUnixlikePackages[platformKey];
+    subpath = "bin/esbuild";
+  } else if (platformKey in knownWebAssemblyFallbackPackages) {
+    pkg = knownWebAssemblyFallbackPackages[platformKey];
+    subpath = "bin/esbuild";
+    isWASM = true;
+  } else {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  return { pkg, subpath, isWASM };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = require.resolve("esbuild");
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const unixKey in knownUnixlikePackages) {
+      try {
+        const pkg = knownUnixlikePackages[unixKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+    for (const windowsKey in knownWindowsPackages) {
+      try {
+        const pkg = knownWindowsPackages[windowsKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const esbuildLibDir = path.dirname(require.resolve("esbuild"));
+  return path.join(esbuildLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (isValidBinaryPath(ESBUILD_BINARY_PATH)) {
+    if (!fs.existsSync(ESBUILD_BINARY_PATH)) {
+      console.warn(`[esbuild] Ignoring bad configuration: ESBUILD_BINARY_PATH=${ESBUILD_BINARY_PATH}`);
+    } else {
+      return { binPath: ESBUILD_BINARY_PATH, isWASM: false };
+    }
+  }
+  const { pkg, subpath, isWASM } = pkgAndSubpathForCurrentPlatform();
+  let binPath;
+  try {
+    binPath = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing esbuild with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling esbuild. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of esbuild will be present.
+`;
+          }
+          throw new Error(`
+You installed esbuild for another platform than the one you're currently using.
+This won't work because esbuild is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+Another alternative is to use the "esbuild-wasm" package instead, which works
+the same way on all platforms. But it comes with a heavy performance cost and
+can sometimes be 10x slower than the "esbuild" package, so you may also not
+want to do that.
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by esbuild.
+
+If you are installing esbuild with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by esbuild to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  if (/\.zip\//.test(binPath)) {
+    let pnpapi;
+    try {
+      pnpapi = require("pnpapi");
+    } catch (e) {
+    }
+    if (pnpapi) {
+      const root = pnpapi.getPackageInformation(pnpapi.topLevel).packageLocation;
+      const binTargetPath = path.join(
+        root,
+        "node_modules",
+        ".cache",
+        "esbuild",
+        `pnpapi-${pkg.replace("/", "-")}-${"0.21.5"}-${path.basename(subpath)}`
+      );
+      if (!fs.existsSync(binTargetPath)) {
+        fs.mkdirSync(path.dirname(binTargetPath), { recursive: true });
+        fs.copyFileSync(binPath, binTargetPath);
+        fs.chmodSync(binTargetPath, 493);
+      }
+      return { binPath: binTargetPath, isWASM };
+    }
+  }
+  return { binPath, isWASM };
+}
+
+// lib/npm/node.ts
+var child_process = require("child_process");
+var crypto = require("crypto");
+var path2 = require("path");
+var fs2 = require("fs");
+var os2 = require("os");
+var tty = require("tty");
+var worker_threads;
+if (process.env.ESBUILD_WORKER_THREADS !== "0") {
+  try {
+    worker_threads = require("worker_threads");
+  } catch {
+  }
+  let [major, minor] = process.versions.node.split(".");
+  if (
+    // <v12.17.0 does not work
+    +major < 12 || +major === 12 && +minor < 17 || +major === 13 && +minor < 13
+  ) {
+    worker_threads = void 0;
+  }
+}
+var _a;
+var isInternalWorkerThread = ((_a = worker_threads == null ? void 0 : worker_threads.workerData) == null ? void 0 : _a.esbuildVersion) === "0.21.5";
+var esbuildCommandAndArgs = () => {
+  if ((!ESBUILD_BINARY_PATH || false) && (path2.basename(__filename) !== "main.js" || path2.basename(__dirname) !== "lib")) {
+    throw new Error(
+      `The esbuild JavaScript API cannot be bundled. Please mark the "esbuild" package as external so it's not included in the bundle.
+
+More information: The file containing the code for esbuild's JavaScript API (${__filename}) does not appear to be inside the esbuild package on the file system, which usually means that the esbuild package was bundled into another file. This is problematic because the API needs to run a binary executable inside the esbuild package which is located using a relative path from the API code to the executable. If the esbuild package is bundled, the relative path will be incorrect and the executable won't be found.`
+    );
+  }
+  if (false) {
+    return ["node", [path2.join(__dirname, "..", "bin", "esbuild")]];
+  } else {
+    const { binPath, isWASM } = generateBinPath();
+    if (isWASM) {
+      return ["node", [binPath]];
+    } else {
+      return [binPath, []];
+    }
+  }
+};
+var isTTY = () => tty.isatty(2);
+var fsSync = {
+  readFile(tempFile, callback) {
+    try {
+      let contents = fs2.readFileSync(tempFile, "utf8");
+      try {
+        fs2.unlinkSync(tempFile);
+      } catch {
+      }
+      callback(null, contents);
+    } catch (err) {
+      callback(err, null);
+    }
+  },
+  writeFile(contents, callback) {
+    try {
+      let tempFile = randomFileName();
+      fs2.writeFileSync(tempFile, contents);
+      callback(tempFile);
+    } catch {
+      callback(null);
+    }
+  }
+};
+var fsAsync = {
+  readFile(tempFile, callback) {
+    try {
+      fs2.readFile(tempFile, "utf8", (err, contents) => {
+        try {
+          fs2.unlink(tempFile, () => callback(err, contents));
+        } catch {
+          callback(err, contents);
+        }
+      });
+    } catch (err) {
+      callback(err, null);
+    }
+  },
+  writeFile(contents, callback) {
+    try {
+      let tempFile = randomFileName();
+      fs2.writeFile(tempFile, contents, (err) => err !== null ? callback(null) : callback(tempFile));
+    } catch {
+      callback(null);
+    }
+  }
+};
+var version = "0.21.5";
+var build = (options) => ensureServiceIsRunning().build(options);
+var context = (buildOptions) => ensureServiceIsRunning().context(buildOptions);
+var transform = (input, options) => ensureServiceIsRunning().transform(input, options);
+var formatMessages = (messages, options) => ensureServiceIsRunning().formatMessages(messages, options);
+var analyzeMetafile = (messages, options) => ensureServiceIsRunning().analyzeMetafile(messages, options);
+var buildSync = (options) => {
+  if (worker_threads && !isInternalWorkerThread) {
+    if (!workerThreadService) workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.buildSync(options);
+  }
+  let result;
+  runServiceSync((service) => service.buildOrContext({
+    callName: "buildSync",
+    refs: null,
+    options,
+    isTTY: isTTY(),
+    defaultWD,
+    callback: (err, res) => {
+      if (err) throw err;
+      result = res;
+    }
+  }));
+  return result;
+};
+var transformSync = (input, options) => {
+  if (worker_threads && !isInternalWorkerThread) {
+    if (!workerThreadService) workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.transformSync(input, options);
+  }
+  let result;
+  runServiceSync((service) => service.transform({
+    callName: "transformSync",
+    refs: null,
+    input,
+    options: options || {},
+    isTTY: isTTY(),
+    fs: fsSync,
+    callback: (err, res) => {
+      if (err) throw err;
+      result = res;
+    }
+  }));
+  return result;
+};
+var formatMessagesSync = (messages, options) => {
+  if (worker_threads && !isInternalWorkerThread) {
+    if (!workerThreadService) workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.formatMessagesSync(messages, options);
+  }
+  let result;
+  runServiceSync((service) => service.formatMessages({
+    callName: "formatMessagesSync",
+    refs: null,
+    messages,
+    options,
+    callback: (err, res) => {
+      if (err) throw err;
+      result = res;
+    }
+  }));
+  return result;
+};
+var analyzeMetafileSync = (metafile, options) => {
+  if (worker_threads && !isInternalWorkerThread) {
+    if (!workerThreadService) workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.analyzeMetafileSync(metafile, options);
+  }
+  let result;
+  runServiceSync((service) => service.analyzeMetafile({
+    callName: "analyzeMetafileSync",
+    refs: null,
+    metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
+    options,
+    callback: (err, res) => {
+      if (err) throw err;
+      result = res;
+    }
+  }));
+  return result;
+};
+var stop = () => {
+  if (stopService) stopService();
+  if (workerThreadService) workerThreadService.stop();
+  return Promise.resolve();
+};
+var initializeWasCalled = false;
+var initialize = (options) => {
+  options = validateInitializeOptions(options || {});
+  if (options.wasmURL) throw new Error(`The "wasmURL" option only works in the browser`);
+  if (options.wasmModule) throw new Error(`The "wasmModule" option only works in the browser`);
+  if (options.worker) throw new Error(`The "worker" option only works in the browser`);
+  if (initializeWasCalled) throw new Error('Cannot call "initialize" more than once');
+  ensureServiceIsRunning();
+  initializeWasCalled = true;
+  return Promise.resolve();
+};
+var defaultWD = process.cwd();
+var longLivedService;
+var stopService;
+var ensureServiceIsRunning = () => {
+  if (longLivedService) return longLivedService;
+  let [command, args] = esbuildCommandAndArgs();
+  let child = child_process.spawn(command, args.concat(`--service=${"0.21.5"}`, "--ping"), {
+    windowsHide: true,
+    stdio: ["pipe", "pipe", "inherit"],
+    cwd: defaultWD
+  });
+  let { readFromStdout, afterClose, service } = createChannel({
+    writeToStdin(bytes) {
+      child.stdin.write(bytes, (err) => {
+        if (err) afterClose(err);
+      });
+    },
+    readFileSync: fs2.readFileSync,
+    isSync: false,
+    hasFS: true,
+    esbuild: node_exports
+  });
+  child.stdin.on("error", afterClose);
+  child.on("error", afterClose);
+  const stdin = child.stdin;
+  const stdout = child.stdout;
+  stdout.on("data", readFromStdout);
+  stdout.on("end", afterClose);
+  stopService = () => {
+    stdin.destroy();
+    stdout.destroy();
+    child.kill();
+    initializeWasCalled = false;
+    longLivedService = void 0;
+    stopService = void 0;
+  };
+  let refCount = 0;
+  child.unref();
+  if (stdin.unref) {
+    stdin.unref();
+  }
+  if (stdout.unref) {
+    stdout.unref();
+  }
+  const refs = {
+    ref() {
+      if (++refCount === 1) child.ref();
+    },
+    unref() {
+      if (--refCount === 0) child.unref();
+    }
+  };
+  longLivedService = {
+    build: (options) => new Promise((resolve, reject) => {
+      service.buildOrContext({
+        callName: "build",
+        refs,
+        options,
+        isTTY: isTTY(),
+        defaultWD,
+        callback: (err, res) => err ? reject(err) : resolve(res)
+      });
+    }),
+    context: (options) => new Promise((resolve, reject) => service.buildOrContext({
+      callName: "context",
+      refs,
+      options,
+      isTTY: isTTY(),
+      defaultWD,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    transform: (input, options) => new Promise((resolve, reject) => service.transform({
+      callName: "transform",
+      refs,
+      input,
+      options: options || {},
+      isTTY: isTTY(),
+      fs: fsAsync,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    formatMessages: (messages, options) => new Promise((resolve, reject) => service.formatMessages({
+      callName: "formatMessages",
+      refs,
+      messages,
+      options,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    })),
+    analyzeMetafile: (metafile, options) => new Promise((resolve, reject) => service.analyzeMetafile({
+      callName: "analyzeMetafile",
+      refs,
+      metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
+      options,
+      callback: (err, res) => err ? reject(err) : resolve(res)
+    }))
+  };
+  return longLivedService;
+};
+var runServiceSync = (callback) => {
+  let [command, args] = esbuildCommandAndArgs();
+  let stdin = new Uint8Array();
+  let { readFromStdout, afterClose, service } = createChannel({
+    writeToStdin(bytes) {
+      if (stdin.length !== 0) throw new Error("Must run at most one command");
+      stdin = bytes;
+    },
+    isSync: true,
+    hasFS: true,
+    esbuild: node_exports
+  });
+  callback(service);
+  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.21.5"}`), {
+    cwd: defaultWD,
+    windowsHide: true,
+    input: stdin,
+    // We don't know how large the output could be. If it's too large, the
+    // command will fail with ENOBUFS. Reserve 16mb for now since that feels
+    // like it should be enough. Also allow overriding this with an environment
+    // variable.
+    maxBuffer: +process.env.ESBUILD_MAX_BUFFER || 16 * 1024 * 1024
+  });
+  readFromStdout(stdout);
+  afterClose(null);
+};
+var randomFileName = () => {
+  return path2.join(os2.tmpdir(), `esbuild-${crypto.randomBytes(32).toString("hex")}`);
+};
+var workerThreadService = null;
+var startWorkerThreadService = (worker_threads2) => {
+  let { port1: mainPort, port2: workerPort } = new worker_threads2.MessageChannel();
+  let worker = new worker_threads2.Worker(__filename, {
+    workerData: { workerPort, defaultWD, esbuildVersion: "0.21.5" },
+    transferList: [workerPort],
+    // From node's documentation: https://nodejs.org/api/worker_threads.html
+    //
+    //   Take care when launching worker threads from preload scripts (scripts loaded
+    //   and run using the `-r` command line flag). Unless the `execArgv` option is
+    //   explicitly set, new Worker threads automatically inherit the command line flags
+    //   from the running process and will preload the same preload scripts as the main
+    //   thread. If the preload script unconditionally launches a worker thread, every
+    //   thread spawned will spawn another until the application crashes.
+    //
+    execArgv: []
+  });
+  let nextID = 0;
+  let fakeBuildError = (text) => {
+    let error = new Error(`Build failed with 1 error:
+error: ${text}`);
+    let errors = [{ id: "", pluginName: "", text, location: null, notes: [], detail: void 0 }];
+    error.errors = errors;
+    error.warnings = [];
+    return error;
+  };
+  let validateBuildSyncOptions = (options) => {
+    if (!options) return;
+    let plugins = options.plugins;
+    if (plugins && plugins.length > 0) throw fakeBuildError(`Cannot use plugins in synchronous API calls`);
+  };
+  let applyProperties = (object, properties) => {
+    for (let key in properties) {
+      object[key] = properties[key];
+    }
+  };
+  let runCallSync = (command, args) => {
+    let id = nextID++;
+    let sharedBuffer = new SharedArrayBuffer(8);
+    let sharedBufferView = new Int32Array(sharedBuffer);
+    let msg = { sharedBuffer, id, command, args };
+    worker.postMessage(msg);
+    let status = Atomics.wait(sharedBufferView, 0, 0);
+    if (status !== "ok" && status !== "not-equal") throw new Error("Internal error: Atomics.wait() failed: " + status);
+    let { message: { id: id2, resolve, reject, properties } } = worker_threads2.receiveMessageOnPort(mainPort);
+    if (id !== id2) throw new Error(`Internal error: Expected id ${id} but got id ${id2}`);
+    if (reject) {
+      applyProperties(reject, properties);
+      throw reject;
+    }
+    return resolve;
+  };
+  worker.unref();
+  return {
+    buildSync(options) {
+      validateBuildSyncOptions(options);
+      return runCallSync("build", [options]);
+    },
+    transformSync(input, options) {
+      return runCallSync("transform", [input, options]);
+    },
+    formatMessagesSync(messages, options) {
+      return runCallSync("formatMessages", [messages, options]);
+    },
+    analyzeMetafileSync(metafile, options) {
+      return runCallSync("analyzeMetafile", [metafile, options]);
+    },
+    stop() {
+      worker.terminate();
+      workerThreadService = null;
+    }
+  };
+};
+var startSyncServiceWorker = () => {
+  let workerPort = worker_threads.workerData.workerPort;
+  let parentPort = worker_threads.parentPort;
+  let extractProperties = (object) => {
+    let properties = {};
+    if (object && typeof object === "object") {
+      for (let key in object) {
+        properties[key] = object[key];
+      }
+    }
+    return properties;
+  };
+  try {
+    let service = ensureServiceIsRunning();
+    defaultWD = worker_threads.workerData.defaultWD;
+    parentPort.on("message", (msg) => {
+      (async () => {
+        let { sharedBuffer, id, command, args } = msg;
+        let sharedBufferView = new Int32Array(sharedBuffer);
+        try {
+          switch (command) {
+            case "build":
+              workerPort.postMessage({ id, resolve: await service.build(args[0]) });
+              break;
+            case "transform":
+              workerPort.postMessage({ id, resolve: await service.transform(args[0], args[1]) });
+              break;
+            case "formatMessages":
+              workerPort.postMessage({ id, resolve: await service.formatMessages(args[0], args[1]) });
+              break;
+            case "analyzeMetafile":
+              workerPort.postMessage({ id, resolve: await service.analyzeMetafile(args[0], args[1]) });
+              break;
+            default:
+              throw new Error(`Invalid command: ${command}`);
+          }
+        } catch (reject) {
+          workerPort.postMessage({ id, reject, properties: extractProperties(reject) });
+        }
+        Atomics.add(sharedBufferView, 0, 1);
+        Atomics.notify(sharedBufferView, 0, Infinity);
+      })();
+    });
+  } catch (reject) {
+    parentPort.on("message", (msg) => {
+      let { sharedBuffer, id } = msg;
+      let sharedBufferView = new Int32Array(sharedBuffer);
+      workerPort.postMessage({ id, reject, properties: extractProperties(reject) });
+      Atomics.add(sharedBufferView, 0, 1);
+      Atomics.notify(sharedBufferView, 0, Infinity);
+    });
+  }
+};
+if (isInternalWorkerThread) {
+  startSyncServiceWorker();
+}
+var node_default = node_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeMetafile,
+  analyzeMetafileSync,
+  build,
+  buildSync,
+  context,
+  formatMessages,
+  formatMessagesSync,
+  initialize,
+  stop,
+  transform,
+  transformSync,
+  version
+});
diff --git a/node_modules/esbuild/package.json b/node_modules/esbuild/package.json
new file mode 100644
index 0000000..fe253fb
--- /dev/null
+++ b/node_modules/esbuild/package.json
@@ -0,0 +1,46 @@
+{
+  "name": "esbuild",
+  "version": "0.21.5",
+  "description": "An extremely fast JavaScript and CSS bundler and minifier.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evanw/esbuild.git"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "main": "lib/main.js",
+  "types": "lib/main.d.ts",
+  "engines": {
+    "node": ">=12"
+  },
+  "bin": {
+    "esbuild": "bin/esbuild"
+  },
+  "optionalDependencies": {
+    "@esbuild/aix-ppc64": "0.21.5",
+    "@esbuild/android-arm": "0.21.5",
+    "@esbuild/android-arm64": "0.21.5",
+    "@esbuild/android-x64": "0.21.5",
+    "@esbuild/darwin-arm64": "0.21.5",
+    "@esbuild/darwin-x64": "0.21.5",
+    "@esbuild/freebsd-arm64": "0.21.5",
+    "@esbuild/freebsd-x64": "0.21.5",
+    "@esbuild/linux-arm": "0.21.5",
+    "@esbuild/linux-arm64": "0.21.5",
+    "@esbuild/linux-ia32": "0.21.5",
+    "@esbuild/linux-loong64": "0.21.5",
+    "@esbuild/linux-mips64el": "0.21.5",
+    "@esbuild/linux-ppc64": "0.21.5",
+    "@esbuild/linux-riscv64": "0.21.5",
+    "@esbuild/linux-s390x": "0.21.5",
+    "@esbuild/linux-x64": "0.21.5",
+    "@esbuild/netbsd-x64": "0.21.5",
+    "@esbuild/openbsd-x64": "0.21.5",
+    "@esbuild/sunos-x64": "0.21.5",
+    "@esbuild/win32-arm64": "0.21.5",
+    "@esbuild/win32-ia32": "0.21.5",
+    "@esbuild/win32-x64": "0.21.5"
+  },
+  "license": "MIT"
+}
diff --git a/node_modules/fsevents/LICENSE b/node_modules/fsevents/LICENSE
new file mode 100644
index 0000000..5d70441
--- /dev/null
+++ b/node_modules/fsevents/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+-----------
+
+Copyright (C) 2010-2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/fsevents/README.md b/node_modules/fsevents/README.md
new file mode 100644
index 0000000..50373a0
--- /dev/null
+++ b/node_modules/fsevents/README.md
@@ -0,0 +1,89 @@
+# fsevents
+
+Native access to MacOS FSEvents in [Node.js](https://nodejs.org/)
+
+The FSEvents API in MacOS allows applications to register for notifications of
+changes to a given directory tree. It is a very fast and lightweight alternative
+to kqueue.
+
+This is a low-level library. For a cross-platform file watching module that
+uses fsevents, check out [Chokidar](https://github.com/paulmillr/chokidar).
+
+## Usage
+
+```sh
+npm install fsevents
+```
+
+Supports only **Node.js v8.16 and higher**.
+
+```js
+const fsevents = require('fsevents');
+
+// To start observation
+const stop = fsevents.watch(__dirname, (path, flags, id) => {
+  const info = fsevents.getInfo(path, flags);
+});
+
+// To end observation
+stop();
+```
+
+> **Important note:** The API behaviour is slightly different from typical JS APIs. The `stop` function **must** be
+> retrieved and stored somewhere, even if you don't plan to stop the watcher. If you forget it, the garbage collector
+> will eventually kick in, the watcher will be unregistered, and your callbacks won't be called anymore.
+
+The callback passed as the second parameter to `.watch` get's called whenever the operating system detects a
+a change in the file system. It takes three arguments:
+
+###### `fsevents.watch(dirname: string, (path: string, flags: number, id: string) => void): () => Promise<undefined>`
+
+ * `path: string` - the item in the filesystem that have been changed
+ * `flags: number` - a numeric value describing what the change was
+ * `id: string` - an unique-id identifying this specific event
+
+ Returns closer callback which when called returns a Promise resolving when the watcher process has been shut down.
+
+###### `fsevents.getInfo(path: string, flags: number, id: string): FsEventInfo`
+
+The `getInfo` function takes the `path`, `flags` and `id` arguments and converts those parameters into a structure
+that is easier to digest to determine what the change was.
+
+The `FsEventsInfo` has the following shape:
+
+```js
+/**
+ * @typedef {'created'|'modified'|'deleted'|'moved'|'root-changed'|'cloned'|'unknown'} FsEventsEvent
+ * @typedef {'file'|'directory'|'symlink'} FsEventsType
+ */
+{
+  "event": "created", // {FsEventsEvent}
+  "path": "file.txt",
+  "type": "file",    // {FsEventsType}
+  "changes": {
+    "inode": true,   // Had iNode Meta-Information changed
+    "finder": false, // Had Finder Meta-Data changed
+    "access": false, // Had access permissions changed
+    "xattrs": false  // Had xAttributes changed
+  },
+  "flags": 0x100000000
+}
+```
+
+## Changelog
+
+- v2.3 supports Apple Silicon ARM CPUs
+- v2 supports node 8.16+ and reduces package size massively
+- v1.2.8 supports node 6+
+- v1.2.7 supports node 4+
+
+## Troubleshooting
+
+- I'm getting `EBADPLATFORM` `Unsupported platform for fsevents` error.
+- It's fine, nothing is broken. fsevents is macos-only. Other platforms are skipped. If you want to hide this warning, report a bug to NPM bugtracker asking them to hide ebadplatform warnings by default.
+
+## License
+
+The MIT License Copyright (C) 2010-2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller — see LICENSE file.
+
+Visit our [GitHub page](https://github.com/fsevents/fsevents) and [NPM Page](https://npmjs.org/package/fsevents)
diff --git a/node_modules/fsevents/fsevents.d.ts b/node_modules/fsevents/fsevents.d.ts
new file mode 100644
index 0000000..2723c04
--- /dev/null
+++ b/node_modules/fsevents/fsevents.d.ts
@@ -0,0 +1,46 @@
+declare type Event = "created" | "cloned" | "modified" | "deleted" | "moved" | "root-changed" | "unknown";
+declare type Type = "file" | "directory" | "symlink";
+declare type FileChanges = {
+  inode: boolean;
+  finder: boolean;
+  access: boolean;
+  xattrs: boolean;
+};
+declare type Info = {
+  event: Event;
+  path: string;
+  type: Type;
+  changes: FileChanges;
+  flags: number;
+};
+declare type WatchHandler = (path: string, flags: number, id: string) => void;
+export declare function watch(path: string, handler: WatchHandler): () => Promise<void>;
+export declare function watch(path: string, since: number, handler: WatchHandler): () => Promise<void>;
+export declare function getInfo(path: string, flags: number): Info;
+export declare const constants: {
+  None: 0x00000000;
+  MustScanSubDirs: 0x00000001;
+  UserDropped: 0x00000002;
+  KernelDropped: 0x00000004;
+  EventIdsWrapped: 0x00000008;
+  HistoryDone: 0x00000010;
+  RootChanged: 0x00000020;
+  Mount: 0x00000040;
+  Unmount: 0x00000080;
+  ItemCreated: 0x00000100;
+  ItemRemoved: 0x00000200;
+  ItemInodeMetaMod: 0x00000400;
+  ItemRenamed: 0x00000800;
+  ItemModified: 0x00001000;
+  ItemFinderInfoMod: 0x00002000;
+  ItemChangeOwner: 0x00004000;
+  ItemXattrMod: 0x00008000;
+  ItemIsFile: 0x00010000;
+  ItemIsDir: 0x00020000;
+  ItemIsSymlink: 0x00040000;
+  ItemIsHardlink: 0x00100000;
+  ItemIsLastHardlink: 0x00200000;
+  OwnEvent: 0x00080000;
+  ItemCloned: 0x00400000;
+};
+export {};
diff --git a/node_modules/fsevents/fsevents.js b/node_modules/fsevents/fsevents.js
new file mode 100644
index 0000000..198da98
--- /dev/null
+++ b/node_modules/fsevents/fsevents.js
@@ -0,0 +1,83 @@
+/*
+ ** © 2020 by Philipp Dunkel, Ben Noordhuis, Elan Shankar, Paul Miller
+ ** Licensed under MIT License.
+ */
+
+/* jshint node:true */
+"use strict";
+
+if (process.platform !== "darwin") {
+  throw new Error(`Module 'fsevents' is not compatible with platform '${process.platform}'`);
+}
+
+const Native = require("./fsevents.node");
+const events = Native.constants;
+
+function watch(path, since, handler) {
+  if (typeof path !== "string") {
+    throw new TypeError(`fsevents argument 1 must be a string and not a ${typeof path}`);
+  }
+  if ("function" === typeof since && "undefined" === typeof handler) {
+    handler = since;
+    since = Native.flags.SinceNow;
+  }
+  if (typeof since !== "number") {
+    throw new TypeError(`fsevents argument 2 must be a number and not a ${typeof since}`);
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError(`fsevents argument 3 must be a function and not a ${typeof handler}`);
+  }
+
+  let instance = Native.start(Native.global, path, since, handler);
+  if (!instance) throw new Error(`could not watch: ${path}`);
+  return () => {
+    const result = instance ? Promise.resolve(instance).then(Native.stop) : Promise.resolve(undefined);
+    instance = undefined;
+    return result;
+  };
+}
+
+function getInfo(path, flags) {
+  return {
+    path,
+    flags,
+    event: getEventType(flags),
+    type: getFileType(flags),
+    changes: getFileChanges(flags),
+  };
+}
+
+function getFileType(flags) {
+  if (events.ItemIsFile & flags) return "file";
+  if (events.ItemIsDir & flags) return "directory";
+  if (events.MustScanSubDirs & flags) return "directory"; 
+  if (events.ItemIsSymlink & flags) return "symlink";
+}
+function anyIsTrue(obj) {
+  for (let key in obj) {
+    if (obj[key]) return true;
+  }
+  return false;
+}
+function getEventType(flags) {
+  if (events.ItemRemoved & flags) return "deleted";
+  if (events.ItemRenamed & flags) return "moved";
+  if (events.ItemCreated & flags) return "created";
+  if (events.ItemModified & flags) return "modified";
+  if (events.RootChanged & flags) return "root-changed";
+  if (events.ItemCloned & flags) return "cloned";
+  if (anyIsTrue(flags)) return "modified";
+  return "unknown";
+}
+function getFileChanges(flags) {
+  return {
+    inode: !!(events.ItemInodeMetaMod & flags),
+    finder: !!(events.ItemFinderInfoMod & flags),
+    access: !!(events.ItemChangeOwner & flags),
+    xattrs: !!(events.ItemXattrMod & flags),
+  };
+}
+
+exports.watch = watch;
+exports.getInfo = getInfo;
+exports.constants = events;
diff --git a/node_modules/fsevents/fsevents.node b/node_modules/fsevents/fsevents.node
new file mode 100755
index 0000000..1cc3345
Binary files /dev/null and b/node_modules/fsevents/fsevents.node differ
diff --git a/node_modules/fsevents/package.json b/node_modules/fsevents/package.json
new file mode 100644
index 0000000..5d0ee15
--- /dev/null
+++ b/node_modules/fsevents/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "fsevents",
+  "version": "2.3.3",
+  "description": "Native Access to MacOS FSEvents",
+  "main": "fsevents.js",
+  "types": "fsevents.d.ts",
+  "os": [
+    "darwin"
+  ],
+  "files": [
+    "fsevents.d.ts",
+    "fsevents.js",
+    "fsevents.node"
+  ],
+  "engines": {
+    "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+  },
+  "scripts": {
+    "clean": "node-gyp clean && rm -f fsevents.node",
+    "build": "node-gyp clean && rm -f fsevents.node && node-gyp rebuild && node-gyp clean",
+    "test": "/bin/bash ./test.sh 2>/dev/null",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fsevents/fsevents.git"
+  },
+  "keywords": [
+    "fsevents",
+    "mac"
+  ],
+  "contributors": [
+    {
+      "name": "Philipp Dunkel",
+      "email": "pip@pipobscure.com"
+    },
+    {
+      "name": "Ben Noordhuis",
+      "email": "info@bnoordhuis.nl"
+    },
+    {
+      "name": "Elan Shankar",
+      "email": "elan.shanker@gmail.com"
+    },
+    {
+      "name": "Miroslav Bajtoš",
+      "email": "mbajtoss@gmail.com"
+    },
+    {
+      "name": "Paul Miller",
+      "url": "https://paulmillr.com"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fsevents/fsevents/issues"
+  },
+  "homepage": "https://github.com/fsevents/fsevents",
+  "devDependencies": {
+    "node-gyp": "^9.4.0"
+  }
+}
diff --git a/node_modules/nanoid/LICENSE b/node_modules/nanoid/LICENSE
new file mode 100644
index 0000000..37f56aa
--- /dev/null
+++ b/node_modules/nanoid/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/nanoid/README.md b/node_modules/nanoid/README.md
new file mode 100644
index 0000000..35abb57
--- /dev/null
+++ b/node_modules/nanoid/README.md
@@ -0,0 +1,39 @@
+# Nano ID
+
+<img src="https://ai.github.io/nanoid/logo.svg" align="right"
+     alt="Nano ID logo by Anton Lovchikov" width="180" height="94">
+
+**English** | [Русский](./README.ru.md) | [简体中文](./README.zh-CN.md) | [Bahasa Indonesia](./README.id-ID.md)
+
+A tiny, secure, URL-friendly, unique string ID generator for JavaScript.
+
+> “An amazing level of senseless perfectionism,
+> which is simply impossible not to respect.”
+
+* **Small.** 130 bytes (minified and gzipped). No dependencies.
+  [Size Limit] controls the size.
+* **Fast.** It is 2 times faster than UUID.
+* **Safe.** It uses hardware random generator. Can be used in clusters.
+* **Short IDs.** It uses a larger alphabet than UUID (`A-Za-z0-9_-`).
+  So ID size was reduced from 36 to 21 symbols.
+* **Portable.** Nano ID was ported
+  to [20 programming languages](#other-programming-languages).
+
+```js
+import { nanoid } from 'nanoid'
+model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
+```
+
+Supports modern browsers, IE [with Babel], Node.js and React Native.
+
+[online tool]: https://gitpod.io/#https://github.com/ai/nanoid/
+[with Babel]:  https://developer.epages.com/blog/coding/how-to-transpile-node-modules-with-babel-and-webpack-in-a-monorepo/
+[Size Limit]:  https://github.com/ai/size-limit
+
+<a href="https://evilmartians.com/?utm_source=nanoid">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+       alt="Sponsored by Evil Martians" width="236" height="54">
+</a>
+
+## Docs
+Read full docs **[here](https://github.com/ai/nanoid#readme)**.
diff --git a/node_modules/nanoid/async/index.browser.cjs b/node_modules/nanoid/async/index.browser.cjs
new file mode 100644
index 0000000..7e5bba8
--- /dev/null
+++ b/node_modules/nanoid/async/index.browser.cjs
@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return async (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = crypto.getRandomValues(new Uint8Array(step))
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let nanoid = async (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array(size))
+  while (size--) {
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+module.exports = { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.browser.js b/node_modules/nanoid/async/index.browser.js
new file mode 100644
index 0000000..5ece04d
--- /dev/null
+++ b/node_modules/nanoid/async/index.browser.js
@@ -0,0 +1,34 @@
+let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return async (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = crypto.getRandomValues(new Uint8Array(step))
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let nanoid = async (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array(size))
+  while (size--) {
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.cjs b/node_modules/nanoid/async/index.cjs
new file mode 100644
index 0000000..50db105
--- /dev/null
+++ b/node_modules/nanoid/async/index.cjs
@@ -0,0 +1,35 @@
+let crypto = require('crypto')
+let { urlAlphabet } = require('../url-alphabet/index.cjs')
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random(size).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+module.exports = { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.d.ts b/node_modules/nanoid/async/index.d.ts
new file mode 100644
index 0000000..9e91965
--- /dev/null
+++ b/node_modules/nanoid/async/index.d.ts
@@ -0,0 +1,56 @@
+/**
+ * Generate secure URL-friendly unique ID. The non-blocking version.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/async'
+ * nanoid().then(id => {
+ *   model.id = id
+ * })
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A promise with a random string.
+ */
+export function nanoid(size?: number): Promise<string>
+
+/**
+ * A low-level function.
+ * Generate secure unique ID with custom alphabet. The non-blocking version.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A function that returns a promise with a random string.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/async'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid().then(id => {
+ *   model.id = id //=> "8ё56а"
+ * })
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => Promise<string>
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { random } from 'nanoid/async'
+ * random(5).then(bytes => {
+ *   bytes //=> [10, 67, 212, 67, 89]
+ * })
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns A promise with a random bytes array.
+ */
+export function random(bytes: number): Promise<Uint8Array>
diff --git a/node_modules/nanoid/async/index.js b/node_modules/nanoid/async/index.js
new file mode 100644
index 0000000..803fad6
--- /dev/null
+++ b/node_modules/nanoid/async/index.js
@@ -0,0 +1,35 @@
+import crypto from 'crypto'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random(size).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/index.native.js b/node_modules/nanoid/async/index.native.js
new file mode 100644
index 0000000..5cb3d57
--- /dev/null
+++ b/node_modules/nanoid/async/index.native.js
@@ -0,0 +1,26 @@
+import { getRandomBytesAsync } from 'expo-random'
+import { urlAlphabet } from '../url-alphabet/index.js'
+let random = getRandomBytesAsync
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  let tick = (id, size = defaultSize) =>
+    random(step).then(bytes => {
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+      return tick(id, size)
+    })
+  return size => tick('', size)
+}
+let nanoid = (size = 21) =>
+  random(size).then(bytes => {
+    let id = ''
+    while (size--) {
+      id += urlAlphabet[bytes[size] & 63]
+    }
+    return id
+  })
+export { nanoid, customAlphabet, random }
diff --git a/node_modules/nanoid/async/package.json b/node_modules/nanoid/async/package.json
new file mode 100644
index 0000000..578cdb4
--- /dev/null
+++ b/node_modules/nanoid/async/package.json
@@ -0,0 +1,12 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": {
+    "./index.js": "./index.native.js"
+  },
+  "browser": {
+    "./index.js": "./index.browser.js",
+    "./index.cjs": "./index.browser.cjs"
+  }
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/bin/nanoid.cjs b/node_modules/nanoid/bin/nanoid.cjs
new file mode 100755
index 0000000..c76db0f
--- /dev/null
+++ b/node_modules/nanoid/bin/nanoid.cjs
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+let { nanoid, customAlphabet } = require('..')
+
+function print(msg) {
+  process.stdout.write(msg + '\n')
+}
+
+function error(msg) {
+  process.stderr.write(msg + '\n')
+  process.exit(1)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  print(`
+  Usage
+    $ nanoid [options]
+
+  Options
+    -s, --size       Generated ID size
+    -a, --alphabet   Alphabet to use
+    -h, --help       Show this help
+
+  Examples
+    $ nanoid --s 15
+    S9sBF77U6sDB8Yg
+
+    $ nanoid --size 10 --alphabet abc
+    bcabababca`)
+  process.exit()
+}
+
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+  let arg = process.argv[i]
+  if (arg === '--size' || arg === '-s') {
+    size = Number(process.argv[i + 1])
+    i += 1
+    if (Number.isNaN(size) || size <= 0) {
+      error('Size must be positive integer')
+    }
+  } else if (arg === '--alphabet' || arg === '-a') {
+    alphabet = process.argv[i + 1]
+    i += 1
+  } else {
+    error('Unknown argument ' + arg)
+  }
+}
+
+if (alphabet) {
+  let customNanoid = customAlphabet(alphabet, size)
+  print(customNanoid())
+} else {
+  print(nanoid(size))
+}
diff --git a/node_modules/nanoid/index.browser.cjs b/node_modules/nanoid/index.browser.cjs
new file mode 100644
index 0000000..f800d6f
--- /dev/null
+++ b/node_modules/nanoid/index.browser.cjs
@@ -0,0 +1,34 @@
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let j = step
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte > 62) {
+      id += '-'
+    } else {
+      id += '_'
+    }
+    return id
+  }, '')
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.browser.js b/node_modules/nanoid/index.browser.js
new file mode 100644
index 0000000..8b3139b
--- /dev/null
+++ b/node_modules/nanoid/index.browser.js
@@ -0,0 +1,34 @@
+import { urlAlphabet } from './url-alphabet/index.js'
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
+  let step = -~((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let j = step
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) =>
+  crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+    byte &= 63
+    if (byte < 36) {
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte > 62) {
+      id += '-'
+    } else {
+      id += '_'
+    }
+    return id
+  }, '')
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.cjs b/node_modules/nanoid/index.cjs
new file mode 100644
index 0000000..0fa85e9
--- /dev/null
+++ b/node_modules/nanoid/index.cjs
@@ -0,0 +1,45 @@
+let crypto = require('crypto')
+let { urlAlphabet } = require('./url-alphabet/index.cjs')
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+let fillPool = bytes => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  }
+  poolOffset += bytes
+}
+let random = bytes => {
+  fillPool((bytes -= 0))
+  return pool.subarray(poolOffset - bytes, poolOffset)
+}
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) => {
+  fillPool((size -= 0))
+  let id = ''
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63]
+  }
+  return id
+}
+module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/index.d.cts b/node_modules/nanoid/index.d.cts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/node_modules/nanoid/index.d.cts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/node_modules/nanoid/index.d.ts b/node_modules/nanoid/index.d.ts
new file mode 100644
index 0000000..3e111a3
--- /dev/null
+++ b/node_modules/nanoid/index.d.ts
@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from 'nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from 'nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from 'nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array
diff --git a/node_modules/nanoid/index.js b/node_modules/nanoid/index.js
new file mode 100644
index 0000000..21e155f
--- /dev/null
+++ b/node_modules/nanoid/index.js
@@ -0,0 +1,45 @@
+import crypto from 'crypto'
+import { urlAlphabet } from './url-alphabet/index.js'
+const POOL_SIZE_MULTIPLIER = 128
+let pool, poolOffset
+let fillPool = bytes => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool)
+    poolOffset = 0
+  }
+  poolOffset += bytes
+}
+let random = bytes => {
+  fillPool((bytes -= 0))
+  return pool.subarray(poolOffset - bytes, poolOffset)
+}
+let customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
+  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
+  return (size = defaultSize) => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      let i = step
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+let customAlphabet = (alphabet, size = 21) =>
+  customRandom(alphabet, size, random)
+let nanoid = (size = 21) => {
+  fillPool((size -= 0))
+  let id = ''
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63]
+  }
+  return id
+}
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }
diff --git a/node_modules/nanoid/nanoid.js b/node_modules/nanoid/nanoid.js
new file mode 100644
index 0000000..ec242ea
--- /dev/null
+++ b/node_modules/nanoid/nanoid.js
@@ -0,0 +1 @@
+export let nanoid=(t=21)=>crypto.getRandomValues(new Uint8Array(t)).reduce(((t,e)=>t+=(e&=63)<36?e.toString(36):e<62?(e-26).toString(36).toUpperCase():e<63?"_":"-"),"");
\ No newline at end of file
diff --git a/node_modules/nanoid/non-secure/index.cjs b/node_modules/nanoid/non-secure/index.cjs
new file mode 100644
index 0000000..09d57cd
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.cjs
@@ -0,0 +1,21 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = ''
+    let i = size
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+let nanoid = (size = 21) => {
+  let id = ''
+  let i = size
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}
+module.exports = { nanoid, customAlphabet }
diff --git a/node_modules/nanoid/non-secure/index.d.ts b/node_modules/nanoid/non-secure/index.d.ts
new file mode 100644
index 0000000..4965322
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.d.ts
@@ -0,0 +1,33 @@
+/**
+ * Generate URL-friendly unique ID. This method uses the non-secure
+ * predictable random generator with bigger collision probability.
+ *
+ * ```js
+ * import { nanoid } from 'nanoid/non-secure'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate a unique ID based on a custom alphabet.
+ * This method uses the non-secure predictable random generator
+ * with bigger collision probability.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * import { customAlphabet } from 'nanoid/non-secure'
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * model.id = //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
diff --git a/node_modules/nanoid/non-secure/index.js b/node_modules/nanoid/non-secure/index.js
new file mode 100644
index 0000000..e7e19ad
--- /dev/null
+++ b/node_modules/nanoid/non-secure/index.js
@@ -0,0 +1,21 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+let customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = ''
+    let i = size
+    while (i--) {
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+let nanoid = (size = 21) => {
+  let id = ''
+  let i = size
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}
+export { nanoid, customAlphabet }
diff --git a/node_modules/nanoid/non-secure/package.json b/node_modules/nanoid/non-secure/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/node_modules/nanoid/non-secure/package.json
@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/package.json b/node_modules/nanoid/package.json
new file mode 100644
index 0000000..4f24d96
--- /dev/null
+++ b/node_modules/nanoid/package.json
@@ -0,0 +1,88 @@
+{
+  "name": "nanoid",
+  "version": "3.3.7",
+  "description": "A tiny (116 bytes), secure URL-friendly unique string ID generator",
+  "keywords": [
+    "uuid",
+    "random",
+    "id",
+    "url"
+  ],
+  "engines": {
+    "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "repository": "ai/nanoid",
+  "browser": {
+    "./index.js": "./index.browser.js",
+    "./async/index.js": "./async/index.browser.js",
+    "./async/index.cjs": "./async/index.browser.cjs",
+    "./index.cjs": "./index.browser.cjs"
+  },
+  "react-native": "index.js",
+  "bin": "./bin/nanoid.cjs",
+  "sideEffects": false,
+  "types": "./index.d.ts",
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./index.browser.js",
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json",
+    "./async/package.json": "./async/package.json",
+    "./async": {
+      "browser": "./async/index.browser.js",
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./async/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./async/index.js"
+      },
+      "default": "./async/index.js"
+    },
+    "./non-secure/package.json": "./non-secure/package.json",
+    "./non-secure": {
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./non-secure/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./non-secure/index.js"
+      },
+      "default": "./non-secure/index.js"
+    },
+    "./url-alphabet/package.json": "./url-alphabet/package.json",
+    "./url-alphabet": {
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./url-alphabet/index.cjs"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./url-alphabet/index.js"
+      },
+      "default": "./url-alphabet/index.js"
+    }
+  }
+}
\ No newline at end of file
diff --git a/node_modules/nanoid/url-alphabet/index.cjs b/node_modules/nanoid/url-alphabet/index.cjs
new file mode 100644
index 0000000..757b709
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/index.cjs
@@ -0,0 +1,3 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+module.exports = { urlAlphabet }
diff --git a/node_modules/nanoid/url-alphabet/index.js b/node_modules/nanoid/url-alphabet/index.js
new file mode 100644
index 0000000..c2782e5
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/index.js
@@ -0,0 +1,3 @@
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
+export { urlAlphabet }
diff --git a/node_modules/nanoid/url-alphabet/package.json b/node_modules/nanoid/url-alphabet/package.json
new file mode 100644
index 0000000..9930d6a
--- /dev/null
+++ b/node_modules/nanoid/url-alphabet/package.json
@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}
\ No newline at end of file
diff --git a/node_modules/picocolors/LICENSE b/node_modules/picocolors/LICENSE
new file mode 100644
index 0000000..46c9b95
--- /dev/null
+++ b/node_modules/picocolors/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2021-2024 Oleksii Raspopov, Kostiantyn Denysov, Anton Verinov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/picocolors/README.md b/node_modules/picocolors/README.md
new file mode 100644
index 0000000..54e3aa3
--- /dev/null
+++ b/node_modules/picocolors/README.md
@@ -0,0 +1,177 @@
+# picocolors
+
+The tiniest and the fastest library for terminal output formatting with ANSI colors.
+
+```javascript
+import pc from "picocolors"
+
+console.log(
+  pc.green(`How are ${pc.italic(`you`)} doing?`)
+)
+```
+
+- **No dependencies.**
+- **14 times** smaller and **2 times** faster than chalk.
+- Used by popular tools like PostCSS, SVGO, Stylelint, and Browserslist.
+- Node.js v6+ & browsers support. Support for both CJS and ESM projects.
+- TypeScript type declarations included.
+- [`NO_COLOR`](https://no-color.org/) friendly.
+
+## Motivation
+
+With `picocolors` we are trying to draw attention to the `node_modules` size
+problem and promote performance-first culture.
+
+## Prior Art
+
+Credits go to the following projects:
+
+- [Nanocolors](https://github.com/ai/nanocolors) by [@ai](https://github.com/ai)
+- [Colorette](https://github.com/jorgebucaran/colorette) by [@jorgebucaran](https://github.com/jorgebucaran)
+- [Kleur](https://github.com/lukeed/kleur) by [@lukeed](https://github.com/lukeed)
+- [Colors.js](https://github.com/Marak/colors.js) by [@Marak](https://github.com/Marak)
+- [Chalk](https://github.com/chalk/chalk) by [@sindresorhus](https://github.com/sindresorhus)
+
+## Benchmarks
+
+The space in node_modules including sub-dependencies:
+
+```diff
+$ node ./benchmarks/size.js
+Data from packagephobia.com
+  chalk       101 kB
+  cli-color  1249 kB
+  ansi-colors  25 kB
+  kleur        21 kB
+  colorette    17 kB
+  nanocolors   16 kB
++ picocolors    7 kB
+```
+
+Library loading time:
+
+```diff
+$ node ./benchmarks/loading.js
+  chalk          6.167 ms
+  cli-color     31.431 ms
+  ansi-colors    1.585 ms
+  kleur          2.008 ms
+  kleur/colors   0.773 ms
+  colorette      2.476 ms
+  nanocolors     0.833 ms
++ picocolors     0.466 ms
+```
+
+Benchmark for simple use case:
+
+```diff
+$ node ./benchmarks/simple.js
+  chalk         24,066,342 ops/sec
+  cli-color        938,700 ops/sec
+  ansi-colors    4,532,542 ops/sec
+  kleur         20,343,122 ops/sec
+  kleur/colors  35,415,770 ops/sec
+  colorette     34,244,834 ops/sec
+  nanocolors    33,443,265 ops/sec
++ picocolors    33,271,645 ops/sec
+```
+
+Benchmark for complex use cases:
+
+```diff
+$ node ./benchmarks/complex.js
+  chalk            969,915 ops/sec
+  cli-color        131,639 ops/sec
+  ansi-colors      342,250 ops/sec
+  kleur            611,880 ops/sec
+  kleur/colors   1,129,526 ops/sec
+  colorette      1,747,277 ops/sec
+  nanocolors     1,251,312 ops/sec
++ picocolors     2,024,086 ops/sec
+```
+
+## Usage
+
+Picocolors provides an object which includes a variety of text coloring and formatting functions
+
+```javascript
+import pc from "picocolors"
+```
+
+The object includes following coloring functions: `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, `gray`.
+
+```javascript
+console.log(`I see a ${pc.red("red door")} and I want it painted ${pc.black("black")}`)
+```
+
+The object also includes following background color modifier functions: `bgBlack`, `bgRed`, `bgGreen`, `bgYellow`, `bgBlue`, `bgMagenta`, `bgCyan`, `bgWhite` and bright variants `bgBlackBright`, `bgRedBright`, `bgGreenBright`, `bgYellowBright`, `bgBlueBright`, `bgMagentaBright`, `bgCyanBright`, `bgWhiteBright`.
+
+```javascript
+console.log(
+  pc.bgBlack(
+    pc.white(`Tom appeared on the sidewalk with a bucket of whitewash and a long-handled brush.`)
+  )
+)
+```
+
+Besides colors, the object includes following formatting functions: `dim`, `bold`, `hidden`, `italic`, `underline`, `strikethrough`, `reset`, `inverse` and bright variants `blackBright`, `redBright`, `greenBright`, `yellowBright`, `blueBright`, `magentaBright`, `cyanBright`, `whiteBright`.
+
+```javascript
+for (let task of tasks) {
+  console.log(`${pc.bold(task.name)} ${pc.dim(task.durationMs + "ms")}`)
+}
+```
+
+The library provides additional utilities to ensure the best results for the task:
+
+- `isColorSupported` — boolean, explicitly tells whether or not the colors or formatting appear on the screen
+
+  ```javascript
+  import pc from "picocolors"
+
+  if (pc.isColorSupported) {
+    console.log("Yay! This script can use colors and formatters")
+  }
+  ```
+
+- `createColors(enabled)` — a function that returns a new API object with manually defined color support configuration
+
+  ```javascript
+  import pc from "picocolors"
+
+  let { red, bgWhite } = pc.createColors(options.enableColors)
+  ```
+
+## Replacing `chalk`
+
+1. Replace package name in import:
+
+   ```diff
+   - import chalk from 'chalk'
+   + import pico from 'picocolors'
+   ```
+
+2. Replace variable:
+
+   ```diff
+   - chalk.red(text)
+   + pico.red(text)
+   ```
+
+3. Replace chains to nested calls:
+
+   ```diff
+   - chalk.red.bold(text)
+   + pico.red(pico.bold(text))
+   ```
+
+4. You can use [`colorize-template`](https://github.com/usmanyunusov/colorize-template)
+   to replace chalk’s tagged template literal.
+
+   ```diff
+   + import { createColorize } from 'colorize-template'
+
+   + let colorize = createColorize(pico)
+   - chalk.red.bold`full {yellow ${"text"}}`
+   + colorize`{red.bold full {yellow ${"text"}}}`
+   ```
diff --git a/node_modules/picocolors/package.json b/node_modules/picocolors/package.json
new file mode 100644
index 0000000..fd781f4
--- /dev/null
+++ b/node_modules/picocolors/package.json
@@ -0,0 +1,49 @@
+{
+  "name": "picocolors",
+  "version": "1.1.0",
+  "main": "./picocolors.js",
+  "types": "./picocolors.d.ts",
+  "browser": {
+    "./picocolors.js": "./picocolors.browser.js"
+  },
+  "sideEffects": false,
+  "description": "The tiniest and the fastest library for terminal output formatting with ANSI colors",
+  "scripts": {
+    "test": "node tests/test.js"
+  },
+  "files": [
+    "picocolors.*",
+    "types.ts"
+  ],
+  "keywords": [
+    "terminal",
+    "colors",
+    "formatting",
+    "cli",
+    "console"
+  ],
+  "author": "Alexey Raspopov",
+  "repository": "alexeyraspopov/picocolors",
+  "license": "ISC",
+  "devDependencies": {
+    "ansi-colors": "^4.1.1",
+    "benchmark": "^2.1.4",
+    "chalk": "^4.1.2",
+    "clean-publish": "^3.0.3",
+    "cli-color": "^2.0.0",
+    "colorette": "^2.0.12",
+    "kleur": "^4.1.4",
+    "nanocolors": "^0.2.12",
+    "prettier": "^2.4.1"
+  },
+  "prettier": {
+    "printWidth": 100,
+    "useTabs": true,
+    "tabWidth": 2,
+    "semi": false,
+    "arrowParens": "avoid"
+  },
+  "clean-publish": {
+    "cleanDocs": true
+  }
+}
diff --git a/node_modules/picocolors/picocolors.browser.js b/node_modules/picocolors/picocolors.browser.js
new file mode 100644
index 0000000..9dcf637
--- /dev/null
+++ b/node_modules/picocolors/picocolors.browser.js
@@ -0,0 +1,4 @@
+var x=String;
+var create=function() {return {isColorSupported:false,reset:x,bold:x,dim:x,italic:x,underline:x,inverse:x,hidden:x,strikethrough:x,black:x,red:x,green:x,yellow:x,blue:x,magenta:x,cyan:x,white:x,gray:x,bgBlack:x,bgRed:x,bgGreen:x,bgYellow:x,bgBlue:x,bgMagenta:x,bgCyan:x,bgWhite:x,blackBright:x,redBright:x,greenBright:x,yellowBright:x,blueBright:x,magentaBright:x,cyanBright:x,whiteBright:x,bgBlackBright:x,bgRedBright:x,bgGreenBright:x,bgYellowBright:x,bgBlueBright:x,bgMagentaBright:x,bgCyanBright:x,bgWhiteBright:x}};
+module.exports=create();
+module.exports.createColors = create;
diff --git a/node_modules/picocolors/picocolors.d.ts b/node_modules/picocolors/picocolors.d.ts
new file mode 100644
index 0000000..94e146a
--- /dev/null
+++ b/node_modules/picocolors/picocolors.d.ts
@@ -0,0 +1,5 @@
+import { Colors } from "./types"
+
+declare const picocolors: Colors & { createColors: (enabled?: boolean) => Colors }
+
+export = picocolors
diff --git a/node_modules/picocolors/picocolors.js b/node_modules/picocolors/picocolors.js
new file mode 100644
index 0000000..f5ea2a1
--- /dev/null
+++ b/node_modules/picocolors/picocolors.js
@@ -0,0 +1,85 @@
+let argv = process.argv || [],
+	env = process.env
+let isColorSupported =
+	!("NO_COLOR" in env || argv.includes("--no-color")) &&
+	("FORCE_COLOR" in env ||
+		argv.includes("--color") ||
+		process.platform === "win32" ||
+		(require != null && require("tty").isatty(1) && env.TERM !== "dumb") ||
+		"CI" in env)
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input
+		let index = string.indexOf(close, open.length)
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	}
+
+let replaceClose = (string, close, replace, index) => {
+	let result = ""
+	let cursor = 0
+	do {
+		result += string.substring(cursor, index) + replace
+		cursor = index + close.length
+		index = string.indexOf(close, cursor)
+	} while (~index)
+	return result + string.substring(cursor)
+}
+
+let createColors = (enabled = isColorSupported) => {
+	let init = enabled ? formatter : () => String
+	return {
+		isColorSupported: enabled,
+		reset: init("\x1b[0m", "\x1b[0m"),
+		bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: init("\x1b[3m", "\x1b[23m"),
+		underline: init("\x1b[4m", "\x1b[24m"),
+		inverse: init("\x1b[7m", "\x1b[27m"),
+		hidden: init("\x1b[8m", "\x1b[28m"),
+		strikethrough: init("\x1b[9m", "\x1b[29m"),
+
+		black: init("\x1b[30m", "\x1b[39m"),
+		red: init("\x1b[31m", "\x1b[39m"),
+		green: init("\x1b[32m", "\x1b[39m"),
+		yellow: init("\x1b[33m", "\x1b[39m"),
+		blue: init("\x1b[34m", "\x1b[39m"),
+		magenta: init("\x1b[35m", "\x1b[39m"),
+		cyan: init("\x1b[36m", "\x1b[39m"),
+		white: init("\x1b[37m", "\x1b[39m"),
+		gray: init("\x1b[90m", "\x1b[39m"),
+
+		bgBlack: init("\x1b[40m", "\x1b[49m"),
+		bgRed: init("\x1b[41m", "\x1b[49m"),
+		bgGreen: init("\x1b[42m", "\x1b[49m"),
+		bgYellow: init("\x1b[43m", "\x1b[49m"),
+		bgBlue: init("\x1b[44m", "\x1b[49m"),
+		bgMagenta: init("\x1b[45m", "\x1b[49m"),
+		bgCyan: init("\x1b[46m", "\x1b[49m"),
+		bgWhite: init("\x1b[47m", "\x1b[49m"),
+
+		blackBright: init("\x1b[90m", "\x1b[39m"),
+		redBright: init("\x1b[91m", "\x1b[39m"),
+		greenBright: init("\x1b[92m", "\x1b[39m"),
+		yellowBright: init("\x1b[93m", "\x1b[39m"),
+		blueBright: init("\x1b[94m", "\x1b[39m"),
+		magentaBright: init("\x1b[95m", "\x1b[39m"),
+		cyanBright: init("\x1b[96m", "\x1b[39m"),
+		whiteBright: init("\x1b[97m", "\x1b[39m"),
+
+		bgBlackBright: init("\x1b[100m","\x1b[49m"),
+		bgRedBright: init("\x1b[101m","\x1b[49m"),
+		bgGreenBright: init("\x1b[102m","\x1b[49m"),
+		bgYellowBright: init("\x1b[103m","\x1b[49m"),
+		bgBlueBright: init("\x1b[104m","\x1b[49m"),
+		bgMagentaBright: init("\x1b[105m","\x1b[49m"),
+		bgCyanBright: init("\x1b[106m","\x1b[49m"),
+		bgWhiteBright: init("\x1b[107m","\x1b[49m"),
+	}
+}
+
+module.exports = createColors()
+module.exports.createColors = createColors
diff --git a/node_modules/picocolors/types.ts b/node_modules/picocolors/types.ts
new file mode 100644
index 0000000..8046e27
--- /dev/null
+++ b/node_modules/picocolors/types.ts
@@ -0,0 +1,52 @@
+export type Formatter = (input: string | number | null | undefined) => string
+
+export interface Colors {
+	isColorSupported: boolean
+	
+	reset: Formatter
+	bold: Formatter
+	dim: Formatter
+	italic: Formatter
+	underline: Formatter
+	inverse: Formatter
+	hidden: Formatter
+	strikethrough: Formatter
+	
+	black: Formatter
+	red: Formatter
+	green: Formatter
+	yellow: Formatter
+	blue: Formatter
+	magenta: Formatter
+	cyan: Formatter
+	white: Formatter
+	gray: Formatter
+	
+	bgBlack: Formatter
+	bgRed: Formatter
+	bgGreen: Formatter
+	bgYellow: Formatter
+	bgBlue: Formatter
+	bgMagenta: Formatter
+	bgCyan: Formatter
+	bgWhite: Formatter
+
+	blackBright: Formatter
+  redBright: Formatter
+  greenBright: Formatter
+  yellowBright: Formatter
+  blueBright: Formatter
+  magentaBright: Formatter
+  cyanBright: Formatter
+  whiteBright: Formatter
+
+	bgBlackBright: Formatter
+  bgRedBright: Formatter
+  bgGreenBright: Formatter
+  bgYellowBright: Formatter
+  bgBlueBright: Formatter
+  bgMagentaBright: Formatter
+  bgCyanBright: Formatter
+  bgWhiteBright: Formatter
+
+}
diff --git a/node_modules/postcss/LICENSE b/node_modules/postcss/LICENSE
new file mode 100644
index 0000000..da057b4
--- /dev/null
+++ b/node_modules/postcss/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2013 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/postcss/README.md b/node_modules/postcss/README.md
new file mode 100644
index 0000000..939a802
--- /dev/null
+++ b/node_modules/postcss/README.md
@@ -0,0 +1,28 @@
+# PostCSS
+
+<img align="right" width="95" height="95"
+     alt="Philosopher’s stone, logo of PostCSS"
+     src="https://postcss.org/logo.svg">
+
+PostCSS is a tool for transforming styles with JS plugins.
+These plugins can lint your CSS, support variables and mixins,
+transpile future CSS syntax, inline images, and more.
+
+PostCSS is used by industry leaders including Wikipedia, Twitter, Alibaba,
+and JetBrains. The [Autoprefixer] and [Stylelint] PostCSS plugins is one of the most popular CSS tools.
+
+---
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="" width="22" height="16" />  Made at <b><a href="https://evilmartians.com/devtools?utm_source=postcss&utm_campaign=devtools-button&utm_medium=github">Evil Martians</a></b>, product consulting for <b>developer tools</b>.
+
+---
+
+[Abstract Syntax Tree]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[Evil Martians]:        https://evilmartians.com/?utm_source=postcss
+[Autoprefixer]:         https://github.com/postcss/autoprefixer
+[Stylelint]:            https://stylelint.io/
+[plugins]:              https://github.com/postcss/postcss#plugins
+
+
+## Docs
+Read full docs **[here](https://postcss.org/)**.
diff --git a/node_modules/postcss/lib/at-rule.d.ts b/node_modules/postcss/lib/at-rule.d.ts
new file mode 100644
index 0000000..b2a0e0f
--- /dev/null
+++ b/node_modules/postcss/lib/at-rule.d.ts
@@ -0,0 +1,140 @@
+import Container, {
+  ContainerProps,
+  ContainerWithChildren
+} from './container.js'
+
+declare namespace AtRule {
+  export interface AtRuleRaws extends Record<string, unknown> {
+    /**
+     * The space symbols after the last child of the node to the end of the node.
+     */
+    after?: string
+
+    /**
+     * The space between the at-rule name and its parameters.
+     */
+    afterName?: string
+
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the last parameter and `{` for rules.
+     */
+    between?: string
+
+    /**
+     * The rule’s selector with comments.
+     */
+    params?: {
+      raw: string
+      value: string
+    }
+
+    /**
+     * Contains `true` if the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export interface AtRuleProps extends ContainerProps {
+    /** Name of the at-rule. */
+    name: string
+    /** Parameters following the name of the at-rule. */
+    params?: number | string
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: AtRuleRaws
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { AtRule_ as default }
+}
+
+/**
+ * Represents an at-rule.
+ *
+ * ```js
+ * Once (root, { AtRule }) {
+ *   let media = new AtRule({ name: 'media', params: 'print' })
+ *   media.append(…)
+ *   root.append(media)
+ * }
+ * ```
+ *
+ * If it’s followed in the CSS by a `{}` block, this node will have
+ * a nodes property representing its children.
+ *
+ * ```js
+ * const root = postcss.parse('@charset "UTF-8"; @media print {}')
+ *
+ * const charset = root.first
+ * charset.type  //=> 'atrule'
+ * charset.nodes //=> undefined
+ *
+ * const media = root.last
+ * media.nodes   //=> []
+ * ```
+ */
+declare class AtRule_ extends Container {
+  /**
+   * An array containing the layer’s children.
+   *
+   * ```js
+   * const root = postcss.parse('@layer example { a { color: black } }')
+   * const layer = root.first
+   * layer.nodes.length           //=> 1
+   * layer.nodes[0].selector      //=> 'a'
+   * ```
+   *
+   * Can be `undefinded` if the at-rule has no body.
+   *
+   * ```js
+   * const root = postcss.parse('@layer a, b, c;')
+   * const layer = root.first
+   * layer.nodes //=> undefined
+   * ```
+   */
+  nodes: Container['nodes']
+  parent: ContainerWithChildren | undefined
+
+  raws: AtRule.AtRuleRaws
+  type: 'atrule'
+  constructor(defaults?: AtRule.AtRuleProps)
+  assign(overrides: AtRule.AtRuleProps | object): this
+
+  clone(overrides?: Partial<AtRule.AtRuleProps>): this
+
+  cloneAfter(overrides?: Partial<AtRule.AtRuleProps>): this
+
+  cloneBefore(overrides?: Partial<AtRule.AtRuleProps>): this
+  /**
+   * The at-rule’s name immediately follows the `@`.
+   *
+   * ```js
+   * const root  = postcss.parse('@media print {}')
+   * const media = root.first
+   * media.name //=> 'media'
+   * ```
+   */
+  get name(): string
+  set name(value: string)
+  /**
+   * The at-rule’s parameters, the values that follow the at-rule’s name
+   * but precede any `{}` block.
+   *
+   * ```js
+   * const root  = postcss.parse('@media print, screen {}')
+   * const media = root.first
+   * media.params //=> 'print, screen'
+   * ```
+   */
+  get params(): string
+  set params(value: string)
+}
+
+declare class AtRule extends AtRule_ {}
+
+export = AtRule
diff --git a/node_modules/postcss/lib/at-rule.js b/node_modules/postcss/lib/at-rule.js
new file mode 100644
index 0000000..9486447
--- /dev/null
+++ b/node_modules/postcss/lib/at-rule.js
@@ -0,0 +1,25 @@
+'use strict'
+
+let Container = require('./container')
+
+class AtRule extends Container {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'atrule'
+  }
+
+  append(...children) {
+    if (!this.proxyOf.nodes) this.nodes = []
+    return super.append(...children)
+  }
+
+  prepend(...children) {
+    if (!this.proxyOf.nodes) this.nodes = []
+    return super.prepend(...children)
+  }
+}
+
+module.exports = AtRule
+AtRule.default = AtRule
+
+Container.registerAtRule(AtRule)
diff --git a/node_modules/postcss/lib/comment.d.ts b/node_modules/postcss/lib/comment.d.ts
new file mode 100644
index 0000000..2b1a156
--- /dev/null
+++ b/node_modules/postcss/lib/comment.d.ts
@@ -0,0 +1,68 @@
+import Container from './container.js'
+import Node, { NodeProps } from './node.js'
+
+declare namespace Comment {
+  export interface CommentRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node.
+     */
+    before?: string
+
+    /**
+     * The space symbols between `/*` and the comment’s text.
+     */
+    left?: string
+
+    /**
+     * The space symbols between the comment’s text.
+     */
+    right?: string
+  }
+
+  export interface CommentProps extends NodeProps {
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: CommentRaws
+    /** Content of the comment. */
+    text: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Comment_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS comments](https://developer.mozilla.org/en-US/docs/Web/CSS/Comments)
+ *
+ * ```js
+ * Once (root, { Comment }) {
+ *   const note = new Comment({ text: 'Note: …' })
+ *   root.append(note)
+ * }
+ * ```
+ *
+ * Remember that CSS comments inside selectors, at-rule parameters,
+ * or declaration values will be stored in the `raws` properties
+ * explained above.
+ */
+declare class Comment_ extends Node {
+  parent: Container | undefined
+  raws: Comment.CommentRaws
+  type: 'comment'
+  constructor(defaults?: Comment.CommentProps)
+
+  assign(overrides: Comment.CommentProps | object): this
+
+  clone(overrides?: Partial<Comment.CommentProps>): this
+  cloneAfter(overrides?: Partial<Comment.CommentProps>): this
+  cloneBefore(overrides?: Partial<Comment.CommentProps>): this
+  /**
+   * The comment's text.
+   */
+  get text(): string
+  set text(value: string)
+}
+
+declare class Comment extends Comment_ {}
+
+export = Comment
diff --git a/node_modules/postcss/lib/comment.js b/node_modules/postcss/lib/comment.js
new file mode 100644
index 0000000..c566506
--- /dev/null
+++ b/node_modules/postcss/lib/comment.js
@@ -0,0 +1,13 @@
+'use strict'
+
+let Node = require('./node')
+
+class Comment extends Node {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'comment'
+  }
+}
+
+module.exports = Comment
+Comment.default = Comment
diff --git a/node_modules/postcss/lib/container.d.ts b/node_modules/postcss/lib/container.d.ts
new file mode 100644
index 0000000..692bd69
--- /dev/null
+++ b/node_modules/postcss/lib/container.d.ts
@@ -0,0 +1,483 @@
+import AtRule from './at-rule.js'
+import Comment from './comment.js'
+import Declaration from './declaration.js'
+import Node, { ChildNode, ChildProps, NodeProps } from './node.js'
+import Rule from './rule.js'
+
+declare namespace Container {
+  export class ContainerWithChildren<
+    Child extends Node = ChildNode
+  > extends Container_<Child> {
+    nodes: Child[]
+  }
+
+  export interface ValueOptions {
+    /**
+     * String that’s used to narrow down values and speed up the regexp search.
+     */
+    fast?: string
+
+    /**
+     * An array of property names.
+     */
+    props?: readonly string[]
+  }
+
+  export interface ContainerProps extends NodeProps {
+    nodes?: readonly (ChildProps | Node)[]
+  }
+
+  /**
+   * All types that can be passed into container methods to create or add a new
+   * child node.
+   */
+  export type NewChild =
+    | ChildProps
+    | Node
+    | readonly ChildProps[]
+    | readonly Node[]
+    | readonly string[]
+    | string
+    | undefined
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Container_ as default }
+}
+
+/**
+ * The `Root`, `AtRule`, and `Rule` container nodes
+ * inherit some common methods to help work with their children.
+ *
+ * Note that all containers can store any content. If you write a rule inside
+ * a rule, PostCSS will parse it.
+ */
+declare abstract class Container_<Child extends Node = ChildNode> extends Node {
+  /**
+   * An array containing the container’s children.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * root.nodes.length           //=> 1
+   * root.nodes[0].selector      //=> 'a'
+   * root.nodes[0].nodes[0].prop //=> 'color'
+   * ```
+   */
+  nodes: Child[] | undefined
+
+  /**
+   * An internal method that converts a {@link NewChild} into a list of actual
+   * child nodes that can then be added to this container.
+   *
+   * This ensures that the nodes' parent is set to this container, that they use
+   * the correct prototype chain, and that they're marked as dirty.
+   *
+   * @param mnodes The new node or nodes to add.
+   * @param sample A node from whose raws the new node's `before` raw should be
+   *               taken.
+   * @param type   This should be set to `'prepend'` if the new nodes will be
+   *               inserted at the beginning of the container.
+   * @hidden
+   */
+  protected normalize(
+    nodes: Container.NewChild,
+    sample: Node | undefined,
+    type?: 'prepend' | false
+  ): Child[]
+
+  /**
+   * Inserts new nodes to the end of the container.
+   *
+   * ```js
+   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
+   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
+   * rule.append(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   * ```
+   *
+   * @param nodes New nodes.
+   * @return This node for methods chain.
+   */
+  append(...nodes: Container.NewChild[]): this
+  assign(overrides: Container.ContainerProps | object): this
+  clone(overrides?: Partial<Container.ContainerProps>): this
+  cloneAfter(overrides?: Partial<Container.ContainerProps>): this
+
+  cloneBefore(overrides?: Partial<Container.ContainerProps>): this
+
+  /**
+   * Iterates through the container’s immediate children,
+   * calling `callback` for each child.
+   *
+   * Returning `false` in the callback will break iteration.
+   *
+   * This method only iterates through the container’s immediate children.
+   * If you need to recursively iterate through all the container’s descendant
+   * nodes, use `Container#walk`.
+   *
+   * Unlike the for `{}`-cycle or `Array#forEach` this iterator is safe
+   * if you are mutating the array of child nodes during iteration.
+   * PostCSS will adjust the current index to match the mutations.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black; z-index: 1 }')
+   * const rule = root.first
+   *
+   * for (const decl of rule.nodes) {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Cycle will be infinite, because cloneBefore moves the current node
+   *   // to the next index
+   * }
+   *
+   * rule.each(decl => {
+   *   decl.cloneBefore({ prop: '-webkit-' + decl.prop })
+   *   // Will be executed only for color and z-index
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  each(
+    callback: (node: Child, index: number) => false | void
+  ): false | undefined
+  /**
+   * Returns `true` if callback returns `true`
+   * for all of the container’s children.
+   *
+   * ```js
+   * const noPrefixes = rule.every(i => i.prop[0] !== '-')
+   * ```
+   *
+   * @param condition Iterator returns true or false.
+   * @return Is every child pass condition.
+   */
+  every(
+    condition: (node: Child, index: number, nodes: Child[]) => boolean
+  ): boolean
+
+  /**
+   * Returns a `child`’s index within the `Container#nodes` array.
+   *
+   * ```js
+   * rule.index( rule.nodes[2] ) //=> 2
+   * ```
+   *
+   * @param child Child of the current container.
+   * @return Child index.
+   */
+  index(child: Child | number): number
+  /**
+   * Insert new node after old node within the container.
+   *
+   * @param oldNode Child or child’s index.
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  insertAfter(oldNode: Child | number, newNode: Container.NewChild): this
+
+  /**
+   * Insert new node before old node within the container.
+   *
+   * ```js
+   * rule.insertBefore(decl, decl.clone({ prop: '-webkit-' + decl.prop }))
+   * ```
+   *
+   * @param oldNode Child or child’s index.
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  insertBefore(oldNode: Child | number, newNode: Container.NewChild): this
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each comment node.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * root.walkComments(comment => {
+   *   comment.remove()
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+
+  /**
+   * Inserts new nodes to the start of the container.
+   *
+   * ```js
+   * const decl1 = new Declaration({ prop: 'color', value: 'black' })
+   * const decl2 = new Declaration({ prop: 'background-color', value: 'white' })
+   * rule.prepend(decl1, decl2)
+   *
+   * root.append({ name: 'charset', params: '"UTF-8"' })  // at-rule
+   * root.append({ selector: 'a' })                       // rule
+   * rule.append({ prop: 'color', value: 'black' })       // declaration
+   * rule.append({ text: 'Comment' })                     // comment
+   *
+   * root.append('a {}')
+   * root.first.append('color: black; z-index: 1')
+   * ```
+   *
+   * @param nodes New nodes.
+   * @return This node for methods chain.
+   */
+  prepend(...nodes: Container.NewChild[]): this
+  /**
+   * Add child to the end of the node.
+   *
+   * ```js
+   * rule.push(new Declaration({ prop: 'color', value: 'black' }))
+   * ```
+   *
+   * @param child New node.
+   * @return This node for methods chain.
+   */
+  push(child: Child): this
+
+  /**
+   * Removes all children from the container
+   * and cleans their parent properties.
+   *
+   * ```js
+   * rule.removeAll()
+   * rule.nodes.length //=> 0
+   * ```
+   *
+   * @return This node for methods chain.
+   */
+  removeAll(): this
+
+  /**
+   * Removes node from the container and cleans the parent properties
+   * from the node and its children.
+   *
+   * ```js
+   * rule.nodes.length  //=> 5
+   * rule.removeChild(decl)
+   * rule.nodes.length  //=> 4
+   * decl.parent        //=> undefined
+   * ```
+   *
+   * @param child Child or child’s index.
+   * @return This node for methods chain.
+   */
+  removeChild(child: Child | number): this
+
+  replaceValues(
+    pattern: RegExp | string,
+    replaced: { (substring: string, ...args: any[]): string } | string
+  ): this
+
+  /**
+   * Passes all declaration values within the container that match pattern
+   * through callback, replacing those values with the returned result
+   * of callback.
+   *
+   * This method is useful if you are using a custom unit or function
+   * and need to iterate through all values.
+   *
+   * ```js
+   * root.replaceValues(/\d+rem/, { fast: 'rem' }, string => {
+   *   return 15 * parseInt(string) + 'px'
+   * })
+   * ```
+   *
+   * @param pattern      Replace pattern.
+   * @param {object} options             Options to speed up the search.
+   * @param replaced   String to replace pattern or callback
+   *                                     that returns a new value. The callback
+   *                                     will receive the same arguments
+   *                                     as those passed to a function parameter
+   *                                     of `String#replace`.
+   * @return This node for methods chain.
+   */
+  replaceValues(
+    pattern: RegExp | string,
+    options: Container.ValueOptions,
+    replaced: { (substring: string, ...args: any[]): string } | string
+  ): this
+
+  /**
+   * Returns `true` if callback returns `true` for (at least) one
+   * of the container’s children.
+   *
+   * ```js
+   * const hasPrefix = rule.some(i => i.prop[0] === '-')
+   * ```
+   *
+   * @param condition Iterator returns true or false.
+   * @return Is some child pass condition.
+   */
+  some(
+    condition: (node: Child, index: number, nodes: Child[]) => boolean
+  ): boolean
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each node.
+   *
+   * Like container.each(), this method is safe to use
+   * if you are mutating arrays during iteration.
+   *
+   * If you only need to iterate through the container’s immediate children,
+   * use `Container#each`.
+   *
+   * ```js
+   * root.walk(node => {
+   *   // Traverses all descendant nodes.
+   * })
+   * ```
+   *
+   * @param callback Iterator receives each node and index.
+   * @return  Returns `false` if iteration was broke.
+   */
+  walk(
+    callback: (node: ChildNode, index: number) => false | void
+  ): false | undefined
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each at-rule node.
+   *
+   * If you pass a filter, iteration will only happen over at-rules
+   * that have matching names.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * root.walkAtRules(rule => {
+   *   if (isOld(rule.name)) rule.remove()
+   * })
+   *
+   * let first = false
+   * root.walkAtRules('charset', rule => {
+   *   if (!first) {
+   *     first = true
+   *   } else {
+   *     rule.remove()
+   *   }
+   * })
+   * ```
+   *
+   * @param name     String or regular expression to filter at-rules by name.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkAtRules(
+    nameFilter: RegExp | string,
+    callback: (atRule: AtRule, index: number) => false | void
+  ): false | undefined
+
+  walkAtRules(
+    callback: (atRule: AtRule, index: number) => false | void
+  ): false | undefined
+  walkComments(
+    callback: (comment: Comment, indexed: number) => false | void
+  ): false | undefined
+
+  walkComments(
+    callback: (comment: Comment, indexed: number) => false | void
+  ): false | undefined
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each declaration node.
+   *
+   * If you pass a filter, iteration will only happen over declarations
+   * with matching properties.
+   *
+   * ```js
+   * root.walkDecls(decl => {
+   *   checkPropertySupport(decl.prop)
+   * })
+   *
+   * root.walkDecls('border-radius', decl => {
+   *   decl.remove()
+   * })
+   *
+   * root.walkDecls(/^background/, decl => {
+   *   decl.value = takeFirstColorFromGradient(decl.value)
+   * })
+   * ```
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * @param prop     String or regular expression to filter declarations
+   *                 by property name.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkDecls(
+    propFilter: RegExp | string,
+    callback: (decl: Declaration, index: number) => false | void
+  ): false | undefined
+
+  walkDecls(
+    callback: (decl: Declaration, index: number) => false | void
+  ): false | undefined
+
+  /**
+   * Traverses the container’s descendant nodes, calling callback
+   * for each rule node.
+   *
+   * If you pass a filter, iteration will only happen over rules
+   * with matching selectors.
+   *
+   * Like `Container#each`, this method is safe
+   * to use if you are mutating arrays during iteration.
+   *
+   * ```js
+   * const selectors = []
+   * root.walkRules(rule => {
+   *   selectors.push(rule.selector)
+   * })
+   * console.log(`Your CSS uses ${ selectors.length } selectors`)
+   * ```
+   *
+   * @param selector String or regular expression to filter rules by selector.
+   * @param callback Iterator receives each node and index.
+   * @return Returns `false` if iteration was broke.
+   */
+  walkRules(
+    selectorFilter: RegExp | string,
+    callback: (rule: Rule, index: number) => false | void
+  ): false | undefined
+  walkRules(
+    callback: (rule: Rule, index: number) => false | void
+  ): false | undefined
+  /**
+   * The container’s first child.
+   *
+   * ```js
+   * rule.first === rules.nodes[0]
+   * ```
+   */
+  get first(): Child | undefined
+  /**
+   * The container’s last child.
+   *
+   * ```js
+   * rule.last === rule.nodes[rule.nodes.length - 1]
+   * ```
+   */
+  get last(): Child | undefined
+}
+
+declare class Container<
+  Child extends Node = ChildNode
+> extends Container_<Child> {}
+
+export = Container
diff --git a/node_modules/postcss/lib/container.js b/node_modules/postcss/lib/container.js
new file mode 100644
index 0000000..8b9e1ef
--- /dev/null
+++ b/node_modules/postcss/lib/container.js
@@ -0,0 +1,447 @@
+'use strict'
+
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Node = require('./node')
+let { isClean, my } = require('./symbols')
+
+let AtRule, parse, Root, Rule
+
+function cleanSource(nodes) {
+  return nodes.map(i => {
+    if (i.nodes) i.nodes = cleanSource(i.nodes)
+    delete i.source
+    return i
+  })
+}
+
+function markTreeDirty(node) {
+  node[isClean] = false
+  if (node.proxyOf.nodes) {
+    for (let i of node.proxyOf.nodes) {
+      markTreeDirty(i)
+    }
+  }
+}
+
+class Container extends Node {
+  append(...children) {
+    for (let child of children) {
+      let nodes = this.normalize(child, this.last)
+      for (let node of nodes) this.proxyOf.nodes.push(node)
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween)
+    if (this.nodes) {
+      for (let node of this.nodes) node.cleanRaws(keepBetween)
+    }
+  }
+
+  each(callback) {
+    if (!this.proxyOf.nodes) return undefined
+    let iterator = this.getIterator()
+
+    let index, result
+    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+      index = this.indexes[iterator]
+      result = callback(this.proxyOf.nodes[index], index)
+      if (result === false) break
+
+      this.indexes[iterator] += 1
+    }
+
+    delete this.indexes[iterator]
+    return result
+  }
+
+  every(condition) {
+    return this.nodes.every(condition)
+  }
+
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0
+    if (!this.indexes) this.indexes = {}
+
+    this.lastEach += 1
+    let iterator = this.lastEach
+    this.indexes[iterator] = 0
+
+    return iterator
+  }
+
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (!node[prop]) {
+          return node[prop]
+        } else if (
+          prop === 'each' ||
+          (typeof prop === 'string' && prop.startsWith('walk'))
+        ) {
+          return (...args) => {
+            return node[prop](
+              ...args.map(i => {
+                if (typeof i === 'function') {
+                  return (child, index) => i(child.toProxy(), index)
+                } else {
+                  return i
+                }
+              })
+            )
+          }
+        } else if (prop === 'every' || prop === 'some') {
+          return cb => {
+            return node[prop]((child, ...other) =>
+              cb(child.toProxy(), ...other)
+            )
+          }
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
+        } else if (prop === 'nodes') {
+          return node.nodes.map(i => i.toProxy())
+        } else if (prop === 'first' || prop === 'last') {
+          return node[prop].toProxy()
+        } else {
+          return node[prop]
+        }
+      },
+
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value
+        if (prop === 'name' || prop === 'params' || prop === 'selector') {
+          node.markDirty()
+        }
+        return true
+      }
+    }
+  }
+
+  index(child) {
+    if (typeof child === 'number') return child
+    if (child.proxyOf) child = child.proxyOf
+    return this.proxyOf.nodes.indexOf(child)
+  }
+
+  insertAfter(exist, add) {
+    let existIndex = this.index(exist)
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse()
+    existIndex = this.index(exist)
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (existIndex < index) {
+        this.indexes[id] = index + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  insertBefore(exist, add) {
+    let existIndex = this.index(exist)
+    let type = existIndex === 0 ? 'prepend' : false
+    let nodes = this.normalize(
+      add,
+      this.proxyOf.nodes[existIndex],
+      type
+    ).reverse()
+    existIndex = this.index(exist)
+    for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (existIndex <= index) {
+        this.indexes[id] = index + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  normalize(nodes, sample) {
+    if (typeof nodes === 'string') {
+      nodes = cleanSource(parse(nodes).nodes)
+    } else if (typeof nodes === 'undefined') {
+      nodes = []
+    } else if (Array.isArray(nodes)) {
+      nodes = nodes.slice(0)
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore')
+      }
+    } else if (nodes.type === 'root' && this.type !== 'document') {
+      nodes = nodes.nodes.slice(0)
+      for (let i of nodes) {
+        if (i.parent) i.parent.removeChild(i, 'ignore')
+      }
+    } else if (nodes.type) {
+      nodes = [nodes]
+    } else if (nodes.prop) {
+      if (typeof nodes.value === 'undefined') {
+        throw new Error('Value field is missed in node creation')
+      } else if (typeof nodes.value !== 'string') {
+        nodes.value = String(nodes.value)
+      }
+      nodes = [new Declaration(nodes)]
+    } else if (nodes.selector || nodes.selectors) {
+      nodes = [new Rule(nodes)]
+    } else if (nodes.name) {
+      nodes = [new AtRule(nodes)]
+    } else if (nodes.text) {
+      nodes = [new Comment(nodes)]
+    } else {
+      throw new Error('Unknown node type in node creation')
+    }
+
+    let processed = nodes.map(i => {
+      /* c8 ignore next */
+      if (!i[my]) Container.rebuild(i)
+      i = i.proxyOf
+      if (i.parent) i.parent.removeChild(i)
+      if (i[isClean]) markTreeDirty(i)
+
+      if (!i.raws) i.raws = {}
+      if (typeof i.raws.before === 'undefined') {
+        if (sample && typeof sample.raws.before !== 'undefined') {
+          i.raws.before = sample.raws.before.replace(/\S/g, '')
+        }
+      }
+      i.parent = this.proxyOf
+      return i
+    })
+
+    return processed
+  }
+
+  prepend(...children) {
+    children = children.reverse()
+    for (let child of children) {
+      let nodes = this.normalize(child, this.first, 'prepend').reverse()
+      for (let node of nodes) this.proxyOf.nodes.unshift(node)
+      for (let id in this.indexes) {
+        this.indexes[id] = this.indexes[id] + nodes.length
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  push(child) {
+    child.parent = this
+    this.proxyOf.nodes.push(child)
+    return this
+  }
+
+  removeAll() {
+    for (let node of this.proxyOf.nodes) node.parent = undefined
+    this.proxyOf.nodes = []
+
+    this.markDirty()
+
+    return this
+  }
+
+  removeChild(child) {
+    child = this.index(child)
+    this.proxyOf.nodes[child].parent = undefined
+    this.proxyOf.nodes.splice(child, 1)
+
+    let index
+    for (let id in this.indexes) {
+      index = this.indexes[id]
+      if (index >= child) {
+        this.indexes[id] = index - 1
+      }
+    }
+
+    this.markDirty()
+
+    return this
+  }
+
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts
+      opts = {}
+    }
+
+    this.walkDecls(decl => {
+      if (opts.props && !opts.props.includes(decl.prop)) return
+      if (opts.fast && !decl.value.includes(opts.fast)) return
+
+      decl.value = decl.value.replace(pattern, callback)
+    })
+
+    this.markDirty()
+
+    return this
+  }
+
+  some(condition) {
+    return this.nodes.some(condition)
+  }
+
+  walk(callback) {
+    return this.each((child, i) => {
+      let result
+      try {
+        result = callback(child, i)
+      } catch (e) {
+        throw child.addToError(e)
+      }
+      if (result !== false && child.walk) {
+        result = child.walk(callback)
+      }
+
+      return result
+    })
+  }
+
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name
+      return this.walk((child, i) => {
+        if (child.type === 'atrule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'atrule' && name.test(child.name)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'atrule' && child.name === name) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === 'comment') {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop
+      return this.walk((child, i) => {
+        if (child.type === 'decl') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'decl' && prop.test(child.prop)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'decl' && child.prop === prop) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector
+
+      return this.walk((child, i) => {
+        if (child.type === 'rule') {
+          return callback(child, i)
+        }
+      })
+    }
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === 'rule' && selector.test(child.selector)) {
+          return callback(child, i)
+        }
+      })
+    }
+    return this.walk((child, i) => {
+      if (child.type === 'rule' && child.selector === selector) {
+        return callback(child, i)
+      }
+    })
+  }
+
+  get first() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[0]
+  }
+
+  get last() {
+    if (!this.proxyOf.nodes) return undefined
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
+  }
+}
+
+Container.registerParse = dependant => {
+  parse = dependant
+}
+
+Container.registerRule = dependant => {
+  Rule = dependant
+}
+
+Container.registerAtRule = dependant => {
+  AtRule = dependant
+}
+
+Container.registerRoot = dependant => {
+  Root = dependant
+}
+
+module.exports = Container
+Container.default = Container
+
+/* c8 ignore start */
+Container.rebuild = node => {
+  if (node.type === 'atrule') {
+    Object.setPrototypeOf(node, AtRule.prototype)
+  } else if (node.type === 'rule') {
+    Object.setPrototypeOf(node, Rule.prototype)
+  } else if (node.type === 'decl') {
+    Object.setPrototypeOf(node, Declaration.prototype)
+  } else if (node.type === 'comment') {
+    Object.setPrototypeOf(node, Comment.prototype)
+  } else if (node.type === 'root') {
+    Object.setPrototypeOf(node, Root.prototype)
+  }
+
+  node[my] = true
+
+  if (node.nodes) {
+    node.nodes.forEach(child => {
+      Container.rebuild(child)
+    })
+  }
+}
+/* c8 ignore stop */
diff --git a/node_modules/postcss/lib/css-syntax-error.d.ts b/node_modules/postcss/lib/css-syntax-error.d.ts
new file mode 100644
index 0000000..e540d84
--- /dev/null
+++ b/node_modules/postcss/lib/css-syntax-error.d.ts
@@ -0,0 +1,248 @@
+import { FilePosition } from './input.js'
+
+declare namespace CssSyntaxError {
+  /**
+   * A position that is part of a range.
+   */
+  export interface RangePosition {
+    /**
+     * The column number in the input.
+     */
+    column: number
+
+    /**
+     * The line number in the input.
+     */
+    line: number
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { CssSyntaxError_ as default }
+}
+
+/**
+ * The CSS parser throws this error for broken CSS.
+ *
+ * Custom parsers can throw this error for broken custom syntax using
+ * the `Node#error` method.
+ *
+ * PostCSS will use the input source map to detect the original error location.
+ * If you wrote a Sass file, compiled it to CSS and then parsed it with PostCSS,
+ * PostCSS will show the original position in the Sass file.
+ *
+ * If you need the position in the PostCSS input
+ * (e.g., to debug the previous compiler), use `error.input.file`.
+ *
+ * ```js
+ * // Raising error from plugin
+ * throw node.error('Unknown variable', { plugin: 'postcss-vars' })
+ * ```
+ *
+ * ```js
+ * // Catching and checking syntax error
+ * try {
+ *   postcss.parse('a{')
+ * } catch (error) {
+ *   if (error.name === 'CssSyntaxError') {
+ *     error //=> CssSyntaxError
+ *   }
+ * }
+ * ```
+ */
+declare class CssSyntaxError_ extends Error {
+  /**
+   * Source column of the error.
+   *
+   * ```js
+   * error.column       //=> 1
+   * error.input.column //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.column`.
+   */
+  column?: number
+
+  /**
+   * Source column of the error's end, exclusive. Provided if the error pertains
+   * to a range.
+   *
+   * ```js
+   * error.endColumn       //=> 1
+   * error.input.endColumn //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.endColumn`.
+   */
+  endColumn?: number
+
+  /**
+   * Source line of the error's end, exclusive. Provided if the error pertains
+   * to a range.
+   *
+   * ```js
+   * error.endLine       //=> 3
+   * error.input.endLine //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.endLine`.
+   */
+  endLine?: number
+
+  /**
+   * Absolute path to the broken file.
+   *
+   * ```js
+   * error.file       //=> 'a.sass'
+   * error.input.file //=> 'a.css'
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.file`.
+   */
+  file?: string
+
+  /**
+   * Input object with PostCSS internal information
+   * about input file. If input has source map
+   * from previous tool, PostCSS will use origin
+   * (for example, Sass) source. You can use this
+   * object to get PostCSS input source.
+   *
+   * ```js
+   * error.input.file //=> 'a.css'
+   * error.file       //=> 'a.sass'
+   * ```
+   */
+  input?: FilePosition
+
+  /**
+   * Source line of the error.
+   *
+   * ```js
+   * error.line       //=> 2
+   * error.input.line //=> 4
+   * ```
+   *
+   * PostCSS will use the input source map to detect the original location.
+   * If you need the position in the PostCSS input, use `error.input.line`.
+   */
+  line?: number
+
+  /**
+   * Full error text in the GNU error format
+   * with plugin, file, line and column.
+   *
+   * ```js
+   * error.message //=> 'a.css:1:1: Unclosed block'
+   * ```
+   */
+  message: string
+
+  /**
+   * Always equal to `'CssSyntaxError'`. You should always check error type
+   * by `error.name === 'CssSyntaxError'`
+   * instead of `error instanceof CssSyntaxError`,
+   * because npm could have several PostCSS versions.
+   *
+   * ```js
+   * if (error.name === 'CssSyntaxError') {
+   *   error //=> CssSyntaxError
+   * }
+   * ```
+   */
+  name: 'CssSyntaxError'
+
+  /**
+   * Plugin name, if error came from plugin.
+   *
+   * ```js
+   * error.plugin //=> 'postcss-vars'
+   * ```
+   */
+  plugin?: string
+
+  /**
+   * Error message.
+   *
+   * ```js
+   * error.message //=> 'Unclosed block'
+   * ```
+   */
+  reason: string
+
+  /**
+   * Source code of the broken file.
+   *
+   * ```js
+   * error.source       //=> 'a { b {} }'
+   * error.input.source //=> 'a b { }'
+   * ```
+   */
+  source?: string
+
+  stack: string
+
+  /**
+   * Instantiates a CSS syntax error. Can be instantiated for a single position
+   * or for a range.
+   * @param message        Error message.
+   * @param lineOrStartPos If for a single position, the line number, or if for
+   *                       a range, the inclusive start position of the error.
+   * @param columnOrEndPos If for a single position, the column number, or if for
+   *                       a range, the exclusive end position of the error.
+   * @param source         Source code of the broken file.
+   * @param file           Absolute path to the broken file.
+   * @param plugin         PostCSS plugin name, if error came from plugin.
+   */
+  constructor(
+    message: string,
+    lineOrStartPos?: CssSyntaxError.RangePosition | number,
+    columnOrEndPos?: CssSyntaxError.RangePosition | number,
+    source?: string,
+    file?: string,
+    plugin?: string
+  )
+
+  /**
+   * Returns a few lines of CSS source that caused the error.
+   *
+   * If the CSS has an input source map without `sourceContent`,
+   * this method will return an empty string.
+   *
+   * ```js
+   * error.showSourceCode() //=> "  4 | }
+   *                        //      5 | a {
+   *                        //    > 6 |   bad
+   *                        //        |   ^
+   *                        //      7 | }
+   *                        //      8 | b {"
+   * ```
+   *
+   * @param color Whether arrow will be colored red by terminal
+   *              color codes. By default, PostCSS will detect
+   *              color support by `process.stdout.isTTY`
+   *              and `process.env.NODE_DISABLE_COLORS`.
+   * @return Few lines of CSS source that caused the error.
+   */
+  showSourceCode(color?: boolean): string
+
+  /**
+   * Returns error position, message and source code of the broken part.
+   *
+   * ```js
+   * error.toString() //=> "CssSyntaxError: app.css:1:1: Unclosed block
+   *                  //    > 1 | a {
+   *                  //        | ^"
+   * ```
+   *
+   * @return Error position, message and source code.
+   */
+  toString(): string
+}
+
+declare class CssSyntaxError extends CssSyntaxError_ {}
+
+export = CssSyntaxError
diff --git a/node_modules/postcss/lib/css-syntax-error.js b/node_modules/postcss/lib/css-syntax-error.js
new file mode 100644
index 0000000..275a4f6
--- /dev/null
+++ b/node_modules/postcss/lib/css-syntax-error.js
@@ -0,0 +1,133 @@
+'use strict'
+
+let pico = require('picocolors')
+
+let terminalHighlight = require('./terminal-highlight')
+
+class CssSyntaxError extends Error {
+  constructor(message, line, column, source, file, plugin) {
+    super(message)
+    this.name = 'CssSyntaxError'
+    this.reason = message
+
+    if (file) {
+      this.file = file
+    }
+    if (source) {
+      this.source = source
+    }
+    if (plugin) {
+      this.plugin = plugin
+    }
+    if (typeof line !== 'undefined' && typeof column !== 'undefined') {
+      if (typeof line === 'number') {
+        this.line = line
+        this.column = column
+      } else {
+        this.line = line.line
+        this.column = line.column
+        this.endLine = column.line
+        this.endColumn = column.column
+      }
+    }
+
+    this.setMessage()
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CssSyntaxError)
+    }
+  }
+
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ': ' : ''
+    this.message += this.file ? this.file : '<css input>'
+    if (typeof this.line !== 'undefined') {
+      this.message += ':' + this.line + ':' + this.column
+    }
+    this.message += ': ' + this.reason
+  }
+
+  showSourceCode(color) {
+    if (!this.source) return ''
+
+    let css = this.source
+    if (color == null) color = pico.isColorSupported
+
+    let aside = text => text
+    let mark = text => text
+    let highlight = text => text
+    if (color) {
+      let { bold, gray, red } = pico.createColors(true)
+      mark = text => bold(red(text))
+      aside = text => gray(text)
+      if (terminalHighlight) {
+        highlight = text => terminalHighlight(text)
+      }
+    }
+
+    let lines = css.split(/\r?\n/)
+    let start = Math.max(this.line - 3, 0)
+    let end = Math.min(this.line + 2, lines.length)
+    let maxWidth = String(end).length
+
+    return lines
+      .slice(start, end)
+      .map((line, index) => {
+        let number = start + 1 + index
+        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | '
+        if (number === this.line) {
+          if (line.length > 160) {
+            let padding = 20
+            let subLineStart = Math.max(0, this.column - padding)
+            let subLineEnd = Math.max(
+              this.column + padding,
+              this.endColumn + padding
+            )
+            let subLine = line.slice(subLineStart, subLineEnd)
+
+            let spacing =
+              aside(gutter.replace(/\d/g, ' ')) +
+              line
+                .slice(0, Math.min(this.column - 1, padding - 1))
+                .replace(/[^\t]/g, ' ')
+
+            return (
+              mark('>') +
+              aside(gutter) +
+              highlight(subLine) +
+              '\n ' +
+              spacing +
+              mark('^')
+            )
+          }
+
+          let spacing =
+            aside(gutter.replace(/\d/g, ' ')) +
+            line.slice(0, this.column - 1).replace(/[^\t]/g, ' ')
+
+          return (
+            mark('>') +
+            aside(gutter) +
+            highlight(line) +
+            '\n ' +
+            spacing +
+            mark('^')
+          )
+        }
+
+        return ' ' + aside(gutter) + highlight(line)
+      })
+      .join('\n')
+  }
+
+  toString() {
+    let code = this.showSourceCode()
+    if (code) {
+      code = '\n\n' + code + '\n'
+    }
+    return this.name + ': ' + this.message + code
+  }
+}
+
+module.exports = CssSyntaxError
+CssSyntaxError.default = CssSyntaxError
diff --git a/node_modules/postcss/lib/declaration.d.ts b/node_modules/postcss/lib/declaration.d.ts
new file mode 100644
index 0000000..e707ad6
--- /dev/null
+++ b/node_modules/postcss/lib/declaration.d.ts
@@ -0,0 +1,151 @@
+import { ContainerWithChildren } from './container.js'
+import Node from './node.js'
+
+declare namespace Declaration {
+  export interface DeclarationRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the property and value for declarations.
+     */
+    between?: string
+
+    /**
+     * The content of the important statement, if it is not just `!important`.
+     */
+    important?: string
+
+    /**
+     * Declaration value with comments.
+     */
+    value?: {
+      raw: string
+      value: string
+    }
+  }
+
+  export interface DeclarationProps {
+    /** Whether the declaration has an `!important` annotation. */
+    important?: boolean
+    /** Name of the declaration. */
+    prop: string
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: DeclarationRaws
+    /** Value of the declaration. */
+    value: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Declaration_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS declarations](https://developer.mozilla.org/en-US/docs/Web/CSS/Syntax#css_declarations)
+ *
+ * ```js
+ * Once (root, { Declaration }) {
+ *   const color = new Declaration({ prop: 'color', value: 'black' })
+ *   root.append(color)
+ * }
+ * ```
+ *
+ * ```js
+ * const root = postcss.parse('a { color: black }')
+ * const decl = root.first?.first
+ *
+ * decl.type       //=> 'decl'
+ * decl.toString() //=> ' color: black'
+ * ```
+ */
+declare class Declaration_ extends Node {
+  parent: ContainerWithChildren | undefined
+  raws: Declaration.DeclarationRaws
+
+  type: 'decl'
+
+  constructor(defaults?: Declaration.DeclarationProps)
+  assign(overrides: Declaration.DeclarationProps | object): this
+
+  clone(overrides?: Partial<Declaration.DeclarationProps>): this
+
+  cloneAfter(overrides?: Partial<Declaration.DeclarationProps>): this
+
+  cloneBefore(overrides?: Partial<Declaration.DeclarationProps>): this
+  /**
+   * It represents a specificity of the declaration.
+   *
+   * If true, the CSS declaration will have an
+   * [important](https://developer.mozilla.org/en-US/docs/Web/CSS/important)
+   * specifier.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black !important; color: red }')
+   *
+   * root.first.first.important //=> true
+   * root.first.last.important  //=> undefined
+   * ```
+   */
+  get important(): boolean
+
+  set important(value: boolean)
+  /**
+   * The property name for a CSS declaration.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.prop //=> 'color'
+   * ```
+   */
+  get prop(): string
+
+  set prop(value: string)
+  /**
+   * The property value for a CSS declaration.
+   *
+   * Any CSS comments inside the value string will be filtered out.
+   * CSS comments present in the source value will be available in
+   * the `raws` property.
+   *
+   * Assigning new `value` would ignore the comments in `raws`
+   * property while compiling node to string.
+   *
+   * ```js
+   * const root = postcss.parse('a { color: black }')
+   * const decl = root.first.first
+   *
+   * decl.value //=> 'black'
+   * ```
+   */
+  get value(): string
+  set value(value: string)
+  /**
+   * It represents a getter that returns `true` if a declaration starts with
+   * `--` or `$`, which are used to declare variables in CSS and SASS/SCSS.
+   *
+   * ```js
+   * const root = postcss.parse(':root { --one: 1 }')
+   * const one = root.first.first
+   *
+   * one.variable //=> true
+   * ```
+   *
+   * ```js
+   * const root = postcss.parse('$one: 1')
+   * const one = root.first
+   *
+   * one.variable //=> true
+   * ```
+   */
+  get variable(): boolean
+}
+
+declare class Declaration extends Declaration_ {}
+
+export = Declaration
diff --git a/node_modules/postcss/lib/declaration.js b/node_modules/postcss/lib/declaration.js
new file mode 100644
index 0000000..a04bdec
--- /dev/null
+++ b/node_modules/postcss/lib/declaration.js
@@ -0,0 +1,24 @@
+'use strict'
+
+let Node = require('./node')
+
+class Declaration extends Node {
+  constructor(defaults) {
+    if (
+      defaults &&
+      typeof defaults.value !== 'undefined' &&
+      typeof defaults.value !== 'string'
+    ) {
+      defaults = { ...defaults, value: String(defaults.value) }
+    }
+    super(defaults)
+    this.type = 'decl'
+  }
+
+  get variable() {
+    return this.prop.startsWith('--') || this.prop[0] === '$'
+  }
+}
+
+module.exports = Declaration
+Declaration.default = Declaration
diff --git a/node_modules/postcss/lib/document.d.ts b/node_modules/postcss/lib/document.d.ts
new file mode 100644
index 0000000..f9e8063
--- /dev/null
+++ b/node_modules/postcss/lib/document.d.ts
@@ -0,0 +1,69 @@
+import Container, { ContainerProps } from './container.js'
+import { ProcessOptions } from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Document {
+  export interface DocumentProps extends ContainerProps {
+    nodes?: readonly Root[]
+
+    /**
+     * Information to generate byte-to-byte equal node string as it was
+     * in the origin input.
+     *
+     * Every parser saves its own properties.
+     */
+    raws?: Record<string, any>
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Document_ as default }
+}
+
+/**
+ * Represents a file and contains all its parsed nodes.
+ *
+ * **Experimental:** some aspects of this node could change within minor
+ * or patch version releases.
+ *
+ * ```js
+ * const document = htmlParser(
+ *   '<html><style>a{color:black}</style><style>b{z-index:2}</style>'
+ * )
+ * document.type         //=> 'document'
+ * document.nodes.length //=> 2
+ * ```
+ */
+declare class Document_ extends Container<Root> {
+  nodes: Root[]
+  parent: undefined
+  type: 'document'
+
+  constructor(defaults?: Document.DocumentProps)
+
+  assign(overrides: Document.DocumentProps | object): this
+  clone(overrides?: Partial<Document.DocumentProps>): this
+  cloneAfter(overrides?: Partial<Document.DocumentProps>): this
+  cloneBefore(overrides?: Partial<Document.DocumentProps>): this
+
+  /**
+   * Returns a `Result` instance representing the document’s CSS roots.
+   *
+   * ```js
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * const document = postcss.document()
+   * document.append(root1)
+   * document.append(root2)
+   * const result = document.toResult({ to: 'all.css', map: true })
+   * ```
+   *
+   * @param opts Options.
+   * @return Result with current document’s CSS.
+   */
+  toResult(options?: ProcessOptions): Result
+}
+
+declare class Document extends Document_ {}
+
+export = Document
diff --git a/node_modules/postcss/lib/document.js b/node_modules/postcss/lib/document.js
new file mode 100644
index 0000000..4468991
--- /dev/null
+++ b/node_modules/postcss/lib/document.js
@@ -0,0 +1,33 @@
+'use strict'
+
+let Container = require('./container')
+
+let LazyResult, Processor
+
+class Document extends Container {
+  constructor(defaults) {
+    // type needs to be passed to super, otherwise child roots won't be normalized correctly
+    super({ type: 'document', ...defaults })
+
+    if (!this.nodes) {
+      this.nodes = []
+    }
+  }
+
+  toResult(opts = {}) {
+    let lazy = new LazyResult(new Processor(), this, opts)
+
+    return lazy.stringify()
+  }
+}
+
+Document.registerLazyResult = dependant => {
+  LazyResult = dependant
+}
+
+Document.registerProcessor = dependant => {
+  Processor = dependant
+}
+
+module.exports = Document
+Document.default = Document
diff --git a/node_modules/postcss/lib/fromJSON.d.ts b/node_modules/postcss/lib/fromJSON.d.ts
new file mode 100644
index 0000000..e1deedb
--- /dev/null
+++ b/node_modules/postcss/lib/fromJSON.d.ts
@@ -0,0 +1,9 @@
+import { JSONHydrator } from './postcss.js'
+
+interface FromJSON extends JSONHydrator {
+  default: FromJSON
+}
+
+declare const fromJSON: FromJSON
+
+export = fromJSON
diff --git a/node_modules/postcss/lib/fromJSON.js b/node_modules/postcss/lib/fromJSON.js
new file mode 100644
index 0000000..c9ac1a8
--- /dev/null
+++ b/node_modules/postcss/lib/fromJSON.js
@@ -0,0 +1,54 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Input = require('./input')
+let PreviousMap = require('./previous-map')
+let Root = require('./root')
+let Rule = require('./rule')
+
+function fromJSON(json, inputs) {
+  if (Array.isArray(json)) return json.map(n => fromJSON(n))
+
+  let { inputs: ownInputs, ...defaults } = json
+  if (ownInputs) {
+    inputs = []
+    for (let input of ownInputs) {
+      let inputHydrated = { ...input, __proto__: Input.prototype }
+      if (inputHydrated.map) {
+        inputHydrated.map = {
+          ...inputHydrated.map,
+          __proto__: PreviousMap.prototype
+        }
+      }
+      inputs.push(inputHydrated)
+    }
+  }
+  if (defaults.nodes) {
+    defaults.nodes = json.nodes.map(n => fromJSON(n, inputs))
+  }
+  if (defaults.source) {
+    let { inputId, ...source } = defaults.source
+    defaults.source = source
+    if (inputId != null) {
+      defaults.source.input = inputs[inputId]
+    }
+  }
+  if (defaults.type === 'root') {
+    return new Root(defaults)
+  } else if (defaults.type === 'decl') {
+    return new Declaration(defaults)
+  } else if (defaults.type === 'rule') {
+    return new Rule(defaults)
+  } else if (defaults.type === 'comment') {
+    return new Comment(defaults)
+  } else if (defaults.type === 'atrule') {
+    return new AtRule(defaults)
+  } else {
+    throw new Error('Unknown node type: ' + json.type)
+  }
+}
+
+module.exports = fromJSON
+fromJSON.default = fromJSON
diff --git a/node_modules/postcss/lib/input.d.ts b/node_modules/postcss/lib/input.d.ts
new file mode 100644
index 0000000..46ded09
--- /dev/null
+++ b/node_modules/postcss/lib/input.d.ts
@@ -0,0 +1,197 @@
+import { CssSyntaxError, ProcessOptions } from './postcss.js'
+import PreviousMap from './previous-map.js'
+
+declare namespace Input {
+  export interface FilePosition {
+    /**
+     * Column of inclusive start position in source file.
+     */
+    column: number
+
+    /**
+     * Column of exclusive end position in source file.
+     */
+    endColumn?: number
+
+    /**
+     * Line of exclusive end position in source file.
+     */
+    endLine?: number
+
+    /**
+     * Absolute path to the source file.
+     */
+    file?: string
+
+    /**
+     * Line of inclusive start position in source file.
+     */
+    line: number
+
+    /**
+     * Source code.
+     */
+    source?: string
+
+    /**
+     * URL for the source file.
+     */
+    url: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Input_ as default }
+}
+
+/**
+ * Represents the source CSS.
+ *
+ * ```js
+ * const root  = postcss.parse(css, { from: file })
+ * const input = root.source.input
+ * ```
+ */
+declare class Input_ {
+  /**
+   * Input CSS source.
+   *
+   * ```js
+   * const input = postcss.parse('a{}', { from: file }).input
+   * input.css //=> "a{}"
+   * ```
+   */
+  css: string
+
+  /**
+   * The absolute path to the CSS source file defined
+   * with the `from` option.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.file //=> '/home/ai/a.css'
+   * ```
+   */
+  file?: string
+
+  /**
+   * The flag to indicate whether or not the source code has Unicode BOM.
+   */
+  hasBOM: boolean
+
+  /**
+   * The unique ID of the CSS source. It will be created if `from` option
+   * is not provided (because PostCSS does not know the file path).
+   *
+   * ```js
+   * const root = postcss.parse(css)
+   * root.source.input.file //=> undefined
+   * root.source.input.id   //=> "<input css 8LZeVF>"
+   * ```
+   */
+  id?: string
+
+  /**
+   * The input source map passed from a compilation step before PostCSS
+   * (for example, from Sass compiler).
+   *
+   * ```js
+   * root.source.input.map.consumer().sources //=> ['a.sass']
+   * ```
+   */
+  map: PreviousMap
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  error(
+    message: string,
+    start:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    end:
+      | {
+          column: number
+          line: number
+        }
+      | {
+          offset: number
+        },
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  /**
+   * Returns `CssSyntaxError` with information about the error and its position.
+   */
+  error(
+    message: string,
+    line: number,
+    column: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  error(
+    message: string,
+    offset: number,
+    opts?: { plugin?: CssSyntaxError['plugin'] }
+  ): CssSyntaxError
+
+  /**
+   * Converts source offset to line and column.
+   *
+   * @param offset Source offset.
+   */
+  fromOffset(offset: number): { col: number; line: number } | null
+  /**
+   * Reads the input source map and returns a symbol position
+   * in the input source (e.g., in a Sass file that was compiled
+   * to CSS before being passed to PostCSS). Optionally takes an
+   * end position, exclusive.
+   *
+   * ```js
+   * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 }
+   * root.source.input.origin(1, 1, 1, 4)
+   * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 }
+   * ```
+   *
+   * @param line      Line for inclusive start position in input CSS.
+   * @param column    Column for inclusive start position in input CSS.
+   * @param endLine   Line for exclusive end position in input CSS.
+   * @param endColumn Column for exclusive end position in input CSS.
+   *
+   * @return Position in input source.
+   */
+  origin(
+    line: number,
+    column: number,
+    endLine?: number,
+    endColumn?: number
+  ): false | Input.FilePosition
+  /** Converts this to a JSON-friendly object representation. */
+  toJSON(): object
+
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   *
+   * ```js
+   * const root = postcss.parse(css, { from: 'a.css' })
+   * root.source.input.from //=> "/home/ai/a.css"
+   *
+   * const root = postcss.parse(css)
+   * root.source.input.from //=> "<input css 1>"
+   * ```
+   */
+  get from(): string
+}
+
+declare class Input extends Input_ {}
+
+export = Input
diff --git a/node_modules/postcss/lib/input.js b/node_modules/postcss/lib/input.js
new file mode 100644
index 0000000..685bce7
--- /dev/null
+++ b/node_modules/postcss/lib/input.js
@@ -0,0 +1,248 @@
+'use strict'
+
+let { nanoid } = require('nanoid/non-secure')
+let { isAbsolute, resolve } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+let { fileURLToPath, pathToFileURL } = require('url')
+
+let CssSyntaxError = require('./css-syntax-error')
+let PreviousMap = require('./previous-map')
+let terminalHighlight = require('./terminal-highlight')
+
+let fromOffsetCache = Symbol('fromOffsetCache')
+
+let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
+let pathAvailable = Boolean(resolve && isAbsolute)
+
+class Input {
+  constructor(css, opts = {}) {
+    if (
+      css === null ||
+      typeof css === 'undefined' ||
+      (typeof css === 'object' && !css.toString)
+    ) {
+      throw new Error(`PostCSS received ${css} instead of CSS string`)
+    }
+
+    this.css = css.toString()
+
+    if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
+      this.hasBOM = true
+      this.css = this.css.slice(1)
+    } else {
+      this.hasBOM = false
+    }
+
+    if (opts.from) {
+      if (
+        !pathAvailable ||
+        /^\w+:\/\//.test(opts.from) ||
+        isAbsolute(opts.from)
+      ) {
+        this.file = opts.from
+      } else {
+        this.file = resolve(opts.from)
+      }
+    }
+
+    if (pathAvailable && sourceMapAvailable) {
+      let map = new PreviousMap(this.css, opts)
+      if (map.text) {
+        this.map = map
+        let file = map.consumer().file
+        if (!this.file && file) this.file = this.mapResolve(file)
+      }
+    }
+
+    if (!this.file) {
+      this.id = '<input css ' + nanoid(6) + '>'
+    }
+    if (this.map) this.map.file = this.from
+  }
+
+  error(message, line, column, opts = {}) {
+    let endColumn, endLine, result
+
+    if (line && typeof line === 'object') {
+      let start = line
+      let end = column
+      if (typeof start.offset === 'number') {
+        let pos = this.fromOffset(start.offset)
+        line = pos.line
+        column = pos.col
+      } else {
+        line = start.line
+        column = start.column
+      }
+      if (typeof end.offset === 'number') {
+        let pos = this.fromOffset(end.offset)
+        endLine = pos.line
+        endColumn = pos.col
+      } else {
+        endLine = end.line
+        endColumn = end.column
+      }
+    } else if (!column) {
+      let pos = this.fromOffset(line)
+      line = pos.line
+      column = pos.col
+    }
+
+    let origin = this.origin(line, column, endLine, endColumn)
+    if (origin) {
+      result = new CssSyntaxError(
+        message,
+        origin.endLine === undefined
+          ? origin.line
+          : { column: origin.column, line: origin.line },
+        origin.endLine === undefined
+          ? origin.column
+          : { column: origin.endColumn, line: origin.endLine },
+        origin.source,
+        origin.file,
+        opts.plugin
+      )
+    } else {
+      result = new CssSyntaxError(
+        message,
+        endLine === undefined ? line : { column, line },
+        endLine === undefined ? column : { column: endColumn, line: endLine },
+        this.css,
+        this.file,
+        opts.plugin
+      )
+    }
+
+    result.input = { column, endColumn, endLine, line, source: this.css }
+    if (this.file) {
+      if (pathToFileURL) {
+        result.input.url = pathToFileURL(this.file).toString()
+      }
+      result.input.file = this.file
+    }
+
+    return result
+  }
+
+  fromOffset(offset) {
+    let lastLine, lineToIndex
+    if (!this[fromOffsetCache]) {
+      let lines = this.css.split('\n')
+      lineToIndex = new Array(lines.length)
+      let prevIndex = 0
+
+      for (let i = 0, l = lines.length; i < l; i++) {
+        lineToIndex[i] = prevIndex
+        prevIndex += lines[i].length + 1
+      }
+
+      this[fromOffsetCache] = lineToIndex
+    } else {
+      lineToIndex = this[fromOffsetCache]
+    }
+    lastLine = lineToIndex[lineToIndex.length - 1]
+
+    let min = 0
+    if (offset >= lastLine) {
+      min = lineToIndex.length - 1
+    } else {
+      let max = lineToIndex.length - 2
+      let mid
+      while (min < max) {
+        mid = min + ((max - min) >> 1)
+        if (offset < lineToIndex[mid]) {
+          max = mid - 1
+        } else if (offset >= lineToIndex[mid + 1]) {
+          min = mid + 1
+        } else {
+          min = mid
+          break
+        }
+      }
+    }
+    return {
+      col: offset - lineToIndex[min] + 1,
+      line: min + 1
+    }
+  }
+
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file
+    }
+    return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file)
+  }
+
+  origin(line, column, endLine, endColumn) {
+    if (!this.map) return false
+    let consumer = this.map.consumer()
+
+    let from = consumer.originalPositionFor({ column, line })
+    if (!from.source) return false
+
+    let to
+    if (typeof endLine === 'number') {
+      to = consumer.originalPositionFor({ column: endColumn, line: endLine })
+    }
+
+    let fromUrl
+
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL(from.source)
+    } else {
+      fromUrl = new URL(
+        from.source,
+        this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
+      )
+    }
+
+    let result = {
+      column: from.column,
+      endColumn: to && to.column,
+      endLine: to && to.line,
+      line: from.line,
+      url: fromUrl.toString()
+    }
+
+    if (fromUrl.protocol === 'file:') {
+      if (fileURLToPath) {
+        result.file = fileURLToPath(fromUrl)
+      } else {
+        /* c8 ignore next 2 */
+        throw new Error(`file: protocol is not available in this PostCSS build`)
+      }
+    }
+
+    let source = consumer.sourceContentFor(from.source)
+    if (source) result.source = source
+
+    return result
+  }
+
+  toJSON() {
+    let json = {}
+    for (let name of ['hasBOM', 'css', 'file', 'id']) {
+      if (this[name] != null) {
+        json[name] = this[name]
+      }
+    }
+    if (this.map) {
+      json.map = { ...this.map }
+      if (json.map.consumerCache) {
+        json.map.consumerCache = undefined
+      }
+    }
+    return json
+  }
+
+  get from() {
+    return this.file || this.id
+  }
+}
+
+module.exports = Input
+Input.default = Input
+
+if (terminalHighlight && terminalHighlight.registerInput) {
+  terminalHighlight.registerInput(Input)
+}
diff --git a/node_modules/postcss/lib/lazy-result.d.ts b/node_modules/postcss/lib/lazy-result.d.ts
new file mode 100644
index 0000000..dd291aa
--- /dev/null
+++ b/node_modules/postcss/lib/lazy-result.d.ts
@@ -0,0 +1,190 @@
+import Document from './document.js'
+import { SourceMap } from './postcss.js'
+import Processor from './processor.js'
+import Result, { Message, ResultOptions } from './result.js'
+import Root from './root.js'
+import Warning from './warning.js'
+
+declare namespace LazyResult {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { LazyResult_ as default }
+}
+
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ *
+ * A `LazyResult` instance is returned by `Processor#process`.
+ *
+ * ```js
+ * const lazy = postcss([autoprefixer]).process(css)
+ * ```
+ */
+declare class LazyResult_<RootNode = Document | Root>
+  implements PromiseLike<Result<RootNode>>
+{
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onRejected for each error thrown in any plugin.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css).then(result => {
+   *   console.log(result.css)
+   * }).catch(error => {
+   *   console.error(error)
+   * })
+   * ```
+   */
+  catch: Promise<Result<RootNode>>['catch']
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls onFinally on any error or when all plugins will finish work.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css).finally(() => {
+   *   console.log('processing ended')
+   * })
+   * ```
+   */
+  finally: Promise<Result<RootNode>>['finally']
+
+  /**
+   * Processes input CSS through synchronous and asynchronous plugins
+   * and calls `onFulfilled` with a Result instance. If a plugin throws
+   * an error, the `onRejected` callback will be executed.
+   *
+   * It implements standard Promise API.
+   *
+   * ```js
+   * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => {
+   *   console.log(result.css)
+   * })
+   * ```
+   */
+  then: Promise<Result<RootNode>>['then']
+
+  /**
+   * @param processor Processor used for this transformation.
+   * @param css       CSS to parse and transform.
+   * @param opts      Options from the `Processor#process` or `Root#toResult`.
+   */
+  constructor(processor: Processor, css: string, opts: ResultOptions)
+
+  /**
+   * Run plugin in async way and return `Result`.
+   *
+   * @return Result with output content.
+   */
+  async(): Promise<Result<RootNode>>
+
+  /**
+   * Run plugin in sync way and return `Result`.
+   *
+   * @return Result with output content.
+   */
+  sync(): Result<RootNode>
+
+  /**
+   * Alias for the `LazyResult#css` property.
+   *
+   * ```js
+   * lazy + '' === lazy.css
+   * ```
+   *
+   * @return Output CSS.
+   */
+  toString(): string
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and calls `Result#warnings`.
+   *
+   * @return Warnings from plugins.
+   */
+  warnings(): Warning[]
+
+  /**
+   * An alias for the `css` property. Use it with syntaxes
+   * that generate non-CSS output.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get content(): string
+
+  /**
+   * Processes input CSS through synchronous plugins, converts `Root`
+   * to a CSS string and returns `Result#css`.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get css(): string
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#map`.
+   *
+   * This property will only work with synchronous plugins.
+   * If the processor contains any asynchronous plugins
+   * it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get map(): SourceMap
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#messages`.
+   *
+   * This property will only work with synchronous plugins. If the processor
+   * contains any asynchronous plugins it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get messages(): Message[]
+
+  /**
+   * Options from the `Processor#process` call.
+   */
+  get opts(): ResultOptions
+
+  /**
+   * Returns a `Processor` instance, which will be used
+   * for CSS transformations.
+   */
+  get processor(): Processor
+
+  /**
+   * Processes input CSS through synchronous plugins
+   * and returns `Result#root`.
+   *
+   * This property will only work with synchronous plugins. If the processor
+   * contains any asynchronous plugins it will throw an error.
+   *
+   * PostCSS runners should always use `LazyResult#then`.
+   */
+  get root(): RootNode
+
+  /**
+   * Returns the default string description of an object.
+   * Required to implement the Promise interface.
+   */
+  get [Symbol.toStringTag](): string
+}
+
+declare class LazyResult<
+  RootNode = Document | Root
+> extends LazyResult_<RootNode> {}
+
+export = LazyResult
diff --git a/node_modules/postcss/lib/lazy-result.js b/node_modules/postcss/lib/lazy-result.js
new file mode 100644
index 0000000..e27701d
--- /dev/null
+++ b/node_modules/postcss/lib/lazy-result.js
@@ -0,0 +1,550 @@
+'use strict'
+
+let Container = require('./container')
+let Document = require('./document')
+let MapGenerator = require('./map-generator')
+let parse = require('./parse')
+let Result = require('./result')
+let Root = require('./root')
+let stringify = require('./stringify')
+let { isClean, my } = require('./symbols')
+let warnOnce = require('./warn-once')
+
+const TYPE_TO_CLASS_NAME = {
+  atrule: 'AtRule',
+  comment: 'Comment',
+  decl: 'Declaration',
+  document: 'Document',
+  root: 'Root',
+  rule: 'Rule'
+}
+
+const PLUGIN_PROPS = {
+  AtRule: true,
+  AtRuleExit: true,
+  Comment: true,
+  CommentExit: true,
+  Declaration: true,
+  DeclarationExit: true,
+  Document: true,
+  DocumentExit: true,
+  Once: true,
+  OnceExit: true,
+  postcssPlugin: true,
+  prepare: true,
+  Root: true,
+  RootExit: true,
+  Rule: true,
+  RuleExit: true
+}
+
+const NOT_VISITORS = {
+  Once: true,
+  postcssPlugin: true,
+  prepare: true
+}
+
+const CHILDREN = 0
+
+function isPromise(obj) {
+  return typeof obj === 'object' && typeof obj.then === 'function'
+}
+
+function getEvents(node) {
+  let key = false
+  let type = TYPE_TO_CLASS_NAME[node.type]
+  if (node.type === 'decl') {
+    key = node.prop.toLowerCase()
+  } else if (node.type === 'atrule') {
+    key = node.name.toLowerCase()
+  }
+
+  if (key && node.append) {
+    return [
+      type,
+      type + '-' + key,
+      CHILDREN,
+      type + 'Exit',
+      type + 'Exit-' + key
+    ]
+  } else if (key) {
+    return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]
+  } else if (node.append) {
+    return [type, CHILDREN, type + 'Exit']
+  } else {
+    return [type, type + 'Exit']
+  }
+}
+
+function toStack(node) {
+  let events
+  if (node.type === 'document') {
+    events = ['Document', CHILDREN, 'DocumentExit']
+  } else if (node.type === 'root') {
+    events = ['Root', CHILDREN, 'RootExit']
+  } else {
+    events = getEvents(node)
+  }
+
+  return {
+    eventIndex: 0,
+    events,
+    iterator: 0,
+    node,
+    visitorIndex: 0,
+    visitors: []
+  }
+}
+
+function cleanMarks(node) {
+  node[isClean] = false
+  if (node.nodes) node.nodes.forEach(i => cleanMarks(i))
+  return node
+}
+
+let postcss = {}
+
+class LazyResult {
+  constructor(processor, css, opts) {
+    this.stringified = false
+    this.processed = false
+
+    let root
+    if (
+      typeof css === 'object' &&
+      css !== null &&
+      (css.type === 'root' || css.type === 'document')
+    ) {
+      root = cleanMarks(css)
+    } else if (css instanceof LazyResult || css instanceof Result) {
+      root = cleanMarks(css.root)
+      if (css.map) {
+        if (typeof opts.map === 'undefined') opts.map = {}
+        if (!opts.map.inline) opts.map.inline = false
+        opts.map.prev = css.map
+      }
+    } else {
+      let parser = parse
+      if (opts.syntax) parser = opts.syntax.parse
+      if (opts.parser) parser = opts.parser
+      if (parser.parse) parser = parser.parse
+
+      try {
+        root = parser(css, opts)
+      } catch (error) {
+        this.processed = true
+        this.error = error
+      }
+
+      if (root && !root[my]) {
+        /* c8 ignore next 2 */
+        Container.rebuild(root)
+      }
+    }
+
+    this.result = new Result(processor, root, opts)
+    this.helpers = { ...postcss, postcss, result: this.result }
+    this.plugins = this.processor.plugins.map(plugin => {
+      if (typeof plugin === 'object' && plugin.prepare) {
+        return { ...plugin, ...plugin.prepare(this.result) }
+      } else {
+        return plugin
+      }
+    })
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    if (this.processed) return Promise.resolve(this.result)
+    if (!this.processing) {
+      this.processing = this.runAsync()
+    }
+    return this.processing
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  getAsyncError() {
+    throw new Error('Use process(css).then(cb) to work with async plugins')
+  }
+
+  handleError(error, node) {
+    let plugin = this.result.lastPlugin
+    try {
+      if (node) node.addToError(error)
+      this.error = error
+      if (error.name === 'CssSyntaxError' && !error.plugin) {
+        error.plugin = plugin.postcssPlugin
+        error.setMessage()
+      } else if (plugin.postcssVersion) {
+        if (process.env.NODE_ENV !== 'production') {
+          let pluginName = plugin.postcssPlugin
+          let pluginVer = plugin.postcssVersion
+          let runtimeVer = this.result.processor.version
+          let a = pluginVer.split('.')
+          let b = runtimeVer.split('.')
+
+          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+            // eslint-disable-next-line no-console
+            console.error(
+              'Unknown error from PostCSS plugin. Your current PostCSS ' +
+                'version is ' +
+                runtimeVer +
+                ', but ' +
+                pluginName +
+                ' uses ' +
+                pluginVer +
+                '. Perhaps this is the source of the error below.'
+            )
+          }
+        }
+      }
+    } catch (err) {
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line no-console
+      if (console && console.error) console.error(err)
+    }
+    return error
+  }
+
+  prepareVisitors() {
+    this.listeners = {}
+    let add = (plugin, type, cb) => {
+      if (!this.listeners[type]) this.listeners[type] = []
+      this.listeners[type].push([plugin, cb])
+    }
+    for (let plugin of this.plugins) {
+      if (typeof plugin === 'object') {
+        for (let event in plugin) {
+          if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
+            throw new Error(
+              `Unknown event ${event} in ${plugin.postcssPlugin}. ` +
+                `Try to update PostCSS (${this.processor.version} now).`
+            )
+          }
+          if (!NOT_VISITORS[event]) {
+            if (typeof plugin[event] === 'object') {
+              for (let filter in plugin[event]) {
+                if (filter === '*') {
+                  add(plugin, event, plugin[event][filter])
+                } else {
+                  add(
+                    plugin,
+                    event + '-' + filter.toLowerCase(),
+                    plugin[event][filter]
+                  )
+                }
+              }
+            } else if (typeof plugin[event] === 'function') {
+              add(plugin, event, plugin[event])
+            }
+          }
+        }
+      }
+    }
+    this.hasListener = Object.keys(this.listeners).length > 0
+  }
+
+  async runAsync() {
+    this.plugin = 0
+    for (let i = 0; i < this.plugins.length; i++) {
+      let plugin = this.plugins[i]
+      let promise = this.runOnRoot(plugin)
+      if (isPromise(promise)) {
+        try {
+          await promise
+        } catch (error) {
+          throw this.handleError(error)
+        }
+      }
+    }
+
+    this.prepareVisitors()
+    if (this.hasListener) {
+      let root = this.result.root
+      while (!root[isClean]) {
+        root[isClean] = true
+        let stack = [toStack(root)]
+        while (stack.length > 0) {
+          let promise = this.visitTick(stack)
+          if (isPromise(promise)) {
+            try {
+              await promise
+            } catch (e) {
+              let node = stack[stack.length - 1].node
+              throw this.handleError(e, node)
+            }
+          }
+        }
+      }
+
+      if (this.listeners.OnceExit) {
+        for (let [plugin, visitor] of this.listeners.OnceExit) {
+          this.result.lastPlugin = plugin
+          try {
+            if (root.type === 'document') {
+              let roots = root.nodes.map(subRoot =>
+                visitor(subRoot, this.helpers)
+              )
+
+              await Promise.all(roots)
+            } else {
+              await visitor(root, this.helpers)
+            }
+          } catch (e) {
+            throw this.handleError(e)
+          }
+        }
+      }
+    }
+
+    this.processed = true
+    return this.stringify()
+  }
+
+  runOnRoot(plugin) {
+    this.result.lastPlugin = plugin
+    try {
+      if (typeof plugin === 'object' && plugin.Once) {
+        if (this.result.root.type === 'document') {
+          let roots = this.result.root.nodes.map(root =>
+            plugin.Once(root, this.helpers)
+          )
+
+          if (isPromise(roots[0])) {
+            return Promise.all(roots)
+          }
+
+          return roots
+        }
+
+        return plugin.Once(this.result.root, this.helpers)
+      } else if (typeof plugin === 'function') {
+        return plugin(this.result.root, this.result)
+      }
+    } catch (error) {
+      throw this.handleError(error)
+    }
+  }
+
+  stringify() {
+    if (this.error) throw this.error
+    if (this.stringified) return this.result
+    this.stringified = true
+
+    this.sync()
+
+    let opts = this.result.opts
+    let str = stringify
+    if (opts.syntax) str = opts.syntax.stringify
+    if (opts.stringifier) str = opts.stringifier
+    if (str.stringify) str = str.stringify
+
+    let map = new MapGenerator(str, this.result.root, this.result.opts)
+    let data = map.generate()
+    this.result.css = data[0]
+    this.result.map = data[1]
+
+    return this.result
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    if (this.processed) return this.result
+    this.processed = true
+
+    if (this.processing) {
+      throw this.getAsyncError()
+    }
+
+    for (let plugin of this.plugins) {
+      let promise = this.runOnRoot(plugin)
+      if (isPromise(promise)) {
+        throw this.getAsyncError()
+      }
+    }
+
+    this.prepareVisitors()
+    if (this.hasListener) {
+      let root = this.result.root
+      while (!root[isClean]) {
+        root[isClean] = true
+        this.walkSync(root)
+      }
+      if (this.listeners.OnceExit) {
+        if (root.type === 'document') {
+          for (let subRoot of root.nodes) {
+            this.visitSync(this.listeners.OnceExit, subRoot)
+          }
+        } else {
+          this.visitSync(this.listeners.OnceExit, root)
+        }
+      }
+    }
+
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this.opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this.css
+  }
+
+  visitSync(visitors, node) {
+    for (let [plugin, visitor] of visitors) {
+      this.result.lastPlugin = plugin
+      let promise
+      try {
+        promise = visitor(node, this.helpers)
+      } catch (e) {
+        throw this.handleError(e, node.proxyOf)
+      }
+      if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
+        return true
+      }
+      if (isPromise(promise)) {
+        throw this.getAsyncError()
+      }
+    }
+  }
+
+  visitTick(stack) {
+    let visit = stack[stack.length - 1]
+    let { node, visitors } = visit
+
+    if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
+      stack.pop()
+      return
+    }
+
+    if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
+      let [plugin, visitor] = visitors[visit.visitorIndex]
+      visit.visitorIndex += 1
+      if (visit.visitorIndex === visitors.length) {
+        visit.visitors = []
+        visit.visitorIndex = 0
+      }
+      this.result.lastPlugin = plugin
+      try {
+        return visitor(node.toProxy(), this.helpers)
+      } catch (e) {
+        throw this.handleError(e, node)
+      }
+    }
+
+    if (visit.iterator !== 0) {
+      let iterator = visit.iterator
+      let child
+      while ((child = node.nodes[node.indexes[iterator]])) {
+        node.indexes[iterator] += 1
+        if (!child[isClean]) {
+          child[isClean] = true
+          stack.push(toStack(child))
+          return
+        }
+      }
+      visit.iterator = 0
+      delete node.indexes[iterator]
+    }
+
+    let events = visit.events
+    while (visit.eventIndex < events.length) {
+      let event = events[visit.eventIndex]
+      visit.eventIndex += 1
+      if (event === CHILDREN) {
+        if (node.nodes && node.nodes.length) {
+          node[isClean] = true
+          visit.iterator = node.getIterator()
+        }
+        return
+      } else if (this.listeners[event]) {
+        visit.visitors = this.listeners[event]
+        return
+      }
+    }
+    stack.pop()
+  }
+
+  walkSync(node) {
+    node[isClean] = true
+    let events = getEvents(node)
+    for (let event of events) {
+      if (event === CHILDREN) {
+        if (node.nodes) {
+          node.each(child => {
+            if (!child[isClean]) this.walkSync(child)
+          })
+        }
+      } else {
+        let visitors = this.listeners[event]
+        if (visitors) {
+          if (this.visitSync(visitors, node.toProxy())) return
+        }
+      }
+    }
+  }
+
+  warnings() {
+    return this.sync().warnings()
+  }
+
+  get content() {
+    return this.stringify().content
+  }
+
+  get css() {
+    return this.stringify().css
+  }
+
+  get map() {
+    return this.stringify().map
+  }
+
+  get messages() {
+    return this.sync().messages
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    return this.sync().root
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'LazyResult'
+  }
+}
+
+LazyResult.registerPostcss = dependant => {
+  postcss = dependant
+}
+
+module.exports = LazyResult
+LazyResult.default = LazyResult
+
+Root.registerLazyResult(LazyResult)
+Document.registerLazyResult(LazyResult)
diff --git a/node_modules/postcss/lib/list.d.ts b/node_modules/postcss/lib/list.d.ts
new file mode 100644
index 0000000..e262ad3
--- /dev/null
+++ b/node_modules/postcss/lib/list.d.ts
@@ -0,0 +1,60 @@
+declare namespace list {
+  type List = {
+    /**
+     * Safely splits comma-separated values (such as those for `transition-*`
+     * and `background` properties).
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.comma('black, linear-gradient(white, black)')
+     *   //=> ['black', 'linear-gradient(white, black)']
+     * }
+     * ```
+     *
+     * @param str Comma-separated values.
+     * @return Split values.
+     */
+    comma(str: string): string[]
+
+    default: List
+
+    /**
+     * Safely splits space-separated values (such as those for `background`,
+     * `border-radius`, and other shorthand properties).
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)']
+     * }
+     * ```
+     *
+     * @param str Space-separated values.
+     * @return Split values.
+     */
+    space(str: string): string[]
+
+    /**
+     * Safely splits values.
+     *
+     * ```js
+     * Once (root, { list }) {
+     *   list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)']
+     * }
+     * ```
+     *
+     * @param string separated values.
+     * @param separators array of separators.
+     * @param last boolean indicator.
+     * @return Split values.
+     */
+    split(
+      string: string,
+      separators: readonly string[],
+      last: boolean
+    ): string[]
+  }
+}
+
+declare const list: list.List
+
+export = list
diff --git a/node_modules/postcss/lib/list.js b/node_modules/postcss/lib/list.js
new file mode 100644
index 0000000..1b31f98
--- /dev/null
+++ b/node_modules/postcss/lib/list.js
@@ -0,0 +1,58 @@
+'use strict'
+
+let list = {
+  comma(string) {
+    return list.split(string, [','], true)
+  },
+
+  space(string) {
+    let spaces = [' ', '\n', '\t']
+    return list.split(string, spaces)
+  },
+
+  split(string, separators, last) {
+    let array = []
+    let current = ''
+    let split = false
+
+    let func = 0
+    let inQuote = false
+    let prevQuote = ''
+    let escape = false
+
+    for (let letter of string) {
+      if (escape) {
+        escape = false
+      } else if (letter === '\\') {
+        escape = true
+      } else if (inQuote) {
+        if (letter === prevQuote) {
+          inQuote = false
+        }
+      } else if (letter === '"' || letter === "'") {
+        inQuote = true
+        prevQuote = letter
+      } else if (letter === '(') {
+        func += 1
+      } else if (letter === ')') {
+        if (func > 0) func -= 1
+      } else if (func === 0) {
+        if (separators.includes(letter)) split = true
+      }
+
+      if (split) {
+        if (current !== '') array.push(current.trim())
+        current = ''
+        split = false
+      } else {
+        current += letter
+      }
+    }
+
+    if (last || current !== '') array.push(current.trim())
+    return array
+  }
+}
+
+module.exports = list
+list.default = list
diff --git a/node_modules/postcss/lib/map-generator.js b/node_modules/postcss/lib/map-generator.js
new file mode 100644
index 0000000..89069d3
--- /dev/null
+++ b/node_modules/postcss/lib/map-generator.js
@@ -0,0 +1,368 @@
+'use strict'
+
+let { dirname, relative, resolve, sep } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+let { pathToFileURL } = require('url')
+
+let Input = require('./input')
+
+let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator)
+let pathAvailable = Boolean(dirname && resolve && relative && sep)
+
+class MapGenerator {
+  constructor(stringify, root, opts, cssString) {
+    this.stringify = stringify
+    this.mapOpts = opts.map || {}
+    this.root = root
+    this.opts = opts
+    this.css = cssString
+    this.originalCSS = cssString
+    this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute
+
+    this.memoizedFileURLs = new Map()
+    this.memoizedPaths = new Map()
+    this.memoizedURLs = new Map()
+  }
+
+  addAnnotation() {
+    let content
+
+    if (this.isInline()) {
+      content =
+        'data:application/json;base64,' + this.toBase64(this.map.toString())
+    } else if (typeof this.mapOpts.annotation === 'string') {
+      content = this.mapOpts.annotation
+    } else if (typeof this.mapOpts.annotation === 'function') {
+      content = this.mapOpts.annotation(this.opts.to, this.root)
+    } else {
+      content = this.outputFile() + '.map'
+    }
+    let eol = '\n'
+    if (this.css.includes('\r\n')) eol = '\r\n'
+
+    this.css += eol + '/*# sourceMappingURL=' + content + ' */'
+  }
+
+  applyPrevMaps() {
+    for (let prev of this.previous()) {
+      let from = this.toUrl(this.path(prev.file))
+      let root = prev.root || dirname(prev.file)
+      let map
+
+      if (this.mapOpts.sourcesContent === false) {
+        map = new SourceMapConsumer(prev.text)
+        if (map.sourcesContent) {
+          map.sourcesContent = null
+        }
+      } else {
+        map = prev.consumer()
+      }
+
+      this.map.applySourceMap(map, from, this.toUrl(this.path(root)))
+    }
+  }
+
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return
+
+    if (this.root) {
+      let node
+      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+        node = this.root.nodes[i]
+        if (node.type !== 'comment') continue
+        if (node.text.startsWith('# sourceMappingURL=')) {
+          this.root.removeChild(i)
+        }
+      }
+    } else if (this.css) {
+      this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, '')
+    }
+  }
+
+  generate() {
+    this.clearAnnotation()
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap()
+    } else {
+      let result = ''
+      this.stringify(this.root, i => {
+        result += i
+      })
+      return [result]
+    }
+  }
+
+  generateMap() {
+    if (this.root) {
+      this.generateString()
+    } else if (this.previous().length === 1) {
+      let prev = this.previous()[0].consumer()
+      prev.file = this.outputFile()
+      this.map = SourceMapGenerator.fromSourceMap(prev, {
+        ignoreInvalidMapping: true
+      })
+    } else {
+      this.map = new SourceMapGenerator({
+        file: this.outputFile(),
+        ignoreInvalidMapping: true
+      })
+      this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from
+          ? this.toUrl(this.path(this.opts.from))
+          : '<no source>'
+      })
+    }
+
+    if (this.isSourcesContent()) this.setSourcesContent()
+    if (this.root && this.previous().length > 0) this.applyPrevMaps()
+    if (this.isAnnotation()) this.addAnnotation()
+
+    if (this.isInline()) {
+      return [this.css]
+    } else {
+      return [this.css, this.map]
+    }
+  }
+
+  generateString() {
+    this.css = ''
+    this.map = new SourceMapGenerator({
+      file: this.outputFile(),
+      ignoreInvalidMapping: true
+    })
+
+    let line = 1
+    let column = 1
+
+    let noSource = '<no source>'
+    let mapping = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ''
+    }
+
+    let last, lines
+    this.stringify(this.root, (str, node, type) => {
+      this.css += str
+
+      if (node && type !== 'end') {
+        mapping.generated.line = line
+        mapping.generated.column = column - 1
+        if (node.source && node.source.start) {
+          mapping.source = this.sourcePath(node)
+          mapping.original.line = node.source.start.line
+          mapping.original.column = node.source.start.column - 1
+          this.map.addMapping(mapping)
+        } else {
+          mapping.source = noSource
+          mapping.original.line = 1
+          mapping.original.column = 0
+          this.map.addMapping(mapping)
+        }
+      }
+
+      lines = str.match(/\n/g)
+      if (lines) {
+        line += lines.length
+        last = str.lastIndexOf('\n')
+        column = str.length - last
+      } else {
+        column += str.length
+      }
+
+      if (node && type !== 'start') {
+        let p = node.parent || { raws: {} }
+        let childless =
+          node.type === 'decl' || (node.type === 'atrule' && !node.nodes)
+        if (!childless || node !== p.last || p.raws.semicolon) {
+          if (node.source && node.source.end) {
+            mapping.source = this.sourcePath(node)
+            mapping.original.line = node.source.end.line
+            mapping.original.column = node.source.end.column - 1
+            mapping.generated.line = line
+            mapping.generated.column = column - 2
+            this.map.addMapping(mapping)
+          } else {
+            mapping.source = noSource
+            mapping.original.line = 1
+            mapping.original.column = 0
+            mapping.generated.line = line
+            mapping.generated.column = column - 1
+            this.map.addMapping(mapping)
+          }
+        }
+      }
+    })
+  }
+
+  isAnnotation() {
+    if (this.isInline()) {
+      return true
+    }
+    if (typeof this.mapOpts.annotation !== 'undefined') {
+      return this.mapOpts.annotation
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.annotation)
+    }
+    return true
+  }
+
+  isInline() {
+    if (typeof this.mapOpts.inline !== 'undefined') {
+      return this.mapOpts.inline
+    }
+
+    let annotation = this.mapOpts.annotation
+    if (typeof annotation !== 'undefined' && annotation !== true) {
+      return false
+    }
+
+    if (this.previous().length) {
+      return this.previous().some(i => i.inline)
+    }
+    return true
+  }
+
+  isMap() {
+    if (typeof this.opts.map !== 'undefined') {
+      return !!this.opts.map
+    }
+    return this.previous().length > 0
+  }
+
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== 'undefined') {
+      return this.mapOpts.sourcesContent
+    }
+    if (this.previous().length) {
+      return this.previous().some(i => i.withContent())
+    }
+    return true
+  }
+
+  outputFile() {
+    if (this.opts.to) {
+      return this.path(this.opts.to)
+    } else if (this.opts.from) {
+      return this.path(this.opts.from)
+    } else {
+      return 'to.css'
+    }
+  }
+
+  path(file) {
+    if (this.mapOpts.absolute) return file
+    if (file.charCodeAt(0) === 60 /* `<` */) return file
+    if (/^\w+:\/\//.test(file)) return file
+    let cached = this.memoizedPaths.get(file)
+    if (cached) return cached
+
+    let from = this.opts.to ? dirname(this.opts.to) : '.'
+
+    if (typeof this.mapOpts.annotation === 'string') {
+      from = dirname(resolve(from, this.mapOpts.annotation))
+    }
+
+    let path = relative(from, file)
+    this.memoizedPaths.set(file, path)
+
+    return path
+  }
+
+  previous() {
+    if (!this.previousMaps) {
+      this.previousMaps = []
+      if (this.root) {
+        this.root.walk(node => {
+          if (node.source && node.source.input.map) {
+            let map = node.source.input.map
+            if (!this.previousMaps.includes(map)) {
+              this.previousMaps.push(map)
+            }
+          }
+        })
+      } else {
+        let input = new Input(this.originalCSS, this.opts)
+        if (input.map) this.previousMaps.push(input.map)
+      }
+    }
+
+    return this.previousMaps
+  }
+
+  setSourcesContent() {
+    let already = {}
+    if (this.root) {
+      this.root.walk(node => {
+        if (node.source) {
+          let from = node.source.input.from
+          if (from && !already[from]) {
+            already[from] = true
+            let fromUrl = this.usesFileUrls
+              ? this.toFileUrl(from)
+              : this.toUrl(this.path(from))
+            this.map.setSourceContent(fromUrl, node.source.input.css)
+          }
+        }
+      })
+    } else if (this.css) {
+      let from = this.opts.from
+        ? this.toUrl(this.path(this.opts.from))
+        : '<no source>'
+      this.map.setSourceContent(from, this.css)
+    }
+  }
+
+  sourcePath(node) {
+    if (this.mapOpts.from) {
+      return this.toUrl(this.mapOpts.from)
+    } else if (this.usesFileUrls) {
+      return this.toFileUrl(node.source.input.from)
+    } else {
+      return this.toUrl(this.path(node.source.input.from))
+    }
+  }
+
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString('base64')
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)))
+    }
+  }
+
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path)
+    if (cached) return cached
+
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString()
+      this.memoizedFileURLs.set(path, fileURL)
+
+      return fileURL
+    } else {
+      throw new Error(
+        '`map.absolute` option is not available in this PostCSS build'
+      )
+    }
+  }
+
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path)
+    if (cached) return cached
+
+    if (sep === '\\') {
+      path = path.replace(/\\/g, '/')
+    }
+
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent)
+    this.memoizedURLs.set(path, url)
+
+    return url
+  }
+}
+
+module.exports = MapGenerator
diff --git a/node_modules/postcss/lib/no-work-result.d.ts b/node_modules/postcss/lib/no-work-result.d.ts
new file mode 100644
index 0000000..8039076
--- /dev/null
+++ b/node_modules/postcss/lib/no-work-result.d.ts
@@ -0,0 +1,46 @@
+import LazyResult from './lazy-result.js'
+import { SourceMap } from './postcss.js'
+import Processor from './processor.js'
+import Result, { Message, ResultOptions } from './result.js'
+import Root from './root.js'
+import Warning from './warning.js'
+
+declare namespace NoWorkResult {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { NoWorkResult_ as default }
+}
+
+/**
+ * A Promise proxy for the result of PostCSS transformations.
+ * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root`
+ * are accessed. See the example below for details.
+ * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined.
+ *
+ * ```js
+ * const noWorkResult = postcss().process(css) // No plugins are defined.
+ *                                             // CSS is not parsed
+ * let root = noWorkResult.root // now css is parsed because we accessed the root
+ * ```
+ */
+declare class NoWorkResult_ implements LazyResult<Root> {
+  catch: Promise<Result<Root>>['catch']
+  finally: Promise<Result<Root>>['finally']
+  then: Promise<Result<Root>>['then']
+  constructor(processor: Processor, css: string, opts: ResultOptions)
+  async(): Promise<Result<Root>>
+  sync(): Result<Root>
+  toString(): string
+  warnings(): Warning[]
+  get content(): string
+  get css(): string
+  get map(): SourceMap
+  get messages(): Message[]
+  get opts(): ResultOptions
+  get processor(): Processor
+  get root(): Root
+  get [Symbol.toStringTag](): string
+}
+
+declare class NoWorkResult extends NoWorkResult_ {}
+
+export = NoWorkResult
diff --git a/node_modules/postcss/lib/no-work-result.js b/node_modules/postcss/lib/no-work-result.js
new file mode 100644
index 0000000..a84d843
--- /dev/null
+++ b/node_modules/postcss/lib/no-work-result.js
@@ -0,0 +1,138 @@
+'use strict'
+
+let MapGenerator = require('./map-generator')
+let parse = require('./parse')
+const Result = require('./result')
+let stringify = require('./stringify')
+let warnOnce = require('./warn-once')
+
+class NoWorkResult {
+  constructor(processor, css, opts) {
+    css = css.toString()
+    this.stringified = false
+
+    this._processor = processor
+    this._css = css
+    this._opts = opts
+    this._map = undefined
+    let root
+
+    let str = stringify
+    this.result = new Result(this._processor, root, this._opts)
+    this.result.css = css
+
+    let self = this
+    Object.defineProperty(this.result, 'root', {
+      get() {
+        return self.root
+      }
+    })
+
+    let map = new MapGenerator(str, root, this._opts, css)
+    if (map.isMap()) {
+      let [generatedCSS, generatedMap] = map.generate()
+      if (generatedCSS) {
+        this.result.css = generatedCSS
+      }
+      if (generatedMap) {
+        this.result.map = generatedMap
+      }
+    } else {
+      map.clearAnnotation()
+      this.result.css = map.css
+    }
+  }
+
+  async() {
+    if (this.error) return Promise.reject(this.error)
+    return Promise.resolve(this.result)
+  }
+
+  catch(onRejected) {
+    return this.async().catch(onRejected)
+  }
+
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally)
+  }
+
+  sync() {
+    if (this.error) throw this.error
+    return this.result
+  }
+
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (!('from' in this._opts)) {
+        warnOnce(
+          'Without `from` option PostCSS could generate wrong source map ' +
+            'and will not find Browserslist config. Set it to CSS file path ' +
+            'or to `undefined` to prevent this warning.'
+        )
+      }
+    }
+
+    return this.async().then(onFulfilled, onRejected)
+  }
+
+  toString() {
+    return this._css
+  }
+
+  warnings() {
+    return []
+  }
+
+  get content() {
+    return this.result.css
+  }
+
+  get css() {
+    return this.result.css
+  }
+
+  get map() {
+    return this.result.map
+  }
+
+  get messages() {
+    return []
+  }
+
+  get opts() {
+    return this.result.opts
+  }
+
+  get processor() {
+    return this.result.processor
+  }
+
+  get root() {
+    if (this._root) {
+      return this._root
+    }
+
+    let root
+    let parser = parse
+
+    try {
+      root = parser(this._css, this._opts)
+    } catch (error) {
+      this.error = error
+    }
+
+    if (this.error) {
+      throw this.error
+    } else {
+      this._root = root
+      return root
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'NoWorkResult'
+  }
+}
+
+module.exports = NoWorkResult
+NoWorkResult.default = NoWorkResult
diff --git a/node_modules/postcss/lib/node.d.ts b/node_modules/postcss/lib/node.d.ts
new file mode 100644
index 0000000..3597670
--- /dev/null
+++ b/node_modules/postcss/lib/node.d.ts
@@ -0,0 +1,541 @@
+import AtRule = require('./at-rule.js')
+
+import { AtRuleProps } from './at-rule.js'
+import Comment, { CommentProps } from './comment.js'
+import Container, { NewChild } from './container.js'
+import CssSyntaxError from './css-syntax-error.js'
+import Declaration, { DeclarationProps } from './declaration.js'
+import Document from './document.js'
+import Input from './input.js'
+import { Stringifier, Syntax } from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+import Rule, { RuleProps } from './rule.js'
+import Warning, { WarningOptions } from './warning.js'
+
+declare namespace Node {
+  export type ChildNode = AtRule.default | Comment | Declaration | Rule
+
+  export type AnyNode =
+    | AtRule.default
+    | Comment
+    | Declaration
+    | Document
+    | Root
+    | Rule
+
+  export type ChildProps =
+    | AtRuleProps
+    | CommentProps
+    | DeclarationProps
+    | RuleProps
+
+  export interface Position {
+    /**
+     * Source line in file. In contrast to `offset` it starts from 1.
+     */
+    column: number
+
+    /**
+     * Source column in file.
+     */
+    line: number
+
+    /**
+     * Source offset in file. It starts from 0.
+     */
+    offset: number
+  }
+
+  export interface Range {
+    /**
+     * End position, exclusive.
+     */
+    end: Position
+
+    /**
+     * Start position, inclusive.
+     */
+    start: Position
+  }
+
+  /**
+   * Source represents an interface for the {@link Node.source} property.
+   */
+  export interface Source {
+    /**
+     * The inclusive ending position for the source
+     * code of a node.
+     */
+    end?: Position
+
+    /**
+     * The source file from where a node has originated.
+     */
+    input: Input
+
+    /**
+     * The inclusive starting position for the source
+     * code of a node.
+     */
+    start?: Position
+  }
+
+  /**
+   * Interface represents an interface for an object received
+   * as parameter by Node class constructor.
+   */
+  export interface NodeProps {
+    source?: Source
+  }
+
+  export interface NodeErrorOptions {
+    /**
+     * An ending index inside a node's string that should be highlighted as
+     * source of error.
+     */
+    endIndex?: number
+    /**
+     * An index inside a node's string that should be highlighted as source
+     * of error.
+     */
+    index?: number
+    /**
+     * Plugin name that created this error. PostCSS will set it automatically.
+     */
+    plugin?: string
+    /**
+     * A word inside a node's string, that should be highlighted as source
+     * of error.
+     */
+    word?: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  class Node extends Node_ {}
+  export { Node as default }
+}
+
+/**
+ * It represents an abstract class that handles common
+ * methods for other CSS abstract syntax tree nodes.
+ *
+ * Any node that represents CSS selector or value should
+ * not extend the `Node` class.
+ */
+declare abstract class Node_ {
+  /**
+   * It represents parent of the current node.
+   *
+   * ```js
+   * root.nodes[0].parent === root //=> true
+   * ```
+   */
+  parent: Container | Document | undefined
+
+  /**
+   * It represents unnecessary whitespace and characters present
+   * in the css source code.
+   *
+   * Information to generate byte-to-byte equal node string as it was
+   * in the origin input.
+   *
+   * The properties of the raws object are decided by parser,
+   * the default parser uses the following properties:
+   *
+   * * `before`: the space symbols before the node. It also stores `*`
+   *   and `_` symbols before the declaration (IE hack).
+   * * `after`: the space symbols after the last child of the node
+   *   to the end of the node.
+   * * `between`: the symbols between the property and value
+   *   for declarations, selector and `{` for rules, or last parameter
+   *   and `{` for at-rules.
+   * * `semicolon`: contains true if the last child has
+   *   an (optional) semicolon.
+   * * `afterName`: the space between the at-rule name and its parameters.
+   * * `left`: the space symbols between `/*` and the comment’s text.
+   * * `right`: the space symbols between the comment’s text
+   *   and <code>*&#47;</code>.
+   * - `important`: the content of the important statement,
+   *   if it is not just `!important`.
+   *
+   * PostCSS filters out the comments inside selectors, declaration values
+   * and at-rule parameters but it stores the origin content in raws.
+   *
+   * ```js
+   * const root = postcss.parse('a {\n  color:black\n}')
+   * root.first.first.raws //=> { before: '\n  ', between: ':' }
+   * ```
+   */
+  raws: any
+
+  /**
+   * It represents information related to origin of a node and is required
+   * for generating source maps.
+   *
+   * The nodes that are created manually using the public APIs
+   * provided by PostCSS will have `source` undefined and
+   * will be absent in the source map.
+   *
+   * For this reason, the plugin developer should consider
+   * duplicating nodes as the duplicate node will have the
+   * same source as the original node by default or assign
+   * source to a node created manually.
+   *
+   * ```js
+   * decl.source.input.from //=> '/home/ai/source.css'
+   * decl.source.start      //=> { line: 10, column: 2 }
+   * decl.source.end        //=> { line: 10, column: 12 }
+   * ```
+   *
+   * ```js
+   * // Incorrect method, source not specified!
+   * const prefixed = postcss.decl({
+   *   prop: '-moz-' + decl.prop,
+   *   value: decl.value
+   * })
+   *
+   * // Correct method, source is inherited when duplicating.
+   * const prefixed = decl.clone({
+   *   prop: '-moz-' + decl.prop
+   * })
+   * ```
+   *
+   * ```js
+   * if (atrule.name === 'add-link') {
+   *   const rule = postcss.rule({
+   *     selector: 'a',
+   *     source: atrule.source
+   *   })
+   *
+   *  atrule.parent.insertBefore(atrule, rule)
+   * }
+   * ```
+   */
+  source?: Node.Source
+
+  /**
+   * It represents type of a node in
+   * an abstract syntax tree.
+   *
+   * A type of node helps in identification of a node
+   * and perform operation based on it's type.
+   *
+   * ```js
+   * const declaration = new Declaration({
+   *   prop: 'color',
+   *   value: 'black'
+   * })
+   *
+   * declaration.type //=> 'decl'
+   * ```
+   */
+  type: string
+
+  constructor(defaults?: object)
+
+  /**
+   * If this node isn't already dirty, marks it and its ancestors as such. This
+   * indicates to the LazyResult processor that the {@link Root} has been
+   * modified by the current plugin and may need to be processed again by other
+   * plugins.
+   */
+  protected markDirty(): void
+
+  /**
+   * Insert new node after current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertAfter(node, add)`.
+   *
+   * ```js
+   * decl.after('color: black')
+   * ```
+   *
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  after(
+    newNode: Node | Node.ChildProps | readonly Node[] | string | undefined
+  ): this
+
+  /**
+   * It assigns properties to an existing node instance.
+   *
+   * ```js
+   * decl.assign({ prop: 'word-wrap', value: 'break-word' })
+   * ```
+   *
+   * @param overrides New properties to override the node.
+   *
+   * @return `this` for method chaining.
+   */
+  assign(overrides: object): this
+
+  /**
+   * Insert new node before current node to current node’s parent.
+   *
+   * Just alias for `node.parent.insertBefore(node, add)`.
+   *
+   * ```js
+   * decl.before('content: ""')
+   * ```
+   *
+   * @param newNode New node.
+   * @return This node for methods chain.
+   */
+  before(
+    newNode: Node | Node.ChildProps | readonly Node[] | string | undefined
+  ): this
+
+  /**
+   * Clear the code style properties for the node and its children.
+   *
+   * ```js
+   * node.raws.before  //=> ' '
+   * node.cleanRaws()
+   * node.raws.before  //=> undefined
+   * ```
+   *
+   * @param keepBetween Keep the `raws.between` symbols.
+   */
+  cleanRaws(keepBetween?: boolean): void
+
+  /**
+   * It creates clone of an existing node, which includes all the properties
+   * and their values, that includes `raws` but not `type`.
+   *
+   * ```js
+   * decl.raws.before    //=> "\n  "
+   * const cloned = decl.clone({ prop: '-moz-' + decl.prop })
+   * cloned.raws.before  //=> "\n  "
+   * cloned.toString()   //=> -moz-transform: scale(0)
+   * ```
+   *
+   * @param overrides New properties to override in the clone.
+   *
+   * @return Duplicate of the node instance.
+   */
+  clone(overrides?: object): this
+
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * after the current node.
+   *
+   * @param overrides New properties to override in the clone.
+   * @return New node.
+   */
+  cloneAfter(overrides?: object): this
+
+  /**
+   * Shortcut to clone the node and insert the resulting cloned node
+   * before the current node.
+   *
+   * ```js
+   * decl.cloneBefore({ prop: '-moz-' + decl.prop })
+   * ```
+   *
+   * @param overrides Mew properties to override in the clone.
+   *
+   * @return New node
+   */
+  cloneBefore(overrides?: object): this
+
+  /**
+   * It creates an instance of the class `CssSyntaxError` and parameters passed
+   * to this method are assigned to the error instance.
+   *
+   * The error instance will have description for the
+   * error, original position of the node in the
+   * source, showing line and column number.
+   *
+   * If any previous map is present, it would be used
+   * to get original position of the source.
+   *
+   * The Previous Map here is referred to the source map
+   * generated by previous compilation, example: Less,
+   * Stylus and Sass.
+   *
+   * This method returns the error instance instead of
+   * throwing it.
+   *
+   * ```js
+   * if (!variables[name]) {
+   *   throw decl.error(`Unknown variable ${name}`, { word: name })
+   *   // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black
+   *   //   color: $black
+   *   // a
+   *   //          ^
+   *   //   background: white
+   * }
+   * ```
+   *
+   * @param message Description for the error instance.
+   * @param options Options for the error instance.
+   *
+   * @return Error instance is returned.
+   */
+  error(message: string, options?: Node.NodeErrorOptions): CssSyntaxError
+
+  /**
+   * Returns the next child of the node’s parent.
+   * Returns `undefined` if the current node is the last child.
+   *
+   * ```js
+   * if (comment.text === 'delete next') {
+   *   const next = comment.next()
+   *   if (next) {
+   *     next.remove()
+   *   }
+   * }
+   * ```
+   *
+   * @return Next node.
+   */
+  next(): Node.ChildNode | undefined
+
+  /**
+   * Get the position for a word or an index inside the node.
+   *
+   * @param opts Options.
+   * @return Position.
+   */
+  positionBy(opts?: Pick<WarningOptions, 'index' | 'word'>): Node.Position
+
+  /**
+   * Convert string index to line/column.
+   *
+   * @param index The symbol number in the node’s string.
+   * @return Symbol position in file.
+   */
+  positionInside(index: number): Node.Position
+
+  /**
+   * Returns the previous child of the node’s parent.
+   * Returns `undefined` if the current node is the first child.
+   *
+   * ```js
+   * const annotation = decl.prev()
+   * if (annotation.type === 'comment') {
+   *   readAnnotation(annotation.text)
+   * }
+   * ```
+   *
+   * @return Previous node.
+   */
+  prev(): Node.ChildNode | undefined
+
+  /**
+   * Get the range for a word or start and end index inside the node.
+   * The start index is inclusive; the end index is exclusive.
+   *
+   * @param opts Options.
+   * @return Range.
+   */
+  rangeBy(
+    opts?: Pick<WarningOptions, 'endIndex' | 'index' | 'word'>
+  ): Node.Range
+
+  /**
+   * Returns a `raws` value. If the node is missing
+   * the code style property (because the node was manually built or cloned),
+   * PostCSS will try to autodetect the code style property by looking
+   * at other nodes in the tree.
+   *
+   * ```js
+   * const root = postcss.parse('a { background: white }')
+   * root.nodes[0].append({ prop: 'color', value: 'black' })
+   * root.nodes[0].nodes[1].raws.before   //=> undefined
+   * root.nodes[0].nodes[1].raw('before') //=> ' '
+   * ```
+   *
+   * @param prop        Name of code style property.
+   * @param defaultType Name of default value, it can be missed
+   *                    if the value is the same as prop.
+   * @return {string} Code style value.
+   */
+  raw(prop: string, defaultType?: string): string
+
+  /**
+   * It removes the node from its parent and deletes its parent property.
+   *
+   * ```js
+   * if (decl.prop.match(/^-webkit-/)) {
+   *   decl.remove()
+   * }
+   * ```
+   *
+   * @return `this` for method chaining.
+   */
+  remove(): this
+
+  /**
+   * Inserts node(s) before the current node and removes the current node.
+   *
+   * ```js
+   * AtRule: {
+   *   mixin: atrule => {
+   *     atrule.replaceWith(mixinRules[atrule.params])
+   *   }
+   * }
+   * ```
+   *
+   * @param nodes Mode(s) to replace current one.
+   * @return Current node to methods chain.
+   */
+  replaceWith(...nodes: NewChild[]): this
+
+  /**
+   * Finds the Root instance of the node’s tree.
+   *
+   * ```js
+   * root.nodes[0].nodes[0].root() === root
+   * ```
+   *
+   * @return Root parent.
+   */
+  root(): Root
+
+  /**
+   * Fix circular links on `JSON.stringify()`.
+   *
+   * @return Cleaned object.
+   */
+  toJSON(): object
+
+  /**
+   * It compiles the node to browser readable cascading style sheets string
+   * depending on it's type.
+   *
+   * ```js
+   * new Rule({ selector: 'a' }).toString() //=> "a {}"
+   * ```
+   *
+   * @param stringifier A syntax to use in string generation.
+   * @return CSS string of this node.
+   */
+  toString(stringifier?: Stringifier | Syntax): string
+
+  /**
+   * It is a wrapper for {@link Result#warn}, providing convenient
+   * way of generating warnings.
+   *
+   * ```js
+   *   Declaration: {
+   *     bad: (decl, { result }) => {
+   *       decl.warn(result, 'Deprecated property: bad')
+   *     }
+   *   }
+   * ```
+   *
+   * @param result The `Result` instance that will receive the warning.
+   * @param message Description for the warning.
+   * @param options Options for the warning.
+   *
+   * @return `Warning` instance is returned
+   */
+  warn(result: Result, message: string, options?: WarningOptions): Warning
+}
+
+declare class Node extends Node_ {}
+
+export = Node
diff --git a/node_modules/postcss/lib/node.js b/node_modules/postcss/lib/node.js
new file mode 100644
index 0000000..88f382a
--- /dev/null
+++ b/node_modules/postcss/lib/node.js
@@ -0,0 +1,389 @@
+'use strict'
+
+let CssSyntaxError = require('./css-syntax-error')
+let Stringifier = require('./stringifier')
+let stringify = require('./stringify')
+let { isClean, my } = require('./symbols')
+
+function cloneNode(obj, parent) {
+  let cloned = new obj.constructor()
+
+  for (let i in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
+      /* c8 ignore next 2 */
+      continue
+    }
+    if (i === 'proxyCache') continue
+    let value = obj[i]
+    let type = typeof value
+
+    if (i === 'parent' && type === 'object') {
+      if (parent) cloned[i] = parent
+    } else if (i === 'source') {
+      cloned[i] = value
+    } else if (Array.isArray(value)) {
+      cloned[i] = value.map(j => cloneNode(j, cloned))
+    } else {
+      if (type === 'object' && value !== null) value = cloneNode(value)
+      cloned[i] = value
+    }
+  }
+
+  return cloned
+}
+
+class Node {
+  constructor(defaults = {}) {
+    this.raws = {}
+    this[isClean] = false
+    this[my] = true
+
+    for (let name in defaults) {
+      if (name === 'nodes') {
+        this.nodes = []
+        for (let node of defaults[name]) {
+          if (typeof node.clone === 'function') {
+            this.append(node.clone())
+          } else {
+            this.append(node)
+          }
+        }
+      } else {
+        this[name] = defaults[name]
+      }
+    }
+  }
+
+  addToError(error) {
+    error.postcssNode = this
+    if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+      let s = this.source
+      error.stack = error.stack.replace(
+        /\n\s{4}at /,
+        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`
+      )
+    }
+    return error
+  }
+
+  after(add) {
+    this.parent.insertAfter(this, add)
+    return this
+  }
+
+  assign(overrides = {}) {
+    for (let name in overrides) {
+      this[name] = overrides[name]
+    }
+    return this
+  }
+
+  before(add) {
+    this.parent.insertBefore(this, add)
+    return this
+  }
+
+  cleanRaws(keepBetween) {
+    delete this.raws.before
+    delete this.raws.after
+    if (!keepBetween) delete this.raws.between
+  }
+
+  clone(overrides = {}) {
+    let cloned = cloneNode(this)
+    for (let name in overrides) {
+      cloned[name] = overrides[name]
+    }
+    return cloned
+  }
+
+  cloneAfter(overrides = {}) {
+    let cloned = this.clone(overrides)
+    this.parent.insertAfter(this, cloned)
+    return cloned
+  }
+
+  cloneBefore(overrides = {}) {
+    let cloned = this.clone(overrides)
+    this.parent.insertBefore(this, cloned)
+    return cloned
+  }
+
+  error(message, opts = {}) {
+    if (this.source) {
+      let { end, start } = this.rangeBy(opts)
+      return this.source.input.error(
+        message,
+        { column: start.column, line: start.line },
+        { column: end.column, line: end.line },
+        opts
+      )
+    }
+    return new CssSyntaxError(message)
+  }
+
+  getProxyProcessor() {
+    return {
+      get(node, prop) {
+        if (prop === 'proxyOf') {
+          return node
+        } else if (prop === 'root') {
+          return () => node.root().toProxy()
+        } else {
+          return node[prop]
+        }
+      },
+
+      set(node, prop, value) {
+        if (node[prop] === value) return true
+        node[prop] = value
+        if (
+          prop === 'prop' ||
+          prop === 'value' ||
+          prop === 'name' ||
+          prop === 'params' ||
+          prop === 'important' ||
+          /* c8 ignore next */
+          prop === 'text'
+        ) {
+          node.markDirty()
+        }
+        return true
+      }
+    }
+  }
+
+  /* c8 ignore next 3 */
+  markClean() {
+    this[isClean] = true
+  }
+
+  markDirty() {
+    if (this[isClean]) {
+      this[isClean] = false
+      let next = this
+      while ((next = next.parent)) {
+        next[isClean] = false
+      }
+    }
+  }
+
+  next() {
+    if (!this.parent) return undefined
+    let index = this.parent.index(this)
+    return this.parent.nodes[index + 1]
+  }
+
+  positionBy(opts, stringRepresentation) {
+    let pos = this.source.start
+    if (opts.index) {
+      pos = this.positionInside(opts.index, stringRepresentation)
+    } else if (opts.word) {
+      stringRepresentation = this.toString()
+      let index = stringRepresentation.indexOf(opts.word)
+      if (index !== -1) pos = this.positionInside(index, stringRepresentation)
+    }
+    return pos
+  }
+
+  positionInside(index, stringRepresentation) {
+    let string = stringRepresentation || this.toString()
+    let column = this.source.start.column
+    let line = this.source.start.line
+
+    for (let i = 0; i < index; i++) {
+      if (string[i] === '\n') {
+        column = 1
+        line += 1
+      } else {
+        column += 1
+      }
+    }
+
+    return { column, line }
+  }
+
+  prev() {
+    if (!this.parent) return undefined
+    let index = this.parent.index(this)
+    return this.parent.nodes[index - 1]
+  }
+
+  rangeBy(opts) {
+    let start = {
+      column: this.source.start.column,
+      line: this.source.start.line
+    }
+    let end = this.source.end
+      ? {
+          column: this.source.end.column + 1,
+          line: this.source.end.line
+        }
+      : {
+          column: start.column + 1,
+          line: start.line
+        }
+
+    if (opts.word) {
+      let stringRepresentation = this.toString()
+      let index = stringRepresentation.indexOf(opts.word)
+      if (index !== -1) {
+        start = this.positionInside(index, stringRepresentation)
+        end = this.positionInside(
+          index + opts.word.length,
+          stringRepresentation
+        )
+      }
+    } else {
+      if (opts.start) {
+        start = {
+          column: opts.start.column,
+          line: opts.start.line
+        }
+      } else if (opts.index) {
+        start = this.positionInside(opts.index)
+      }
+
+      if (opts.end) {
+        end = {
+          column: opts.end.column,
+          line: opts.end.line
+        }
+      } else if (typeof opts.endIndex === 'number') {
+        end = this.positionInside(opts.endIndex)
+      } else if (opts.index) {
+        end = this.positionInside(opts.index + 1)
+      }
+    }
+
+    if (
+      end.line < start.line ||
+      (end.line === start.line && end.column <= start.column)
+    ) {
+      end = { column: start.column + 1, line: start.line }
+    }
+
+    return { end, start }
+  }
+
+  raw(prop, defaultType) {
+    let str = new Stringifier()
+    return str.raw(this, prop, defaultType)
+  }
+
+  remove() {
+    if (this.parent) {
+      this.parent.removeChild(this)
+    }
+    this.parent = undefined
+    return this
+  }
+
+  replaceWith(...nodes) {
+    if (this.parent) {
+      let bookmark = this
+      let foundSelf = false
+      for (let node of nodes) {
+        if (node === this) {
+          foundSelf = true
+        } else if (foundSelf) {
+          this.parent.insertAfter(bookmark, node)
+          bookmark = node
+        } else {
+          this.parent.insertBefore(bookmark, node)
+        }
+      }
+
+      if (!foundSelf) {
+        this.remove()
+      }
+    }
+
+    return this
+  }
+
+  root() {
+    let result = this
+    while (result.parent && result.parent.type !== 'document') {
+      result = result.parent
+    }
+    return result
+  }
+
+  toJSON(_, inputs) {
+    let fixed = {}
+    let emitInputs = inputs == null
+    inputs = inputs || new Map()
+    let inputsNextIndex = 0
+
+    for (let name in this) {
+      if (!Object.prototype.hasOwnProperty.call(this, name)) {
+        /* c8 ignore next 2 */
+        continue
+      }
+      if (name === 'parent' || name === 'proxyCache') continue
+      let value = this[name]
+
+      if (Array.isArray(value)) {
+        fixed[name] = value.map(i => {
+          if (typeof i === 'object' && i.toJSON) {
+            return i.toJSON(null, inputs)
+          } else {
+            return i
+          }
+        })
+      } else if (typeof value === 'object' && value.toJSON) {
+        fixed[name] = value.toJSON(null, inputs)
+      } else if (name === 'source') {
+        let inputId = inputs.get(value.input)
+        if (inputId == null) {
+          inputId = inputsNextIndex
+          inputs.set(value.input, inputsNextIndex)
+          inputsNextIndex++
+        }
+        fixed[name] = {
+          end: value.end,
+          inputId,
+          start: value.start
+        }
+      } else {
+        fixed[name] = value
+      }
+    }
+
+    if (emitInputs) {
+      fixed.inputs = [...inputs.keys()].map(input => input.toJSON())
+    }
+
+    return fixed
+  }
+
+  toProxy() {
+    if (!this.proxyCache) {
+      this.proxyCache = new Proxy(this, this.getProxyProcessor())
+    }
+    return this.proxyCache
+  }
+
+  toString(stringifier = stringify) {
+    if (stringifier.stringify) stringifier = stringifier.stringify
+    let result = ''
+    stringifier(this, i => {
+      result += i
+    })
+    return result
+  }
+
+  warn(result, text, opts) {
+    let data = { node: this }
+    for (let i in opts) data[i] = opts[i]
+    return result.warn(text, data)
+  }
+
+  get proxyOf() {
+    return this
+  }
+}
+
+module.exports = Node
+Node.default = Node
diff --git a/node_modules/postcss/lib/parse.d.ts b/node_modules/postcss/lib/parse.d.ts
new file mode 100644
index 0000000..4c943a4
--- /dev/null
+++ b/node_modules/postcss/lib/parse.d.ts
@@ -0,0 +1,9 @@
+import { Parser } from './postcss.js'
+
+interface Parse extends Parser {
+  default: Parse
+}
+
+declare const parse: Parse
+
+export = parse
diff --git a/node_modules/postcss/lib/parse.js b/node_modules/postcss/lib/parse.js
new file mode 100644
index 0000000..00a1037
--- /dev/null
+++ b/node_modules/postcss/lib/parse.js
@@ -0,0 +1,42 @@
+'use strict'
+
+let Container = require('./container')
+let Input = require('./input')
+let Parser = require('./parser')
+
+function parse(css, opts) {
+  let input = new Input(css, opts)
+  let parser = new Parser(input)
+  try {
+    parser.parse()
+  } catch (e) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (e.name === 'CssSyntaxError' && opts && opts.from) {
+        if (/\.scss$/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse SCSS with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-scss parser'
+        } else if (/\.sass/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse Sass with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-sass parser'
+        } else if (/\.less$/i.test(opts.from)) {
+          e.message +=
+            '\nYou tried to parse Less with ' +
+            'the standard CSS parser; ' +
+            'try again with the postcss-less parser'
+        }
+      }
+    }
+    throw e
+  }
+
+  return parser.root
+}
+
+module.exports = parse
+parse.default = parse
+
+Container.registerParse(parse)
diff --git a/node_modules/postcss/lib/parser.js b/node_modules/postcss/lib/parser.js
new file mode 100644
index 0000000..8a04411
--- /dev/null
+++ b/node_modules/postcss/lib/parser.js
@@ -0,0 +1,609 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Declaration = require('./declaration')
+let Root = require('./root')
+let Rule = require('./rule')
+let tokenizer = require('./tokenize')
+
+const SAFE_COMMENT_NEIGHBOR = {
+  empty: true,
+  space: true
+}
+
+function findLastWithPosition(tokens) {
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    let token = tokens[i]
+    let pos = token[3] || token[2]
+    if (pos) return pos
+  }
+}
+
+class Parser {
+  constructor(input) {
+    this.input = input
+
+    this.root = new Root()
+    this.current = this.root
+    this.spaces = ''
+    this.semicolon = false
+
+    this.createTokenizer()
+    this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }
+  }
+
+  atrule(token) {
+    let node = new AtRule()
+    node.name = token[1].slice(1)
+    if (node.name === '') {
+      this.unnamedAtrule(node, token)
+    }
+    this.init(node, token[2])
+
+    let type
+    let prev
+    let shift
+    let last = false
+    let open = false
+    let params = []
+    let brackets = []
+
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken()
+      type = token[0]
+
+      if (type === '(' || type === '[') {
+        brackets.push(type === '(' ? ')' : ']')
+      } else if (type === '{' && brackets.length > 0) {
+        brackets.push('}')
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop()
+      }
+
+      if (brackets.length === 0) {
+        if (type === ';') {
+          node.source.end = this.getPosition(token[2])
+          node.source.end.offset++
+          this.semicolon = true
+          break
+        } else if (type === '{') {
+          open = true
+          break
+        } else if (type === '}') {
+          if (params.length > 0) {
+            shift = params.length - 1
+            prev = params[shift]
+            while (prev && prev[0] === 'space') {
+              prev = params[--shift]
+            }
+            if (prev) {
+              node.source.end = this.getPosition(prev[3] || prev[2])
+              node.source.end.offset++
+            }
+          }
+          this.end(token)
+          break
+        } else {
+          params.push(token)
+        }
+      } else {
+        params.push(token)
+      }
+
+      if (this.tokenizer.endOfFile()) {
+        last = true
+        break
+      }
+    }
+
+    node.raws.between = this.spacesAndCommentsFromEnd(params)
+    if (params.length) {
+      node.raws.afterName = this.spacesAndCommentsFromStart(params)
+      this.raw(node, 'params', params)
+      if (last) {
+        token = params[params.length - 1]
+        node.source.end = this.getPosition(token[3] || token[2])
+        node.source.end.offset++
+        this.spaces = node.raws.between
+        node.raws.between = ''
+      }
+    } else {
+      node.raws.afterName = ''
+      node.params = ''
+    }
+
+    if (open) {
+      node.nodes = []
+      this.current = node
+    }
+  }
+
+  checkMissedSemicolon(tokens) {
+    let colon = this.colon(tokens)
+    if (colon === false) return
+
+    let founded = 0
+    let token
+    for (let j = colon - 1; j >= 0; j--) {
+      token = tokens[j]
+      if (token[0] !== 'space') {
+        founded += 1
+        if (founded === 2) break
+      }
+    }
+    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
+    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
+    // And because we need it after that one we do +1 to get the next one.
+    throw this.input.error(
+      'Missed semicolon',
+      token[0] === 'word' ? token[3] + 1 : token[2]
+    )
+  }
+
+  colon(tokens) {
+    let brackets = 0
+    let prev, token, type
+    for (let [i, element] of tokens.entries()) {
+      token = element
+      type = token[0]
+
+      if (type === '(') {
+        brackets += 1
+      }
+      if (type === ')') {
+        brackets -= 1
+      }
+      if (brackets === 0 && type === ':') {
+        if (!prev) {
+          this.doubleColon(token)
+        } else if (prev[0] === 'word' && prev[1] === 'progid') {
+          continue
+        } else {
+          return i
+        }
+      }
+
+      prev = token
+    }
+    return false
+  }
+
+  comment(token) {
+    let node = new Comment()
+    this.init(node, token[2])
+    node.source.end = this.getPosition(token[3] || token[2])
+    node.source.end.offset++
+
+    let text = token[1].slice(2, -2)
+    if (/^\s*$/.test(text)) {
+      node.text = ''
+      node.raws.left = text
+      node.raws.right = ''
+    } else {
+      let match = text.match(/^(\s*)([^]*\S)(\s*)$/)
+      node.text = match[2]
+      node.raws.left = match[1]
+      node.raws.right = match[3]
+    }
+  }
+
+  createTokenizer() {
+    this.tokenizer = tokenizer(this.input)
+  }
+
+  decl(tokens, customProperty) {
+    let node = new Declaration()
+    this.init(node, tokens[0][2])
+
+    let last = tokens[tokens.length - 1]
+    if (last[0] === ';') {
+      this.semicolon = true
+      tokens.pop()
+    }
+
+    node.source.end = this.getPosition(
+      last[3] || last[2] || findLastWithPosition(tokens)
+    )
+    node.source.end.offset++
+
+    while (tokens[0][0] !== 'word') {
+      if (tokens.length === 1) this.unknownWord(tokens)
+      node.raws.before += tokens.shift()[1]
+    }
+    node.source.start = this.getPosition(tokens[0][2])
+
+    node.prop = ''
+    while (tokens.length) {
+      let type = tokens[0][0]
+      if (type === ':' || type === 'space' || type === 'comment') {
+        break
+      }
+      node.prop += tokens.shift()[1]
+    }
+
+    node.raws.between = ''
+
+    let token
+    while (tokens.length) {
+      token = tokens.shift()
+
+      if (token[0] === ':') {
+        node.raws.between += token[1]
+        break
+      } else {
+        if (token[0] === 'word' && /\w/.test(token[1])) {
+          this.unknownWord([token])
+        }
+        node.raws.between += token[1]
+      }
+    }
+
+    if (node.prop[0] === '_' || node.prop[0] === '*') {
+      node.raws.before += node.prop[0]
+      node.prop = node.prop.slice(1)
+    }
+
+    let firstSpaces = []
+    let next
+    while (tokens.length) {
+      next = tokens[0][0]
+      if (next !== 'space' && next !== 'comment') break
+      firstSpaces.push(tokens.shift())
+    }
+
+    this.precheckMissedSemicolon(tokens)
+
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      token = tokens[i]
+      if (token[1].toLowerCase() === '!important') {
+        node.important = true
+        let string = this.stringFrom(tokens, i)
+        string = this.spacesFromEnd(tokens) + string
+        if (string !== ' !important') node.raws.important = string
+        break
+      } else if (token[1].toLowerCase() === 'important') {
+        let cache = tokens.slice(0)
+        let str = ''
+        for (let j = i; j > 0; j--) {
+          let type = cache[j][0]
+          if (str.trim().startsWith('!') && type !== 'space') {
+            break
+          }
+          str = cache.pop()[1] + str
+        }
+        if (str.trim().startsWith('!')) {
+          node.important = true
+          node.raws.important = str
+          tokens = cache
+        }
+      }
+
+      if (token[0] !== 'space' && token[0] !== 'comment') {
+        break
+      }
+    }
+
+    let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')
+
+    if (hasWord) {
+      node.raws.between += firstSpaces.map(i => i[1]).join('')
+      firstSpaces = []
+    }
+    this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)
+
+    if (node.value.includes(':') && !customProperty) {
+      this.checkMissedSemicolon(tokens)
+    }
+  }
+
+  doubleColon(token) {
+    throw this.input.error(
+      'Double colon',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
+  }
+
+  emptyRule(token) {
+    let node = new Rule()
+    this.init(node, token[2])
+    node.selector = ''
+    node.raws.between = ''
+    this.current = node
+  }
+
+  end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon
+    }
+    this.semicolon = false
+
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces
+    this.spaces = ''
+
+    if (this.current.parent) {
+      this.current.source.end = this.getPosition(token[2])
+      this.current.source.end.offset++
+      this.current = this.current.parent
+    } else {
+      this.unexpectedClose(token)
+    }
+  }
+
+  endFile() {
+    if (this.current.parent) this.unclosedBlock()
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon
+    }
+    this.current.raws.after = (this.current.raws.after || '') + this.spaces
+    this.root.source.end = this.getPosition(this.tokenizer.position())
+  }
+
+  freeSemicolon(token) {
+    this.spaces += token[1]
+    if (this.current.nodes) {
+      let prev = this.current.nodes[this.current.nodes.length - 1]
+      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
+        prev.raws.ownSemicolon = this.spaces
+        this.spaces = ''
+      }
+    }
+  }
+
+  // Helpers
+
+  getPosition(offset) {
+    let pos = this.input.fromOffset(offset)
+    return {
+      column: pos.col,
+      line: pos.line,
+      offset
+    }
+  }
+
+  init(node, offset) {
+    this.current.push(node)
+    node.source = {
+      input: this.input,
+      start: this.getPosition(offset)
+    }
+    node.raws.before = this.spaces
+    this.spaces = ''
+    if (node.type !== 'comment') this.semicolon = false
+  }
+
+  other(start) {
+    let end = false
+    let type = null
+    let colon = false
+    let bracket = null
+    let brackets = []
+    let customProperty = start[1].startsWith('--')
+
+    let tokens = []
+    let token = start
+    while (token) {
+      type = token[0]
+      tokens.push(token)
+
+      if (type === '(' || type === '[') {
+        if (!bracket) bracket = token
+        brackets.push(type === '(' ? ')' : ']')
+      } else if (customProperty && colon && type === '{') {
+        if (!bracket) bracket = token
+        brackets.push('}')
+      } else if (brackets.length === 0) {
+        if (type === ';') {
+          if (colon) {
+            this.decl(tokens, customProperty)
+            return
+          } else {
+            break
+          }
+        } else if (type === '{') {
+          this.rule(tokens)
+          return
+        } else if (type === '}') {
+          this.tokenizer.back(tokens.pop())
+          end = true
+          break
+        } else if (type === ':') {
+          colon = true
+        }
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop()
+        if (brackets.length === 0) bracket = null
+      }
+
+      token = this.tokenizer.nextToken()
+    }
+
+    if (this.tokenizer.endOfFile()) end = true
+    if (brackets.length > 0) this.unclosedBracket(bracket)
+
+    if (end && colon) {
+      if (!customProperty) {
+        while (tokens.length) {
+          token = tokens[tokens.length - 1][0]
+          if (token !== 'space' && token !== 'comment') break
+          this.tokenizer.back(tokens.pop())
+        }
+      }
+      this.decl(tokens, customProperty)
+    } else {
+      this.unknownWord(tokens)
+    }
+  }
+
+  parse() {
+    let token
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken()
+
+      switch (token[0]) {
+        case 'space':
+          this.spaces += token[1]
+          break
+
+        case ';':
+          this.freeSemicolon(token)
+          break
+
+        case '}':
+          this.end(token)
+          break
+
+        case 'comment':
+          this.comment(token)
+          break
+
+        case 'at-word':
+          this.atrule(token)
+          break
+
+        case '{':
+          this.emptyRule(token)
+          break
+
+        default:
+          this.other(token)
+          break
+      }
+    }
+    this.endFile()
+  }
+
+  precheckMissedSemicolon(/* tokens */) {
+    // Hook for Safe Parser
+  }
+
+  raw(node, prop, tokens, customProperty) {
+    let token, type
+    let length = tokens.length
+    let value = ''
+    let clean = true
+    let next, prev
+
+    for (let i = 0; i < length; i += 1) {
+      token = tokens[i]
+      type = token[0]
+      if (type === 'space' && i === length - 1 && !customProperty) {
+        clean = false
+      } else if (type === 'comment') {
+        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'
+        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'
+        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
+          if (value.slice(-1) === ',') {
+            clean = false
+          } else {
+            value += token[1]
+          }
+        } else {
+          clean = false
+        }
+      } else {
+        value += token[1]
+      }
+    }
+    if (!clean) {
+      let raw = tokens.reduce((all, i) => all + i[1], '')
+      node.raws[prop] = { raw, value }
+    }
+    node[prop] = value
+  }
+
+  rule(tokens) {
+    tokens.pop()
+
+    let node = new Rule()
+    this.init(node, tokens[0][2])
+
+    node.raws.between = this.spacesAndCommentsFromEnd(tokens)
+    this.raw(node, 'selector', tokens)
+    this.current = node
+  }
+
+  spacesAndCommentsFromEnd(tokens) {
+    let lastTokenType
+    let spaces = ''
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0]
+      if (lastTokenType !== 'space' && lastTokenType !== 'comment') break
+      spaces = tokens.pop()[1] + spaces
+    }
+    return spaces
+  }
+
+  // Errors
+
+  spacesAndCommentsFromStart(tokens) {
+    let next
+    let spaces = ''
+    while (tokens.length) {
+      next = tokens[0][0]
+      if (next !== 'space' && next !== 'comment') break
+      spaces += tokens.shift()[1]
+    }
+    return spaces
+  }
+
+  spacesFromEnd(tokens) {
+    let lastTokenType
+    let spaces = ''
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0]
+      if (lastTokenType !== 'space') break
+      spaces = tokens.pop()[1] + spaces
+    }
+    return spaces
+  }
+
+  stringFrom(tokens, from) {
+    let result = ''
+    for (let i = from; i < tokens.length; i++) {
+      result += tokens[i][1]
+    }
+    tokens.splice(from, tokens.length - from)
+    return result
+  }
+
+  unclosedBlock() {
+    let pos = this.current.source.start
+    throw this.input.error('Unclosed block', pos.line, pos.column)
+  }
+
+  unclosedBracket(bracket) {
+    throw this.input.error(
+      'Unclosed bracket',
+      { offset: bracket[2] },
+      { offset: bracket[2] + 1 }
+    )
+  }
+
+  unexpectedClose(token) {
+    throw this.input.error(
+      'Unexpected }',
+      { offset: token[2] },
+      { offset: token[2] + 1 }
+    )
+  }
+
+  unknownWord(tokens) {
+    throw this.input.error(
+      'Unknown word',
+      { offset: tokens[0][2] },
+      { offset: tokens[0][2] + tokens[0][1].length }
+    )
+  }
+
+  unnamedAtrule(node, token) {
+    throw this.input.error(
+      'At-rule without name',
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    )
+  }
+}
+
+module.exports = Parser
diff --git a/node_modules/postcss/lib/postcss.d.mts b/node_modules/postcss/lib/postcss.d.mts
new file mode 100644
index 0000000..4cf5b49
--- /dev/null
+++ b/node_modules/postcss/lib/postcss.d.mts
@@ -0,0 +1,69 @@
+export {
+  // postcss function / namespace
+  default,
+
+  // Value exports from postcss.mjs
+  stringify,
+  fromJSON,
+  // @ts-expect-error This value exists, but it’s untyped.
+  plugin,
+  parse,
+  list,
+  document,
+  comment,
+  atRule,
+  rule,
+  decl,
+  root,
+  CssSyntaxError,
+  Declaration,
+  Container,
+  Processor,
+  Document,
+  Comment,
+  Warning,
+  AtRule,
+  Result,
+  Input,
+  Rule,
+  Root,
+  Node,
+
+  // Type-only exports
+  AcceptedPlugin,
+  AnyNode,
+  AtRuleProps,
+  Builder,
+  ChildNode,
+  ChildProps,
+  CommentProps,
+  ContainerProps,
+  DeclarationProps,
+  DocumentProps,
+  FilePosition,
+  Helpers,
+  JSONHydrator,
+  Message,
+  NodeErrorOptions,
+  NodeProps,
+  OldPlugin,
+  Parser,
+  Plugin,
+  PluginCreator,
+  Position,
+  Postcss,
+  ProcessOptions,
+  RootProps,
+  RuleProps,
+  Source,
+  SourceMap,
+  SourceMapOptions,
+  Stringifier,
+  Syntax,
+  TransformCallback,
+  Transformer,
+  WarningOptions,
+
+  // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here.
+  type LazyResult
+} from './postcss.js'
diff --git a/node_modules/postcss/lib/postcss.d.ts b/node_modules/postcss/lib/postcss.d.ts
new file mode 100644
index 0000000..d0b8b53
--- /dev/null
+++ b/node_modules/postcss/lib/postcss.d.ts
@@ -0,0 +1,453 @@
+import { RawSourceMap, SourceMapGenerator } from 'source-map-js'
+
+import AtRule, { AtRuleProps } from './at-rule.js'
+import Comment, { CommentProps } from './comment.js'
+import Container, { ContainerProps, NewChild } from './container.js'
+import CssSyntaxError from './css-syntax-error.js'
+import Declaration, { DeclarationProps } from './declaration.js'
+import Document, { DocumentProps } from './document.js'
+import Input, { FilePosition } from './input.js'
+import LazyResult from './lazy-result.js'
+import list from './list.js'
+import Node, {
+  AnyNode,
+  ChildNode,
+  ChildProps,
+  NodeErrorOptions,
+  NodeProps,
+  Position,
+  Source
+} from './node.js'
+import Processor from './processor.js'
+import Result, { Message } from './result.js'
+import Root, { RootProps } from './root.js'
+import Rule, { RuleProps } from './rule.js'
+import Warning, { WarningOptions } from './warning.js'
+
+type DocumentProcessor = (
+  document: Document,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type RootProcessor = (
+  root: Root,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type DeclarationProcessor = (
+  decl: Declaration,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type RuleProcessor = (
+  rule: Rule,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type AtRuleProcessor = (
+  atRule: AtRule,
+  helper: postcss.Helpers
+) => Promise<void> | void
+type CommentProcessor = (
+  comment: Comment,
+  helper: postcss.Helpers
+) => Promise<void> | void
+
+interface Processors {
+  /**
+   * Will be called on all`AtRule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor
+
+  /**
+   * Will be called on all `AtRule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  AtRuleExit?: { [name: string]: AtRuleProcessor } | AtRuleProcessor
+
+  /**
+   * Will be called on all `Comment` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Comment?: CommentProcessor
+
+  /**
+   * Will be called on all `Comment` nodes after listeners
+   * for `Comment` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  CommentExit?: CommentProcessor
+
+  /**
+   * Will be called on all `Declaration` nodes after listeners
+   * for `Declaration` event.
+   *
+   * Will be called again on node or children changes.
+   */
+  Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor
+
+  /**
+   * Will be called on all `Declaration` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  DeclarationExit?:
+    | { [prop: string]: DeclarationProcessor }
+    | DeclarationProcessor
+
+  /**
+   * Will be called on `Document` node.
+   *
+   * Will be called again on children changes.
+   */
+  Document?: DocumentProcessor
+
+  /**
+   * Will be called on `Document` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  DocumentExit?: DocumentProcessor
+
+  /**
+   * Will be called on `Root` node once.
+   */
+  Once?: RootProcessor
+
+  /**
+   * Will be called on `Root` node once, when all children will be processed.
+   */
+  OnceExit?: RootProcessor
+
+  /**
+   * Will be called on `Root` node.
+   *
+   * Will be called again on children changes.
+   */
+  Root?: RootProcessor
+
+  /**
+   * Will be called on `Root` node, when all children will be processed.
+   *
+   * Will be called again on children changes.
+   */
+  RootExit?: RootProcessor
+
+  /**
+   * Will be called on all `Rule` nodes.
+   *
+   * Will be called again on node or children changes.
+   */
+  Rule?: RuleProcessor
+
+  /**
+   * Will be called on all `Rule` nodes, when all children will be processed.
+   *
+   * Will be called again on node or children changes.
+   */
+  RuleExit?: RuleProcessor
+}
+
+declare namespace postcss {
+  export {
+    AnyNode,
+    AtRule,
+    AtRuleProps,
+    ChildNode,
+    ChildProps,
+    Comment,
+    CommentProps,
+    Container,
+    ContainerProps,
+    CssSyntaxError,
+    Declaration,
+    DeclarationProps,
+    Document,
+    DocumentProps,
+    FilePosition,
+    Input,
+    LazyResult,
+    list,
+    Message,
+    NewChild,
+    Node,
+    NodeErrorOptions,
+    NodeProps,
+    Position,
+    Processor,
+    Result,
+    Root,
+    RootProps,
+    Rule,
+    RuleProps,
+    Source,
+    Warning,
+    WarningOptions
+  }
+
+  export type SourceMap = {
+    toJSON(): RawSourceMap
+  } & SourceMapGenerator
+
+  export type Helpers = { postcss: Postcss; result: Result } & Postcss
+
+  export interface Plugin extends Processors {
+    postcssPlugin: string
+    prepare?: (result: Result) => Processors
+  }
+
+  export interface PluginCreator<PluginOptions> {
+    (opts?: PluginOptions): Plugin | Processor
+    postcss: true
+  }
+
+  export interface Transformer extends TransformCallback {
+    postcssPlugin: string
+    postcssVersion: string
+  }
+
+  export interface TransformCallback {
+    (root: Root, result: Result): Promise<void> | void
+  }
+
+  export interface OldPlugin<T> extends Transformer {
+    (opts?: T): Transformer
+    postcss: Transformer
+  }
+
+  export type AcceptedPlugin =
+    | {
+        postcss: Processor | TransformCallback
+      }
+    | OldPlugin<any>
+    | Plugin
+    | PluginCreator<any>
+    | Processor
+    | TransformCallback
+
+  export interface Parser<RootNode = Document | Root> {
+    (
+      css: { toString(): string } | string,
+      opts?: Pick<ProcessOptions, 'from' | 'map'>
+    ): RootNode
+  }
+
+  export interface Builder {
+    (part: string, node?: AnyNode, type?: 'end' | 'start'): void
+  }
+
+  export interface Stringifier {
+    (node: AnyNode, builder: Builder): void
+  }
+
+  export interface JSONHydrator {
+    (data: object): Node
+    (data: object[]): Node[]
+  }
+
+  export interface Syntax<RootNode = Document | Root> {
+    /**
+     * Function to generate AST by string.
+     */
+    parse?: Parser<RootNode>
+
+    /**
+     * Class to generate string by AST.
+     */
+    stringify?: Stringifier
+  }
+
+  export interface SourceMapOptions {
+    /**
+     * Use absolute path in generated source map.
+     */
+    absolute?: boolean
+
+    /**
+     * Indicates that PostCSS should add annotation comments to the CSS.
+     * By default, PostCSS will always add a comment with a path
+     * to the source map. PostCSS will not add annotations to CSS files
+     * that do not contain any comments.
+     *
+     * By default, PostCSS presumes that you want to save the source map as
+     * `opts.to + '.map'` and will use this path in the annotation comment.
+     * A different path can be set by providing a string value for annotation.
+     *
+     * If you have set `inline: true`, annotation cannot be disabled.
+     */
+    annotation?: ((file: string, root: Root) => string) | boolean | string
+
+    /**
+     * Override `from` in map’s sources.
+     */
+    from?: string
+
+    /**
+     * Indicates that the source map should be embedded in the output CSS
+     * as a Base64-encoded comment. By default, it is `true`.
+     * But if all previous maps are external, not inline, PostCSS will not embed
+     * the map even if you do not set this option.
+     *
+     * If you have an inline source map, the result.map property will be empty,
+     * as the source map will be contained within the text of `result.css`.
+     */
+    inline?: boolean
+
+    /**
+     * Source map content from a previous processing step (e.g., Sass).
+     *
+     * PostCSS will try to read the previous source map
+     * automatically (based on comments within the source CSS), but you can use
+     * this option to identify it manually.
+     *
+     * If desired, you can omit the previous map with prev: `false`.
+     */
+    prev?: ((file: string) => string) | boolean | object | string
+
+    /**
+     * Indicates that PostCSS should set the origin content (e.g., Sass source)
+     * of the source map. By default, it is true. But if all previous maps do not
+     * contain sources content, PostCSS will also leave it out even if you
+     * do not set this option.
+     */
+    sourcesContent?: boolean
+  }
+
+  export interface ProcessOptions<RootNode = Document | Root> {
+    /**
+     * The path of the CSS source file. You should always set `from`,
+     * because it is used in source map generation and syntax error messages.
+     */
+    from?: string | undefined
+
+    /**
+     * Source map options
+     */
+    map?: boolean | SourceMapOptions
+
+    /**
+     * Function to generate AST by string.
+     */
+    parser?: Parser<RootNode> | Syntax<RootNode>
+
+    /**
+     * Class to generate string by AST.
+     */
+    stringifier?: Stringifier | Syntax<RootNode>
+
+    /**
+     * Object with parse and stringify.
+     */
+    syntax?: Syntax<RootNode>
+
+    /**
+     * The path where you'll put the output CSS file. You should always set `to`
+     * to generate correct source maps.
+     */
+    to?: string
+  }
+
+  export type Postcss = typeof postcss
+
+  /**
+   * Default function to convert a node tree into a CSS string.
+   */
+  export let stringify: Stringifier
+
+  /**
+   * Parses source css and returns a new `Root` or `Document` node,
+   * which contains the source CSS nodes.
+   *
+   * ```js
+   * // Simple CSS concatenation with source map support
+   * const root1 = postcss.parse(css1, { from: file1 })
+   * const root2 = postcss.parse(css2, { from: file2 })
+   * root1.append(root2).toResult().css
+   * ```
+   */
+  export let parse: Parser<Root>
+
+  /**
+   * Rehydrate a JSON AST (from `Node#toJSON`) back into the AST classes.
+   *
+   * ```js
+   * const json = root.toJSON()
+   * // save to file, send by network, etc
+   * const root2  = postcss.fromJSON(json)
+   * ```
+   */
+  export let fromJSON: JSONHydrator
+
+  /**
+   * Creates a new `Comment` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New comment node
+   */
+  export function comment(defaults?: CommentProps): Comment
+
+  /**
+   * Creates a new `AtRule` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New at-rule node.
+   */
+  export function atRule(defaults?: AtRuleProps): AtRule
+
+  /**
+   * Creates a new `Declaration` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New declaration node.
+   */
+  export function decl(defaults?: DeclarationProps): Declaration
+
+  /**
+   * Creates a new `Rule` node.
+   *
+   * @param default Properties for the new node.
+   * @return New rule node.
+   */
+  export function rule(defaults?: RuleProps): Rule
+
+  /**
+   * Creates a new `Root` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New root node.
+   */
+  export function root(defaults?: RootProps): Root
+
+  /**
+   * Creates a new `Document` node.
+   *
+   * @param defaults Properties for the new node.
+   * @return New document node.
+   */
+  export function document(defaults?: DocumentProps): Document
+
+  export { postcss as default }
+}
+
+/**
+ * Create a new `Processor` instance that will apply `plugins`
+ * as CSS processors.
+ *
+ * ```js
+ * let postcss = require('postcss')
+ *
+ * postcss(plugins).process(css, { from, to }).then(result => {
+ *   console.log(result.css)
+ * })
+ * ```
+ *
+ * @param plugins PostCSS plugins.
+ * @return Processor to process multiple CSS.
+ */
+declare function postcss(
+  plugins?: readonly postcss.AcceptedPlugin[]
+): Processor
+declare function postcss(...plugins: postcss.AcceptedPlugin[]): Processor
+
+export = postcss
diff --git a/node_modules/postcss/lib/postcss.js b/node_modules/postcss/lib/postcss.js
new file mode 100644
index 0000000..8f0773b
--- /dev/null
+++ b/node_modules/postcss/lib/postcss.js
@@ -0,0 +1,101 @@
+'use strict'
+
+let AtRule = require('./at-rule')
+let Comment = require('./comment')
+let Container = require('./container')
+let CssSyntaxError = require('./css-syntax-error')
+let Declaration = require('./declaration')
+let Document = require('./document')
+let fromJSON = require('./fromJSON')
+let Input = require('./input')
+let LazyResult = require('./lazy-result')
+let list = require('./list')
+let Node = require('./node')
+let parse = require('./parse')
+let Processor = require('./processor')
+let Result = require('./result.js')
+let Root = require('./root')
+let Rule = require('./rule')
+let stringify = require('./stringify')
+let Warning = require('./warning')
+
+function postcss(...plugins) {
+  if (plugins.length === 1 && Array.isArray(plugins[0])) {
+    plugins = plugins[0]
+  }
+  return new Processor(plugins)
+}
+
+postcss.plugin = function plugin(name, initializer) {
+  let warningPrinted = false
+  function creator(...args) {
+    // eslint-disable-next-line no-console
+    if (console && console.warn && !warningPrinted) {
+      warningPrinted = true
+      // eslint-disable-next-line no-console
+      console.warn(
+        name +
+          ': postcss.plugin was deprecated. Migration guide:\n' +
+          'https://evilmartians.com/chronicles/postcss-8-plugin-migration'
+      )
+      if (process.env.LANG && process.env.LANG.startsWith('cn')) {
+        /* c8 ignore next 7 */
+        // eslint-disable-next-line no-console
+        console.warn(
+          name +
+            ': 里面 postcss.plugin 被弃用. 迁移指南:\n' +
+            'https://www.w3ctech.com/topic/2226'
+        )
+      }
+    }
+    let transformer = initializer(...args)
+    transformer.postcssPlugin = name
+    transformer.postcssVersion = new Processor().version
+    return transformer
+  }
+
+  let cache
+  Object.defineProperty(creator, 'postcss', {
+    get() {
+      if (!cache) cache = creator()
+      return cache
+    }
+  })
+
+  creator.process = function (css, processOpts, pluginOpts) {
+    return postcss([creator(pluginOpts)]).process(css, processOpts)
+  }
+
+  return creator
+}
+
+postcss.stringify = stringify
+postcss.parse = parse
+postcss.fromJSON = fromJSON
+postcss.list = list
+
+postcss.comment = defaults => new Comment(defaults)
+postcss.atRule = defaults => new AtRule(defaults)
+postcss.decl = defaults => new Declaration(defaults)
+postcss.rule = defaults => new Rule(defaults)
+postcss.root = defaults => new Root(defaults)
+postcss.document = defaults => new Document(defaults)
+
+postcss.CssSyntaxError = CssSyntaxError
+postcss.Declaration = Declaration
+postcss.Container = Container
+postcss.Processor = Processor
+postcss.Document = Document
+postcss.Comment = Comment
+postcss.Warning = Warning
+postcss.AtRule = AtRule
+postcss.Result = Result
+postcss.Input = Input
+postcss.Rule = Rule
+postcss.Root = Root
+postcss.Node = Node
+
+LazyResult.registerPostcss(postcss)
+
+module.exports = postcss
+postcss.default = postcss
diff --git a/node_modules/postcss/lib/postcss.mjs b/node_modules/postcss/lib/postcss.mjs
new file mode 100644
index 0000000..3507598
--- /dev/null
+++ b/node_modules/postcss/lib/postcss.mjs
@@ -0,0 +1,30 @@
+import postcss from './postcss.js'
+
+export default postcss
+
+export const stringify = postcss.stringify
+export const fromJSON = postcss.fromJSON
+export const plugin = postcss.plugin
+export const parse = postcss.parse
+export const list = postcss.list
+
+export const document = postcss.document
+export const comment = postcss.comment
+export const atRule = postcss.atRule
+export const rule = postcss.rule
+export const decl = postcss.decl
+export const root = postcss.root
+
+export const CssSyntaxError = postcss.CssSyntaxError
+export const Declaration = postcss.Declaration
+export const Container = postcss.Container
+export const Processor = postcss.Processor
+export const Document = postcss.Document
+export const Comment = postcss.Comment
+export const Warning = postcss.Warning
+export const AtRule = postcss.AtRule
+export const Result = postcss.Result
+export const Input = postcss.Input
+export const Rule = postcss.Rule
+export const Root = postcss.Root
+export const Node = postcss.Node
diff --git a/node_modules/postcss/lib/previous-map.d.ts b/node_modules/postcss/lib/previous-map.d.ts
new file mode 100644
index 0000000..23edeb5
--- /dev/null
+++ b/node_modules/postcss/lib/previous-map.d.ts
@@ -0,0 +1,81 @@
+import { SourceMapConsumer } from 'source-map-js'
+
+import { ProcessOptions } from './postcss.js'
+
+declare namespace PreviousMap {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { PreviousMap_ as default }
+}
+
+/**
+ * Source map information from input CSS.
+ * For example, source map after Sass compiler.
+ *
+ * This class will automatically find source map in input CSS or in file system
+ * near input file (according `from` option).
+ *
+ * ```js
+ * const root = parse(css, { from: 'a.sass.css' })
+ * root.input.map //=> PreviousMap
+ * ```
+ */
+declare class PreviousMap_ {
+  /**
+   * `sourceMappingURL` content.
+   */
+  annotation?: string
+
+  /**
+   * The CSS source identifier. Contains `Input#file` if the user
+   * set the `from` option, or `Input#id` if they did not.
+   */
+  file?: string
+
+  /**
+   * Was source map inlined by data-uri to input CSS.
+   */
+  inline: boolean
+
+  /**
+   * Path to source map file.
+   */
+  mapFile?: string
+
+  /**
+   * The directory with source map file, if source map is in separated file.
+   */
+  root?: string
+
+  /**
+   * Source map file content.
+   */
+  text?: string
+
+  /**
+   * @param css  Input CSS source.
+   * @param opts Process options.
+   */
+  constructor(css: string, opts?: ProcessOptions)
+
+  /**
+   * Create a instance of `SourceMapGenerator` class
+   * from the `source-map` library to work with source map information.
+   *
+   * It is lazy method, so it will create object only on first call
+   * and then it will use cache.
+   *
+   * @return Object with source map information.
+   */
+  consumer(): SourceMapConsumer
+
+  /**
+   * Does source map contains `sourcesContent` with input source text.
+   *
+   * @return Is `sourcesContent` present.
+   */
+  withContent(): boolean
+}
+
+declare class PreviousMap extends PreviousMap_ {}
+
+export = PreviousMap
diff --git a/node_modules/postcss/lib/previous-map.js b/node_modules/postcss/lib/previous-map.js
new file mode 100644
index 0000000..b123dcd
--- /dev/null
+++ b/node_modules/postcss/lib/previous-map.js
@@ -0,0 +1,144 @@
+'use strict'
+
+let { existsSync, readFileSync } = require('fs')
+let { dirname, join } = require('path')
+let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js')
+
+function fromBase64(str) {
+  if (Buffer) {
+    return Buffer.from(str, 'base64').toString()
+  } else {
+    /* c8 ignore next 2 */
+    return window.atob(str)
+  }
+}
+
+class PreviousMap {
+  constructor(css, opts) {
+    if (opts.map === false) return
+    this.loadAnnotation(css)
+    this.inline = this.startWith(this.annotation, 'data:')
+
+    let prev = opts.map ? opts.map.prev : undefined
+    let text = this.loadMap(opts.from, prev)
+    if (!this.mapFile && opts.from) {
+      this.mapFile = opts.from
+    }
+    if (this.mapFile) this.root = dirname(this.mapFile)
+    if (text) this.text = text
+  }
+
+  consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new SourceMapConsumer(this.text)
+    }
+    return this.consumerCache
+  }
+
+  decodeInline(text) {
+    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/
+    let baseUri = /^data:application\/json;base64,/
+    let charsetUri = /^data:application\/json;charset=utf-?8,/
+    let uri = /^data:application\/json,/
+
+    let uriMatch = text.match(charsetUri) || text.match(uri)
+    if (uriMatch) {
+      return decodeURIComponent(text.substr(uriMatch[0].length))
+    }
+
+    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri)
+    if (baseUriMatch) {
+      return fromBase64(text.substr(baseUriMatch[0].length))
+    }
+
+    let encoding = text.match(/data:application\/json;([^,]+),/)[1]
+    throw new Error('Unsupported source map encoding ' + encoding)
+  }
+
+  getAnnotationURL(sourceMapString) {
+    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
+  }
+
+  isMap(map) {
+    if (typeof map !== 'object') return false
+    return (
+      typeof map.mappings === 'string' ||
+      typeof map._mappings === 'string' ||
+      Array.isArray(map.sections)
+    )
+  }
+
+  loadAnnotation(css) {
+    let comments = css.match(/\/\*\s*# sourceMappingURL=/g)
+    if (!comments) return
+
+    // sourceMappingURLs from comments, strings, etc.
+    let start = css.lastIndexOf(comments.pop())
+    let end = css.indexOf('*/', start)
+
+    if (start > -1 && end > -1) {
+      // Locate the last sourceMappingURL to avoid pickin
+      this.annotation = this.getAnnotationURL(css.substring(start, end))
+    }
+  }
+
+  loadFile(path) {
+    this.root = dirname(path)
+    if (existsSync(path)) {
+      this.mapFile = path
+      return readFileSync(path, 'utf-8').toString().trim()
+    }
+  }
+
+  loadMap(file, prev) {
+    if (prev === false) return false
+
+    if (prev) {
+      if (typeof prev === 'string') {
+        return prev
+      } else if (typeof prev === 'function') {
+        let prevPath = prev(file)
+        if (prevPath) {
+          let map = this.loadFile(prevPath)
+          if (!map) {
+            throw new Error(
+              'Unable to load previous source map: ' + prevPath.toString()
+            )
+          }
+          return map
+        }
+      } else if (prev instanceof SourceMapConsumer) {
+        return SourceMapGenerator.fromSourceMap(prev).toString()
+      } else if (prev instanceof SourceMapGenerator) {
+        return prev.toString()
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev)
+      } else {
+        throw new Error(
+          'Unsupported previous source map format: ' + prev.toString()
+        )
+      }
+    } else if (this.inline) {
+      return this.decodeInline(this.annotation)
+    } else if (this.annotation) {
+      let map = this.annotation
+      if (file) map = join(dirname(file), map)
+      return this.loadFile(map)
+    }
+  }
+
+  startWith(string, start) {
+    if (!string) return false
+    return string.substr(0, start.length) === start
+  }
+
+  withContent() {
+    return !!(
+      this.consumer().sourcesContent &&
+      this.consumer().sourcesContent.length > 0
+    )
+  }
+}
+
+module.exports = PreviousMap
+PreviousMap.default = PreviousMap
diff --git a/node_modules/postcss/lib/processor.d.ts b/node_modules/postcss/lib/processor.d.ts
new file mode 100644
index 0000000..aa2942c
--- /dev/null
+++ b/node_modules/postcss/lib/processor.d.ts
@@ -0,0 +1,115 @@
+import Document from './document.js'
+import LazyResult from './lazy-result.js'
+import NoWorkResult from './no-work-result.js'
+import {
+  AcceptedPlugin,
+  Plugin,
+  ProcessOptions,
+  TransformCallback,
+  Transformer
+} from './postcss.js'
+import Result from './result.js'
+import Root from './root.js'
+
+declare namespace Processor {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Processor_ as default }
+}
+
+/**
+ * Contains plugins to process CSS. Create one `Processor` instance,
+ * initialize its plugins, and then use that instance on numerous CSS files.
+ *
+ * ```js
+ * const processor = postcss([autoprefixer, postcssNested])
+ * processor.process(css1).then(result => console.log(result.css))
+ * processor.process(css2).then(result => console.log(result.css))
+ * ```
+ */
+declare class Processor_ {
+  /**
+   * Plugins added to this processor.
+   *
+   * ```js
+   * const processor = postcss([autoprefixer, postcssNested])
+   * processor.plugins.length //=> 2
+   * ```
+   */
+  plugins: (Plugin | TransformCallback | Transformer)[]
+
+  /**
+   * Current PostCSS version.
+   *
+   * ```js
+   * if (result.processor.version.split('.')[0] !== '6') {
+   *   throw new Error('This plugin works only with PostCSS 6')
+   * }
+   * ```
+   */
+  version: string
+
+  /**
+   * @param plugins PostCSS plugins
+   */
+  constructor(plugins?: readonly AcceptedPlugin[])
+
+  /**
+   * Parses source CSS and returns a `LazyResult` Promise proxy.
+   * Because some plugins can be asynchronous it doesn’t make
+   * any transformations. Transformations will be applied
+   * in the `LazyResult` methods.
+   *
+   * ```js
+   * processor.process(css, { from: 'a.css', to: 'a.out.css' })
+   *   .then(result => {
+   *      console.log(result.css)
+   *   })
+   * ```
+   *
+   * @param css String with input CSS or any object with a `toString()` method,
+   *            like a Buffer. Optionally, send a `Result` instance
+   *            and the processor will take the `Root` from it.
+   * @param opts Options.
+   * @return Promise proxy.
+   */
+  process(
+    css: { toString(): string } | LazyResult | Result | Root | string
+  ): LazyResult | NoWorkResult
+  process<RootNode extends Document | Root = Root>(
+    css: { toString(): string } | LazyResult | Result | Root | string,
+    options: ProcessOptions<RootNode>
+  ): LazyResult<RootNode>
+
+  /**
+   * Adds a plugin to be used as a CSS processor.
+   *
+   * PostCSS plugin can be in 4 formats:
+   * * A plugin in `Plugin` format.
+   * * A plugin creator function with `pluginCreator.postcss = true`.
+   *   PostCSS will call this function without argument to get plugin.
+   * * A function. PostCSS will pass the function a {@link Root}
+   *   as the first argument and current `Result` instance
+   *   as the second.
+   * * Another `Processor` instance. PostCSS will copy plugins
+   *   from that instance into this one.
+   *
+   * Plugins can also be added by passing them as arguments when creating
+   * a `postcss` instance (see [`postcss(plugins)`]).
+   *
+   * Asynchronous plugins should return a `Promise` instance.
+   *
+   * ```js
+   * const processor = postcss()
+   *   .use(autoprefixer)
+   *   .use(postcssNested)
+   * ```
+   *
+   * @param plugin PostCSS plugin or `Processor` with plugins.
+   * @return Current processor to make methods chain.
+   */
+  use(plugin: AcceptedPlugin): this
+}
+
+declare class Processor extends Processor_ {}
+
+export = Processor
diff --git a/node_modules/postcss/lib/processor.js b/node_modules/postcss/lib/processor.js
new file mode 100644
index 0000000..729f725
--- /dev/null
+++ b/node_modules/postcss/lib/processor.js
@@ -0,0 +1,67 @@
+'use strict'
+
+let Document = require('./document')
+let LazyResult = require('./lazy-result')
+let NoWorkResult = require('./no-work-result')
+let Root = require('./root')
+
+class Processor {
+  constructor(plugins = []) {
+    this.version = '8.4.47'
+    this.plugins = this.normalize(plugins)
+  }
+
+  normalize(plugins) {
+    let normalized = []
+    for (let i of plugins) {
+      if (i.postcss === true) {
+        i = i()
+      } else if (i.postcss) {
+        i = i.postcss
+      }
+
+      if (typeof i === 'object' && Array.isArray(i.plugins)) {
+        normalized = normalized.concat(i.plugins)
+      } else if (typeof i === 'object' && i.postcssPlugin) {
+        normalized.push(i)
+      } else if (typeof i === 'function') {
+        normalized.push(i)
+      } else if (typeof i === 'object' && (i.parse || i.stringify)) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error(
+            'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +
+              'one of the syntax/parser/stringifier options as outlined ' +
+              'in your PostCSS runner documentation.'
+          )
+        }
+      } else {
+        throw new Error(i + ' is not a PostCSS plugin')
+      }
+    }
+    return normalized
+  }
+
+  process(css, opts = {}) {
+    if (
+      !this.plugins.length &&
+      !opts.parser &&
+      !opts.stringifier &&
+      !opts.syntax
+    ) {
+      return new NoWorkResult(this, css, opts)
+    } else {
+      return new LazyResult(this, css, opts)
+    }
+  }
+
+  use(plugin) {
+    this.plugins = this.plugins.concat(this.normalize([plugin]))
+    return this
+  }
+}
+
+module.exports = Processor
+Processor.default = Processor
+
+Root.registerProcessor(Processor)
+Document.registerProcessor(Processor)
diff --git a/node_modules/postcss/lib/result.d.ts b/node_modules/postcss/lib/result.d.ts
new file mode 100644
index 0000000..40e086f
--- /dev/null
+++ b/node_modules/postcss/lib/result.d.ts
@@ -0,0 +1,205 @@
+import {
+  Document,
+  Node,
+  Plugin,
+  ProcessOptions,
+  Root,
+  SourceMap,
+  TransformCallback,
+  Warning,
+  WarningOptions
+} from './postcss.js'
+import Processor from './processor.js'
+
+declare namespace Result {
+  export interface Message {
+    [others: string]: any
+
+    /**
+     * Source PostCSS plugin name.
+     */
+    plugin?: string
+
+    /**
+     * Message type.
+     */
+    type: string
+  }
+
+  export interface ResultOptions extends ProcessOptions {
+    /**
+     * The CSS node that was the source of the warning.
+     */
+    node?: Node
+
+    /**
+     * Name of plugin that created this warning. `Result#warn` will fill it
+     * automatically with `Plugin#postcssPlugin` value.
+     */
+    plugin?: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Result_ as default }
+}
+
+/**
+ * Provides the result of the PostCSS transformations.
+ *
+ * A Result instance is returned by `LazyResult#then`
+ * or `Root#toResult` methods.
+ *
+ * ```js
+ * postcss([autoprefixer]).process(css).then(result => {
+ *  console.log(result.css)
+ * })
+ * ```
+ *
+ * ```js
+ * const result2 = postcss.parse(css).toResult()
+ * ```
+ */
+declare class Result_<RootNode = Document | Root> {
+  /**
+   * A CSS string representing of `Result#root`.
+   *
+   * ```js
+   * postcss.parse('a{}').toResult().css //=> "a{}"
+   * ```
+   */
+  css: string
+
+  /**
+   * Last runned PostCSS plugin.
+   */
+  lastPlugin: Plugin | TransformCallback
+
+  /**
+   * An instance of `SourceMapGenerator` class from the `source-map` library,
+   * representing changes to the `Result#root` instance.
+   *
+   * ```js
+   * result.map.toJSON() //=> { version: 3, file: 'a.css', … }
+   * ```
+   *
+   * ```js
+   * if (result.map) {
+   *   fs.writeFileSync(result.opts.to + '.map', result.map.toString())
+   * }
+   * ```
+   */
+  map: SourceMap
+
+  /**
+   * Contains messages from plugins (e.g., warnings or custom messages).
+   * Each message should have type and plugin properties.
+   *
+   * ```js
+   * AtRule: {
+   *   import: (atRule, { result }) {
+   *     const importedFile = parseImport(atRule)
+   *     result.messages.push({
+   *       type: 'dependency',
+   *       plugin: 'postcss-import',
+   *       file: importedFile,
+   *       parent: result.opts.from
+   *     })
+   *   }
+   * }
+   * ```
+   */
+  messages: Result.Message[]
+
+  /**
+   * Options from the `Processor#process` or `Root#toResult` call
+   * that produced this Result instance.]
+   *
+   * ```js
+   * root.toResult(opts).opts === opts
+   * ```
+   */
+  opts: Result.ResultOptions
+
+  /**
+   * The Processor instance used for this transformation.
+   *
+   * ```js
+   * for (const plugin of result.processor.plugins) {
+   *   if (plugin.postcssPlugin === 'postcss-bad') {
+   *     throw 'postcss-good is incompatible with postcss-bad'
+   *   }
+   * })
+   * ```
+   */
+  processor: Processor
+
+  /**
+   * Root node after all transformations.
+   *
+   * ```js
+   * root.toResult().root === root
+   * ```
+   */
+  root: RootNode
+
+  /**
+   * @param processor Processor used for this transformation.
+   * @param root      Root node after all transformations.
+   * @param opts      Options from the `Processor#process` or `Root#toResult`.
+   */
+  constructor(processor: Processor, root: RootNode, opts: Result.ResultOptions)
+
+  /**
+   * Returns for `Result#css` content.
+   *
+   * ```js
+   * result + '' === result.css
+   * ```
+   *
+   * @return String representing of `Result#root`.
+   */
+  toString(): string
+
+  /**
+   * Creates an instance of `Warning` and adds it to `Result#messages`.
+   *
+   * ```js
+   * if (decl.important) {
+   *   result.warn('Avoid !important', { node: decl, word: '!important' })
+   * }
+   * ```
+   *
+   * @param text Warning message.
+   * @param opts Warning options.
+   * @return Created warning.
+   */
+  warn(message: string, options?: WarningOptions): Warning
+
+  /**
+   * Returns warnings from plugins. Filters `Warning` instances
+   * from `Result#messages`.
+   *
+   * ```js
+   * result.warnings().forEach(warn => {
+   *   console.warn(warn.toString())
+   * })
+   * ```
+   *
+   * @return Warnings from plugins.
+   */
+  warnings(): Warning[]
+
+  /**
+   * An alias for the `Result#css` property.
+   * Use it with syntaxes that generate non-CSS output.
+   *
+   * ```js
+   * result.css === result.content
+   * ```
+   */
+  get content(): string
+}
+
+declare class Result<RootNode = Document | Root> extends Result_<RootNode> {}
+
+export = Result
diff --git a/node_modules/postcss/lib/result.js b/node_modules/postcss/lib/result.js
new file mode 100644
index 0000000..a39751d
--- /dev/null
+++ b/node_modules/postcss/lib/result.js
@@ -0,0 +1,42 @@
+'use strict'
+
+let Warning = require('./warning')
+
+class Result {
+  constructor(processor, root, opts) {
+    this.processor = processor
+    this.messages = []
+    this.root = root
+    this.opts = opts
+    this.css = undefined
+    this.map = undefined
+  }
+
+  toString() {
+    return this.css
+  }
+
+  warn(text, opts = {}) {
+    if (!opts.plugin) {
+      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+        opts.plugin = this.lastPlugin.postcssPlugin
+      }
+    }
+
+    let warning = new Warning(text, opts)
+    this.messages.push(warning)
+
+    return warning
+  }
+
+  warnings() {
+    return this.messages.filter(i => i.type === 'warning')
+  }
+
+  get content() {
+    return this.css
+  }
+}
+
+module.exports = Result
+Result.default = Result
diff --git a/node_modules/postcss/lib/root.d.ts b/node_modules/postcss/lib/root.d.ts
new file mode 100644
index 0000000..5c91139
--- /dev/null
+++ b/node_modules/postcss/lib/root.d.ts
@@ -0,0 +1,87 @@
+import Container, { ContainerProps } from './container.js'
+import Document from './document.js'
+import { ProcessOptions } from './postcss.js'
+import Result from './result.js'
+
+declare namespace Root {
+  export interface RootRaws extends Record<string, any> {
+    /**
+     * The space symbols after the last child to the end of file.
+     */
+    after?: string
+
+    /**
+     * Non-CSS code after `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeAfter?: string
+
+    /**
+     * Non-CSS code before `Root`, when `Root` is inside `Document`.
+     *
+     * **Experimental:** some aspects of this node could change within minor
+     * or patch version releases.
+     */
+    codeBefore?: string
+
+    /**
+     * Is the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export interface RootProps extends ContainerProps {
+    /**
+     * Information used to generate byte-to-byte equal node string
+     * as it was in the origin input.
+     * */
+    raws?: RootRaws
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Root_ as default }
+}
+
+/**
+ * Represents a CSS file and contains all its parsed nodes.
+ *
+ * ```js
+ * const root = postcss.parse('a{color:black} b{z-index:2}')
+ * root.type         //=> 'root'
+ * root.nodes.length //=> 2
+ * ```
+ */
+declare class Root_ extends Container {
+  nodes: NonNullable<Container['nodes']>
+  parent: Document | undefined
+  raws: Root.RootRaws
+  type: 'root'
+
+  constructor(defaults?: Root.RootProps)
+
+  assign(overrides: object | Root.RootProps): this
+  clone(overrides?: Partial<Root.RootProps>): this
+  cloneAfter(overrides?: Partial<Root.RootProps>): this
+  cloneBefore(overrides?: Partial<Root.RootProps>): this
+
+  /**
+   * Returns a `Result` instance representing the root’s CSS.
+   *
+   * ```js
+   * const root1 = postcss.parse(css1, { from: 'a.css' })
+   * const root2 = postcss.parse(css2, { from: 'b.css' })
+   * root1.append(root2)
+   * const result = root1.toResult({ to: 'all.css', map: true })
+   * ```
+   *
+   * @param options Options.
+   * @return Result with current root’s CSS.
+   */
+  toResult(options?: ProcessOptions): Result
+}
+
+declare class Root extends Root_ {}
+
+export = Root
diff --git a/node_modules/postcss/lib/root.js b/node_modules/postcss/lib/root.js
new file mode 100644
index 0000000..ea574ed
--- /dev/null
+++ b/node_modules/postcss/lib/root.js
@@ -0,0 +1,61 @@
+'use strict'
+
+let Container = require('./container')
+
+let LazyResult, Processor
+
+class Root extends Container {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'root'
+    if (!this.nodes) this.nodes = []
+  }
+
+  normalize(child, sample, type) {
+    let nodes = super.normalize(child)
+
+    if (sample) {
+      if (type === 'prepend') {
+        if (this.nodes.length > 1) {
+          sample.raws.before = this.nodes[1].raws.before
+        } else {
+          delete sample.raws.before
+        }
+      } else if (this.first !== sample) {
+        for (let node of nodes) {
+          node.raws.before = sample.raws.before
+        }
+      }
+    }
+
+    return nodes
+  }
+
+  removeChild(child, ignore) {
+    let index = this.index(child)
+
+    if (!ignore && index === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index].raws.before
+    }
+
+    return super.removeChild(child)
+  }
+
+  toResult(opts = {}) {
+    let lazy = new LazyResult(new Processor(), this, opts)
+    return lazy.stringify()
+  }
+}
+
+Root.registerLazyResult = dependant => {
+  LazyResult = dependant
+}
+
+Root.registerProcessor = dependant => {
+  Processor = dependant
+}
+
+module.exports = Root
+Root.default = Root
+
+Container.registerRoot(Root)
diff --git a/node_modules/postcss/lib/rule.d.ts b/node_modules/postcss/lib/rule.d.ts
new file mode 100644
index 0000000..da8aae7
--- /dev/null
+++ b/node_modules/postcss/lib/rule.d.ts
@@ -0,0 +1,126 @@
+import Container, {
+  ContainerProps,
+  ContainerWithChildren
+} from './container.js'
+
+declare namespace Rule {
+  export interface RuleRaws extends Record<string, unknown> {
+    /**
+     * The space symbols after the last child of the node to the end of the node.
+     */
+    after?: string
+
+    /**
+     * The space symbols before the node. It also stores `*`
+     * and `_` symbols before the declaration (IE hack).
+     */
+    before?: string
+
+    /**
+     * The symbols between the selector and `{` for rules.
+     */
+    between?: string
+
+    /**
+     * Contains `true` if there is semicolon after rule.
+     */
+    ownSemicolon?: string
+
+    /**
+     * The rule’s selector with comments.
+     */
+    selector?: {
+      raw: string
+      value: string
+    }
+
+    /**
+     * Contains `true` if the last child has an (optional) semicolon.
+     */
+    semicolon?: boolean
+  }
+
+  export type RuleProps = {
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: RuleRaws
+  } & (
+      | {
+          /** Selector or selectors of the rule. */
+          selector: string
+          selectors?: never
+        }
+      | {
+          selector?: never
+          /** Selectors of the rule represented as an array of strings. */
+          selectors: readonly string[]
+        }
+    ) & ContainerProps
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Rule_ as default }
+}
+
+/**
+ * Represents a CSS rule: a selector followed by a declaration block.
+ *
+ * ```js
+ * Once (root, { Rule }) {
+ *   let a = new Rule({ selector: 'a' })
+ *   a.append(…)
+ *   root.append(a)
+ * }
+ * ```
+ *
+ * ```js
+ * const root = postcss.parse('a{}')
+ * const rule = root.first
+ * rule.type       //=> 'rule'
+ * rule.toString() //=> 'a{}'
+ * ```
+ */
+declare class Rule_ extends Container {
+  nodes: NonNullable<Container['nodes']>
+  parent: ContainerWithChildren | undefined
+  raws: Rule.RuleRaws
+  type: 'rule'
+  constructor(defaults?: Rule.RuleProps)
+
+  assign(overrides: object | Rule.RuleProps): this
+  clone(overrides?: Partial<Rule.RuleProps>): this
+
+  cloneAfter(overrides?: Partial<Rule.RuleProps>): this
+
+  cloneBefore(overrides?: Partial<Rule.RuleProps>): this
+  /**
+   * The rule’s full selector represented as a string.
+   *
+   * ```js
+   * const root = postcss.parse('a, b { }')
+   * const rule = root.first
+   * rule.selector //=> 'a, b'
+   * ```
+   */
+  get selector(): string
+  set selector(value: string)
+  /**
+   * An array containing the rule’s individual selectors.
+   * Groups of selectors are split at commas.
+   *
+   * ```js
+   * const root = postcss.parse('a, b { }')
+   * const rule = root.first
+   *
+   * rule.selector  //=> 'a, b'
+   * rule.selectors //=> ['a', 'b']
+   *
+   * rule.selectors = ['a', 'strong']
+   * rule.selector //=> 'a, strong'
+   * ```
+   */
+  get selectors(): string[]
+  set selectors(values: string[])
+}
+
+declare class Rule extends Rule_ {}
+
+export = Rule
diff --git a/node_modules/postcss/lib/rule.js b/node_modules/postcss/lib/rule.js
new file mode 100644
index 0000000..a93ab25
--- /dev/null
+++ b/node_modules/postcss/lib/rule.js
@@ -0,0 +1,27 @@
+'use strict'
+
+let Container = require('./container')
+let list = require('./list')
+
+class Rule extends Container {
+  constructor(defaults) {
+    super(defaults)
+    this.type = 'rule'
+    if (!this.nodes) this.nodes = []
+  }
+
+  get selectors() {
+    return list.comma(this.selector)
+  }
+
+  set selectors(values) {
+    let match = this.selector ? this.selector.match(/,\s*/) : null
+    let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen')
+    this.selector = values.join(sep)
+  }
+}
+
+module.exports = Rule
+Rule.default = Rule
+
+Container.registerRule(Rule)
diff --git a/node_modules/postcss/lib/stringifier.d.ts b/node_modules/postcss/lib/stringifier.d.ts
new file mode 100644
index 0000000..f707a6a
--- /dev/null
+++ b/node_modules/postcss/lib/stringifier.d.ts
@@ -0,0 +1,46 @@
+import {
+  AnyNode,
+  AtRule,
+  Builder,
+  Comment,
+  Container,
+  Declaration,
+  Document,
+  Root,
+  Rule
+} from './postcss.js'
+
+declare namespace Stringifier {
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Stringifier_ as default }
+}
+
+declare class Stringifier_ {
+  builder: Builder
+  constructor(builder: Builder)
+  atrule(node: AtRule, semicolon?: boolean): void
+  beforeAfter(node: AnyNode, detect: 'after' | 'before'): string
+  block(node: AnyNode, start: string): void
+  body(node: Container): void
+  comment(node: Comment): void
+  decl(node: Declaration, semicolon?: boolean): void
+  document(node: Document): void
+  raw(node: AnyNode, own: null | string, detect?: string): string
+  rawBeforeClose(root: Root): string | undefined
+  rawBeforeComment(root: Root, node: Comment): string | undefined
+  rawBeforeDecl(root: Root, node: Declaration): string | undefined
+  rawBeforeOpen(root: Root): string | undefined
+  rawBeforeRule(root: Root): string | undefined
+  rawColon(root: Root): string | undefined
+  rawEmptyBody(root: Root): string | undefined
+  rawIndent(root: Root): string | undefined
+  rawSemicolon(root: Root): boolean | undefined
+  rawValue(node: AnyNode, prop: string): string
+  root(node: Root): void
+  rule(node: Rule): void
+  stringify(node: AnyNode, semicolon?: boolean): void
+}
+
+declare class Stringifier extends Stringifier_ {}
+
+export = Stringifier
diff --git a/node_modules/postcss/lib/stringifier.js b/node_modules/postcss/lib/stringifier.js
new file mode 100644
index 0000000..e07ad12
--- /dev/null
+++ b/node_modules/postcss/lib/stringifier.js
@@ -0,0 +1,353 @@
+'use strict'
+
+const DEFAULT_RAW = {
+  after: '\n',
+  beforeClose: '\n',
+  beforeComment: '\n',
+  beforeDecl: '\n',
+  beforeOpen: ' ',
+  beforeRule: '\n',
+  colon: ': ',
+  commentLeft: ' ',
+  commentRight: ' ',
+  emptyBody: '',
+  indent: '    ',
+  semicolon: false
+}
+
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1)
+}
+
+class Stringifier {
+  constructor(builder) {
+    this.builder = builder
+  }
+
+  atrule(node, semicolon) {
+    let name = '@' + node.name
+    let params = node.params ? this.rawValue(node, 'params') : ''
+
+    if (typeof node.raws.afterName !== 'undefined') {
+      name += node.raws.afterName
+    } else if (params) {
+      name += ' '
+    }
+
+    if (node.nodes) {
+      this.block(node, name + params)
+    } else {
+      let end = (node.raws.between || '') + (semicolon ? ';' : '')
+      this.builder(name + params + end, node)
+    }
+  }
+
+  beforeAfter(node, detect) {
+    let value
+    if (node.type === 'decl') {
+      value = this.raw(node, null, 'beforeDecl')
+    } else if (node.type === 'comment') {
+      value = this.raw(node, null, 'beforeComment')
+    } else if (detect === 'before') {
+      value = this.raw(node, null, 'beforeRule')
+    } else {
+      value = this.raw(node, null, 'beforeClose')
+    }
+
+    let buf = node.parent
+    let depth = 0
+    while (buf && buf.type !== 'root') {
+      depth += 1
+      buf = buf.parent
+    }
+
+    if (value.includes('\n')) {
+      let indent = this.raw(node, null, 'indent')
+      if (indent.length) {
+        for (let step = 0; step < depth; step++) value += indent
+      }
+    }
+
+    return value
+  }
+
+  block(node, start) {
+    let between = this.raw(node, 'between', 'beforeOpen')
+    this.builder(start + between + '{', node, 'start')
+
+    let after
+    if (node.nodes && node.nodes.length) {
+      this.body(node)
+      after = this.raw(node, 'after')
+    } else {
+      after = this.raw(node, 'after', 'emptyBody')
+    }
+
+    if (after) this.builder(after)
+    this.builder('}', node, 'end')
+  }
+
+  body(node) {
+    let last = node.nodes.length - 1
+    while (last > 0) {
+      if (node.nodes[last].type !== 'comment') break
+      last -= 1
+    }
+
+    let semicolon = this.raw(node, 'semicolon')
+    for (let i = 0; i < node.nodes.length; i++) {
+      let child = node.nodes[i]
+      let before = this.raw(child, 'before')
+      if (before) this.builder(before)
+      this.stringify(child, last !== i || semicolon)
+    }
+  }
+
+  comment(node) {
+    let left = this.raw(node, 'left', 'commentLeft')
+    let right = this.raw(node, 'right', 'commentRight')
+    this.builder('/*' + left + node.text + right + '*/', node)
+  }
+
+  decl(node, semicolon) {
+    let between = this.raw(node, 'between', 'colon')
+    let string = node.prop + between + this.rawValue(node, 'value')
+
+    if (node.important) {
+      string += node.raws.important || ' !important'
+    }
+
+    if (semicolon) string += ';'
+    this.builder(string, node)
+  }
+
+  document(node) {
+    this.body(node)
+  }
+
+  raw(node, own, detect) {
+    let value
+    if (!detect) detect = own
+
+    // Already had
+    if (own) {
+      value = node.raws[own]
+      if (typeof value !== 'undefined') return value
+    }
+
+    let parent = node.parent
+
+    if (detect === 'before') {
+      // Hack for first rule in CSS
+      if (!parent || (parent.type === 'root' && parent.first === node)) {
+        return ''
+      }
+
+      // `root` nodes in `document` should use only their own raws
+      if (parent && parent.type === 'document') {
+        return ''
+      }
+    }
+
+    // Floating child without parent
+    if (!parent) return DEFAULT_RAW[detect]
+
+    // Detect style by other nodes
+    let root = node.root()
+    if (!root.rawCache) root.rawCache = {}
+    if (typeof root.rawCache[detect] !== 'undefined') {
+      return root.rawCache[detect]
+    }
+
+    if (detect === 'before' || detect === 'after') {
+      return this.beforeAfter(node, detect)
+    } else {
+      let method = 'raw' + capitalize(detect)
+      if (this[method]) {
+        value = this[method](root, node)
+      } else {
+        root.walk(i => {
+          value = i.raws[own]
+          if (typeof value !== 'undefined') return false
+        })
+      }
+    }
+
+    if (typeof value === 'undefined') value = DEFAULT_RAW[detect]
+
+    root.rawCache[detect] = value
+    return value
+  }
+
+  rawBeforeClose(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length > 0) {
+        if (typeof i.raws.after !== 'undefined') {
+          value = i.raws.after
+          if (value.includes('\n')) {
+            value = value.replace(/[^\n]+$/, '')
+          }
+          return false
+        }
+      }
+    })
+    if (value) value = value.replace(/\S/g, '')
+    return value
+  }
+
+  rawBeforeComment(root, node) {
+    let value
+    root.walkComments(i => {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before
+        if (value.includes('\n')) {
+          value = value.replace(/[^\n]+$/, '')
+        }
+        return false
+      }
+    })
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeDecl')
+    } else if (value) {
+      value = value.replace(/\S/g, '')
+    }
+    return value
+  }
+
+  rawBeforeDecl(root, node) {
+    let value
+    root.walkDecls(i => {
+      if (typeof i.raws.before !== 'undefined') {
+        value = i.raws.before
+        if (value.includes('\n')) {
+          value = value.replace(/[^\n]+$/, '')
+        }
+        return false
+      }
+    })
+    if (typeof value === 'undefined') {
+      value = this.raw(node, null, 'beforeRule')
+    } else if (value) {
+      value = value.replace(/\S/g, '')
+    }
+    return value
+  }
+
+  rawBeforeOpen(root) {
+    let value
+    root.walk(i => {
+      if (i.type !== 'decl') {
+        value = i.raws.between
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawBeforeRule(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && (i.parent !== root || root.first !== i)) {
+        if (typeof i.raws.before !== 'undefined') {
+          value = i.raws.before
+          if (value.includes('\n')) {
+            value = value.replace(/[^\n]+$/, '')
+          }
+          return false
+        }
+      }
+    })
+    if (value) value = value.replace(/\S/g, '')
+    return value
+  }
+
+  rawColon(root) {
+    let value
+    root.walkDecls(i => {
+      if (typeof i.raws.between !== 'undefined') {
+        value = i.raws.between.replace(/[^\s:]/g, '')
+        return false
+      }
+    })
+    return value
+  }
+
+  rawEmptyBody(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawIndent(root) {
+    if (root.raws.indent) return root.raws.indent
+    let value
+    root.walk(i => {
+      let p = i.parent
+      if (p && p !== root && p.parent && p.parent === root) {
+        if (typeof i.raws.before !== 'undefined') {
+          let parts = i.raws.before.split('\n')
+          value = parts[parts.length - 1]
+          value = value.replace(/\S/g, '')
+          return false
+        }
+      }
+    })
+    return value
+  }
+
+  rawSemicolon(root) {
+    let value
+    root.walk(i => {
+      if (i.nodes && i.nodes.length && i.last.type === 'decl') {
+        value = i.raws.semicolon
+        if (typeof value !== 'undefined') return false
+      }
+    })
+    return value
+  }
+
+  rawValue(node, prop) {
+    let value = node[prop]
+    let raw = node.raws[prop]
+    if (raw && raw.value === value) {
+      return raw.raw
+    }
+
+    return value
+  }
+
+  root(node) {
+    this.body(node)
+    if (node.raws.after) this.builder(node.raws.after)
+  }
+
+  rule(node) {
+    this.block(node, this.rawValue(node, 'selector'))
+    if (node.raws.ownSemicolon) {
+      this.builder(node.raws.ownSemicolon, node, 'end')
+    }
+  }
+
+  stringify(node, semicolon) {
+    /* c8 ignore start */
+    if (!this[node.type]) {
+      throw new Error(
+        'Unknown AST node type ' +
+          node.type +
+          '. ' +
+          'Maybe you need to change PostCSS stringifier.'
+      )
+    }
+    /* c8 ignore stop */
+    this[node.type](node, semicolon)
+  }
+}
+
+module.exports = Stringifier
+Stringifier.default = Stringifier
diff --git a/node_modules/postcss/lib/stringify.d.ts b/node_modules/postcss/lib/stringify.d.ts
new file mode 100644
index 0000000..06ad0b4
--- /dev/null
+++ b/node_modules/postcss/lib/stringify.d.ts
@@ -0,0 +1,9 @@
+import { Stringifier } from './postcss.js'
+
+interface Stringify extends Stringifier {
+  default: Stringify
+}
+
+declare const stringify: Stringify
+
+export = stringify
diff --git a/node_modules/postcss/lib/stringify.js b/node_modules/postcss/lib/stringify.js
new file mode 100644
index 0000000..77bd017
--- /dev/null
+++ b/node_modules/postcss/lib/stringify.js
@@ -0,0 +1,11 @@
+'use strict'
+
+let Stringifier = require('./stringifier')
+
+function stringify(node, builder) {
+  let str = new Stringifier(builder)
+  str.stringify(node)
+}
+
+module.exports = stringify
+stringify.default = stringify
diff --git a/node_modules/postcss/lib/symbols.js b/node_modules/postcss/lib/symbols.js
new file mode 100644
index 0000000..a142c26
--- /dev/null
+++ b/node_modules/postcss/lib/symbols.js
@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports.isClean = Symbol('isClean')
+
+module.exports.my = Symbol('my')
diff --git a/node_modules/postcss/lib/terminal-highlight.js b/node_modules/postcss/lib/terminal-highlight.js
new file mode 100644
index 0000000..6196c9d
--- /dev/null
+++ b/node_modules/postcss/lib/terminal-highlight.js
@@ -0,0 +1,70 @@
+'use strict'
+
+let pico = require('picocolors')
+
+let tokenizer = require('./tokenize')
+
+let Input
+
+function registerInput(dependant) {
+  Input = dependant
+}
+
+const HIGHLIGHT_THEME = {
+  ';': pico.yellow,
+  ':': pico.yellow,
+  '(': pico.cyan,
+  ')': pico.cyan,
+  '[': pico.yellow,
+  ']': pico.yellow,
+  '{': pico.yellow,
+  '}': pico.yellow,
+  'at-word': pico.cyan,
+  'brackets': pico.cyan,
+  'call': pico.cyan,
+  'class': pico.yellow,
+  'comment': pico.gray,
+  'hash': pico.magenta,
+  'string': pico.green
+}
+
+function getTokenType([type, value], processor) {
+  if (type === 'word') {
+    if (value[0] === '.') {
+      return 'class'
+    }
+    if (value[0] === '#') {
+      return 'hash'
+    }
+  }
+
+  if (!processor.endOfFile()) {
+    let next = processor.nextToken()
+    processor.back(next)
+    if (next[0] === 'brackets' || next[0] === '(') return 'call'
+  }
+
+  return type
+}
+
+function terminalHighlight(css) {
+  let processor = tokenizer(new Input(css), { ignoreErrors: true })
+  let result = ''
+  while (!processor.endOfFile()) {
+    let token = processor.nextToken()
+    let color = HIGHLIGHT_THEME[getTokenType(token, processor)]
+    if (color) {
+      result += token[1]
+        .split(/\r?\n/)
+        .map(i => color(i))
+        .join('\n')
+    } else {
+      result += token[1]
+    }
+  }
+  return result
+}
+
+terminalHighlight.registerInput = registerInput
+
+module.exports = terminalHighlight
diff --git a/node_modules/postcss/lib/tokenize.js b/node_modules/postcss/lib/tokenize.js
new file mode 100644
index 0000000..1d41284
--- /dev/null
+++ b/node_modules/postcss/lib/tokenize.js
@@ -0,0 +1,266 @@
+'use strict'
+
+const SINGLE_QUOTE = "'".charCodeAt(0)
+const DOUBLE_QUOTE = '"'.charCodeAt(0)
+const BACKSLASH = '\\'.charCodeAt(0)
+const SLASH = '/'.charCodeAt(0)
+const NEWLINE = '\n'.charCodeAt(0)
+const SPACE = ' '.charCodeAt(0)
+const FEED = '\f'.charCodeAt(0)
+const TAB = '\t'.charCodeAt(0)
+const CR = '\r'.charCodeAt(0)
+const OPEN_SQUARE = '['.charCodeAt(0)
+const CLOSE_SQUARE = ']'.charCodeAt(0)
+const OPEN_PARENTHESES = '('.charCodeAt(0)
+const CLOSE_PARENTHESES = ')'.charCodeAt(0)
+const OPEN_CURLY = '{'.charCodeAt(0)
+const CLOSE_CURLY = '}'.charCodeAt(0)
+const SEMICOLON = ';'.charCodeAt(0)
+const ASTERISK = '*'.charCodeAt(0)
+const COLON = ':'.charCodeAt(0)
+const AT = '@'.charCodeAt(0)
+
+const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g
+const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g
+const RE_BAD_BRACKET = /.[\r\n"'(/\\]/
+const RE_HEX_ESCAPE = /[\da-f]/i
+
+module.exports = function tokenizer(input, options = {}) {
+  let css = input.css.valueOf()
+  let ignore = options.ignoreErrors
+
+  let code, content, escape, next, quote
+  let currentToken, escaped, escapePos, n, prev
+
+  let length = css.length
+  let pos = 0
+  let buffer = []
+  let returned = []
+
+  function position() {
+    return pos
+  }
+
+  function unclosed(what) {
+    throw input.error('Unclosed ' + what, pos)
+  }
+
+  function endOfFile() {
+    return returned.length === 0 && pos >= length
+  }
+
+  function nextToken(opts) {
+    if (returned.length) return returned.pop()
+    if (pos >= length) return
+
+    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false
+
+    code = css.charCodeAt(pos)
+
+    switch (code) {
+      case NEWLINE:
+      case SPACE:
+      case TAB:
+      case CR:
+      case FEED: {
+        next = pos
+        do {
+          next += 1
+          code = css.charCodeAt(next)
+        } while (
+          code === SPACE ||
+          code === NEWLINE ||
+          code === TAB ||
+          code === CR ||
+          code === FEED
+        )
+
+        currentToken = ['space', css.slice(pos, next)]
+        pos = next - 1
+        break
+      }
+
+      case OPEN_SQUARE:
+      case CLOSE_SQUARE:
+      case OPEN_CURLY:
+      case CLOSE_CURLY:
+      case COLON:
+      case SEMICOLON:
+      case CLOSE_PARENTHESES: {
+        let controlChar = String.fromCharCode(code)
+        currentToken = [controlChar, controlChar, pos]
+        break
+      }
+
+      case OPEN_PARENTHESES: {
+        prev = buffer.length ? buffer.pop()[1] : ''
+        n = css.charCodeAt(pos + 1)
+        if (
+          prev === 'url' &&
+          n !== SINGLE_QUOTE &&
+          n !== DOUBLE_QUOTE &&
+          n !== SPACE &&
+          n !== NEWLINE &&
+          n !== TAB &&
+          n !== FEED &&
+          n !== CR
+        ) {
+          next = pos
+          do {
+            escaped = false
+            next = css.indexOf(')', next + 1)
+            if (next === -1) {
+              if (ignore || ignoreUnclosed) {
+                next = pos
+                break
+              } else {
+                unclosed('bracket')
+              }
+            }
+            escapePos = next
+            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+              escapePos -= 1
+              escaped = !escaped
+            }
+          } while (escaped)
+
+          currentToken = ['brackets', css.slice(pos, next + 1), pos, next]
+
+          pos = next
+        } else {
+          next = css.indexOf(')', pos + 1)
+          content = css.slice(pos, next + 1)
+
+          if (next === -1 || RE_BAD_BRACKET.test(content)) {
+            currentToken = ['(', '(', pos]
+          } else {
+            currentToken = ['brackets', content, pos, next]
+            pos = next
+          }
+        }
+
+        break
+      }
+
+      case SINGLE_QUOTE:
+      case DOUBLE_QUOTE: {
+        quote = code === SINGLE_QUOTE ? "'" : '"'
+        next = pos
+        do {
+          escaped = false
+          next = css.indexOf(quote, next + 1)
+          if (next === -1) {
+            if (ignore || ignoreUnclosed) {
+              next = pos + 1
+              break
+            } else {
+              unclosed('string')
+            }
+          }
+          escapePos = next
+          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+            escapePos -= 1
+            escaped = !escaped
+          }
+        } while (escaped)
+
+        currentToken = ['string', css.slice(pos, next + 1), pos, next]
+        pos = next
+        break
+      }
+
+      case AT: {
+        RE_AT_END.lastIndex = pos + 1
+        RE_AT_END.test(css)
+        if (RE_AT_END.lastIndex === 0) {
+          next = css.length - 1
+        } else {
+          next = RE_AT_END.lastIndex - 2
+        }
+
+        currentToken = ['at-word', css.slice(pos, next + 1), pos, next]
+
+        pos = next
+        break
+      }
+
+      case BACKSLASH: {
+        next = pos
+        escape = true
+        while (css.charCodeAt(next + 1) === BACKSLASH) {
+          next += 1
+          escape = !escape
+        }
+        code = css.charCodeAt(next + 1)
+        if (
+          escape &&
+          code !== SLASH &&
+          code !== SPACE &&
+          code !== NEWLINE &&
+          code !== TAB &&
+          code !== CR &&
+          code !== FEED
+        ) {
+          next += 1
+          if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
+              next += 1
+            }
+            if (css.charCodeAt(next + 1) === SPACE) {
+              next += 1
+            }
+          }
+        }
+
+        currentToken = ['word', css.slice(pos, next + 1), pos, next]
+
+        pos = next
+        break
+      }
+
+      default: {
+        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+          next = css.indexOf('*/', pos + 2) + 1
+          if (next === 0) {
+            if (ignore || ignoreUnclosed) {
+              next = css.length
+            } else {
+              unclosed('comment')
+            }
+          }
+
+          currentToken = ['comment', css.slice(pos, next + 1), pos, next]
+          pos = next
+        } else {
+          RE_WORD_END.lastIndex = pos + 1
+          RE_WORD_END.test(css)
+          if (RE_WORD_END.lastIndex === 0) {
+            next = css.length - 1
+          } else {
+            next = RE_WORD_END.lastIndex - 2
+          }
+
+          currentToken = ['word', css.slice(pos, next + 1), pos, next]
+          buffer.push(currentToken)
+          pos = next
+        }
+
+        break
+      }
+    }
+
+    pos++
+    return currentToken
+  }
+
+  function back(token) {
+    returned.push(token)
+  }
+
+  return {
+    back,
+    endOfFile,
+    nextToken,
+    position
+  }
+}
diff --git a/node_modules/postcss/lib/warn-once.js b/node_modules/postcss/lib/warn-once.js
new file mode 100644
index 0000000..316e1cf
--- /dev/null
+++ b/node_modules/postcss/lib/warn-once.js
@@ -0,0 +1,13 @@
+/* eslint-disable no-console */
+'use strict'
+
+let printed = {}
+
+module.exports = function warnOnce(message) {
+  if (printed[message]) return
+  printed[message] = true
+
+  if (typeof console !== 'undefined' && console.warn) {
+    console.warn(message)
+  }
+}
diff --git a/node_modules/postcss/lib/warning.d.ts b/node_modules/postcss/lib/warning.d.ts
new file mode 100644
index 0000000..b25bba8
--- /dev/null
+++ b/node_modules/postcss/lib/warning.d.ts
@@ -0,0 +1,147 @@
+import { RangePosition } from './css-syntax-error.js'
+import Node from './node.js'
+
+declare namespace Warning {
+  export interface WarningOptions {
+    /**
+     * End position, exclusive, in CSS node string that caused the warning.
+     */
+    end?: RangePosition
+
+    /**
+     * End index, exclusive, in CSS node string that caused the warning.
+     */
+    endIndex?: number
+
+    /**
+     * Start index, inclusive, in CSS node string that caused the warning.
+     */
+    index?: number
+
+    /**
+     * CSS node that caused the warning.
+     */
+    node?: Node
+
+    /**
+     * Name of the plugin that created this warning. `Result#warn` fills
+     * this property automatically.
+     */
+    plugin?: string
+
+    /**
+     * Start position, inclusive, in CSS node string that caused the warning.
+     */
+    start?: RangePosition
+
+    /**
+     * Word in CSS source that caused the warning.
+     */
+    word?: string
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  export { Warning_ as default }
+}
+
+/**
+ * Represents a plugin’s warning. It can be created using `Node#warn`.
+ *
+ * ```js
+ * if (decl.important) {
+ *   decl.warn(result, 'Avoid !important', { word: '!important' })
+ * }
+ * ```
+ */
+declare class Warning_ {
+  /**
+   * Column for inclusive start position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.column //=> 6
+   * ```
+   */
+  column: number
+
+  /**
+   * Column for exclusive end position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.endColumn //=> 4
+   * ```
+   */
+  endColumn?: number
+
+  /**
+   * Line for exclusive end position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.endLine //=> 6
+   * ```
+   */
+  endLine?: number
+
+  /**
+   * Line for inclusive start position in the input file with this warning’s source.
+   *
+   * ```js
+   * warning.line //=> 5
+   * ```
+   */
+  line: number
+
+  /**
+   * Contains the CSS node that caused the warning.
+   *
+   * ```js
+   * warning.node.toString() //=> 'color: white !important'
+   * ```
+   */
+  node: Node
+
+  /**
+   * The name of the plugin that created this warning.
+   * When you call `Node#warn` it will fill this property automatically.
+   *
+   * ```js
+   * warning.plugin //=> 'postcss-important'
+   * ```
+   */
+  plugin: string
+
+  /**
+   * The warning message.
+   *
+   * ```js
+   * warning.text //=> 'Try to avoid !important'
+   * ```
+   */
+  text: string
+
+  /**
+   * Type to filter warnings from `Result#messages`.
+   * Always equal to `"warning"`.
+   */
+  type: 'warning'
+
+  /**
+   * @param text Warning message.
+   * @param opts Warning options.
+   */
+  constructor(text: string, opts?: Warning.WarningOptions)
+
+  /**
+   * Returns a warning position and message.
+   *
+   * ```js
+   * warning.toString() //=> 'postcss-lint:a.css:10:14: Avoid !important'
+   * ```
+   *
+   * @return Warning position and message.
+   */
+  toString(): string
+}
+
+declare class Warning extends Warning_ {}
+
+export = Warning
diff --git a/node_modules/postcss/lib/warning.js b/node_modules/postcss/lib/warning.js
new file mode 100644
index 0000000..3a3d79c
--- /dev/null
+++ b/node_modules/postcss/lib/warning.js
@@ -0,0 +1,37 @@
+'use strict'
+
+class Warning {
+  constructor(text, opts = {}) {
+    this.type = 'warning'
+    this.text = text
+
+    if (opts.node && opts.node.source) {
+      let range = opts.node.rangeBy(opts)
+      this.line = range.start.line
+      this.column = range.start.column
+      this.endLine = range.end.line
+      this.endColumn = range.end.column
+    }
+
+    for (let opt in opts) this[opt] = opts[opt]
+  }
+
+  toString() {
+    if (this.node) {
+      return this.node.error(this.text, {
+        index: this.index,
+        plugin: this.plugin,
+        word: this.word
+      }).message
+    }
+
+    if (this.plugin) {
+      return this.plugin + ': ' + this.text
+    }
+
+    return this.text
+  }
+}
+
+module.exports = Warning
+Warning.default = Warning
diff --git a/node_modules/postcss/node_modules/.bin/nanoid b/node_modules/postcss/node_modules/.bin/nanoid
new file mode 120000
index 0000000..7b4e5ad
--- /dev/null
+++ b/node_modules/postcss/node_modules/.bin/nanoid
@@ -0,0 +1 @@
+../../../nanoid/bin/nanoid.cjs
\ No newline at end of file
diff --git a/node_modules/postcss/package.json b/node_modules/postcss/package.json
new file mode 100755
index 0000000..bd8992a
--- /dev/null
+++ b/node_modules/postcss/package.json
@@ -0,0 +1,88 @@
+{
+  "name": "postcss",
+  "version": "8.4.47",
+  "description": "Tool for transforming styles with JS plugins",
+  "engines": {
+    "node": "^10 || ^12 || >=14"
+  },
+  "exports": {
+    ".": {
+      "require": "./lib/postcss.js",
+      "import": "./lib/postcss.mjs"
+    },
+    "./lib/at-rule": "./lib/at-rule.js",
+    "./lib/comment": "./lib/comment.js",
+    "./lib/container": "./lib/container.js",
+    "./lib/css-syntax-error": "./lib/css-syntax-error.js",
+    "./lib/declaration": "./lib/declaration.js",
+    "./lib/fromJSON": "./lib/fromJSON.js",
+    "./lib/input": "./lib/input.js",
+    "./lib/lazy-result": "./lib/lazy-result.js",
+    "./lib/no-work-result": "./lib/no-work-result.js",
+    "./lib/list": "./lib/list.js",
+    "./lib/map-generator": "./lib/map-generator.js",
+    "./lib/node": "./lib/node.js",
+    "./lib/parse": "./lib/parse.js",
+    "./lib/parser": "./lib/parser.js",
+    "./lib/postcss": "./lib/postcss.js",
+    "./lib/previous-map": "./lib/previous-map.js",
+    "./lib/processor": "./lib/processor.js",
+    "./lib/result": "./lib/result.js",
+    "./lib/root": "./lib/root.js",
+    "./lib/rule": "./lib/rule.js",
+    "./lib/stringifier": "./lib/stringifier.js",
+    "./lib/stringify": "./lib/stringify.js",
+    "./lib/symbols": "./lib/symbols.js",
+    "./lib/terminal-highlight": "./lib/terminal-highlight.js",
+    "./lib/tokenize": "./lib/tokenize.js",
+    "./lib/warn-once": "./lib/warn-once.js",
+    "./lib/warning": "./lib/warning.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./lib/postcss.js",
+  "types": "./lib/postcss.d.ts",
+  "keywords": [
+    "css",
+    "postcss",
+    "rework",
+    "preprocessor",
+    "parser",
+    "source map",
+    "transform",
+    "manipulation",
+    "transpiler"
+  ],
+  "funding": [
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/postcss/"
+    },
+    {
+      "type": "tidelift",
+      "url": "https://tidelift.com/funding/github/npm/postcss"
+    },
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/ai"
+    }
+  ],
+  "author": "Andrey Sitnik <andrey@sitnik.ru>",
+  "license": "MIT",
+  "homepage": "https://postcss.org/",
+  "repository": "postcss/postcss",
+  "bugs": {
+    "url": "https://github.com/postcss/postcss/issues"
+  },
+  "dependencies": {
+    "nanoid": "^3.3.7",
+    "picocolors": "^1.1.0",
+    "source-map-js": "^1.2.1"
+  },
+  "browser": {
+    "./lib/terminal-highlight": false,
+    "source-map-js": false,
+    "path": false,
+    "url": false,
+    "fs": false
+  }
+}
diff --git a/node_modules/rollup/LICENSE.md b/node_modules/rollup/LICENSE.md
new file mode 100644
index 0000000..ce44fa2
--- /dev/null
+++ b/node_modules/rollup/LICENSE.md
@@ -0,0 +1,653 @@
+# Rollup core license
+Rollup is released under the MIT license:
+
+The MIT License (MIT)
+
+Copyright (c) 2017 [these people](https://github.com/rollup/rollup/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Licenses of bundled dependencies
+The published Rollup artifact additionally contains code with the following licenses:
+MIT, ISC
+
+# Bundled dependencies:
+## @jridgewell/sourcemap-codec
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/jridgewell/sourcemap-codec.git
+
+> The MIT License
+> 
+> Copyright (c) 2015 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## @rollup/pluginutils
+License: MIT
+By: Rich Harris
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## anymatch
+License: ISC
+By: Elan Shanker
+Repository: https://github.com/micromatch/anymatch
+
+> The ISC License
+> 
+> Copyright (c) 2019 Elan Shanker, Paul Miller (https://paulmillr.com)
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## binary-extensions
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/binary-extensions
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> Copyright (c) Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## braces
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Elan Shanker, Eugene Sharygin, hemanth.hm
+Repository: micromatch/braces
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## builtin-modules
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/builtin-modules
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## chokidar
+License: MIT
+By: Paul Miller, Elan Shanker
+Repository: git+https://github.com/paulmillr/chokidar.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2012-2019 Paul Miller (https://paulmillr.com), Elan Shanker
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the “Software”), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## colorette
+License: MIT
+By: Jorge Bucaran
+Repository: jorgebucaran/colorette
+
+> Copyright © Jorge Bucaran <<https://jorgebucaran.com>>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## date-time
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/date-time
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## fill-range
+License: MIT
+By: Jon Schlinkert, Edo Rivai, Paul Miller, Rouven Weßling
+Repository: jonschlinkert/fill-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## flru
+License: MIT
+By: Luke Edwards
+Repository: lukeed/flru
+
+> MIT License
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## glob-parent
+License: ISC
+By: Gulp Team, Elan Shanker, Blaine Bublitz
+Repository: gulpjs/glob-parent
+
+> The ISC License
+> 
+> Copyright (c) 2015, 2019 Elan Shanker
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## is-binary-path
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/is-binary-path
+
+> MIT License
+> 
+> Copyright (c) 2019 Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com), Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## is-extglob
+License: MIT
+By: Jon Schlinkert
+Repository: jonschlinkert/is-extglob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2016, Jon Schlinkert
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-glob
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Daniel Perez
+Repository: micromatch/is-glob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2017, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-number
+License: MIT
+By: Jon Schlinkert, Olsten Larck, Rouven Weßling
+Repository: jonschlinkert/is-number
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-reference
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/Rich-Harris/is-reference.git
+
+---------------------------------------
+
+## locate-character
+License: MIT
+By: Rich Harris
+Repository: git+https://gitlab.com/Rich-Harris/locate-character.git
+
+---------------------------------------
+
+## magic-string
+License: MIT
+By: Rich Harris
+Repository: https://github.com/rich-harris/magic-string
+
+> Copyright 2018 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## normalize-path
+License: MIT
+By: Jon Schlinkert, Blaine Bublitz
+Repository: jonschlinkert/normalize-path
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2018, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## parse-ms
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/parse-ms
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## picomatch
+License: MIT
+By: Jon Schlinkert
+Repository: micromatch/picomatch
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## pretty-bytes
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/pretty-bytes
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## pretty-ms
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/pretty-ms
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## readdirp
+License: MIT
+By: Thorsten Lorenz, Paul Miller
+Repository: git://github.com/paulmillr/readdirp.git
+
+> MIT License
+> 
+> Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## signal-exit
+License: ISC
+By: Ben Coe
+Repository: https://github.com/tapjs/signal-exit.git
+
+> The ISC License
+> 
+> Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software
+> for any purpose with or without fee is hereby granted, provided
+> that the above copyright notice and this permission notice
+> appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+> OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+> LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+> OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+> WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+> ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## time-zone
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/time-zone
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## to-regex-range
+License: MIT
+By: Jon Schlinkert, Rouven Weßling
+Repository: micromatch/to-regex-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## yargs-parser
+License: ISC
+By: Ben Coe
+Repository: https://github.com/yargs/yargs-parser.git
+
+> Copyright (c) 2016, Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software
+> for any purpose with or without fee is hereby granted, provided
+> that the above copyright notice and this permission notice
+> appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+> OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+> LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+> OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+> WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+> ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/rollup/README.md b/node_modules/rollup/README.md
new file mode 100644
index 0000000..a1b6b9e
--- /dev/null
+++ b/node_modules/rollup/README.md
@@ -0,0 +1,134 @@
+<p align="center">
+	<a href="https://rollupjs.org/"><img src="https://rollupjs.org/rollup-logo.svg" width="150" /></a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/rollup">
+    <img src="https://img.shields.io/npm/v/rollup.svg" alt="npm version" >
+  </a>
+  <a href="https://nodejs.org/en/about/previous-releases">
+    <img src="https://img.shields.io/node/v/rollup.svg" alt="node compatibility">
+  </a>
+  <a href="https://packagephobia.now.sh/result?p=rollup">
+    <img src="https://packagephobia.now.sh/badge?p=rollup" alt="install size" >
+  </a>
+  <a href="https://codecov.io/gh/rollup/rollup">
+    <img src="https://codecov.io/gh/rollup/rollup/graph/badge.svg" alt="code coverage" >
+  </a>
+  <a href="#backers" alt="sponsors on Open Collective">
+    <img src="https://opencollective.com/rollup/backers/badge.svg" alt="backers" >
+  </a> 
+  <a href="#sponsors" alt="Sponsors on Open Collective">
+    <img src="https://opencollective.com/rollup/sponsors/badge.svg" alt="sponsors" >
+  </a> 
+  <a href="https://github.com/rollup/rollup/blob/master/LICENSE.md">
+    <img src="https://img.shields.io/npm/l/rollup.svg" alt="license">
+  </a>
+  <a href='https://is.gd/rollup_chat?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge'>
+    <img src='https://img.shields.io/discord/466787075518365708?color=778cd1&label=chat' alt='Join the chat at https://is.gd/rollup_chat'>
+  </a>
+</p>
+
+<h1 align="center">Rollup</h1>
+
+## Overview
+
+Rollup is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application. It uses the standardized ES module format for code, instead of previous idiosyncratic solutions such as CommonJS and AMD. ES modules let you freely and seamlessly combine the most useful individual functions from your favorite libraries. Rollup can optimize ES modules for faster native loading in modern browsers, or output a legacy module format allowing ES module workflows today.
+
+## Quick Start Guide
+
+Install with `npm install --global rollup`. Rollup can be used either through a [command line interface](https://rollupjs.org/command-line-interface/) with an optional configuration file or else through its [JavaScript API](https://rollupjs.org/javascript-api/). Run `rollup --help` to see the available options and parameters. The starter project templates, [rollup-starter-lib](https://github.com/rollup/rollup-starter-lib) and [rollup-starter-app](https://github.com/rollup/rollup-starter-app), demonstrate common configuration options, and more detailed instructions are available throughout the [user guide](https://rollupjs.org/introduction/).
+
+### Commands
+
+These commands assume the entry point to your application is named main.js, and that you'd like all imports compiled into a single file named bundle.js.
+
+For browsers:
+
+```bash
+# compile to a <script> containing a self-executing function
+rollup main.js --format iife --name "myBundle" --file bundle.js
+```
+
+For Node.js:
+
+```bash
+# compile to a CommonJS module
+rollup main.js --format cjs --file bundle.js
+```
+
+For both browsers and Node.js:
+
+```bash
+# UMD format requires a bundle name
+rollup main.js --format umd --name "myBundle" --file bundle.js
+```
+
+## Why
+
+Developing software is usually easier if you break your project into smaller separate pieces, since that often removes unexpected interactions and dramatically reduces the complexity of the problems you'll need to solve, and simply writing smaller projects in the first place [isn't necessarily the answer](https://medium.com/@Rich_Harris/small-modules-it-s-not-quite-that-simple-3ca532d65de4). Unfortunately, JavaScript has not historically included this capability as a core feature in the language.
+
+This finally changed with ES modules support in JavaScript, which provides a syntax for importing and exporting functions and data so they can be shared between separate scripts. Most browsers and Node.js support ES modules. However, Node.js releases before 12.17 support ES modules only behind the `--experimental-modules` flag, and older browsers like Internet Explorer do not support ES modules at all. Rollup allows you to write your code using ES modules, and run your application even in environments that do not support ES modules natively. For environments that support them, Rollup can output optimized ES modules; for environments that don't, Rollup can compile your code to other formats such as CommonJS modules, AMD modules, and IIFE-style scripts. This means that you get to _write future-proof code_, and you also get the tremendous benefits of...
+
+## Tree Shaking
+
+In addition to enabling the use of ES modules, Rollup also statically analyzes and optimizes the code you are importing, and will exclude anything that isn't actually used. This allows you to build on top of existing tools and modules without adding extra dependencies or bloating the size of your project.
+
+For example, with CommonJS, the _entire tool or library must be imported_.
+
+```js
+// import the entire utils object with CommonJS
+var utils = require('node:utils');
+var query = 'Rollup';
+// use the ajax method of the utils object
+utils.ajax('https://api.example.com?search=' + query).then(handleResponse);
+```
+
+But with ES modules, instead of importing the whole `utils` object, we can just import the one `ajax` function we need:
+
+```js
+// import the ajax function with an ES import statement
+import { ajax } from 'node:utils';
+
+var query = 'Rollup';
+// call the ajax function
+ajax('https://api.example.com?search=' + query).then(handleResponse);
+```
+
+Because Rollup includes the bare minimum, it results in lighter, faster, and less complicated libraries and applications. Since this approach is based on explicit `import` and `export` statements, it is vastly more effective than simply running an automated minifier to detect unused variables in the compiled output code.
+
+## Compatibility
+
+### Importing CommonJS
+
+Rollup can import existing CommonJS modules [through a plugin](https://github.com/rollup/plugins/tree/master/packages/commonjs).
+
+### Publishing ES Modules
+
+To make sure your ES modules are immediately usable by tools that work with CommonJS such as Node.js and webpack, you can use Rollup to compile to UMD or CommonJS format, and then point to that compiled version with the `main` property in your `package.json` file. If your `package.json` file also has a `module` field, ES-module-aware tools like Rollup and [webpack](https://webpack.js.org/) will [import the ES module version](https://github.com/rollup/rollup/wiki/pkg.module) directly.
+
+## Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]. <a href="https://github.com/rollup/rollup/graphs/contributors"><img src="https://opencollective.com/rollup/contributors.svg?width=890" /></a>. If you want to contribute yourself, head over to the [contribution guidelines](CONTRIBUTING.md).
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/rollup#backer)]
+
+<a href="https://opencollective.com/rollup#backers" target="_blank"><img src="https://opencollective.com/rollup/backers.svg?width=890"></a>
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/rollup#sponsor)]
+
+<a href="https://opencollective.com/rollup/sponsor/0/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/0/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/1/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/1/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/2/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/2/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/3/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/3/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/4/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/4/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/5/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/5/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/6/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/6/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/7/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/7/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/8/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/8/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/9/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/9/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/10/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/10/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/11/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/11/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/12/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/12/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/13/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/13/avatar.svg"></a> <a href="https://opencollective.com/rollup/sponsor/14/website" target="_blank"><img src="https://opencollective.com/rollup/sponsor/14/avatar.svg"></a>
+
+## Special Sponsor
+
+<a href="https://www.tngtech.com/en/index.html" target="_blank"><img src="https://www.tngtech.com/fileadmin/Public/Images/Logos/TNG_Logo_medium_400x64.svg" alt="TNG Logo" width="280"/></a>
+
+TNG has been supporting the work of [Lukas Taegert-Atkinson](https://github.com/lukastaegert) on Rollup since 2017.
+
+## License
+
+[MIT](https://github.com/rollup/rollup/blob/master/LICENSE.md)
diff --git a/node_modules/rollup/dist/bin/rollup b/node_modules/rollup/dist/bin/rollup
new file mode 100755
index 0000000..33b3e8b
--- /dev/null
+++ b/node_modules/rollup/dist/bin/rollup
@@ -0,0 +1,1762 @@
+#!/usr/bin/env node
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const process$1 = require('node:process');
+const rollup = require('../shared/rollup.js');
+const require$$2 = require('util');
+const require$$0 = require('path');
+const require$$0$1 = require('fs');
+const parseAst_js = require('../shared/parseAst.js');
+const fseventsImporter = require('../shared/fsevents-importer.js');
+const promises = require('node:fs/promises');
+const path = require('node:path');
+const loadConfigFile_js = require('../shared/loadConfigFile.js');
+require('tty');
+require('../native.js');
+require('node:perf_hooks');
+require('node:url');
+require('../getLogFilter.js');
+
+const help = "rollup version __VERSION__\n=====================================\n\nUsage: rollup [options] <entry file>\n\nBasic options:\n\n-c, --config <filename>     Use this config file (if argument is used but value\n                              is unspecified, defaults to rollup.config.js)\n-d, --dir <dirname>         Directory for chunks (if absent, prints to stdout)\n-e, --external <ids>        Comma-separate list of module IDs to exclude\n-f, --format <format>       Type of output (amd, cjs, es, iife, umd, system)\n-g, --globals <pairs>       Comma-separate list of `moduleID:Global` pairs\n-h, --help                  Show this help message\n-i, --input <filename>      Input (alternative to <entry file>)\n-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)\n-n, --name <name>           Name for UMD export\n-o, --file <output>         Single output file (if absent, prints to stdout)\n-p, --plugin <plugin>       Use the plugin specified (may be repeated)\n-v, --version               Show version number\n-w, --watch                 Watch files in bundle and rebuild on changes\n--amd.autoId                Generate the AMD ID based off the chunk name\n--amd.basePath <prefix>     Path to prepend to auto generated AMD ID\n--amd.define <name>         Function to use in place of `define`\n--amd.forceJsExtensionForImports Use `.js` extension in AMD imports\n--amd.id <id>               ID for AMD module (default is anonymous)\n--assetFileNames <pattern>  Name pattern for emitted assets\n--banner <text>             Code to insert at top of bundle (outside wrapper)\n--chunkFileNames <pattern>  Name pattern for emitted secondary chunks\n--compact                   Minify wrapper code\n--context <variable>        Specify top-level `this` value\n--no-dynamicImportInCjs     Write external dynamic CommonJS imports as require\n--entryFileNames <pattern>  Name pattern for emitted entry chunks\n--environment <values>      Settings passed to config file (see example)\n--no-esModule               Do not add __esModule property\n--exports <mode>            Specify export mode (auto, default, named, none)\n--extend                    Extend global variable defined by --name\n--no-externalImportAttributes Omit import attributes in \"es\" output\n--no-externalLiveBindings   Do not generate code to support live bindings\n--failAfterWarnings         Exit with an error if the build produced warnings\n--filterLogs <filter>       Filter log messages\n--footer <text>             Code to insert at end of bundle (outside wrapper)\n--forceExit                 Force exit the process when done\n--no-freeze                 Do not freeze namespace objects\n--generatedCode <preset>    Which code features to use (es5/es2015)\n--generatedCode.arrowFunctions Use arrow functions in generated code\n--generatedCode.constBindings Use \"const\" in generated code\n--generatedCode.objectShorthand Use shorthand properties in generated code\n--no-generatedCode.reservedNamesAsProps Always quote reserved names as props\n--generatedCode.symbols     Use symbols in generated code\n--hashCharacters <name>     Use the specified character set for file hashes\n--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks\n--importAttributesKey <name> Use the specified keyword for import attributes\n--no-indent                 Don't indent result\n--inlineDynamicImports      Create single bundle when using dynamic imports\n--no-interop                Do not include interop block\n--intro <text>              Code to insert at top of bundle (inside wrapper)\n--logLevel <level>          Which kind of logs to display\n--no-makeAbsoluteExternalsRelative Prevent normalization of external imports\n--maxParallelFileOps <value> How many files to read in parallel\n--minifyInternalExports     Force or disable minification of internal exports\n--noConflict                Generate a noConflict method for UMD globals\n--outro <text>              Code to insert at end of bundle (inside wrapper)\n--perf                      Display performance timings\n--no-preserveEntrySignatures Avoid facade chunks for entry points\n--preserveModules           Preserve module structure\n--preserveModulesRoot       Put preserved modules under this path at root level\n--preserveSymlinks          Do not follow symlinks when resolving files\n--no-reexportProtoFromExternal Ignore `__proto__` in star re-exports\n--no-sanitizeFileName       Do not replace invalid characters in file names\n--shimMissingExports        Create shim variables for missing exports\n--silent                    Don't print warnings\n--sourcemapBaseUrl <url>    Emit absolute sourcemap URLs with given base\n--sourcemapExcludeSources   Do not include source code in source maps\n--sourcemapFile <file>      Specify bundle position for source maps\n--sourcemapFileNames <pattern> Name pattern for emitted sourcemaps\n--stdin=ext                 Specify file extension used for stdin input\n--no-stdin                  Do not read \"-\" from stdin\n--no-strict                 Don't emit `\"use strict\";` in the generated modules\n--strictDeprecations        Throw errors for deprecated features\n--no-systemNullSetters      Do not replace empty SystemJS setters with `null`\n--no-treeshake              Disable tree-shaking optimisations\n--no-treeshake.annotations  Ignore pure call annotations\n--treeshake.correctVarValueBeforeDeclaration Deoptimize variables until declared\n--treeshake.manualPureFunctions <names> Manually declare functions as pure\n--no-treeshake.moduleSideEffects Assume modules have no side effects\n--no-treeshake.propertyReadSideEffects Ignore property access side effects\n--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking\n--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw\n--validate                  Validate output\n--waitForBundleInput        Wait for bundle input files\n--watch.buildDelay <number> Throttle watch rebuilds\n--no-watch.clearScreen      Do not clear the screen when rebuilding\n--watch.exclude <files>     Exclude files from being watched\n--watch.include <files>     Limit watching to specified files\n--watch.onBundleEnd <cmd>   Shell command to run on `\"BUNDLE_END\"` event\n--watch.onBundleStart <cmd> Shell command to run on `\"BUNDLE_START\"` event\n--watch.onEnd <cmd>         Shell command to run on `\"END\"` event\n--watch.onError <cmd>       Shell command to run on `\"ERROR\"` event\n--watch.onStart <cmd>       Shell command to run on `\"START\"` event\n--watch.skipWrite           Do not write files to disk when watching\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n  -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n";
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+function camelCase(str) {
+    // Handle the case where an argument is provided as camel case, e.g., fooBar.
+    // by ensuring that the string isn't already mixed case:
+    const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
+    if (!isCamelCase) {
+        str = str.toLowerCase();
+    }
+    if (str.indexOf('-') === -1 && str.indexOf('_') === -1) {
+        return str;
+    }
+    else {
+        let camelcase = '';
+        let nextChrUpper = false;
+        const leadingHyphens = str.match(/^-+/);
+        for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
+            let chr = str.charAt(i);
+            if (nextChrUpper) {
+                nextChrUpper = false;
+                chr = chr.toUpperCase();
+            }
+            if (i !== 0 && (chr === '-' || chr === '_')) {
+                nextChrUpper = true;
+            }
+            else if (chr !== '-' && chr !== '_') {
+                camelcase += chr;
+            }
+        }
+        return camelcase;
+    }
+}
+function decamelize(str, joinString) {
+    const lowercase = str.toLowerCase();
+    joinString = joinString || '-';
+    let notCamelcase = '';
+    for (let i = 0; i < str.length; i++) {
+        const chrLower = lowercase.charAt(i);
+        const chrString = str.charAt(i);
+        if (chrLower !== chrString && i > 0) {
+            notCamelcase += `${joinString}${lowercase.charAt(i)}`;
+        }
+        else {
+            notCamelcase += chrString;
+        }
+    }
+    return notCamelcase;
+}
+function looksLikeNumber(x) {
+    if (x === null || x === undefined)
+        return false;
+    // if loaded from config, may already be a number.
+    if (typeof x === 'number')
+        return true;
+    // hexadecimal.
+    if (/^0x[0-9a-f]+$/i.test(x))
+        return true;
+    // don't treat 0123 as a number; as it drops the leading '0'.
+    if (/^0[^.]/.test(x))
+        return false;
+    return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+// take an un-split argv string and tokenize it.
+function tokenizeArgString(argString) {
+    if (Array.isArray(argString)) {
+        return argString.map(e => typeof e !== 'string' ? e + '' : e);
+    }
+    argString = argString.trim();
+    let i = 0;
+    let prevC = null;
+    let c = null;
+    let opening = null;
+    const args = [];
+    for (let ii = 0; ii < argString.length; ii++) {
+        prevC = c;
+        c = argString.charAt(ii);
+        // split on spaces unless we're in quotes.
+        if (c === ' ' && !opening) {
+            if (!(prevC === ' ')) {
+                i++;
+            }
+            continue;
+        }
+        // don't split the string if we're in matching
+        // opening or closing single and double quotes.
+        if (c === opening) {
+            opening = null;
+        }
+        else if ((c === "'" || c === '"') && !opening) {
+            opening = c;
+        }
+        if (!args[i])
+            args[i] = '';
+        args[i] += c;
+    }
+    return args;
+}
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+var DefaultValuesForTypeKey;
+(function (DefaultValuesForTypeKey) {
+    DefaultValuesForTypeKey["BOOLEAN"] = "boolean";
+    DefaultValuesForTypeKey["STRING"] = "string";
+    DefaultValuesForTypeKey["NUMBER"] = "number";
+    DefaultValuesForTypeKey["ARRAY"] = "array";
+})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+let mixin;
+class YargsParser {
+    constructor(_mixin) {
+        mixin = _mixin;
+    }
+    parse(argsInput, options) {
+        const opts = Object.assign({
+            alias: undefined,
+            array: undefined,
+            boolean: undefined,
+            config: undefined,
+            configObjects: undefined,
+            configuration: undefined,
+            coerce: undefined,
+            count: undefined,
+            default: undefined,
+            envPrefix: undefined,
+            narg: undefined,
+            normalize: undefined,
+            string: undefined,
+            number: undefined,
+            __: undefined,
+            key: undefined
+        }, options);
+        // allow a string argument to be passed in rather
+        // than an argv array.
+        const args = tokenizeArgString(argsInput);
+        // tokenizeArgString adds extra quotes to args if argsInput is a string
+        // only strip those extra quotes in processValue if argsInput is a string
+        const inputIsString = typeof argsInput === 'string';
+        // aliases might have transitive relationships, normalize this.
+        const aliases = combineAliases(Object.assign(Object.create(null), opts.alias));
+        const configuration = Object.assign({
+            'boolean-negation': true,
+            'camel-case-expansion': true,
+            'combine-arrays': false,
+            'dot-notation': true,
+            'duplicate-arguments-array': true,
+            'flatten-duplicate-arrays': true,
+            'greedy-arrays': true,
+            'halt-at-non-option': false,
+            'nargs-eats-options': false,
+            'negation-prefix': 'no-',
+            'parse-numbers': true,
+            'parse-positional-numbers': true,
+            'populate--': false,
+            'set-placeholder-key': false,
+            'short-option-groups': true,
+            'strip-aliased': false,
+            'strip-dashed': false,
+            'unknown-options-as-args': false
+        }, opts.configuration);
+        const defaults = Object.assign(Object.create(null), opts.default);
+        const configObjects = opts.configObjects || [];
+        const envPrefix = opts.envPrefix;
+        const notFlagsOption = configuration['populate--'];
+        const notFlagsArgv = notFlagsOption ? '--' : '_';
+        const newAliases = Object.create(null);
+        const defaulted = Object.create(null);
+        // allow a i18n handler to be passed in, default to a fake one (util.format).
+        const __ = opts.__ || mixin.format;
+        const flags = {
+            aliases: Object.create(null),
+            arrays: Object.create(null),
+            bools: Object.create(null),
+            strings: Object.create(null),
+            numbers: Object.create(null),
+            counts: Object.create(null),
+            normalize: Object.create(null),
+            configs: Object.create(null),
+            nargs: Object.create(null),
+            coercions: Object.create(null),
+            keys: []
+        };
+        const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+        const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)');
+        [].concat(opts.array || []).filter(Boolean).forEach(function (opt) {
+            const key = typeof opt === 'object' ? opt.key : opt;
+            // assign to flags[bools|strings|numbers]
+            const assignment = Object.keys(opt).map(function (key) {
+                const arrayFlagKeys = {
+                    boolean: 'bools',
+                    string: 'strings',
+                    number: 'numbers'
+                };
+                return arrayFlagKeys[key];
+            }).filter(Boolean).pop();
+            // assign key to be coerced
+            if (assignment) {
+                flags[assignment][key] = true;
+            }
+            flags.arrays[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) {
+            flags.bools[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.string || []).filter(Boolean).forEach(function (key) {
+            flags.strings[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.number || []).filter(Boolean).forEach(function (key) {
+            flags.numbers[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.count || []).filter(Boolean).forEach(function (key) {
+            flags.counts[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) {
+            flags.normalize[key] = true;
+            flags.keys.push(key);
+        });
+        if (typeof opts.narg === 'object') {
+            Object.entries(opts.narg).forEach(([key, value]) => {
+                if (typeof value === 'number') {
+                    flags.nargs[key] = value;
+                    flags.keys.push(key);
+                }
+            });
+        }
+        if (typeof opts.coerce === 'object') {
+            Object.entries(opts.coerce).forEach(([key, value]) => {
+                if (typeof value === 'function') {
+                    flags.coercions[key] = value;
+                    flags.keys.push(key);
+                }
+            });
+        }
+        if (typeof opts.config !== 'undefined') {
+            if (Array.isArray(opts.config) || typeof opts.config === 'string') {
+                [].concat(opts.config).filter(Boolean).forEach(function (key) {
+                    flags.configs[key] = true;
+                });
+            }
+            else if (typeof opts.config === 'object') {
+                Object.entries(opts.config).forEach(([key, value]) => {
+                    if (typeof value === 'boolean' || typeof value === 'function') {
+                        flags.configs[key] = value;
+                    }
+                });
+            }
+        }
+        // create a lookup table that takes into account all
+        // combinations of aliases: {f: ['foo'], foo: ['f']}
+        extendAliases(opts.key, aliases, opts.default, flags.arrays);
+        // apply default values to all aliases.
+        Object.keys(defaults).forEach(function (key) {
+            (flags.aliases[key] || []).forEach(function (alias) {
+                defaults[alias] = defaults[key];
+            });
+        });
+        let error = null;
+        checkConfiguration();
+        let notFlags = [];
+        const argv = Object.assign(Object.create(null), { _: [] });
+        // TODO(bcoe): for the first pass at removing object prototype  we didn't
+        // remove all prototypes from objects returned by this API, we might want
+        // to gradually move towards doing so.
+        const argvReturn = {};
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            const truncatedArg = arg.replace(/^-{3,}/, '---');
+            let broken;
+            let key;
+            let letters;
+            let m;
+            let next;
+            let value;
+            // any unknown option (except for end-of-options, "--")
+            if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
+                pushPositional(arg);
+                // ---, ---=, ----, etc,
+            }
+            else if (truncatedArg.match(/^---+(=|$)/)) {
+                // options without key name are invalid.
+                pushPositional(arg);
+                continue;
+                // -- separated by =
+            }
+            else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) {
+                // Using [\s\S] instead of . because js doesn't support the
+                // 'dotall' regex modifier. See:
+                // http://stackoverflow.com/a/1068308/13216
+                m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
+                // arrays format = '--f=a b c'
+                if (m !== null && Array.isArray(m) && m.length >= 3) {
+                    if (checkAllAliases(m[1], flags.arrays)) {
+                        i = eatArray(i, m[1], args, m[2]);
+                    }
+                    else if (checkAllAliases(m[1], flags.nargs) !== false) {
+                        // nargs format = '--f=monkey washing cat'
+                        i = eatNargs(i, m[1], args, m[2]);
+                    }
+                    else {
+                        setArg(m[1], m[2], true);
+                    }
+                }
+            }
+            else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
+                m = arg.match(negatedBoolean);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
+                }
+                // -- separated by space.
+            }
+            else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) {
+                m = arg.match(/^--?(.+)/);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    if (checkAllAliases(key, flags.arrays)) {
+                        // array format = '--foo a b c'
+                        i = eatArray(i, key, args);
+                    }
+                    else if (checkAllAliases(key, flags.nargs) !== false) {
+                        // nargs format = '--foo a b c'
+                        // should be truthy even if: flags.nargs[key] === 0
+                        i = eatNargs(i, key, args);
+                    }
+                    else {
+                        next = args[i + 1];
+                        if (next !== undefined && (!next.match(/^-/) ||
+                            next.match(negative)) &&
+                            !checkAllAliases(key, flags.bools) &&
+                            !checkAllAliases(key, flags.counts)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else if (/^(true|false)$/.test(next)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else {
+                            setArg(key, defaultValue(key));
+                        }
+                    }
+                }
+                // dot-notation flag separated by '='.
+            }
+            else if (arg.match(/^-.\..+=/)) {
+                m = arg.match(/^-([^=]+)=([\s\S]*)$/);
+                if (m !== null && Array.isArray(m) && m.length >= 3) {
+                    setArg(m[1], m[2]);
+                }
+                // dot-notation flag separated by space.
+            }
+            else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
+                next = args[i + 1];
+                m = arg.match(/^-(.\..+)/);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    if (next !== undefined && !next.match(/^-/) &&
+                        !checkAllAliases(key, flags.bools) &&
+                        !checkAllAliases(key, flags.counts)) {
+                        setArg(key, next);
+                        i++;
+                    }
+                    else {
+                        setArg(key, defaultValue(key));
+                    }
+                }
+            }
+            else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
+                letters = arg.slice(1, -1).split('');
+                broken = false;
+                for (let j = 0; j < letters.length; j++) {
+                    next = arg.slice(j + 2);
+                    if (letters[j + 1] && letters[j + 1] === '=') {
+                        value = arg.slice(j + 3);
+                        key = letters[j];
+                        if (checkAllAliases(key, flags.arrays)) {
+                            // array format = '-f=a b c'
+                            i = eatArray(i, key, args, value);
+                        }
+                        else if (checkAllAliases(key, flags.nargs) !== false) {
+                            // nargs format = '-f=monkey washing cat'
+                            i = eatNargs(i, key, args, value);
+                        }
+                        else {
+                            setArg(key, value);
+                        }
+                        broken = true;
+                        break;
+                    }
+                    if (next === '-') {
+                        setArg(letters[j], next);
+                        continue;
+                    }
+                    // current letter is an alphabetic character and next value is a number
+                    if (/[A-Za-z]/.test(letters[j]) &&
+                        /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) &&
+                        checkAllAliases(next, flags.bools) === false) {
+                        setArg(letters[j], next);
+                        broken = true;
+                        break;
+                    }
+                    if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                        setArg(letters[j], next);
+                        broken = true;
+                        break;
+                    }
+                    else {
+                        setArg(letters[j], defaultValue(letters[j]));
+                    }
+                }
+                key = arg.slice(-1)[0];
+                if (!broken && key !== '-') {
+                    if (checkAllAliases(key, flags.arrays)) {
+                        // array format = '-f a b c'
+                        i = eatArray(i, key, args);
+                    }
+                    else if (checkAllAliases(key, flags.nargs) !== false) {
+                        // nargs format = '-f a b c'
+                        // should be truthy even if: flags.nargs[key] === 0
+                        i = eatNargs(i, key, args);
+                    }
+                    else {
+                        next = args[i + 1];
+                        if (next !== undefined && (!/^(-|--)[^-]/.test(next) ||
+                            next.match(negative)) &&
+                            !checkAllAliases(key, flags.bools) &&
+                            !checkAllAliases(key, flags.counts)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else if (/^(true|false)$/.test(next)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else {
+                            setArg(key, defaultValue(key));
+                        }
+                    }
+                }
+            }
+            else if (arg.match(/^-[0-9]$/) &&
+                arg.match(negative) &&
+                checkAllAliases(arg.slice(1), flags.bools)) {
+                // single-digit boolean alias, e.g: xargs -0
+                key = arg.slice(1);
+                setArg(key, defaultValue(key));
+            }
+            else if (arg === '--') {
+                notFlags = args.slice(i + 1);
+                break;
+            }
+            else if (configuration['halt-at-non-option']) {
+                notFlags = args.slice(i);
+                break;
+            }
+            else {
+                pushPositional(arg);
+            }
+        }
+        // order of precedence:
+        // 1. command line arg
+        // 2. value from env var
+        // 3. value from config file
+        // 4. value from config objects
+        // 5. configured default value
+        applyEnvVars(argv, true); // special case: check env vars that point to config file
+        applyEnvVars(argv, false);
+        setConfig(argv);
+        setConfigObjects();
+        applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
+        applyCoercions(argv);
+        if (configuration['set-placeholder-key'])
+            setPlaceholderKeys(argv);
+        // for any counts either not in args or without an explicit default, set to 0
+        Object.keys(flags.counts).forEach(function (key) {
+            if (!hasKey(argv, key.split('.')))
+                setArg(key, 0);
+        });
+        // '--' defaults to undefined.
+        if (notFlagsOption && notFlags.length)
+            argv[notFlagsArgv] = [];
+        notFlags.forEach(function (key) {
+            argv[notFlagsArgv].push(key);
+        });
+        if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {
+            Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
+                delete argv[key];
+            });
+        }
+        if (configuration['strip-aliased']) {
+            [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {
+                if (configuration['camel-case-expansion'] && alias.includes('-')) {
+                    delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')];
+                }
+                delete argv[alias];
+            });
+        }
+        // Push argument into positional array, applying numeric coercion:
+        function pushPositional(arg) {
+            const maybeCoercedNumber = maybeCoerceNumber('_', arg);
+            if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') {
+                argv._.push(maybeCoercedNumber);
+            }
+        }
+        // how many arguments should we consume, based
+        // on the nargs option?
+        function eatNargs(i, key, args, argAfterEqualSign) {
+            let ii;
+            let toEat = checkAllAliases(key, flags.nargs);
+            // NaN has a special meaning for the array type, indicating that one or
+            // more values are expected.
+            toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat;
+            if (toEat === 0) {
+                if (!isUndefined(argAfterEqualSign)) {
+                    error = Error(__('Argument unexpected for: %s', key));
+                }
+                setArg(key, defaultValue(key));
+                return i;
+            }
+            let available = isUndefined(argAfterEqualSign) ? 0 : 1;
+            if (configuration['nargs-eats-options']) {
+                // classic behavior, yargs eats positional and dash arguments.
+                if (args.length - (i + 1) + available < toEat) {
+                    error = Error(__('Not enough arguments following: %s', key));
+                }
+                available = toEat;
+            }
+            else {
+                // nargs will not consume flag arguments, e.g., -abc, --foo,
+                // and terminates when one is observed.
+                for (ii = i + 1; ii < args.length; ii++) {
+                    if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii]))
+                        available++;
+                    else
+                        break;
+                }
+                if (available < toEat)
+                    error = Error(__('Not enough arguments following: %s', key));
+            }
+            let consumed = Math.min(available, toEat);
+            if (!isUndefined(argAfterEqualSign) && consumed > 0) {
+                setArg(key, argAfterEqualSign);
+                consumed--;
+            }
+            for (ii = i + 1; ii < (consumed + i + 1); ii++) {
+                setArg(key, args[ii]);
+            }
+            return (i + consumed);
+        }
+        // if an option is an array, eat all non-hyphenated arguments
+        // following it... YUM!
+        // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
+        function eatArray(i, key, args, argAfterEqualSign) {
+            let argsToSet = [];
+            let next = argAfterEqualSign || args[i + 1];
+            // If both array and nargs are configured, enforce the nargs count:
+            const nargsCount = checkAllAliases(key, flags.nargs);
+            if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
+                argsToSet.push(true);
+            }
+            else if (isUndefined(next) ||
+                (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {
+                // for keys without value ==> argsToSet remains an empty []
+                // set user default value, if available
+                if (defaults[key] !== undefined) {
+                    const defVal = defaults[key];
+                    argsToSet = Array.isArray(defVal) ? defVal : [defVal];
+                }
+            }
+            else {
+                // value in --option=value is eaten as is
+                if (!isUndefined(argAfterEqualSign)) {
+                    argsToSet.push(processValue(key, argAfterEqualSign, true));
+                }
+                for (let ii = i + 1; ii < args.length; ii++) {
+                    if ((!configuration['greedy-arrays'] && argsToSet.length > 0) ||
+                        (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount))
+                        break;
+                    next = args[ii];
+                    if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
+                        break;
+                    i = ii;
+                    argsToSet.push(processValue(key, next, inputIsString));
+                }
+            }
+            // If both array and nargs are configured, create an error if less than
+            // nargs positionals were found. NaN has special meaning, indicating
+            // that at least one value is required (more are okay).
+            if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) ||
+                (isNaN(nargsCount) && argsToSet.length === 0))) {
+                error = Error(__('Not enough arguments following: %s', key));
+            }
+            setArg(key, argsToSet);
+            return i;
+        }
+        function setArg(key, val, shouldStripQuotes = inputIsString) {
+            if (/-/.test(key) && configuration['camel-case-expansion']) {
+                const alias = key.split('.').map(function (prop) {
+                    return camelCase(prop);
+                }).join('.');
+                addNewAlias(key, alias);
+            }
+            const value = processValue(key, val, shouldStripQuotes);
+            const splitKey = key.split('.');
+            setKey(argv, splitKey, value);
+            // handle populating aliases of the full key
+            if (flags.aliases[key]) {
+                flags.aliases[key].forEach(function (x) {
+                    const keyProperties = x.split('.');
+                    setKey(argv, keyProperties, value);
+                });
+            }
+            // handle populating aliases of the first element of the dot-notation key
+            if (splitKey.length > 1 && configuration['dot-notation']) {
+                (flags.aliases[splitKey[0]] || []).forEach(function (x) {
+                    let keyProperties = x.split('.');
+                    // expand alias with nested objects in key
+                    const a = [].concat(splitKey);
+                    a.shift(); // nuke the old key.
+                    keyProperties = keyProperties.concat(a);
+                    // populate alias only if is not already an alias of the full key
+                    // (already populated above)
+                    if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) {
+                        setKey(argv, keyProperties, value);
+                    }
+                });
+            }
+            // Set normalize getter and setter when key is in 'normalize' but isn't an array
+            if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
+                const keys = [key].concat(flags.aliases[key] || []);
+                keys.forEach(function (key) {
+                    Object.defineProperty(argvReturn, key, {
+                        enumerable: true,
+                        get() {
+                            return val;
+                        },
+                        set(value) {
+                            val = typeof value === 'string' ? mixin.normalize(value) : value;
+                        }
+                    });
+                });
+            }
+        }
+        function addNewAlias(key, alias) {
+            if (!(flags.aliases[key] && flags.aliases[key].length)) {
+                flags.aliases[key] = [alias];
+                newAliases[alias] = true;
+            }
+            if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
+                addNewAlias(alias, key);
+            }
+        }
+        function processValue(key, val, shouldStripQuotes) {
+            // strings may be quoted, clean this up as we assign values.
+            if (shouldStripQuotes) {
+                val = stripQuotes(val);
+            }
+            // handle parsing boolean arguments --foo=true --bar false.
+            if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
+                if (typeof val === 'string')
+                    val = val === 'true';
+            }
+            let value = Array.isArray(val)
+                ? val.map(function (v) { return maybeCoerceNumber(key, v); })
+                : maybeCoerceNumber(key, val);
+            // increment a count given as arg (either no value or value parsed as boolean)
+            if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
+                value = increment();
+            }
+            // Set normalized value when key is in 'normalize' and in 'arrays'
+            if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
+                if (Array.isArray(val))
+                    value = val.map((val) => { return mixin.normalize(val); });
+                else
+                    value = mixin.normalize(val);
+            }
+            return value;
+        }
+        function maybeCoerceNumber(key, value) {
+            if (!configuration['parse-positional-numbers'] && key === '_')
+                return value;
+            if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
+                const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`))));
+                if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) {
+                    value = Number(value);
+                }
+            }
+            return value;
+        }
+        // set args from config.json file, this should be
+        // applied last so that defaults can be applied.
+        function setConfig(argv) {
+            const configLookup = Object.create(null);
+            // expand defaults/aliases, in-case any happen to reference
+            // the config.json file.
+            applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
+            Object.keys(flags.configs).forEach(function (configKey) {
+                const configPath = argv[configKey] || configLookup[configKey];
+                if (configPath) {
+                    try {
+                        let config = null;
+                        const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
+                        const resolveConfig = flags.configs[configKey];
+                        if (typeof resolveConfig === 'function') {
+                            try {
+                                config = resolveConfig(resolvedConfigPath);
+                            }
+                            catch (e) {
+                                config = e;
+                            }
+                            if (config instanceof Error) {
+                                error = config;
+                                return;
+                            }
+                        }
+                        else {
+                            config = mixin.require(resolvedConfigPath);
+                        }
+                        setConfigObject(config);
+                    }
+                    catch (ex) {
+                        // Deno will receive a PermissionDenied error if an attempt is
+                        // made to load config without the --allow-read flag:
+                        if (ex.name === 'PermissionDenied')
+                            error = ex;
+                        else if (argv[configKey])
+                            error = Error(__('Invalid JSON config file: %s', configPath));
+                    }
+                }
+            });
+        }
+        // set args from config object.
+        // it recursively checks nested objects.
+        function setConfigObject(config, prev) {
+            Object.keys(config).forEach(function (key) {
+                const value = config[key];
+                const fullKey = prev ? prev + '.' + key : key;
+                // if the value is an inner object and we have dot-notation
+                // enabled, treat inner objects in config the same as
+                // heavily nested dot notations (foo.bar.apple).
+                if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) {
+                    // if the value is an object but not an array, check nested object
+                    setConfigObject(value, fullKey);
+                }
+                else {
+                    // setting arguments via CLI takes precedence over
+                    // values within the config file.
+                    if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {
+                        setArg(fullKey, value);
+                    }
+                }
+            });
+        }
+        // set all config objects passed in opts
+        function setConfigObjects() {
+            if (typeof configObjects !== 'undefined') {
+                configObjects.forEach(function (configObject) {
+                    setConfigObject(configObject);
+                });
+            }
+        }
+        function applyEnvVars(argv, configOnly) {
+            if (typeof envPrefix === 'undefined')
+                return;
+            const prefix = typeof envPrefix === 'string' ? envPrefix : '';
+            const env = mixin.env();
+            Object.keys(env).forEach(function (envVar) {
+                if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {
+                    // get array of nested keys and convert them to camel case
+                    const keys = envVar.split('__').map(function (key, i) {
+                        if (i === 0) {
+                            key = key.substring(prefix.length);
+                        }
+                        return camelCase(key);
+                    });
+                    if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {
+                        setArg(keys.join('.'), env[envVar]);
+                    }
+                }
+            });
+        }
+        function applyCoercions(argv) {
+            let coerce;
+            const applied = new Set();
+            Object.keys(argv).forEach(function (key) {
+                if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases
+                    coerce = checkAllAliases(key, flags.coercions);
+                    if (typeof coerce === 'function') {
+                        try {
+                            const value = maybeCoerceNumber(key, coerce(argv[key]));
+                            ([].concat(flags.aliases[key] || [], key)).forEach(ali => {
+                                applied.add(ali);
+                                argv[ali] = value;
+                            });
+                        }
+                        catch (err) {
+                            error = err;
+                        }
+                    }
+                }
+            });
+        }
+        function setPlaceholderKeys(argv) {
+            flags.keys.forEach((key) => {
+                // don't set placeholder keys for dot notation options 'foo.bar'.
+                if (~key.indexOf('.'))
+                    return;
+                if (typeof argv[key] === 'undefined')
+                    argv[key] = undefined;
+            });
+            return argv;
+        }
+        function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) {
+            Object.keys(defaults).forEach(function (key) {
+                if (!hasKey(obj, key.split('.'))) {
+                    setKey(obj, key.split('.'), defaults[key]);
+                    if (canLog)
+                        defaulted[key] = true;
+                    (aliases[key] || []).forEach(function (x) {
+                        if (hasKey(obj, x.split('.')))
+                            return;
+                        setKey(obj, x.split('.'), defaults[key]);
+                    });
+                }
+            });
+        }
+        function hasKey(obj, keys) {
+            let o = obj;
+            if (!configuration['dot-notation'])
+                keys = [keys.join('.')];
+            keys.slice(0, -1).forEach(function (key) {
+                o = (o[key] || {});
+            });
+            const key = keys[keys.length - 1];
+            if (typeof o !== 'object')
+                return false;
+            else
+                return key in o;
+        }
+        function setKey(obj, keys, value) {
+            let o = obj;
+            if (!configuration['dot-notation'])
+                keys = [keys.join('.')];
+            keys.slice(0, -1).forEach(function (key) {
+                // TODO(bcoe): in the next major version of yargs, switch to
+                // Object.create(null) for dot notation:
+                key = sanitizeKey(key);
+                if (typeof o === 'object' && o[key] === undefined) {
+                    o[key] = {};
+                }
+                if (typeof o[key] !== 'object' || Array.isArray(o[key])) {
+                    // ensure that o[key] is an array, and that the last item is an empty object.
+                    if (Array.isArray(o[key])) {
+                        o[key].push({});
+                    }
+                    else {
+                        o[key] = [o[key], {}];
+                    }
+                    // we want to update the empty object at the end of the o[key] array, so set o to that object
+                    o = o[key][o[key].length - 1];
+                }
+                else {
+                    o = o[key];
+                }
+            });
+            // TODO(bcoe): in the next major version of yargs, switch to
+            // Object.create(null) for dot notation:
+            const key = sanitizeKey(keys[keys.length - 1]);
+            const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays);
+            const isValueArray = Array.isArray(value);
+            let duplicate = configuration['duplicate-arguments-array'];
+            // nargs has higher priority than duplicate
+            if (!duplicate && checkAllAliases(key, flags.nargs)) {
+                duplicate = true;
+                if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {
+                    o[key] = undefined;
+                }
+            }
+            if (value === increment()) {
+                o[key] = increment(o[key]);
+            }
+            else if (Array.isArray(o[key])) {
+                if (duplicate && isTypeArray && isValueArray) {
+                    o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
+                }
+                else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
+                    o[key] = value;
+                }
+                else {
+                    o[key] = o[key].concat([value]);
+                }
+            }
+            else if (o[key] === undefined && isTypeArray) {
+                o[key] = isValueArray ? value : [value];
+            }
+            else if (duplicate && !(o[key] === undefined ||
+                checkAllAliases(key, flags.counts) ||
+                checkAllAliases(key, flags.bools))) {
+                o[key] = [o[key], value];
+            }
+            else {
+                o[key] = value;
+            }
+        }
+        // extend the aliases list with inferred aliases.
+        function extendAliases(...args) {
+            args.forEach(function (obj) {
+                Object.keys(obj || {}).forEach(function (key) {
+                    // short-circuit if we've already added a key
+                    // to the aliases array, for example it might
+                    // exist in both 'opts.default' and 'opts.key'.
+                    if (flags.aliases[key])
+                        return;
+                    flags.aliases[key] = [].concat(aliases[key] || []);
+                    // For "--option-name", also set argv.optionName
+                    flags.aliases[key].concat(key).forEach(function (x) {
+                        if (/-/.test(x) && configuration['camel-case-expansion']) {
+                            const c = camelCase(x);
+                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+                                flags.aliases[key].push(c);
+                                newAliases[c] = true;
+                            }
+                        }
+                    });
+                    // For "--optionName", also set argv['option-name']
+                    flags.aliases[key].concat(key).forEach(function (x) {
+                        if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {
+                            const c = decamelize(x, '-');
+                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+                                flags.aliases[key].push(c);
+                                newAliases[c] = true;
+                            }
+                        }
+                    });
+                    flags.aliases[key].forEach(function (x) {
+                        flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
+                            return x !== y;
+                        }));
+                    });
+                });
+            });
+        }
+        function checkAllAliases(key, flag) {
+            const toCheck = [].concat(flags.aliases[key] || [], key);
+            const keys = Object.keys(flag);
+            const setAlias = toCheck.find(key => keys.includes(key));
+            return setAlias ? flag[setAlias] : false;
+        }
+        function hasAnyFlag(key) {
+            const flagsKeys = Object.keys(flags);
+            const toCheck = [].concat(flagsKeys.map(k => flags[k]));
+            return toCheck.some(function (flag) {
+                return Array.isArray(flag) ? flag.includes(key) : flag[key];
+            });
+        }
+        function hasFlagsMatching(arg, ...patterns) {
+            const toCheck = [].concat(...patterns);
+            return toCheck.some(function (pattern) {
+                const match = arg.match(pattern);
+                return match && hasAnyFlag(match[1]);
+            });
+        }
+        // based on a simplified version of the short flag group parsing logic
+        function hasAllShortFlags(arg) {
+            // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group
+            if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
+                return false;
+            }
+            let hasAllFlags = true;
+            let next;
+            const letters = arg.slice(1).split('');
+            for (let j = 0; j < letters.length; j++) {
+                next = arg.slice(j + 2);
+                if (!hasAnyFlag(letters[j])) {
+                    hasAllFlags = false;
+                    break;
+                }
+                if ((letters[j + 1] && letters[j + 1] === '=') ||
+                    next === '-' ||
+                    (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) ||
+                    (letters[j + 1] && letters[j + 1].match(/\W/))) {
+                    break;
+                }
+            }
+            return hasAllFlags;
+        }
+        function isUnknownOptionAsArg(arg) {
+            return configuration['unknown-options-as-args'] && isUnknownOption(arg);
+        }
+        function isUnknownOption(arg) {
+            arg = arg.replace(/^-{3,}/, '--');
+            // ignore negative numbers
+            if (arg.match(negative)) {
+                return false;
+            }
+            // if this is a short option group and all of them are configured, it isn't unknown
+            if (hasAllShortFlags(arg)) {
+                return false;
+            }
+            // e.g. '--count=2'
+            const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
+            // e.g. '-a' or '--arg'
+            const normalFlag = /^-+([^=]+?)$/;
+            // e.g. '-a-'
+            const flagEndingInHyphen = /^-+([^=]+?)-$/;
+            // e.g. '-abc123'
+            const flagEndingInDigits = /^-+([^=]+?\d+)$/;
+            // e.g. '-a/usr/local'
+            const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
+            // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method
+            return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
+        }
+        // make a best effort to pick a default value
+        // for an option based on name and type.
+        function defaultValue(key) {
+            if (!checkAllAliases(key, flags.bools) &&
+                !checkAllAliases(key, flags.counts) &&
+                `${key}` in defaults) {
+                return defaults[key];
+            }
+            else {
+                return defaultForType(guessType(key));
+            }
+        }
+        // return a default value, given the type of a flag.,
+        function defaultForType(type) {
+            const def = {
+                [DefaultValuesForTypeKey.BOOLEAN]: true,
+                [DefaultValuesForTypeKey.STRING]: '',
+                [DefaultValuesForTypeKey.NUMBER]: undefined,
+                [DefaultValuesForTypeKey.ARRAY]: []
+            };
+            return def[type];
+        }
+        // given a flag, enforce a default type.
+        function guessType(key) {
+            let type = DefaultValuesForTypeKey.BOOLEAN;
+            if (checkAllAliases(key, flags.strings))
+                type = DefaultValuesForTypeKey.STRING;
+            else if (checkAllAliases(key, flags.numbers))
+                type = DefaultValuesForTypeKey.NUMBER;
+            else if (checkAllAliases(key, flags.bools))
+                type = DefaultValuesForTypeKey.BOOLEAN;
+            else if (checkAllAliases(key, flags.arrays))
+                type = DefaultValuesForTypeKey.ARRAY;
+            return type;
+        }
+        function isUndefined(num) {
+            return num === undefined;
+        }
+        // check user configuration settings for inconsistencies
+        function checkConfiguration() {
+            // count keys should not be set as array/narg
+            Object.keys(flags.counts).find(key => {
+                if (checkAllAliases(key, flags.arrays)) {
+                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key));
+                    return true;
+                }
+                else if (checkAllAliases(key, flags.nargs)) {
+                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key));
+                    return true;
+                }
+                return false;
+            });
+        }
+        return {
+            aliases: Object.assign({}, flags.aliases),
+            argv: Object.assign(argvReturn, argv),
+            configuration: configuration,
+            defaulted: Object.assign({}, defaulted),
+            error: error,
+            newAliases: Object.assign({}, newAliases)
+        };
+    }
+}
+// if any aliases reference each other, we should
+// merge them together.
+function combineAliases(aliases) {
+    const aliasArrays = [];
+    const combined = Object.create(null);
+    let change = true;
+    // turn alias lookup hash {key: ['alias1', 'alias2']} into
+    // a simple array ['key', 'alias1', 'alias2']
+    Object.keys(aliases).forEach(function (key) {
+        aliasArrays.push([].concat(aliases[key], key));
+    });
+    // combine arrays until zero changes are
+    // made in an iteration.
+    while (change) {
+        change = false;
+        for (let i = 0; i < aliasArrays.length; i++) {
+            for (let ii = i + 1; ii < aliasArrays.length; ii++) {
+                const intersect = aliasArrays[i].filter(function (v) {
+                    return aliasArrays[ii].indexOf(v) !== -1;
+                });
+                if (intersect.length) {
+                    aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
+                    aliasArrays.splice(ii, 1);
+                    change = true;
+                    break;
+                }
+            }
+        }
+    }
+    // map arrays back to the hash-lookup (de-dupe while
+    // we're at it).
+    aliasArrays.forEach(function (aliasArray) {
+        aliasArray = aliasArray.filter(function (v, i, self) {
+            return self.indexOf(v) === i;
+        });
+        const lastAlias = aliasArray.pop();
+        if (lastAlias !== undefined && typeof lastAlias === 'string') {
+            combined[lastAlias] = aliasArray;
+        }
+    });
+    return combined;
+}
+// this function should only be called when a count is given as an arg
+// it is NOT called to set a default value
+// thus we can start the count at 1 instead of 0
+function increment(orig) {
+    return orig !== undefined ? orig + 1 : 1;
+}
+// TODO(bcoe): in the next major version of yargs, switch to
+// Object.create(null) for dot notation:
+function sanitizeKey(key) {
+    if (key === '__proto__')
+        return '___proto___';
+    return key;
+}
+function stripQuotes(val) {
+    return (typeof val === 'string' &&
+        (val[0] === "'" || val[0] === '"') &&
+        val[val.length - 1] === val[0])
+        ? val.substring(1, val.length - 1)
+        : val;
+}
+
+/**
+ * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js
+ * CJS and ESM environments.
+ *
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+var _a, _b, _c;
+// See https://github.com/yargs/yargs-parser#supported-nodejs-versions for our
+// version support policy. The YARGS_MIN_NODE_VERSION is used for testing only.
+const minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION)
+    ? Number(process.env.YARGS_MIN_NODE_VERSION)
+    : 12;
+const nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
+if (nodeVersion) {
+    const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
+    if (major < minNodeVersion) {
+        throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
+    }
+}
+// Creates a yargs-parser instance using Node.js standard libraries:
+const env = process ? process.env : {};
+const parser = new YargsParser({
+    cwd: process.cwd,
+    env: () => {
+        return env;
+    },
+    format: require$$2.format,
+    normalize: require$$0.normalize,
+    resolve: require$$0.resolve,
+    // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
+    // we can exercise all the lines below:
+    require: (path) => {
+        if (typeof require !== 'undefined') {
+            return require(path);
+        }
+        else if (path.match(/\.json$/)) {
+            // Addresses: https://github.com/yargs/yargs/issues/2040
+            return JSON.parse(require$$0$1.readFileSync(path, 'utf8'));
+        }
+        else {
+            throw Error('only .json config files are supported in ESM');
+        }
+    }
+});
+const yargsParser = function Parser(args, opts) {
+    const result = parser.parse(args.slice(), opts);
+    return result.argv;
+};
+yargsParser.detailed = function (args, opts) {
+    return parser.parse(args.slice(), opts);
+};
+yargsParser.camelCase = camelCase;
+yargsParser.decamelize = decamelize;
+yargsParser.looksLikeNumber = looksLikeNumber;
+
+const toZeroIfInfinity = value => Number.isFinite(value) ? value : 0;
+
+function parseNumber(milliseconds) {
+	return {
+		days: Math.trunc(milliseconds / 86_400_000),
+		hours: Math.trunc(milliseconds / 3_600_000 % 24),
+		minutes: Math.trunc(milliseconds / 60_000 % 60),
+		seconds: Math.trunc(milliseconds / 1000 % 60),
+		milliseconds: Math.trunc(milliseconds % 1000),
+		microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1000) % 1000),
+		nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1000),
+	};
+}
+
+function parseBigint(milliseconds) {
+	return {
+		days: milliseconds / 86_400_000n,
+		hours: milliseconds / 3_600_000n % 24n,
+		minutes: milliseconds / 60_000n % 60n,
+		seconds: milliseconds / 1000n % 60n,
+		milliseconds: milliseconds % 1000n,
+		microseconds: 0n,
+		nanoseconds: 0n,
+	};
+}
+
+function parseMilliseconds(milliseconds) {
+	switch (typeof milliseconds) {
+		case 'number': {
+			if (Number.isFinite(milliseconds)) {
+				return parseNumber(milliseconds);
+			}
+
+			break;
+		}
+
+		case 'bigint': {
+			return parseBigint(milliseconds);
+		}
+
+		// No default
+	}
+
+	throw new TypeError('Expected a finite number or bigint');
+}
+
+const isZero = value => value === 0 || value === 0n;
+const pluralize = (word, count) => (count === 1 || count === 1n) ? word : `${word}s`;
+
+const SECOND_ROUNDING_EPSILON = 0.000_000_1;
+const ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
+
+function prettyMilliseconds(milliseconds, options) {
+	const isBigInt = typeof milliseconds === 'bigint';
+	if (!isBigInt && !Number.isFinite(milliseconds)) {
+		throw new TypeError('Expected a finite number or bigint');
+	}
+
+	options = {...options};
+
+	const sign = milliseconds < 0 ? '-' : '';
+	milliseconds = milliseconds < 0 ? -milliseconds : milliseconds; // Cannot use `Math.abs()` because of BigInt support.
+
+	if (options.colonNotation) {
+		options.compact = false;
+		options.formatSubMilliseconds = false;
+		options.separateMilliseconds = false;
+		options.verbose = false;
+	}
+
+	if (options.compact) {
+		options.unitCount = 1;
+		options.secondsDecimalDigits = 0;
+		options.millisecondsDecimalDigits = 0;
+	}
+
+	let result = [];
+
+	const floorDecimals = (value, decimalDigits) => {
+		const flooredInterimValue = Math.floor((value * (10 ** decimalDigits)) + SECOND_ROUNDING_EPSILON);
+		const flooredValue = Math.round(flooredInterimValue) / (10 ** decimalDigits);
+		return flooredValue.toFixed(decimalDigits);
+	};
+
+	const add = (value, long, short, valueString) => {
+		if (
+			(result.length === 0 || !options.colonNotation)
+			&& isZero(value)
+			&& !(options.colonNotation && short === 'm')) {
+			return;
+		}
+
+		valueString ??= String(value);
+		if (options.colonNotation) {
+			const wholeDigits = valueString.includes('.') ? valueString.split('.')[0].length : valueString.length;
+			const minLength = result.length > 0 ? 2 : 1;
+			valueString = '0'.repeat(Math.max(0, minLength - wholeDigits)) + valueString;
+		} else {
+			valueString += options.verbose ? ' ' + pluralize(long, value) : short;
+		}
+
+		result.push(valueString);
+	};
+
+	const parsed = parseMilliseconds(milliseconds);
+	const days = BigInt(parsed.days);
+
+	add(days / 365n, 'year', 'y');
+	add(days % 365n, 'day', 'd');
+	add(Number(parsed.hours), 'hour', 'h');
+	add(Number(parsed.minutes), 'minute', 'm');
+
+	if (
+		options.separateMilliseconds
+		|| options.formatSubMilliseconds
+		|| (!options.colonNotation && milliseconds < 1000)
+	) {
+		const seconds = Number(parsed.seconds);
+		const milliseconds = Number(parsed.milliseconds);
+		const microseconds = Number(parsed.microseconds);
+		const nanoseconds = Number(parsed.nanoseconds);
+
+		add(seconds, 'second', 's');
+
+		if (options.formatSubMilliseconds) {
+			add(milliseconds, 'millisecond', 'ms');
+			add(microseconds, 'microsecond', 'µs');
+			add(nanoseconds, 'nanosecond', 'ns');
+		} else {
+			const millisecondsAndBelow
+				= milliseconds
+				+ (microseconds / 1000)
+				+ (nanoseconds / 1e6);
+
+			const millisecondsDecimalDigits
+				= typeof options.millisecondsDecimalDigits === 'number'
+					? options.millisecondsDecimalDigits
+					: 0;
+
+			const roundedMilliseconds = millisecondsAndBelow >= 1
+				? Math.round(millisecondsAndBelow)
+				: Math.ceil(millisecondsAndBelow);
+
+			const millisecondsString = millisecondsDecimalDigits
+				? millisecondsAndBelow.toFixed(millisecondsDecimalDigits)
+				: roundedMilliseconds;
+
+			add(
+				Number.parseFloat(millisecondsString),
+				'millisecond',
+				'ms',
+				millisecondsString,
+			);
+		}
+	} else {
+		const seconds = (
+			(isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds)
+			/ 1000
+		) % 60;
+		const secondsDecimalDigits
+			= typeof options.secondsDecimalDigits === 'number'
+				? options.secondsDecimalDigits
+				: 1;
+		const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+		const secondsString = options.keepDecimalsOnWholeSeconds
+			? secondsFixed
+			: secondsFixed.replace(/\.0+$/, '');
+		add(Number.parseFloat(secondsString), 'second', 's', secondsString);
+	}
+
+	if (result.length === 0) {
+		return sign + '0' + (options.verbose ? ' milliseconds' : 'ms');
+	}
+
+	const separator = options.colonNotation ? ':' : ' ';
+	if (typeof options.unitCount === 'number') {
+		result = result.slice(0, Math.max(options.unitCount, 1));
+	}
+
+	return sign + result.join(separator);
+}
+
+const BYTE_UNITS = [
+	'B',
+	'kB',
+	'MB',
+	'GB',
+	'TB',
+	'PB',
+	'EB',
+	'ZB',
+	'YB',
+];
+
+const BIBYTE_UNITS = [
+	'B',
+	'KiB',
+	'MiB',
+	'GiB',
+	'TiB',
+	'PiB',
+	'EiB',
+	'ZiB',
+	'YiB',
+];
+
+const BIT_UNITS = [
+	'b',
+	'kbit',
+	'Mbit',
+	'Gbit',
+	'Tbit',
+	'Pbit',
+	'Ebit',
+	'Zbit',
+	'Ybit',
+];
+
+const BIBIT_UNITS = [
+	'b',
+	'kibit',
+	'Mibit',
+	'Gibit',
+	'Tibit',
+	'Pibit',
+	'Eibit',
+	'Zibit',
+	'Yibit',
+];
+
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale, options) => {
+	let result = number;
+	if (typeof locale === 'string' || Array.isArray(locale)) {
+		result = number.toLocaleString(locale, options);
+	} else if (locale === true || options !== undefined) {
+		result = number.toLocaleString(undefined, options);
+	}
+
+	return result;
+};
+
+function prettyBytes(number, options) {
+	if (!Number.isFinite(number)) {
+		throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+	}
+
+	options = {
+		bits: false,
+		binary: false,
+		space: true,
+		...options,
+	};
+
+	const UNITS = options.bits
+		? (options.binary ? BIBIT_UNITS : BIT_UNITS)
+		: (options.binary ? BIBYTE_UNITS : BYTE_UNITS);
+
+	const separator = options.space ? ' ' : '';
+
+	if (options.signed && number === 0) {
+		return ` 0${separator}${UNITS[0]}`;
+	}
+
+	const isNegative = number < 0;
+	const prefix = isNegative ? '-' : (options.signed ? '+' : '');
+
+	if (isNegative) {
+		number = -number;
+	}
+
+	let localeOptions;
+
+	if (options.minimumFractionDigits !== undefined) {
+		localeOptions = {minimumFractionDigits: options.minimumFractionDigits};
+	}
+
+	if (options.maximumFractionDigits !== undefined) {
+		localeOptions = {maximumFractionDigits: options.maximumFractionDigits, ...localeOptions};
+	}
+
+	if (number < 1) {
+		const numberString = toLocaleString(number, options.locale, localeOptions);
+		return prefix + numberString + separator + UNITS[0];
+	}
+
+	const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
+	number /= (options.binary ? 1024 : 1000) ** exponent;
+
+	if (!localeOptions) {
+		number = number.toPrecision(3);
+	}
+
+	const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+
+	const unit = UNITS[exponent];
+
+	return prefix + numberString + separator + unit;
+}
+
+function printTimings(timings) {
+    for (const [label, [time, memory, total]] of Object.entries(timings)) {
+        const appliedColor = label[0] === '#' ? (label[1] === '#' ? rollup.bold : rollup.underline) : (text) => text;
+        const row = `${label}: ${time.toFixed(0)}ms, ${prettyBytes(memory)} / ${prettyBytes(total)}`;
+        console.info(appliedColor(row));
+    }
+}
+
+async function build(inputOptions, warnings, silent = false) {
+    const outputOptions = inputOptions.output;
+    const useStdout = !outputOptions[0].file && !outputOptions[0].dir;
+    const start = Date.now();
+    const files = useStdout ? ['stdout'] : outputOptions.map(t => parseAst_js.relativeId(t.file || t.dir));
+    if (!silent) {
+        let inputFiles;
+        if (typeof inputOptions.input === 'string') {
+            inputFiles = inputOptions.input;
+        }
+        else if (Array.isArray(inputOptions.input)) {
+            inputFiles = inputOptions.input.join(', ');
+        }
+        else if (typeof inputOptions.input === 'object' && inputOptions.input !== null) {
+            inputFiles = Object.values(inputOptions.input).join(', ');
+        }
+        rollup.stderr(rollup.cyan$1(`\n${rollup.bold(inputFiles)} → ${rollup.bold(files.join(', '))}...`));
+    }
+    const bundle = await rollup.rollup(inputOptions);
+    if (useStdout) {
+        const output = outputOptions[0];
+        if (output.sourcemap && output.sourcemap !== 'inline') {
+            rollup.handleError(parseAst_js.logOnlyInlineSourcemapsForStdout());
+        }
+        const { output: outputs } = await bundle.generate(output);
+        for (const file of outputs) {
+            if (outputs.length > 1)
+                process$1.stdout.write(`\n${rollup.cyan$1(rollup.bold(`//→ ${file.fileName}:`))}\n`);
+            process$1.stdout.write(file.type === 'asset' ? file.source : file.code);
+        }
+        if (!silent) {
+            warnings.flush();
+        }
+        return;
+    }
+    await Promise.all(outputOptions.map(bundle.write));
+    await bundle.close();
+    if (!silent) {
+        warnings.flush();
+        rollup.stderr(rollup.green(`created ${rollup.bold(files.join(', '))} in ${rollup.bold(prettyMilliseconds(Date.now() - start))}`));
+        if (bundle && bundle.getTimings) {
+            printTimings(bundle.getTimings());
+        }
+    }
+}
+
+const DEFAULT_CONFIG_BASE = 'rollup.config';
+async function getConfigPath(commandConfig) {
+    if (commandConfig === true) {
+        return path.resolve(await findConfigFileNameInCwd());
+    }
+    if (commandConfig.slice(0, 5) === 'node:') {
+        const packageName = commandConfig.slice(5);
+        try {
+            return require.resolve(`rollup-config-${packageName}`, { paths: [process$1.cwd()] });
+        }
+        catch {
+            try {
+                return require.resolve(packageName, { paths: [process$1.cwd()] });
+            }
+            catch (error) {
+                if (error.code === 'MODULE_NOT_FOUND') {
+                    rollup.handleError(parseAst_js.logMissingExternalConfig(commandConfig));
+                }
+                throw error;
+            }
+        }
+    }
+    return path.resolve(commandConfig);
+}
+async function findConfigFileNameInCwd() {
+    const filesInWorkingDirectory = new Set(await promises.readdir(process$1.cwd()));
+    for (const extension of ['mjs', 'cjs', 'ts']) {
+        const fileName = `${DEFAULT_CONFIG_BASE}.${extension}`;
+        if (filesInWorkingDirectory.has(fileName))
+            return fileName;
+    }
+    return `${DEFAULT_CONFIG_BASE}.js`;
+}
+
+async function loadConfigFromCommand(commandOptions, watchMode) {
+    const warnings = loadConfigFile_js.batchWarnings(commandOptions);
+    if (!commandOptions.input && (commandOptions.stdin || !process$1.stdin.isTTY)) {
+        commandOptions.input = loadConfigFile_js.stdinName;
+    }
+    const options = await rollup.mergeOptions({ input: [] }, watchMode, commandOptions, warnings.log);
+    await loadConfigFile_js.addCommandPluginsToInputOptions(options, commandOptions);
+    return { options: [options], warnings };
+}
+
+async function runRollup(command) {
+    let inputSource;
+    if (command._.length > 0) {
+        if (command.input) {
+            rollup.handleError(parseAst_js.logDuplicateImportOptions());
+        }
+        inputSource = command._;
+    }
+    else if (typeof command.input === 'string') {
+        inputSource = [command.input];
+    }
+    else {
+        inputSource = command.input;
+    }
+    if (inputSource && inputSource.length > 0) {
+        if (inputSource.some((input) => input.includes('='))) {
+            command.input = {};
+            for (const input of inputSource) {
+                const equalsIndex = input.indexOf('=');
+                const value = input.slice(Math.max(0, equalsIndex + 1));
+                const key = input.slice(0, Math.max(0, equalsIndex)) || parseAst_js.getAliasName(input);
+                command.input[key] = value;
+            }
+        }
+        else {
+            command.input = inputSource;
+        }
+    }
+    if (command.environment) {
+        const environment = Array.isArray(command.environment)
+            ? command.environment
+            : [command.environment];
+        for (const argument of environment) {
+            for (const pair of argument.split(',')) {
+                const [key, ...value] = pair.split(':');
+                process$1.env[key] = value.length === 0 ? String(true) : value.join(':');
+            }
+        }
+    }
+    if (rollup.isWatchEnabled(command.watch)) {
+        await fseventsImporter.loadFsEvents();
+        const { watch } = await Promise.resolve().then(() => require('../shared/watch-cli.js'));
+        await watch(command);
+    }
+    else {
+        try {
+            const { options, warnings } = await getConfigs(command);
+            try {
+                for (const inputOptions of options) {
+                    if (!inputOptions.cache) {
+                        // We explicitly disable the cache when unused as the CLI will not
+                        // use the cache object on the bundle when not in watch mode. This
+                        // improves performance as the cache is not generated.
+                        inputOptions.cache = false;
+                    }
+                    await build(inputOptions, warnings, command.silent);
+                }
+                if (command.failAfterWarnings && warnings.warningOccurred) {
+                    warnings.flush();
+                    rollup.handleError(parseAst_js.logFailAfterWarnings());
+                }
+            }
+            catch (error) {
+                warnings.flush();
+                rollup.handleError(error);
+            }
+        }
+        catch (error) {
+            rollup.handleError(error);
+        }
+    }
+}
+async function getConfigs(command) {
+    if (command.config) {
+        const configFile = await getConfigPath(command.config);
+        const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command, false);
+        return { options, warnings };
+    }
+    return await loadConfigFromCommand(command, false);
+}
+
+const command = yargsParser(process$1.argv.slice(2), {
+    alias: rollup.commandAliases,
+    configuration: { 'camel-case-expansion': false }
+});
+if (command.help || (process$1.argv.length <= 2 && process$1.stdin.isTTY)) {
+    console.log(`\n${help.replace('__VERSION__', rollup.version)}\n`);
+}
+else if (command.version) {
+    console.log(`rollup v${rollup.version}`);
+}
+else {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('source-map-support').install();
+    }
+    catch {
+        // do nothing
+    }
+    const promise = runRollup(command);
+    if (command.forceExit) {
+        promise.then(() => process$1.exit());
+    }
+}
+
+exports.getConfigPath = getConfigPath;
+exports.loadConfigFromCommand = loadConfigFromCommand;
+exports.prettyMilliseconds = prettyMilliseconds;
+exports.printTimings = printTimings;
+//# sourceMappingURL=rollup.map
diff --git a/node_modules/rollup/dist/es/getLogFilter.js b/node_modules/rollup/dist/es/getLogFilter.js
new file mode 100644
index 0000000..e5434f8
--- /dev/null
+++ b/node_modules/rollup/dist/es/getLogFilter.js
@@ -0,0 +1,64 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+const getLogFilter = filters => {
+    if (filters.length === 0)
+        return () => true;
+    const normalizedFilters = filters.map(filter => filter.split('&').map(subFilter => {
+        const inverted = subFilter.startsWith('!');
+        if (inverted)
+            subFilter = subFilter.slice(1);
+        const [key, ...value] = subFilter.split(':');
+        return { inverted, key: key.split('.'), parts: value.join(':').split('*') };
+    }));
+    return (log) => {
+        nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+            for (const { inverted, key, parts } of intersectedFilters) {
+                const isFilterSatisfied = testFilter(log, key, parts);
+                if (inverted ? isFilterSatisfied : !isFilterSatisfied) {
+                    continue nextIntersectedFilter;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+};
+const testFilter = (log, key, parts) => {
+    let rawValue = log;
+    for (let index = 0; index < key.length; index++) {
+        if (!rawValue) {
+            return false;
+        }
+        const part = key[index];
+        if (!(part in rawValue)) {
+            return false;
+        }
+        rawValue = rawValue[part];
+    }
+    let value = typeof rawValue === 'object' ? JSON.stringify(rawValue) : String(rawValue);
+    if (parts.length === 1) {
+        return value === parts[0];
+    }
+    if (!value.startsWith(parts[0])) {
+        return false;
+    }
+    const lastPartIndex = parts.length - 1;
+    for (let index = 1; index < lastPartIndex; index++) {
+        const part = parts[index];
+        const position = value.indexOf(part);
+        if (position === -1) {
+            return false;
+        }
+        value = value.slice(position + part.length);
+    }
+    return value.endsWith(parts[lastPartIndex]);
+};
+
+export { getLogFilter };
diff --git a/node_modules/rollup/dist/es/package.json b/node_modules/rollup/dist/es/package.json
new file mode 100644
index 0000000..7c34deb
--- /dev/null
+++ b/node_modules/rollup/dist/es/package.json
@@ -0,0 +1 @@
+{"type":"module"}
\ No newline at end of file
diff --git a/node_modules/rollup/dist/es/parseAst.js b/node_modules/rollup/dist/es/parseAst.js
new file mode 100644
index 0000000..fffc728
--- /dev/null
+++ b/node_modules/rollup/dist/es/parseAst.js
@@ -0,0 +1,12 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+import '../native.js';
+export { parseAst, parseAstAsync } from './shared/parseAst.js';
+import 'node:path';
diff --git a/node_modules/rollup/dist/es/rollup.js b/node_modules/rollup/dist/es/rollup.js
new file mode 100644
index 0000000..99874bb
--- /dev/null
+++ b/node_modules/rollup/dist/es/rollup.js
@@ -0,0 +1,18 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+export { version as VERSION, defineConfig, rollup, watch } from './shared/node-entry.js';
+import './shared/parseAst.js';
+import '../native.js';
+import 'node:path';
+import 'path';
+import 'node:process';
+import 'node:perf_hooks';
+import 'node:fs/promises';
+import 'tty';
diff --git a/node_modules/rollup/dist/es/shared/node-entry.js b/node_modules/rollup/dist/es/shared/node-entry.js
new file mode 100644
index 0000000..e2d6922
--- /dev/null
+++ b/node_modules/rollup/dist/es/shared/node-entry.js
@@ -0,0 +1,22186 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+import { ExportDefaultDeclaration as ExportDefaultDeclaration$1, CallExpression as CallExpression$1, EMPTY_ARRAY, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, Program as Program$1, logIllegalImportReassignment, BLANK, logRedeclarationError, StaticBlock as StaticBlock$1, CatchClause as CatchClause$1, logDuplicateArgumentNameError, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, VariableDeclarator as VariableDeclarator$1, ExpressionStatement as ExpressionStatement$1, logMissingExport, normalize, getImportPath, logMissingNodeBuiltins, logReservedNamespace, error, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, Property as Property$1, logConstVariableReassignError, ArrowFunctionExpression as ArrowFunctionExpression$1, EMPTY_SET, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logParseError, logModuleParseError, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, Identifier as Identifier$1, logThisIsUndefined, getAstBuffer, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, EMPTY_OBJECT, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logMissingJsxExport, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logCircularReexport, logInvalidFormatForTopLevelAwait, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logAnonymousPluginCache, logDuplicatePluginName, logUnknownOption, printQuotedStringList, LOGLEVEL_ERROR, logLevelPriority, LOGLEVEL_DEBUG, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, relativeId, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, warnDeprecation, URL_GENERATEBUNDLE, logFileNameConflict, logAssetNotFinalisedForFileName, logChunkNotGeneratedForFileName, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidFunctionPluginHook, logInvalidAddonPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, augmentLogMessage, URL_JSX, URL_TREESHAKE, URL_TREESHAKE_MODULESIDEEFFECTS, logInvalidExportOptionValue, URL_OUTPUT_INTEROP, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_MANUALCHUNKS, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
+import { relative, dirname, basename, extname, resolve as resolve$1 } from 'node:path';
+import require$$0, { posix, win32, isAbsolute, resolve } from 'path';
+import { parseAsync, xxhashBase64Url, xxhashBase36, xxhashBase16 } from '../../native.js';
+import process$1, { env as env$1 } from 'node:process';
+import { performance } from 'node:perf_hooks';
+import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import * as tty from 'tty';
+
+var version = "4.24.0";
+
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars$1.length; i++) {
+    const c = chars$1.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
+function decode(mappings) {
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(';');
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while (reader.pos < semi) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
+                sorted = false;
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                }
+                else {
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
+            else {
+                seg = [genColumn];
+            }
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+function encode(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0)
+            writer.write(semicolon);
+        if (line.length === 0)
+            continue;
+        let genColumn = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (j > 0)
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+                continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4)
+                continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+
+	has(n) {
+		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+	}
+}
+
+let Chunk$1 = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+
+		this.intro = '';
+		this.outro = '';
+
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+
+		{
+			this.previous = null;
+			this.next = null;
+		}
+	}
+
+	appendLeft(content) {
+		this.outro += content;
+	}
+
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+
+		return chunk;
+	}
+
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = '';
+			this.outro = '';
+		}
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	}
+
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
+	split(index) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+
+		this.original = originalBefore;
+
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = '';
+
+		this.end = index;
+
+		if (this.edited) {
+			// after split we should save the edit content record into the correct chunk
+			// to make sure sourcemap correct
+			// For example:
+			// '  test'.trim()
+			//     split   -> '  ' + 'test'
+			//   ✔️ edit    -> '' + 'test'
+			//   ✖️ edit    -> 'test' + '' 
+			// TODO is this block necessary?...
+			newChunk.edit('', false);
+			this.content = '';
+		} else {
+			this.content = originalBefore;
+		}
+
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+
+		return newChunk;
+	}
+
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit('', undefined, true);
+				if (this.edited) {
+					// save the change, if it has been edited
+					this.edit(trimmed, this.storeName, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.intro = this.intro.replace(rx, '');
+			if (this.intro.length) return true;
+		}
+	}
+
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) {
+					// save the change, if it has been edited
+					newChunk.edit(trimmed, this.storeName, true);
+				}
+				this.edit('', undefined, true);
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.outro = this.outro.replace(rx, '');
+			if (this.outro.length) return true;
+		}
+	}
+};
+
+function getBtoa() {
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
+}
+
+const btoa = /*#__PURE__*/ getBtoa();
+
+class SourceMap {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+	}
+}
+
+function guessIndent(code) {
+	const lines = code.split('\n');
+
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+	if (tabbed.length === 0 && spaced.length === 0) {
+		return null;
+	}
+
+	// More lines tabbed than spaced? Assume tabs, and
+	// default to tabs in the case of a tie (or nothing
+	// to go on)
+	if (tabbed.length >= spaced.length) {
+		return '\t';
+	}
+
+	// Otherwise, we need to guess the multiple
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+
+	return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+
+	fromParts.pop(); // get dirname
+
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = '..';
+	}
+
+	return fromParts.concat(toParts).join('/');
+}
+
+const toString = Object.prototype.toString;
+
+function isObject(thing) {
+	return toString.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+	const originalLines = source.split('\n');
+	const lineOffsets = [];
+
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
+		}
+		const line = i - 1;
+		const column = index - lineOffsets[line];
+		return { line, column };
+	};
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
+			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+			if (nameIndex >= 0) {
+				segment.push(nameIndex);
+			}
+			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+
+		this.pending = null;
+	}
+
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
+
+		while (originalCharIndex < chunk.end) {
+			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+				if (this.hires === 'boundary') {
+					// in hires "boundary", group segments per word boundary than per char
+					if (wordRegex.test(original[originalCharIndex])) {
+						// for first char in the boundary found, start the boundary by pushing a segment
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						// for non-word char, end the boundary by pushing a segment
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+				} else {
+					this.rawSegments.push(segment);
+				}
+			}
+
+			if (original[originalCharIndex] === '\n') {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+			} else {
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+
+			originalCharIndex += 1;
+		}
+
+		this.pending = null;
+	}
+
+	advance(str) {
+		if (!str) return;
+
+		const lines = str.split('\n');
+
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+}
+
+const n = '\n';
+
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false,
+};
+
+class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk$1(0, string.length, string);
+
+		Object.defineProperties(this, {
+			original: { writable: true, value: string },
+			outro: { writable: true, value: '' },
+			intro: { writable: true, value: '' },
+			firstChunk: { writable: true, value: chunk },
+			lastChunk: { writable: true, value: chunk },
+			lastSearchedChunk: { writable: true, value: chunk },
+			byStart: { writable: true, value: {} },
+			byEnd: { writable: true, value: {} },
+			filename: { writable: true, value: options.filename },
+			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+			sourcemapLocations: { writable: true, value: new BitSet() },
+			storedNames: { writable: true, value: {} },
+			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
+		});
+
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+
+	append(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.outro += content;
+		return this;
+	}
+
+	appendLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.appendLeft(content);
+		} else {
+			this.intro += content;
+		}
+		return this;
+	}
+
+	appendRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.appendRight(content);
+		} else {
+			this.outro += content;
+		}
+		return this;
+	}
+
+	clone() {
+		const cloned = new MagicString(this.original, { filename: this.filename });
+
+		let originalChunk = this.firstChunk;
+		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+
+				clonedChunk = nextClonedChunk;
+			}
+
+			originalChunk = nextOriginalChunk;
+		}
+
+		cloned.lastChunk = clonedChunk;
+
+		if (this.indentExclusionRanges) {
+			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		}
+
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+
+		return cloned;
+	}
+
+	generateDecodedMap(options) {
+		options = options || {};
+
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+
+		const locate = getLocator(this.original);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+
+			if (chunk.edited) {
+				mappings.addEdit(
+					sourceIndex,
+					chunk.content,
+					loc,
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
+				);
+			} else {
+				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			}
+
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? '\t' : this.indentStr;
+	}
+
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = undefined;
+		}
+
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
+
+		if (indentStr === '') return this; // noop
+
+		options = options || {};
+
+		// Process exclusion ranges
+		const isExcluded = {};
+
+		if (options.exclude) {
+			const exclusions =
+				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+			exclusions.forEach((exclusion) => {
+				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+					isExcluded[i] = true;
+				}
+			});
+		}
+
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+
+		this.intro = this.intro.replace(pattern, replacer);
+
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+
+		while (chunk) {
+			const end = chunk.end;
+
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+
+					if (chunk.content.length) {
+						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					}
+				}
+			} else {
+				charIndex = chunk.start;
+
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+
+						if (char === '\n') {
+							shouldIndentNextCharacter = true;
+						} else if (char !== '\r' && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+
+							if (charIndex === chunk.start) {
+								chunk.prependRight(indentStr);
+							} else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+
+					charIndex += 1;
+				}
+			}
+
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+
+		this.outro = this.outro.replace(pattern, replacer);
+
+		return this;
+	}
+
+	insert() {
+		throw new Error(
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+		);
+	}
+
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn(
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft(index, content);
+	}
+
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn(
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertRight = true;
+		}
+
+		return this.prependRight(index, content);
+	}
+
+	move(start, end, index) {
+		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+		this._split(start);
+		this._split(end);
+		this._split(index);
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+
+		first.previous = newLeft;
+		last.next = newRight || null;
+
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
+		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (end > this.original.length) throw new Error('end is out of bounds');
+		if (start === end)
+			throw new Error(
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+			);
+
+		this._split(start);
+		this._split(end);
+
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn(
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+				); // eslint-disable-line no-console
+				warned.storeName = true;
+			}
+
+			options = { storeName: true };
+		}
+		const storeName = options !== undefined ? options.storeName : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
+
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true,
+			});
+		}
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) {
+					throw new Error('Cannot overwrite across a split point');
+				}
+				chunk = chunk.next;
+				chunk.edit('', false);
+			}
+
+			first.edit(content, storeName, !overwrite);
+		} else {
+			// must be inserting at the end
+			const newChunk = new Chunk$1(start, end, '').edit(content, storeName);
+
+			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+
+	prepend(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.intro = content + this.intro;
+		return this;
+	}
+
+	prependLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.prependLeft(content);
+		} else {
+			this.intro = content + this.intro;
+		}
+		return this;
+	}
+
+	prependRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.prependRight(content);
+		} else {
+			this.outro = content + this.outro;
+		}
+		return this;
+	}
+
+	remove(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit('');
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	reset(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while ((chunk = chunk.previous));
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return '';
+	}
+
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while ((chunk = chunk.previous));
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+
+	slice(start = 0, end = this.original.length) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		let result = '';
+
+		// find start chunk
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			// found end chunk before start
+			if (chunk.start < end && chunk.end >= end) {
+				return result;
+			}
+
+			chunk = chunk.next;
+		}
+
+		if (chunk && chunk.edited && chunk.start !== start)
+			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+				result += chunk.intro;
+			}
+
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end)
+				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+			result += chunk.content.slice(sliceStart, sliceEnd);
+
+			if (chunk.outro && (!containsEnd || chunk.end === end)) {
+				result += chunk.outro;
+			}
+
+			if (containsEnd) {
+				break;
+			}
+
+			chunk = chunk.next;
+		}
+
+		return result;
+	}
+
+	// TODO deprecate this? not really very useful
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+
+		return clone;
+	}
+
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+
+		let chunk = this.lastSearchedChunk;
+		const searchForward = index > chunk.end;
+
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+		}
+	}
+
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			// zero-length edited chunks are a special case (overlapping replacements)
+			const loc = getLocator(this.original)(index);
+			throw new Error(
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+			);
+		}
+
+		const newChunk = chunk.split(index);
+
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+
+	toString() {
+		let str = this.intro;
+
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+
+		return str + this.outro;
+	}
+
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do {
+			if (
+				(chunk.intro.length && chunk.intro.trim()) ||
+				(chunk.content.length && chunk.content.trim()) ||
+				(chunk.outro.length && chunk.outro.trim())
+			)
+				return false;
+		} while ((chunk = chunk.next));
+		return true;
+	}
+
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		} while ((chunk = chunk.next));
+		return length;
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		let chunk = this.lastChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+
+			// if chunk was trimmed, we have a new lastChunk
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) {
+					this.lastChunk = chunk.next;
+				}
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		let chunk = this.firstChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+
+			if (chunk.end !== end) {
+				// special case...
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === 'string') {
+				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+					if (i === '$') return '$';
+					if (i === '&') return match[0];
+					const num = +i;
+					if (num < match.length) return match[+i];
+					return `$${i}`;
+				});
+			} else {
+				return replacement(...match, match.index, str, match.groups);
+			}
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while ((match = re.exec(str))) {
+				matches.push(match);
+			}
+			return matches;
+		}
+		if (searchValue.global) {
+			const matches = matchAll(searchValue, this.original);
+			matches.forEach((match) => {
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
+					this.overwrite(
+						match.index,
+						match.index + match[0].length,
+						replacement
+					);
+				}
+			}
+		}
+		return this;
+	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+}
+
+const hasOwnProp = Object.prototype.hasOwnProperty;
+
+let Bundle$1 = class Bundle {
+	constructor(options = {}) {
+		this.intro = options.intro || '';
+		this.separator = options.separator !== undefined ? options.separator : '\n';
+		this.sources = [];
+		this.uniqueSources = [];
+		this.uniqueSourceIndexByFilename = {};
+	}
+
+	addSource(source) {
+		if (source instanceof MagicString) {
+			return this.addSource({
+				content: source,
+				filename: source.filename,
+				separator: this.separator,
+			});
+		}
+
+		if (!isObject(source) || !source.content) {
+			throw new Error(
+				'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',
+			);
+		}
+
+		['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {
+			if (!hasOwnProp.call(source, option)) source[option] = source.content[option];
+		});
+
+		if (source.separator === undefined) {
+			// TODO there's a bunch of this sort of thing, needs cleaning up
+			source.separator = this.separator;
+		}
+
+		if (source.filename) {
+			if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
+				this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
+				this.uniqueSources.push({ filename: source.filename, content: source.content.original });
+			} else {
+				const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
+				if (source.content.original !== uniqueSource.content) {
+					throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
+				}
+			}
+		}
+
+		this.sources.push(source);
+		return this;
+	}
+
+	append(str, options) {
+		this.addSource({
+			content: new MagicString(str),
+			separator: (options && options.separator) || '',
+		});
+
+		return this;
+	}
+
+	clone() {
+		const bundle = new Bundle({
+			intro: this.intro,
+			separator: this.separator,
+		});
+
+		this.sources.forEach((source) => {
+			bundle.addSource({
+				filename: source.filename,
+				content: source.content.clone(),
+				separator: source.separator,
+			});
+		});
+
+		return bundle;
+	}
+
+	generateDecodedMap(options = {}) {
+		const names = [];
+		let x_google_ignoreList = undefined;
+		this.sources.forEach((source) => {
+			Object.keys(source.content.storedNames).forEach((name) => {
+				if (!~names.indexOf(name)) names.push(name);
+			});
+		});
+
+		const mappings = new Mappings(options.hires);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.sources.forEach((source, i) => {
+			if (i > 0) {
+				mappings.advance(this.separator);
+			}
+
+			const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
+			const magicString = source.content;
+			const locate = getLocator(magicString.original);
+
+			if (magicString.intro) {
+				mappings.advance(magicString.intro);
+			}
+
+			magicString.firstChunk.eachNext((chunk) => {
+				const loc = locate(chunk.start);
+
+				if (chunk.intro.length) mappings.advance(chunk.intro);
+
+				if (source.filename) {
+					if (chunk.edited) {
+						mappings.addEdit(
+							sourceIndex,
+							chunk.content,
+							loc,
+							chunk.storeName ? names.indexOf(chunk.original) : -1,
+						);
+					} else {
+						mappings.addUneditedChunk(
+							sourceIndex,
+							chunk,
+							magicString.original,
+							loc,
+							magicString.sourcemapLocations,
+						);
+					}
+				} else {
+					mappings.advance(chunk.content);
+				}
+
+				if (chunk.outro.length) mappings.advance(chunk.outro);
+			});
+
+			if (magicString.outro) {
+				mappings.advance(magicString.outro);
+			}
+
+			if (source.ignoreList && sourceIndex !== -1) {
+				if (x_google_ignoreList === undefined) {
+					x_google_ignoreList = [];
+				}
+				x_google_ignoreList.push(sourceIndex);
+			}
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: this.uniqueSources.map((source) => {
+				return options.file ? getRelativePath(options.file, source.filename) : source.filename;
+			}),
+			sourcesContent: this.uniqueSources.map((source) => {
+				return options.includeContent ? source.content : null;
+			}),
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	getIndentString() {
+		const indentStringCounts = {};
+
+		this.sources.forEach((source) => {
+			const indentStr = source.content._getRawIndentString();
+
+			if (indentStr === null) return;
+
+			if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
+			indentStringCounts[indentStr] += 1;
+		});
+
+		return (
+			Object.keys(indentStringCounts).sort((a, b) => {
+				return indentStringCounts[a] - indentStringCounts[b];
+			})[0] || '\t'
+		);
+	}
+
+	indent(indentStr) {
+		if (!arguments.length) {
+			indentStr = this.getIndentString();
+		}
+
+		if (indentStr === '') return this; // noop
+
+		let trailingNewline = !this.intro || this.intro.slice(-1) === '\n';
+
+		this.sources.forEach((source, i) => {
+			const separator = source.separator !== undefined ? source.separator : this.separator;
+			const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator));
+
+			source.content.indent(indentStr, {
+				exclude: source.indentExclusionRanges,
+				indentStart, //: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
+			});
+
+			trailingNewline = source.content.lastChar() === '\n';
+		});
+
+		if (this.intro) {
+			this.intro =
+				indentStr +
+				this.intro.replace(/^[^\n]/gm, (match, index) => {
+					return index > 0 ? indentStr + match : match;
+				});
+		}
+
+		return this;
+	}
+
+	prepend(str) {
+		this.intro = str + this.intro;
+		return this;
+	}
+
+	toString() {
+		const body = this.sources
+			.map((source, i) => {
+				const separator = source.separator !== undefined ? source.separator : this.separator;
+				const str = (i > 0 ? separator : '') + source.content.toString();
+
+				return str;
+			})
+			.join('');
+
+		return this.intro + body;
+	}
+
+	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
+		if (this.sources.some((source) => !source.content.isEmpty())) return false;
+		return true;
+	}
+
+	length() {
+		return this.sources.reduce(
+			(length, source) => length + source.content.length(),
+			this.intro.length,
+		);
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimStart(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+		this.intro = this.intro.replace(rx, '');
+
+		if (!this.intro) {
+			let source;
+			let i = 0;
+
+			do {
+				source = this.sources[i++];
+				if (!source) {
+					break;
+				}
+			} while (!source.content.trimStartAborted(charType));
+		}
+
+		return this;
+	}
+
+	trimEnd(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		let source;
+		let i = this.sources.length - 1;
+
+		do {
+			source = this.sources[i--];
+			if (!source) {
+				this.intro = this.intro.replace(rx, '');
+				break;
+			}
+		} while (!source.content.trimEndAborted(charType));
+
+		return this;
+	}
+};
+
+function treeshakeNode(node, code, start, end) {
+    code.remove(start, end);
+    node.removeAnnotations(code);
+}
+
+const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
+function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
+    let searchPos, charCodeAfterSlash;
+    searchPos = code.indexOf(searchString, start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start >= searchPos)
+            return searchPos;
+        charCodeAfterSlash = code.charCodeAt(++start);
+        ++start;
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
+        }
+    }
+}
+const NON_WHITESPACE = /\S/g;
+function findNonWhiteSpace(code, index) {
+    NON_WHITESPACE.lastIndex = index;
+    const result = NON_WHITESPACE.exec(code);
+    return result.index;
+}
+const WHITESPACE = /\s/;
+function findLastWhiteSpaceReverse(code, start, end) {
+    while (true) {
+        if (start >= end) {
+            return end;
+        }
+        if (WHITESPACE.test(code[end - 1])) {
+            end--;
+        }
+        else {
+            return end;
+        }
+    }
+}
+// This assumes "code" only contains white-space and comments
+// Returns position of line-comment if applicable
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
+    lineBreakPos = code.indexOf('\n', start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start > lineBreakPos)
+            return [lineBreakPos, lineBreakPos + 1];
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        charCodeAfterSlash = code.charCodeAt(start + 1);
+        if (charCodeAfterSlash === 47 /*"/"*/)
+            return [start, lineBreakPos + 1];
+        start = code.indexOf('*/', start + 2) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
+        }
+    }
+}
+function renderStatementList(statements, code, start, end, options) {
+    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
+    let nextNode = statements[0];
+    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
+    if (nextNodeNeedsBoundaries) {
+        nextNodeStart =
+            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
+    }
+    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
+        currentNode = nextNode;
+        currentNodeStart = nextNodeStart;
+        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
+        nextNode = statements[nextIndex];
+        nextNodeNeedsBoundaries =
+            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
+        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
+            nextNodeStart =
+                currentNode.end +
+                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
+            if (currentNode.included) {
+                if (currentNodeNeedsBoundaries) {
+                    currentNode.render(code, options, {
+                        end: nextNodeStart,
+                        start: currentNodeStart
+                    });
+                }
+                else {
+                    currentNode.render(code, options);
+                }
+            }
+            else {
+                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
+            }
+        }
+        else {
+            currentNode.render(code, options);
+        }
+    }
+}
+// This assumes that the first character is not part of the first node
+function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
+    const splitUpNodes = [];
+    let node, nextNodeStart, contentEnd, char;
+    let separator = start - 1;
+    for (const nextNode of nodes) {
+        if (node !== undefined) {
+            separator =
+                node.end +
+                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
+        }
+        nextNodeStart = contentEnd =
+            separator +
+                1 +
+                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
+        while (((char = code.original.charCodeAt(nextNodeStart)),
+            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
+            nextNodeStart++;
+        if (node !== undefined) {
+            splitUpNodes.push({
+                contentEnd,
+                end: nextNodeStart,
+                node,
+                separator,
+                start
+            });
+        }
+        node = nextNode;
+        start = nextNodeStart;
+    }
+    splitUpNodes.push({
+        contentEnd: end,
+        end,
+        node: node,
+        separator: null,
+        start
+    });
+    return splitUpNodes;
+}
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (removeStart === -1) {
+            break;
+        }
+        code.remove(start + removeStart, (start += removeEnd));
+    }
+}
+
+function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
+    if (exportedVariables.length === 1 &&
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        const variable = exportedVariables[0];
+        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
+    }
+    else {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
+        }
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
+    }
+}
+// This is only invoked if there is exactly one export name
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
+    code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getDirectReturnIifeLeft } = options.snippets;
+    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getPropertyAccess } = options.snippets;
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const { _ } = options.snippets;
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
+
+/**
+ *
+ * @param {NodeWithPropertyDefinition} node
+ * @param {NodeWithPropertyDefinition} parent
+ * @returns {boolean}
+ */
+function is_reference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
+
+	if (node.type === 'Identifier') {
+		if (!parent) return true;
+
+		switch (parent.type) {
+			// disregard `bar` in `foo.bar`
+			case 'MemberExpression': return parent.computed || node === parent.object;
+
+			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+			case 'MethodDefinition': return parent.computed;
+
+			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+			case 'PropertyDefinition': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+			case 'Property': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `export { foo as bar }` or
+			// the foo in `import { foo as bar }`
+			case 'ExportSpecifier':
+			case 'ImportSpecifier': return node === parent.local;
+
+			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+			case 'LabeledStatement':
+			case 'BreakStatement':
+			case 'ContinueStatement': return false;
+			default: return true;
+		}
+	}
+
+	return false;
+}
+
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
+        }
+        currentFunctions[PureFunctionKey] = true;
+    }
+    return pureFunctions;
+};
+
+function getOrCreate(map, key, init) {
+    const existing = map.get(key);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const value = init();
+    map.set(key, value);
+    return value;
+}
+function getNewSet() {
+    return new Set();
+}
+function getNewArray() {
+    return [];
+}
+
+const UnknownKey = Symbol('Unknown Key');
+const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
+const UnknownInteger = Symbol('Unknown Integer');
+const SymbolToStringTag = Symbol('Symbol.toStringTag');
+const EMPTY_PATH = [];
+const UNKNOWN_PATH = [UnknownKey];
+// For deoptimizations, this means we are modifying an unknown property but did
+// not lose track of the object or are creating a setter/getter;
+// For assignment effects it means we do not check for setter/getter effects
+// but only if something is mutated that is included, which is relevant for
+// Object.defineProperty
+const UNKNOWN_NON_ACCESSOR_PATH = [UnknownNonAccessorKey];
+const UNKNOWN_INTEGER_PATH = [UnknownInteger];
+const EntitiesKey = Symbol('Entities');
+class PathTracker {
+    constructor() {
+        this.entityPaths = Object.create(null, {
+            [EntitiesKey]: { value: new Set() }
+        });
+    }
+    trackEntityAtPathAndGetIfTracked(path, entity) {
+        const trackedEntities = this.getEntities(path);
+        if (trackedEntities.has(entity))
+            return true;
+        trackedEntities.add(entity);
+        return false;
+    }
+    withTrackedEntityAtPath(path, entity, onUntracked, returnIfTracked) {
+        const trackedEntities = this.getEntities(path);
+        if (trackedEntities.has(entity))
+            return returnIfTracked;
+        trackedEntities.add(entity);
+        const result = onUntracked();
+        trackedEntities.delete(entity);
+        return result;
+    }
+    getEntities(path) {
+        let currentPaths = this.entityPaths;
+        for (const pathSegment of path) {
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Set() } });
+        }
+        return currentPaths[EntitiesKey];
+    }
+}
+const SHARED_RECURSION_TRACKER = new PathTracker();
+class DiscriminatedPathTracker {
+    constructor() {
+        this.entityPaths = Object.create(null, {
+            [EntitiesKey]: { value: new Map() }
+        });
+    }
+    trackEntityAtPathAndGetIfTracked(path, discriminator, entity) {
+        let currentPaths = this.entityPaths;
+        for (const pathSegment of path) {
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Map() } });
+        }
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, (getNewSet));
+        if (trackedEntities.has(entity))
+            return true;
+        trackedEntities.add(entity);
+        return false;
+    }
+}
+
+function isFlagSet(flags, flag) {
+    return (flags & flag) !== 0;
+}
+function setFlag(flags, flag, value) {
+    return (flags & ~flag) | (-value & flag);
+}
+
+const UnknownValue = Symbol('Unknown Value');
+const UnknownTruthyValue = Symbol('Unknown Truthy Value');
+class ExpressionEntity {
+    constructor() {
+        this.flags = 0;
+    }
+    get included() {
+        return isFlagSet(this.flags, 1 /* Flag.included */);
+    }
+    set included(value) {
+        this.flags = setFlag(this.flags, 1 /* Flag.included */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, _path, _recursionTracker) {
+        deoptimizeInteraction(interaction);
+    }
+    deoptimizePath(_path) { }
+    /**
+     * If possible it returns a stringifyable literal value for this node that
+     * can be used for inlining or comparing values. Otherwise, it should return
+     * UnknownValue.
+     */
+    getLiteralValueAtPath(_path, _recursionTracker, _origin) {
+        return UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(_path, _interaction, _recursionTracker, _origin) {
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
+        return true;
+    }
+    include(_context, _includeChildrenRecursively, _options) {
+        this.included = true;
+    }
+    includeCallArguments(context, parameters) {
+        for (const argument of parameters) {
+            argument.include(context, false);
+        }
+    }
+    shouldBeIncluded(_context) {
+        return true;
+    }
+}
+const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
+})();
+const UNKNOWN_RETURN_EXPRESSION = [
+    UNKNOWN_EXPRESSION,
+    false
+];
+const deoptimizeInteraction = (interaction) => {
+    for (const argument of interaction.args) {
+        argument?.deoptimizePath(UNKNOWN_PATH);
+    }
+};
+
+const INTERACTION_ACCESSED = 0;
+const INTERACTION_ASSIGNED = 1;
+const INTERACTION_CALLED = 2;
+const NODE_INTERACTION_UNKNOWN_ACCESS = {
+    args: [null],
+    type: INTERACTION_ACCESSED
+};
+const NODE_INTERACTION_UNKNOWN_ASSIGNMENT = {
+    args: [null, UNKNOWN_EXPRESSION],
+    type: INTERACTION_ASSIGNED
+};
+// While this is technically a call without arguments, we can compare against
+// this reference in places where precise values or this argument would make a
+// difference
+const NODE_INTERACTION_UNKNOWN_CALL = {
+    args: [null],
+    type: INTERACTION_CALLED,
+    withNew: false
+};
+
+class Variable extends ExpressionEntity {
+    markReassigned() {
+        this.isReassigned = true;
+    }
+    constructor(name) {
+        super();
+        this.name = name;
+        this.alwaysRendered = false;
+        this.forbiddenNames = null;
+        this.globalName = null;
+        this.initReached = false;
+        this.isId = false;
+        this.kind = null;
+        this.renderBaseName = null;
+        this.renderName = null;
+        this.isReassigned = false;
+        this.onlyFunctionCallUsed = true;
+    }
+    /**
+     * Binds identifiers that reference this variable to this variable.
+     * Necessary to be able to change variable names.
+     */
+    addReference(_identifier) { }
+    /**
+     * Check if the identifier variable is only used as function call
+     * @returns true if the variable is only used as function call
+     */
+    getOnlyFunctionCallUsed() {
+        return this.onlyFunctionCallUsed;
+    }
+    /**
+     * Collect the places where the identifier variable is used
+     * @param usedPlace Where the variable is used
+     */
+    addUsedPlace(usedPlace) {
+        const isFunctionCall = usedPlace.parent.type === CallExpression$1 &&
+            usedPlace.parent.callee === usedPlace;
+        if (!isFunctionCall && usedPlace.parent.type !== ExportDefaultDeclaration$1) {
+            this.onlyFunctionCallUsed = false;
+        }
+    }
+    /**
+     * Prevent this variable from being renamed to this name to avoid name
+     * collisions
+     */
+    forbidName(name) {
+        (this.forbiddenNames ||= new Set()).add(name);
+    }
+    getBaseVariableName() {
+        return (this.renderedLikeHoisted?.getBaseVariableName() ||
+            this.renderBaseName ||
+            this.renderName ||
+            this.name);
+    }
+    getName(getPropertyAccess, useOriginalName) {
+        if (this.globalName) {
+            return this.globalName;
+        }
+        if (useOriginalName?.(this)) {
+            return this.name;
+        }
+        if (this.renderedLikeHoisted) {
+            return this.renderedLikeHoisted.getName(getPropertyAccess, useOriginalName);
+        }
+        const name = this.renderName || this.name;
+        return this.renderBaseName ? `${this.renderBaseName}${getPropertyAccess(name)}` : name;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }, _context) {
+        return type !== INTERACTION_ACCESSED || path.length > 0;
+    }
+    /**
+     * Marks this variable as being part of the bundle, which is usually the case
+     * when one of its identifiers becomes part of the bundle. Returns true if it
+     * has not been included previously. Once a variable is included, it should
+     * take care all its declarations are included.
+     */
+    include() {
+        this.included = true;
+        this.renderedLikeHoisted?.include();
+    }
+    /**
+     * Links the rendered name of this variable to another variable and includes
+     * this variable if the other variable is included.
+     */
+    renderLikeHoisted(variable) {
+        this.renderedLikeHoisted = variable;
+    }
+    markCalledFromTryStatement() { }
+    setRenderNames(baseName, name) {
+        this.renderBaseName = baseName;
+        this.renderName = name;
+    }
+}
+
+class ExternalVariable extends Variable {
+    constructor(module, name) {
+        super(name);
+        this.referenced = false;
+        this.module = module;
+        this.isNamespace = name === '*';
+    }
+    addReference(identifier) {
+        this.referenced = true;
+        if (this.name === 'default' || this.name === '*') {
+            this.module.suggestName(identifier.name);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.isNamespace ? 1 : 0);
+    }
+    include() {
+        super.include();
+        this.module.used = true;
+    }
+}
+
+function cacheObjectGetters(object, getterProperties) {
+    for (const property of getterProperties) {
+        const propertyGetter = Object.getOwnPropertyDescriptor(object, property).get;
+        Object.defineProperty(object, property, {
+            get() {
+                const value = propertyGetter.call(object);
+                // This replaces the getter with a fixed value for subsequent calls
+                Object.defineProperty(object, property, { value });
+                return value;
+            }
+        });
+    }
+}
+
+const RESERVED_NAMES = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'NaN',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+
+const illegalCharacters = /[^\w$]/g;
+const startsWithDigit = (value) => /\d/.test(value[0]);
+const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES.has(value) || value === 'arguments';
+function isLegal(value) {
+    if (needsEscape(value)) {
+        return false;
+    }
+    return !illegalCharacters.test(value);
+}
+function makeLegal(value) {
+    value = value
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(illegalCharacters, '_');
+    if (needsEscape(value))
+        value = `_${value}`;
+    return value || '_';
+}
+const VALID_IDENTIFIER_REGEXP = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+const NUMBER_REGEXP = /^(?:0|[1-9]\d*)$/;
+function stringifyObjectKeyIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key === '__proto__' ? '["__proto__"]' : key;
+    }
+    if (NUMBER_REGEXP.test(key) && +key <= Number.MAX_SAFE_INTEGER) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+function stringifyIdentifierIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+
+class ExternalModule {
+    constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath, attributes) {
+        this.options = options;
+        this.id = id;
+        this.renormalizeRenderPath = renormalizeRenderPath;
+        this.dynamicImporters = [];
+        this.execIndex = Infinity;
+        this.exportedVariables = new Map();
+        this.importers = [];
+        this.reexported = false;
+        this.used = false;
+        this.declarations = new Map();
+        this.mostCommonSuggestion = 0;
+        this.nameSuggestions = new Map();
+        this.suggestedVariableName = makeLegal(id.split(/[/\\]/).pop());
+        const { importers, dynamicImporters } = this;
+        this.info = {
+            ast: null,
+            attributes,
+            code: null,
+            dynamicallyImportedIdResolutions: EMPTY_ARRAY,
+            dynamicallyImportedIds: EMPTY_ARRAY,
+            get dynamicImporters() {
+                return dynamicImporters.sort();
+            },
+            exportedBindings: null,
+            exports: null,
+            hasDefaultExport: null,
+            id,
+            implicitlyLoadedAfterOneOf: EMPTY_ARRAY,
+            implicitlyLoadedBefore: EMPTY_ARRAY,
+            importedIdResolutions: EMPTY_ARRAY,
+            importedIds: EMPTY_ARRAY,
+            get importers() {
+                return importers.sort();
+            },
+            isEntry: false,
+            isExternal: true,
+            isIncluded: null,
+            meta,
+            moduleSideEffects,
+            syntheticNamedExports: false
+        };
+    }
+    cacheInfoGetters() {
+        cacheObjectGetters(this.info, ['dynamicImporters', 'importers']);
+    }
+    getVariableForExportName(name) {
+        const declaration = this.declarations.get(name);
+        if (declaration)
+            return [declaration];
+        const externalVariable = new ExternalVariable(this, name);
+        this.declarations.set(name, externalVariable);
+        this.exportedVariables.set(externalVariable, name);
+        return [externalVariable];
+    }
+    suggestName(name) {
+        const value = (this.nameSuggestions.get(name) ?? 0) + 1;
+        this.nameSuggestions.set(name, value);
+        if (value > this.mostCommonSuggestion) {
+            this.mostCommonSuggestion = value;
+            this.suggestedVariableName = name;
+        }
+    }
+    warnUnusedImports() {
+        const unused = [...this.declarations]
+            .filter(([name, declaration]) => name !== '*' && !declaration.included && !this.reexported && !declaration.referenced)
+            .map(([name]) => name);
+        if (unused.length === 0)
+            return;
+        const importersSet = new Set();
+        for (const name of unused) {
+            for (const importer of this.declarations.get(name).module.importers) {
+                importersSet.add(importer);
+            }
+        }
+        const importersArray = [...importersSet];
+        this.options.onLog(LOGLEVEL_WARN, logUnusedExternalImports(this.id, unused, importersArray));
+    }
+}
+
+function markModuleAndImpureDependenciesAsExecuted(baseModule) {
+    baseModule.isExecuted = true;
+    const modules = [baseModule];
+    const visitedModules = new Set();
+    for (const module of modules) {
+        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
+            if (!(dependency instanceof ExternalModule) &&
+                !dependency.isExecuted &&
+                (dependency.info.moduleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
+                !visitedModules.has(dependency.id)) {
+                dependency.isExecuted = true;
+                visitedModules.add(dependency.id);
+                modules.push(dependency);
+            }
+        }
+    }
+}
+
+const doNothing = () => { };
+
+function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
+    return Object.create(inheritedDescriptions, memberDescriptions);
+}
+const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+})();
+const returnsUnknown = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_EXPRESSION
+    }
+};
+const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsBoolean = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_BOOLEAN
+    }
+};
+const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsNumber = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_NUMBER
+    }
+};
+const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsString = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const stringReplace = {
+    value: {
+        hasEffectsWhenCalled({ args }, context) {
+            const argument1 = args[2];
+            return (args.length < 3 ||
+                (typeof argument1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                    deoptimizeCache() { }
+                }) === 'symbol' &&
+                    argument1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
+        },
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const objectMembers = assembleMemberDescriptions({
+    hasOwnProperty: returnsBoolean,
+    isPrototypeOf: returnsBoolean,
+    propertyIsEnumerable: returnsBoolean,
+    toLocaleString: returnsString,
+    toString: returnsString,
+    valueOf: returnsUnknown
+});
+const literalBooleanMembers = assembleMemberDescriptions({
+    valueOf: returnsBoolean
+}, objectMembers);
+const literalNumberMembers = assembleMemberDescriptions({
+    toExponential: returnsString,
+    toFixed: returnsString,
+    toLocaleString: returnsString,
+    toPrecision: returnsString,
+    valueOf: returnsNumber
+}, objectMembers);
+/**
+ * RegExp are stateful when they have the global or sticky flags set.
+ * But if we actually don't use them, the side effect does not matter.
+ * the check logic in `hasEffectsOnInteractionAtPath`.
+ */
+const literalRegExpMembers = assembleMemberDescriptions({
+    exec: returnsUnknown,
+    test: returnsBoolean
+}, objectMembers);
+const literalStringMembers = assembleMemberDescriptions({
+    anchor: returnsString,
+    at: returnsUnknown,
+    big: returnsString,
+    blink: returnsString,
+    bold: returnsString,
+    charAt: returnsString,
+    charCodeAt: returnsNumber,
+    codePointAt: returnsUnknown,
+    concat: returnsString,
+    endsWith: returnsBoolean,
+    fixed: returnsString,
+    fontcolor: returnsString,
+    fontsize: returnsString,
+    includes: returnsBoolean,
+    indexOf: returnsNumber,
+    italics: returnsString,
+    lastIndexOf: returnsNumber,
+    link: returnsString,
+    localeCompare: returnsNumber,
+    match: returnsUnknown,
+    matchAll: returnsUnknown,
+    normalize: returnsString,
+    padEnd: returnsString,
+    padStart: returnsString,
+    repeat: returnsString,
+    replace: stringReplace,
+    replaceAll: stringReplace,
+    search: returnsNumber,
+    slice: returnsString,
+    small: returnsString,
+    split: returnsUnknown,
+    startsWith: returnsBoolean,
+    strike: returnsString,
+    sub: returnsString,
+    substr: returnsString,
+    substring: returnsString,
+    sup: returnsString,
+    toLocaleLowerCase: returnsString,
+    toLocaleUpperCase: returnsString,
+    toLowerCase: returnsString,
+    toString: returnsString, // overrides the toString() method of the Object object; it does not inherit Object.prototype.toString()
+    toUpperCase: returnsString,
+    trim: returnsString,
+    trimEnd: returnsString,
+    trimLeft: returnsString,
+    trimRight: returnsString,
+    trimStart: returnsString,
+    valueOf: returnsString
+}, objectMembers);
+function getLiteralMembersForValue(value) {
+    if (value instanceof RegExp) {
+        return literalRegExpMembers;
+    }
+    switch (typeof value) {
+        case 'boolean': {
+            return literalBooleanMembers;
+        }
+        case 'number': {
+            return literalNumberMembers;
+        }
+        case 'string': {
+            return literalStringMembers;
+        }
+    }
+    return Object.create(null);
+}
+function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
+    if (typeof memberName !== 'string' || !members[memberName]) {
+        return true;
+    }
+    return members[memberName].hasEffectsWhenCalled?.(interaction, context) || false;
+}
+function getMemberReturnExpressionWhenCalled(members, memberName) {
+    if (typeof memberName !== 'string' || !members[memberName])
+        return UNKNOWN_RETURN_EXPRESSION;
+    return [members[memberName].returns, false];
+}
+
+// This file is generated by scripts/generate-child-node-keys.js.
+// Do not edit this file directly.
+const childNodeKeys = {
+    ArrayExpression: ['elements'],
+    ArrayPattern: ['elements'],
+    ArrowFunctionExpression: ['params', 'body'],
+    AssignmentExpression: ['left', 'right'],
+    AssignmentPattern: ['left', 'right'],
+    AwaitExpression: ['argument'],
+    BinaryExpression: ['left', 'right'],
+    BlockStatement: ['body'],
+    BreakStatement: ['label'],
+    CallExpression: ['callee', 'arguments'],
+    CatchClause: ['param', 'body'],
+    ChainExpression: ['expression'],
+    ClassBody: ['body'],
+    ClassDeclaration: ['decorators', 'id', 'superClass', 'body'],
+    ClassExpression: ['decorators', 'id', 'superClass', 'body'],
+    ConditionalExpression: ['test', 'consequent', 'alternate'],
+    ContinueStatement: ['label'],
+    DebuggerStatement: [],
+    Decorator: ['expression'],
+    DoWhileStatement: ['body', 'test'],
+    EmptyStatement: [],
+    ExportAllDeclaration: ['exported', 'source', 'attributes'],
+    ExportDefaultDeclaration: ['declaration'],
+    ExportNamedDeclaration: ['specifiers', 'source', 'attributes', 'declaration'],
+    ExportSpecifier: ['local', 'exported'],
+    ExpressionStatement: ['expression'],
+    ForInStatement: ['left', 'right', 'body'],
+    ForOfStatement: ['left', 'right', 'body'],
+    ForStatement: ['init', 'test', 'update', 'body'],
+    FunctionDeclaration: ['id', 'params', 'body'],
+    FunctionExpression: ['id', 'params', 'body'],
+    Identifier: [],
+    IfStatement: ['test', 'consequent', 'alternate'],
+    ImportAttribute: ['key', 'value'],
+    ImportDeclaration: ['specifiers', 'source', 'attributes'],
+    ImportDefaultSpecifier: ['local'],
+    ImportExpression: ['source', 'options'],
+    ImportNamespaceSpecifier: ['local'],
+    ImportSpecifier: ['imported', 'local'],
+    JSXAttribute: ['name', 'value'],
+    JSXClosingElement: ['name'],
+    JSXClosingFragment: [],
+    JSXElement: ['openingElement', 'children', 'closingElement'],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: ['expression'],
+    JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+    JSXIdentifier: [],
+    JSXMemberExpression: ['object', 'property'],
+    JSXNamespacedName: ['namespace', 'name'],
+    JSXOpeningElement: ['name', 'attributes'],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: ['argument'],
+    JSXSpreadChild: ['expression'],
+    JSXText: [],
+    LabeledStatement: ['label', 'body'],
+    Literal: [],
+    LogicalExpression: ['left', 'right'],
+    MemberExpression: ['object', 'property'],
+    MetaProperty: ['meta', 'property'],
+    MethodDefinition: ['decorators', 'key', 'value'],
+    NewExpression: ['callee', 'arguments'],
+    ObjectExpression: ['properties'],
+    ObjectPattern: ['properties'],
+    PanicError: [],
+    ParseError: [],
+    PrivateIdentifier: [],
+    Program: ['body'],
+    Property: ['key', 'value'],
+    PropertyDefinition: ['decorators', 'key', 'value'],
+    RestElement: ['argument'],
+    ReturnStatement: ['argument'],
+    SequenceExpression: ['expressions'],
+    SpreadElement: ['argument'],
+    StaticBlock: ['body'],
+    Super: [],
+    SwitchCase: ['test', 'consequent'],
+    SwitchStatement: ['discriminant', 'cases'],
+    TaggedTemplateExpression: ['tag', 'quasi'],
+    TemplateElement: [],
+    TemplateLiteral: ['quasis', 'expressions'],
+    ThisExpression: [],
+    ThrowStatement: ['argument'],
+    TryStatement: ['block', 'handler', 'finalizer'],
+    UnaryExpression: ['argument'],
+    UpdateExpression: ['argument'],
+    VariableDeclaration: ['declarations'],
+    VariableDeclarator: ['id', 'init'],
+    WhileStatement: ['test', 'body'],
+    YieldExpression: ['argument']
+};
+
+function createInclusionContext() {
+    return {
+        brokenFlow: false,
+        hasBreak: false,
+        hasContinue: false,
+        includedCallArguments: new Set(),
+        includedLabels: new Set()
+    };
+}
+function createHasEffectsContext() {
+    return {
+        accessed: new PathTracker(),
+        assigned: new PathTracker(),
+        brokenFlow: false,
+        called: new DiscriminatedPathTracker(),
+        hasBreak: false,
+        hasContinue: false,
+        ignore: {
+            breaks: false,
+            continues: false,
+            labels: new Set(),
+            returnYield: false,
+            this: false
+        },
+        includedLabels: new Set(),
+        instantiated: new DiscriminatedPathTracker(),
+        replacedVariableInits: new Map()
+    };
+}
+
+const INCLUDE_PARAMETERS = 'variables';
+const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
+class NodeBase extends ExpressionEntity {
+    /**
+     * Nodes can apply custom deoptimizations once they become part of the
+     * executed code. To do this, they must initialize this as false, implement
+     * applyDeoptimizations and call this from include and hasEffects if they have
+     * custom handlers
+     */
+    get deoptimized() {
+        return isFlagSet(this.flags, 2 /* Flag.deoptimized */);
+    }
+    set deoptimized(value) {
+        this.flags = setFlag(this.flags, 2 /* Flag.deoptimized */, value);
+    }
+    constructor(parent, parentScope) {
+        super();
+        this.parent = parent;
+        this.scope = parentScope;
+        this.createScope(parentScope);
+    }
+    addExportedVariables(_variables, _exportNamesByVariable) { }
+    /**
+     * Override this to bind assignments to variables and do any initialisations
+     * that require the scopes to be populated with variables.
+     */
+    bind() {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.bind();
+                }
+            }
+            else if (value) {
+                value.bind();
+            }
+        }
+    }
+    /**
+     * Override if this node should receive a different scope than the parent
+     * scope.
+     */
+    createScope(parentScope) {
+        this.scope = parentScope;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child?.hasEffects(context))
+                        return true;
+                }
+            }
+            else if (value.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    hasEffectsAsAssignmentTarget(context, _checkAccess) {
+        return (this.hasEffects(context) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    include(context, includeChildrenRecursively, _options) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.include(context, includeChildrenRecursively);
+                }
+            }
+            else {
+                value.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
+        this.include(context, includeChildrenRecursively);
+    }
+    /**
+     * Override to perform special initialisation steps after the scope is
+     * initialised
+     */
+    initialise() {
+        this.scope.context.magicString.addSourcemapLocation(this.start);
+        this.scope.context.magicString.addSourcemapLocation(this.end);
+    }
+    parseNode(esTreeNode) {
+        for (const [key, value] of Object.entries(esTreeNode)) {
+            // Skip properties defined on the class already.
+            // This way, we can override this function to add custom initialisation and then call super.parseNode
+            // Note: this doesn't skip properties with defined getters/setters which we use to pack wrap booleans
+            // in bitfields. Those are still assigned from the value in the esTreeNode.
+            if (this.hasOwnProperty(key))
+                continue;
+            if (key.charCodeAt(0) === 95 /* _ */) {
+                if (key === ANNOTATION_KEY) {
+                    this.annotations = value;
+                }
+                else if (key === INVALID_ANNOTATION_KEY) {
+                    this.invalidAnnotations = value;
+                }
+            }
+            else if (typeof value !== 'object' || value === null) {
+                this[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                this[key] = [];
+                for (const child of value) {
+                    this[key].push(child === null
+                        ? null
+                        : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child));
+                }
+            }
+            else {
+                this[key] = new (this.scope.context.getNodeConstructor(value.type))(this, this.scope).parseNode(value);
+            }
+        }
+        // extend child keys for unknown node types
+        childNodeKeys[esTreeNode.type] ||= createChildNodeKeysForNode(esTreeNode);
+        this.initialise();
+        return this;
+    }
+    removeAnnotations(code) {
+        if (this.annotations) {
+            for (const annotation of this.annotations) {
+                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
+    render(code, options) {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.render(code, options);
+                }
+            }
+            else {
+                value.render(code, options);
+            }
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
+    }
+    shouldBeIncluded(context) {
+        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
+    }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+function createChildNodeKeysForNode(esTreeNode) {
+    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+}
+
+class SpreadElement extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 0) {
+            this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, [UnknownKey, ...path], recursionTracker);
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (this.argument.hasEffects(context) ||
+            (propertyReadSideEffects &&
+                (propertyReadSideEffects === 'always' ||
+                    this.argument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context))));
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        // Only properties of properties of the argument could become subject to reassignment
+        // This will also reassign the return values of iterators
+        this.argument.deoptimizePath([UnknownKey, UnknownKey]);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class Method extends ExpressionEntity {
+    constructor(description) {
+        super();
+        this.description = description;
+    }
+    deoptimizeArgumentsOnInteractionAtPath({ args, type }, path) {
+        if (type === INTERACTION_CALLED && path.length === 0) {
+            if (this.description.mutatesSelfAsArray) {
+                args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+            }
+            if (this.description.mutatesArgs) {
+                for (let index = 1; index < args.length; index++) {
+                    args[index].deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path, { args }) {
+        if (path.length > 0) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return [
+            this.description.returnsPrimitive ||
+                (this.description.returns === 'self'
+                    ? args[0] || UNKNOWN_EXPRESSION
+                    : this.description.returns()),
+            false
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (path.length > (type === INTERACTION_ACCESSED ? 1 : 0)) {
+            return true;
+        }
+        if (type === INTERACTION_CALLED) {
+            const { args } = interaction;
+            if (this.description.mutatesSelfAsArray === true &&
+                args[0]?.hasEffectsOnInteractionAtPath(UNKNOWN_INTEGER_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)) {
+                return true;
+            }
+            if (this.description.callsArgs) {
+                for (const argumentIndex of this.description.callsArgs) {
+                    if (args[argumentIndex + 1]?.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+const METHOD_RETURNS_BOOLEAN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
+    })
+];
+const METHOD_RETURNS_STRING = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_STRING
+    })
+];
+const METHOD_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+
+const INTEGER_REG_EXP = /^\d+$/;
+class ObjectEntity extends ExpressionEntity {
+    get hasLostTrack() {
+        return isFlagSet(this.flags, 2048 /* Flag.hasLostTrack */);
+    }
+    set hasLostTrack(value) {
+        this.flags = setFlag(this.flags, 2048 /* Flag.hasLostTrack */, value);
+    }
+    get hasUnknownDeoptimizedInteger() {
+        return isFlagSet(this.flags, 4096 /* Flag.hasUnknownDeoptimizedInteger */);
+    }
+    set hasUnknownDeoptimizedInteger(value) {
+        this.flags = setFlag(this.flags, 4096 /* Flag.hasUnknownDeoptimizedInteger */, value);
+    }
+    get hasUnknownDeoptimizedProperty() {
+        return isFlagSet(this.flags, 8192 /* Flag.hasUnknownDeoptimizedProperty */);
+    }
+    set hasUnknownDeoptimizedProperty(value) {
+        this.flags = setFlag(this.flags, 8192 /* Flag.hasUnknownDeoptimizedProperty */, value);
+    }
+    // If a PropertyMap is used, this will be taken as propertiesAndGettersByKey
+    // and we assume there are no setters or getters
+    constructor(properties, prototypeExpression, immutable = false) {
+        super();
+        this.prototypeExpression = prototypeExpression;
+        this.immutable = immutable;
+        this.additionalExpressionsToBeDeoptimized = new Set();
+        this.allProperties = [];
+        this.deoptimizedPaths = Object.create(null);
+        this.expressionsToBeDeoptimizedByKey = Object.create(null);
+        this.gettersByKey = Object.create(null);
+        this.propertiesAndGettersByKey = Object.create(null);
+        this.propertiesAndSettersByKey = Object.create(null);
+        this.settersByKey = Object.create(null);
+        this.unknownIntegerProps = [];
+        this.unmatchableGetters = [];
+        this.unmatchablePropertiesAndGetters = [];
+        this.unmatchableSetters = [];
+        if (Array.isArray(properties)) {
+            this.buildPropertyMaps(properties);
+        }
+        else {
+            this.propertiesAndGettersByKey = this.propertiesAndSettersByKey = properties;
+            for (const propertiesForKey of Object.values(properties)) {
+                this.allProperties.push(...propertiesForKey);
+            }
+        }
+    }
+    deoptimizeAllProperties(noAccessors) {
+        const isDeoptimized = this.hasLostTrack || this.hasUnknownDeoptimizedProperty;
+        if (noAccessors) {
+            this.hasUnknownDeoptimizedProperty = true;
+        }
+        else {
+            this.hasLostTrack = true;
+        }
+        if (isDeoptimized) {
+            return;
+        }
+        for (const properties of [
+            ...Object.values(this.propertiesAndGettersByKey),
+            ...Object.values(this.settersByKey)
+        ]) {
+            for (const property of properties) {
+                property.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        // While the prototype itself cannot be mutated, each property can
+        this.prototypeExpression?.deoptimizePath([UnknownKey, UnknownKey]);
+        this.deoptimizeCachedEntities();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        const [key, ...subPath] = path;
+        const { args, type } = interaction;
+        if (this.hasLostTrack ||
+            // single paths that are deoptimized will not become getters or setters
+            ((type === INTERACTION_CALLED || path.length > 1) &&
+                (this.hasUnknownDeoptimizedProperty ||
+                    (typeof key === 'string' && this.deoptimizedPaths[key])))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        const [propertiesForExactMatchByKey, relevantPropertiesByKey, relevantUnmatchableProperties] = type === INTERACTION_CALLED || path.length > 1
+            ? [
+                this.propertiesAndGettersByKey,
+                this.propertiesAndGettersByKey,
+                this.unmatchablePropertiesAndGetters
+            ]
+            : type === INTERACTION_ACCESSED
+                ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
+                : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
+        if (typeof key === 'string') {
+            if (propertiesForExactMatchByKey[key]) {
+                const properties = relevantPropertiesByKey[key];
+                if (properties) {
+                    for (const property of properties) {
+                        property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                    }
+                }
+                if (!this.immutable) {
+                    for (const argument of args) {
+                        if (argument) {
+                            this.additionalExpressionsToBeDeoptimized.add(argument);
+                        }
+                    }
+                }
+                return;
+            }
+            for (const property of relevantUnmatchableProperties) {
+                property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+            }
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const property of this.unknownIntegerProps) {
+                    property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                }
+            }
+        }
+        else {
+            for (const properties of [
+                ...Object.values(relevantPropertiesByKey),
+                relevantUnmatchableProperties
+            ]) {
+                for (const property of properties) {
+                    property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                }
+            }
+            for (const property of this.unknownIntegerProps) {
+                property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+            }
+        }
+        if (!this.immutable) {
+            for (const argument of args) {
+                if (argument) {
+                    this.additionalExpressionsToBeDeoptimized.add(argument);
+                }
+            }
+        }
+        this.prototypeExpression?.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeIntegerProperties() {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            this.hasUnknownDeoptimizedInteger) {
+            return;
+        }
+        this.hasUnknownDeoptimizedInteger = true;
+        for (const [key, propertiesAndGetters] of Object.entries(this.propertiesAndGettersByKey)) {
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const property of propertiesAndGetters) {
+                    property.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+        this.deoptimizeCachedIntegerEntities();
+    }
+    // Assumption: If only a specific path is deoptimized, no accessors are created
+    deoptimizePath(path) {
+        if (this.hasLostTrack || this.immutable) {
+            return;
+        }
+        const key = path[0];
+        if (path.length === 1) {
+            if (key === UnknownInteger) {
+                return this.deoptimizeIntegerProperties();
+            }
+            else if (typeof key !== 'string') {
+                return this.deoptimizeAllProperties(key === UnknownNonAccessorKey);
+            }
+            if (!this.deoptimizedPaths[key]) {
+                this.deoptimizedPaths[key] = true;
+                // we only deoptimizeCache exact matches as in all other cases,
+                // we do not return a literal value or return expression
+                const expressionsToBeDeoptimized = this.expressionsToBeDeoptimizedByKey[key];
+                if (expressionsToBeDeoptimized) {
+                    for (const expression of expressionsToBeDeoptimized) {
+                        expression.deoptimizeCache();
+                    }
+                }
+            }
+        }
+        const subPath = path.length === 1 ? UNKNOWN_PATH : path.slice(1);
+        for (const property of typeof key === 'string'
+            ? [
+                ...(this.propertiesAndGettersByKey[key] || this.unmatchablePropertiesAndGetters),
+                ...(this.settersByKey[key] || this.unmatchableSetters)
+            ]
+            : this.allProperties) {
+            property.deoptimizePath(subPath);
+        }
+        this.prototypeExpression?.deoptimizePath(path.length === 1 ? [...path, UnknownKey] : path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length === 0) {
+            return UnknownTruthyValue;
+        }
+        const key = path[0];
+        const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
+        if (expressionAtPath) {
+            return expressionAtPath.getLiteralValueAtPath(path.slice(1), recursionTracker, origin);
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (path.length === 1) {
+            return undefined;
+        }
+        return UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (path.length === 0) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        const [key, ...subPath] = path;
+        const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
+        if (expressionAtPath) {
+            return expressionAtPath.getReturnExpressionWhenCalledAtPath(subPath, interaction, recursionTracker, origin);
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const [key, ...subPath] = path;
+        if (subPath.length > 0 || interaction.type === INTERACTION_CALLED) {
+            const expressionAtPath = this.getMemberExpression(key);
+            if (expressionAtPath) {
+                return expressionAtPath.hasEffectsOnInteractionAtPath(subPath, interaction, context);
+            }
+            if (this.prototypeExpression) {
+                return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            return true;
+        }
+        if (key === UnknownNonAccessorKey)
+            return false;
+        if (this.hasLostTrack)
+            return true;
+        const [propertiesAndAccessorsByKey, accessorsByKey, unmatchableAccessors] = interaction.type === INTERACTION_ACCESSED
+            ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
+            : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
+        if (typeof key === 'string') {
+            if (propertiesAndAccessorsByKey[key]) {
+                const accessors = accessorsByKey[key];
+                if (accessors) {
+                    for (const accessor of accessors) {
+                        if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
+                            return true;
+                    }
+                }
+                return false;
+            }
+            for (const accessor of unmatchableAccessors) {
+                if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            for (const accessors of [...Object.values(accessorsByKey), unmatchableAccessors]) {
+                for (const accessor of accessors) {
+                    if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
+                        return true;
+                }
+            }
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        return false;
+    }
+    buildPropertyMaps(properties) {
+        const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchableGetters, unmatchableSetters } = this;
+        const unmatchablePropertiesAndSetters = [];
+        for (let index = properties.length - 1; index >= 0; index--) {
+            const { key, kind, property } = properties[index];
+            allProperties.push(property);
+            if (typeof key === 'string') {
+                if (kind === 'set') {
+                    if (!propertiesAndSettersByKey[key]) {
+                        propertiesAndSettersByKey[key] = [property, ...unmatchablePropertiesAndSetters];
+                        settersByKey[key] = [property, ...unmatchableSetters];
+                    }
+                }
+                else if (kind === 'get') {
+                    if (!propertiesAndGettersByKey[key]) {
+                        propertiesAndGettersByKey[key] = [property, ...unmatchablePropertiesAndGetters];
+                        gettersByKey[key] = [property, ...unmatchableGetters];
+                    }
+                }
+                else {
+                    if (!propertiesAndSettersByKey[key]) {
+                        propertiesAndSettersByKey[key] = [property, ...unmatchablePropertiesAndSetters];
+                    }
+                    if (!propertiesAndGettersByKey[key]) {
+                        propertiesAndGettersByKey[key] = [property, ...unmatchablePropertiesAndGetters];
+                    }
+                }
+            }
+            else {
+                if (key === UnknownInteger) {
+                    unknownIntegerProps.push(property);
+                    continue;
+                }
+                if (kind === 'set')
+                    unmatchableSetters.push(property);
+                if (kind === 'get')
+                    unmatchableGetters.push(property);
+                if (kind !== 'get')
+                    unmatchablePropertiesAndSetters.push(property);
+                if (kind !== 'set')
+                    unmatchablePropertiesAndGetters.push(property);
+            }
+        }
+    }
+    deoptimizeCachedEntities() {
+        for (const expressionsToBeDeoptimized of Object.values(this.expressionsToBeDeoptimizedByKey)) {
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+        for (const expression of this.additionalExpressionsToBeDeoptimized) {
+            expression.deoptimizePath(UNKNOWN_PATH);
+        }
+    }
+    deoptimizeCachedIntegerEntities() {
+        for (const [key, expressionsToBeDeoptimized] of Object.entries(this.expressionsToBeDeoptimizedByKey)) {
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const expression of expressionsToBeDeoptimized) {
+                    expression.deoptimizeCache();
+                }
+            }
+        }
+        for (const expression of this.additionalExpressionsToBeDeoptimized) {
+            expression.deoptimizePath(UNKNOWN_INTEGER_PATH);
+        }
+    }
+    getMemberExpression(key) {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            typeof key !== 'string' ||
+            (this.hasUnknownDeoptimizedInteger && INTEGER_REG_EXP.test(key)) ||
+            this.deoptimizedPaths[key]) {
+            return UNKNOWN_EXPRESSION;
+        }
+        const properties = this.propertiesAndGettersByKey[key];
+        if (properties?.length === 1) {
+            return properties[0];
+        }
+        if (properties ||
+            this.unmatchablePropertiesAndGetters.length > 0 ||
+            (this.unknownIntegerProps.length > 0 && INTEGER_REG_EXP.test(key))) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return null;
+    }
+    getMemberExpressionAndTrackDeopt(key, origin) {
+        if (typeof key !== 'string') {
+            return UNKNOWN_EXPRESSION;
+        }
+        const expression = this.getMemberExpression(key);
+        if (!(expression === UNKNOWN_EXPRESSION || this.immutable)) {
+            const expressionsToBeDeoptimized = (this.expressionsToBeDeoptimizedByKey[key] =
+                this.expressionsToBeDeoptimizedByKey[key] || []);
+            expressionsToBeDeoptimized.push(origin);
+        }
+        return expression;
+    }
+}
+
+const isInteger = (property) => typeof property === 'string' && /^\d+$/.test(property);
+// This makes sure unknown properties are not handled as "undefined" but as
+// "unknown" but without access side effects. An exception is done for numeric
+// properties as we do not expect new builtin properties to be numbers, this
+// will improve tree-shaking for out-of-bounds array properties
+const OBJECT_PROTOTYPE_FALLBACK = new (class ObjectPrototypeFallbackExpression extends ExpressionEntity {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        if (interaction.type === INTERACTION_CALLED && path.length === 1 && !isInteger(path[0])) {
+            deoptimizeInteraction(interaction);
+        }
+    }
+    getLiteralValueAtPath(path) {
+        // We ignore number properties as we do not expect new properties to be
+        // numbers and also want to keep handling out-of-bound array elements as
+        // "undefined"
+        return path.length === 1 && isInteger(path[0]) ? undefined : UnknownValue;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type === INTERACTION_CALLED;
+    }
+})();
+const OBJECT_PROTOTYPE = new ObjectEntity({
+    __proto__: null,
+    hasOwnProperty: METHOD_RETURNS_BOOLEAN,
+    isPrototypeOf: METHOD_RETURNS_BOOLEAN,
+    propertyIsEnumerable: METHOD_RETURNS_BOOLEAN,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
+    valueOf: METHOD_RETURNS_UNKNOWN
+}, OBJECT_PROTOTYPE_FALLBACK, true);
+
+const NEW_ARRAY_PROPERTIES = [
+    { key: UnknownInteger, kind: 'init', property: UNKNOWN_EXPRESSION },
+    { key: 'length', kind: 'init', property: UNKNOWN_LITERAL_NUMBER }
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: true,
+        mutatesSelfAsArray: true,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_SELF = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: 'self',
+        returnsPrimitive: null
+    })
+];
+const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: 'self',
+        returnsPrimitive: null
+    })
+];
+const ARRAY_PROTOTYPE = new ObjectEntity({
+    __proto__: null,
+    // We assume that accessors have effects as we do not track the accessed value afterwards
+    at: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN,
+    concat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    copyWithin: METHOD_MUTATES_SELF_RETURNS_SELF,
+    entries: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    every: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
+    fill: METHOD_MUTATES_SELF_RETURNS_SELF,
+    filter: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    find: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    findLast: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findLastIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    includes: METHOD_RETURNS_BOOLEAN,
+    indexOf: METHOD_RETURNS_NUMBER,
+    join: METHOD_RETURNS_STRING,
+    keys: METHOD_RETURNS_UNKNOWN,
+    lastIndexOf: METHOD_RETURNS_NUMBER,
+    map: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    pop: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
+    push: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
+    reduce: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    reduceRight: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    reverse: METHOD_MUTATES_SELF_RETURNS_SELF,
+    shift: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
+    slice: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    some: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
+    sort: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF,
+    splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
+    unshift: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
+    values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
+}, OBJECT_PROTOTYPE, true);
+
+class ArrayExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (element && (hasSpread || element instanceof SpreadElement)) {
+                hasSpread = true;
+                element.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        const properties = [
+            { key: 'length', kind: 'init', property: UNKNOWN_LITERAL_NUMBER }
+        ];
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (hasSpread || element instanceof SpreadElement) {
+                if (element) {
+                    hasSpread = true;
+                    properties.unshift({ key: UnknownInteger, kind: 'init', property: element });
+                }
+            }
+            else if (element) {
+                properties.push({ key: String(index), kind: 'init', property: element });
+            }
+            else {
+                properties.push({ key: String(index), kind: 'init', property: UNDEFINED_EXPRESSION });
+            }
+        }
+        return (this.objectEntity = new ObjectEntity(properties, ARRAY_PROTOTYPE));
+    }
+}
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const getTruthyLiteralValue = () => UnknownTruthyValue;
+const returnFalse = () => false;
+const returnTrue = () => true;
+const PURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnFalse
+};
+const IMPURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnTrue
+};
+const PURE_WITH_ARRAY = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }) {
+        return args.length > 1 && !(args[1] instanceof ArrayExpression);
+    }
+};
+const GETTER_ACCESS = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }, context) {
+        const [_thisArgument, firstArgument] = args;
+        return (!(firstArgument instanceof ExpressionEntity) ||
+            firstArgument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+};
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
+};
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
+};
+/* PURE FUNCTION IF FIRST ARG DOES NOT CONTAIN A GETTER */
+const PF_NO_GETTER = {
+    __proto__: null,
+    [ValueProperties]: GETTER_ACCESS
+};
+/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
+const MUTATES_ARG_WITHOUT_ACCESSOR = {
+    __proto__: null,
+    [ValueProperties]: {
+        deoptimizeArgumentsOnCall({ args: [, firstArgument] }) {
+            firstArgument?.deoptimizePath(UNKNOWN_PATH);
+        },
+        getLiteralValue: getTruthyLiteralValue,
+        hasEffectsWhenCalled({ args }, context) {
+            return (args.length <= 1 ||
+                args[1].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
+        }
+    }
+};
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
+};
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
+};
+const PC_WITH_ARRAY = {
+    __proto__: null,
+    [ValueProperties]: PURE_WITH_ARRAY,
+    prototype: O
+};
+const ARRAY_TYPE = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    from: O,
+    of: PF,
+    prototype: O
+};
+const INTL_MEMBER = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    supportedLocalesOf: PC
+};
+const knownGlobals = {
+    // Placeholders for global objects to avoid shape mutations
+    global: O,
+    globalThis: O,
+    self: O,
+    window: O,
+    // Common globals
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    Array: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        from: O,
+        isArray: PF,
+        of: PF,
+        prototype: O
+    },
+    ArrayBuffer: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isView: PF,
+        prototype: O
+    },
+    AggregateError: PC_WITH_ARRAY,
+    Atomics: O,
+    BigInt: C,
+    BigInt64Array: C,
+    BigUint64Array: C,
+    Boolean: PC,
+    constructor: C,
+    DataView: PC,
+    Date: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        now: PF,
+        parse: PF,
+        prototype: O,
+        UTC: PF
+    },
+    decodeURI: PF,
+    decodeURIComponent: PF,
+    encodeURI: PF,
+    encodeURIComponent: PF,
+    Error: PC,
+    escape: PF,
+    eval: O,
+    EvalError: PC,
+    FinalizationRegistry: C,
+    Float32Array: ARRAY_TYPE,
+    Float64Array: ARRAY_TYPE,
+    Function: C,
+    hasOwnProperty: O,
+    Infinity: O,
+    Int16Array: ARRAY_TYPE,
+    Int32Array: ARRAY_TYPE,
+    Int8Array: ARRAY_TYPE,
+    isFinite: PF,
+    isNaN: PF,
+    isPrototypeOf: O,
+    JSON: O,
+    Map: PC_WITH_ARRAY,
+    Math: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        abs: PF,
+        acos: PF,
+        acosh: PF,
+        asin: PF,
+        asinh: PF,
+        atan: PF,
+        atan2: PF,
+        atanh: PF,
+        cbrt: PF,
+        ceil: PF,
+        clz32: PF,
+        cos: PF,
+        cosh: PF,
+        exp: PF,
+        expm1: PF,
+        floor: PF,
+        fround: PF,
+        hypot: PF,
+        imul: PF,
+        log: PF,
+        log10: PF,
+        log1p: PF,
+        log2: PF,
+        max: PF,
+        min: PF,
+        pow: PF,
+        random: PF,
+        round: PF,
+        sign: PF,
+        sin: PF,
+        sinh: PF,
+        sqrt: PF,
+        tan: PF,
+        tanh: PF,
+        trunc: PF
+    },
+    NaN: O,
+    Number: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isFinite: PF,
+        isInteger: PF,
+        isNaN: PF,
+        isSafeInteger: PF,
+        parseFloat: PF,
+        parseInt: PF,
+        prototype: O
+    },
+    Object: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        create: PF,
+        // Technically those can throw in certain situations, but we ignore this as
+        // code that relies on this will hopefully wrap this in a try-catch, which
+        // deoptimizes everything anyway
+        defineProperty: MUTATES_ARG_WITHOUT_ACCESSOR,
+        defineProperties: MUTATES_ARG_WITHOUT_ACCESSOR,
+        freeze: MUTATES_ARG_WITHOUT_ACCESSOR,
+        getOwnPropertyDescriptor: PF,
+        getOwnPropertyDescriptors: PF,
+        getOwnPropertyNames: PF,
+        getOwnPropertySymbols: PF,
+        getPrototypeOf: PF,
+        hasOwn: PF,
+        is: PF,
+        isExtensible: PF,
+        isFrozen: PF,
+        isSealed: PF,
+        keys: PF,
+        fromEntries: O,
+        entries: PF_NO_GETTER,
+        values: PF_NO_GETTER,
+        prototype: O
+    },
+    parseFloat: PF,
+    parseInt: PF,
+    Promise: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        all: O,
+        allSettled: O,
+        any: O,
+        prototype: O,
+        race: O,
+        reject: O,
+        resolve: O
+    },
+    propertyIsEnumerable: O,
+    Proxy: O,
+    RangeError: PC,
+    ReferenceError: PC,
+    Reflect: O,
+    RegExp: PC,
+    Set: PC_WITH_ARRAY,
+    SharedArrayBuffer: C,
+    String: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        fromCharCode: PF,
+        fromCodePoint: PF,
+        prototype: O,
+        raw: PF
+    },
+    Symbol: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        for: PF,
+        keyFor: PF,
+        prototype: O,
+        toStringTag: {
+            __proto__: null,
+            [ValueProperties]: {
+                deoptimizeArgumentsOnCall: doNothing,
+                getLiteralValue() {
+                    return SymbolToStringTag;
+                },
+                hasEffectsWhenCalled: returnTrue
+            }
+        }
+    },
+    SyntaxError: PC,
+    toLocaleString: O,
+    toString: O,
+    TypeError: PC,
+    Uint16Array: ARRAY_TYPE,
+    Uint32Array: ARRAY_TYPE,
+    Uint8Array: ARRAY_TYPE,
+    Uint8ClampedArray: ARRAY_TYPE,
+    // Technically, this is a global, but it needs special handling
+    // undefined: ?,
+    unescape: PF,
+    URIError: PC,
+    valueOf: O,
+    WeakMap: PC_WITH_ARRAY,
+    WeakRef: C,
+    WeakSet: PC_WITH_ARRAY,
+    // Additional globals shared by Node and Browser that are not strictly part of the language
+    clearInterval: C,
+    clearTimeout: C,
+    console: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        assert: C,
+        clear: C,
+        count: C,
+        countReset: C,
+        debug: C,
+        dir: C,
+        dirxml: C,
+        error: C,
+        exception: C,
+        group: C,
+        groupCollapsed: C,
+        groupEnd: C,
+        info: C,
+        log: C,
+        table: C,
+        time: C,
+        timeEnd: C,
+        timeLog: C,
+        trace: C,
+        warn: C
+    },
+    Intl: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        Collator: INTL_MEMBER,
+        DateTimeFormat: INTL_MEMBER,
+        DisplayNames: INTL_MEMBER,
+        ListFormat: INTL_MEMBER,
+        Locale: INTL_MEMBER,
+        NumberFormat: INTL_MEMBER,
+        PluralRules: INTL_MEMBER,
+        RelativeTimeFormat: INTL_MEMBER,
+        Segmenter: INTL_MEMBER
+    },
+    setInterval: C,
+    setTimeout: C,
+    TextDecoder: C,
+    TextEncoder: C,
+    URL: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        prototype: O,
+        canParse: PF
+    },
+    URLSearchParams: C,
+    // Browser specific globals
+    AbortController: C,
+    AbortSignal: C,
+    addEventListener: O,
+    alert: O,
+    AnalyserNode: C,
+    Animation: C,
+    AnimationEvent: C,
+    applicationCache: O,
+    ApplicationCache: C,
+    ApplicationCacheErrorEvent: C,
+    atob: O,
+    Attr: C,
+    Audio: C,
+    AudioBuffer: C,
+    AudioBufferSourceNode: C,
+    AudioContext: C,
+    AudioDestinationNode: C,
+    AudioListener: C,
+    AudioNode: C,
+    AudioParam: C,
+    AudioProcessingEvent: C,
+    AudioScheduledSourceNode: C,
+    AudioWorkletNode: C,
+    BarProp: C,
+    BaseAudioContext: C,
+    BatteryManager: C,
+    BeforeUnloadEvent: C,
+    BiquadFilterNode: C,
+    Blob: C,
+    BlobEvent: C,
+    blur: O,
+    BroadcastChannel: C,
+    btoa: O,
+    ByteLengthQueuingStrategy: C,
+    Cache: C,
+    caches: O,
+    CacheStorage: C,
+    cancelAnimationFrame: O,
+    cancelIdleCallback: O,
+    CanvasCaptureMediaStreamTrack: C,
+    CanvasGradient: C,
+    CanvasPattern: C,
+    CanvasRenderingContext2D: C,
+    ChannelMergerNode: C,
+    ChannelSplitterNode: C,
+    CharacterData: C,
+    clientInformation: O,
+    ClipboardEvent: C,
+    close: O,
+    closed: O,
+    CloseEvent: C,
+    Comment: C,
+    CompositionEvent: C,
+    confirm: O,
+    ConstantSourceNode: C,
+    ConvolverNode: C,
+    CountQueuingStrategy: C,
+    createImageBitmap: O,
+    Credential: C,
+    CredentialsContainer: C,
+    crypto: O,
+    Crypto: C,
+    CryptoKey: C,
+    CSS: C,
+    CSSConditionRule: C,
+    CSSFontFaceRule: C,
+    CSSGroupingRule: C,
+    CSSImportRule: C,
+    CSSKeyframeRule: C,
+    CSSKeyframesRule: C,
+    CSSMediaRule: C,
+    CSSNamespaceRule: C,
+    CSSPageRule: C,
+    CSSRule: C,
+    CSSRuleList: C,
+    CSSStyleDeclaration: C,
+    CSSStyleRule: C,
+    CSSStyleSheet: C,
+    CSSSupportsRule: C,
+    CustomElementRegistry: C,
+    customElements: O,
+    CustomEvent: {
+        __proto__: null,
+        [ValueProperties]: {
+            deoptimizeArgumentsOnCall({ args }) {
+                args[2]?.deoptimizePath(['detail']);
+            },
+            getLiteralValue: getTruthyLiteralValue,
+            hasEffectsWhenCalled: returnFalse
+        },
+        prototype: O
+    },
+    DataTransfer: C,
+    DataTransferItem: C,
+    DataTransferItemList: C,
+    defaultstatus: O,
+    defaultStatus: O,
+    DelayNode: C,
+    DeviceMotionEvent: C,
+    DeviceOrientationEvent: C,
+    devicePixelRatio: O,
+    dispatchEvent: O,
+    document: O,
+    Document: C,
+    DocumentFragment: C,
+    DocumentType: C,
+    DOMError: C,
+    DOMException: C,
+    DOMImplementation: C,
+    DOMMatrix: C,
+    DOMMatrixReadOnly: C,
+    DOMParser: C,
+    DOMPoint: C,
+    DOMPointReadOnly: C,
+    DOMQuad: C,
+    DOMRect: C,
+    DOMRectReadOnly: C,
+    DOMStringList: C,
+    DOMStringMap: C,
+    DOMTokenList: C,
+    DragEvent: C,
+    DynamicsCompressorNode: C,
+    Element: C,
+    ErrorEvent: C,
+    Event: C,
+    EventSource: C,
+    EventTarget: C,
+    external: O,
+    fetch: O,
+    File: C,
+    FileList: C,
+    FileReader: C,
+    find: O,
+    focus: O,
+    FocusEvent: C,
+    FontFace: C,
+    FontFaceSetLoadEvent: C,
+    FormData: C,
+    frames: O,
+    GainNode: C,
+    Gamepad: C,
+    GamepadButton: C,
+    GamepadEvent: C,
+    getComputedStyle: O,
+    getSelection: O,
+    HashChangeEvent: C,
+    Headers: C,
+    history: O,
+    History: C,
+    HTMLAllCollection: C,
+    HTMLAnchorElement: C,
+    HTMLAreaElement: C,
+    HTMLAudioElement: C,
+    HTMLBaseElement: C,
+    HTMLBodyElement: C,
+    HTMLBRElement: C,
+    HTMLButtonElement: C,
+    HTMLCanvasElement: C,
+    HTMLCollection: C,
+    HTMLContentElement: C,
+    HTMLDataElement: C,
+    HTMLDataListElement: C,
+    HTMLDetailsElement: C,
+    HTMLDialogElement: C,
+    HTMLDirectoryElement: C,
+    HTMLDivElement: C,
+    HTMLDListElement: C,
+    HTMLDocument: C,
+    HTMLElement: C,
+    HTMLEmbedElement: C,
+    HTMLFieldSetElement: C,
+    HTMLFontElement: C,
+    HTMLFormControlsCollection: C,
+    HTMLFormElement: C,
+    HTMLFrameElement: C,
+    HTMLFrameSetElement: C,
+    HTMLHeadElement: C,
+    HTMLHeadingElement: C,
+    HTMLHRElement: C,
+    HTMLHtmlElement: C,
+    HTMLIFrameElement: C,
+    HTMLImageElement: C,
+    HTMLInputElement: C,
+    HTMLLabelElement: C,
+    HTMLLegendElement: C,
+    HTMLLIElement: C,
+    HTMLLinkElement: C,
+    HTMLMapElement: C,
+    HTMLMarqueeElement: C,
+    HTMLMediaElement: C,
+    HTMLMenuElement: C,
+    HTMLMetaElement: C,
+    HTMLMeterElement: C,
+    HTMLModElement: C,
+    HTMLObjectElement: C,
+    HTMLOListElement: C,
+    HTMLOptGroupElement: C,
+    HTMLOptionElement: C,
+    HTMLOptionsCollection: C,
+    HTMLOutputElement: C,
+    HTMLParagraphElement: C,
+    HTMLParamElement: C,
+    HTMLPictureElement: C,
+    HTMLPreElement: C,
+    HTMLProgressElement: C,
+    HTMLQuoteElement: C,
+    HTMLScriptElement: C,
+    HTMLSelectElement: C,
+    HTMLShadowElement: C,
+    HTMLSlotElement: C,
+    HTMLSourceElement: C,
+    HTMLSpanElement: C,
+    HTMLStyleElement: C,
+    HTMLTableCaptionElement: C,
+    HTMLTableCellElement: C,
+    HTMLTableColElement: C,
+    HTMLTableElement: C,
+    HTMLTableRowElement: C,
+    HTMLTableSectionElement: C,
+    HTMLTemplateElement: C,
+    HTMLTextAreaElement: C,
+    HTMLTimeElement: C,
+    HTMLTitleElement: C,
+    HTMLTrackElement: C,
+    HTMLUListElement: C,
+    HTMLUnknownElement: C,
+    HTMLVideoElement: C,
+    IDBCursor: C,
+    IDBCursorWithValue: C,
+    IDBDatabase: C,
+    IDBFactory: C,
+    IDBIndex: C,
+    IDBKeyRange: C,
+    IDBObjectStore: C,
+    IDBOpenDBRequest: C,
+    IDBRequest: C,
+    IDBTransaction: C,
+    IDBVersionChangeEvent: C,
+    IdleDeadline: C,
+    IIRFilterNode: C,
+    Image: C,
+    ImageBitmap: C,
+    ImageBitmapRenderingContext: C,
+    ImageCapture: C,
+    ImageData: C,
+    indexedDB: O,
+    innerHeight: O,
+    innerWidth: O,
+    InputEvent: C,
+    IntersectionObserver: C,
+    IntersectionObserverEntry: C,
+    isSecureContext: O,
+    KeyboardEvent: C,
+    KeyframeEffect: C,
+    length: O,
+    localStorage: O,
+    location: O,
+    Location: C,
+    locationbar: O,
+    matchMedia: O,
+    MediaDeviceInfo: C,
+    MediaDevices: C,
+    MediaElementAudioSourceNode: C,
+    MediaEncryptedEvent: C,
+    MediaError: C,
+    MediaKeyMessageEvent: C,
+    MediaKeySession: C,
+    MediaKeyStatusMap: C,
+    MediaKeySystemAccess: C,
+    MediaList: C,
+    MediaQueryList: C,
+    MediaQueryListEvent: C,
+    MediaRecorder: C,
+    MediaSettingsRange: C,
+    MediaSource: C,
+    MediaStream: C,
+    MediaStreamAudioDestinationNode: C,
+    MediaStreamAudioSourceNode: C,
+    MediaStreamEvent: C,
+    MediaStreamTrack: C,
+    MediaStreamTrackEvent: C,
+    menubar: O,
+    MessageChannel: C,
+    MessageEvent: C,
+    MessagePort: C,
+    MIDIAccess: C,
+    MIDIConnectionEvent: C,
+    MIDIInput: C,
+    MIDIInputMap: C,
+    MIDIMessageEvent: C,
+    MIDIOutput: C,
+    MIDIOutputMap: C,
+    MIDIPort: C,
+    MimeType: C,
+    MimeTypeArray: C,
+    MouseEvent: C,
+    moveBy: O,
+    moveTo: O,
+    MutationEvent: C,
+    MutationObserver: C,
+    MutationRecord: C,
+    name: O,
+    NamedNodeMap: C,
+    NavigationPreloadManager: C,
+    navigator: O,
+    Navigator: C,
+    NetworkInformation: C,
+    Node: C,
+    NodeFilter: O,
+    NodeIterator: C,
+    NodeList: C,
+    Notification: C,
+    OfflineAudioCompletionEvent: C,
+    OfflineAudioContext: C,
+    offscreenBuffering: O,
+    OffscreenCanvas: C,
+    open: O,
+    openDatabase: O,
+    Option: C,
+    origin: O,
+    OscillatorNode: C,
+    outerHeight: O,
+    outerWidth: O,
+    PageTransitionEvent: C,
+    pageXOffset: O,
+    pageYOffset: O,
+    PannerNode: C,
+    parent: O,
+    Path2D: C,
+    PaymentAddress: C,
+    PaymentRequest: C,
+    PaymentRequestUpdateEvent: C,
+    PaymentResponse: C,
+    performance: O,
+    Performance: C,
+    PerformanceEntry: C,
+    PerformanceLongTaskTiming: C,
+    PerformanceMark: C,
+    PerformanceMeasure: C,
+    PerformanceNavigation: C,
+    PerformanceNavigationTiming: C,
+    PerformanceObserver: C,
+    PerformanceObserverEntryList: C,
+    PerformancePaintTiming: C,
+    PerformanceResourceTiming: C,
+    PerformanceTiming: C,
+    PeriodicWave: C,
+    Permissions: C,
+    PermissionStatus: C,
+    personalbar: O,
+    PhotoCapabilities: C,
+    Plugin: C,
+    PluginArray: C,
+    PointerEvent: C,
+    PopStateEvent: C,
+    postMessage: O,
+    Presentation: C,
+    PresentationAvailability: C,
+    PresentationConnection: C,
+    PresentationConnectionAvailableEvent: C,
+    PresentationConnectionCloseEvent: C,
+    PresentationConnectionList: C,
+    PresentationReceiver: C,
+    PresentationRequest: C,
+    print: O,
+    ProcessingInstruction: C,
+    ProgressEvent: C,
+    PromiseRejectionEvent: C,
+    prompt: O,
+    PushManager: C,
+    PushSubscription: C,
+    PushSubscriptionOptions: C,
+    queueMicrotask: O,
+    RadioNodeList: C,
+    Range: C,
+    ReadableStream: C,
+    RemotePlayback: C,
+    removeEventListener: O,
+    Request: C,
+    requestAnimationFrame: O,
+    requestIdleCallback: O,
+    resizeBy: O,
+    ResizeObserver: C,
+    ResizeObserverEntry: C,
+    resizeTo: O,
+    Response: C,
+    RTCCertificate: C,
+    RTCDataChannel: C,
+    RTCDataChannelEvent: C,
+    RTCDtlsTransport: C,
+    RTCIceCandidate: C,
+    RTCIceTransport: C,
+    RTCPeerConnection: C,
+    RTCPeerConnectionIceEvent: C,
+    RTCRtpReceiver: C,
+    RTCRtpSender: C,
+    RTCSctpTransport: C,
+    RTCSessionDescription: C,
+    RTCStatsReport: C,
+    RTCTrackEvent: C,
+    screen: O,
+    Screen: C,
+    screenLeft: O,
+    ScreenOrientation: C,
+    screenTop: O,
+    screenX: O,
+    screenY: O,
+    ScriptProcessorNode: C,
+    scroll: O,
+    scrollbars: O,
+    scrollBy: O,
+    scrollTo: O,
+    scrollX: O,
+    scrollY: O,
+    SecurityPolicyViolationEvent: C,
+    Selection: C,
+    ServiceWorker: C,
+    ServiceWorkerContainer: C,
+    ServiceWorkerRegistration: C,
+    sessionStorage: O,
+    ShadowRoot: C,
+    SharedWorker: C,
+    SourceBuffer: C,
+    SourceBufferList: C,
+    speechSynthesis: O,
+    SpeechSynthesisEvent: C,
+    SpeechSynthesisUtterance: C,
+    StaticRange: C,
+    status: O,
+    statusbar: O,
+    StereoPannerNode: C,
+    stop: O,
+    Storage: C,
+    StorageEvent: C,
+    StorageManager: C,
+    styleMedia: O,
+    StyleSheet: C,
+    StyleSheetList: C,
+    SubtleCrypto: C,
+    SVGAElement: C,
+    SVGAngle: C,
+    SVGAnimatedAngle: C,
+    SVGAnimatedBoolean: C,
+    SVGAnimatedEnumeration: C,
+    SVGAnimatedInteger: C,
+    SVGAnimatedLength: C,
+    SVGAnimatedLengthList: C,
+    SVGAnimatedNumber: C,
+    SVGAnimatedNumberList: C,
+    SVGAnimatedPreserveAspectRatio: C,
+    SVGAnimatedRect: C,
+    SVGAnimatedString: C,
+    SVGAnimatedTransformList: C,
+    SVGAnimateElement: C,
+    SVGAnimateMotionElement: C,
+    SVGAnimateTransformElement: C,
+    SVGAnimationElement: C,
+    SVGCircleElement: C,
+    SVGClipPathElement: C,
+    SVGComponentTransferFunctionElement: C,
+    SVGDefsElement: C,
+    SVGDescElement: C,
+    SVGDiscardElement: C,
+    SVGElement: C,
+    SVGEllipseElement: C,
+    SVGFEBlendElement: C,
+    SVGFEColorMatrixElement: C,
+    SVGFEComponentTransferElement: C,
+    SVGFECompositeElement: C,
+    SVGFEConvolveMatrixElement: C,
+    SVGFEDiffuseLightingElement: C,
+    SVGFEDisplacementMapElement: C,
+    SVGFEDistantLightElement: C,
+    SVGFEDropShadowElement: C,
+    SVGFEFloodElement: C,
+    SVGFEFuncAElement: C,
+    SVGFEFuncBElement: C,
+    SVGFEFuncGElement: C,
+    SVGFEFuncRElement: C,
+    SVGFEGaussianBlurElement: C,
+    SVGFEImageElement: C,
+    SVGFEMergeElement: C,
+    SVGFEMergeNodeElement: C,
+    SVGFEMorphologyElement: C,
+    SVGFEOffsetElement: C,
+    SVGFEPointLightElement: C,
+    SVGFESpecularLightingElement: C,
+    SVGFESpotLightElement: C,
+    SVGFETileElement: C,
+    SVGFETurbulenceElement: C,
+    SVGFilterElement: C,
+    SVGForeignObjectElement: C,
+    SVGGElement: C,
+    SVGGeometryElement: C,
+    SVGGradientElement: C,
+    SVGGraphicsElement: C,
+    SVGImageElement: C,
+    SVGLength: C,
+    SVGLengthList: C,
+    SVGLinearGradientElement: C,
+    SVGLineElement: C,
+    SVGMarkerElement: C,
+    SVGMaskElement: C,
+    SVGMatrix: C,
+    SVGMetadataElement: C,
+    SVGMPathElement: C,
+    SVGNumber: C,
+    SVGNumberList: C,
+    SVGPathElement: C,
+    SVGPatternElement: C,
+    SVGPoint: C,
+    SVGPointList: C,
+    SVGPolygonElement: C,
+    SVGPolylineElement: C,
+    SVGPreserveAspectRatio: C,
+    SVGRadialGradientElement: C,
+    SVGRect: C,
+    SVGRectElement: C,
+    SVGScriptElement: C,
+    SVGSetElement: C,
+    SVGStopElement: C,
+    SVGStringList: C,
+    SVGStyleElement: C,
+    SVGSVGElement: C,
+    SVGSwitchElement: C,
+    SVGSymbolElement: C,
+    SVGTextContentElement: C,
+    SVGTextElement: C,
+    SVGTextPathElement: C,
+    SVGTextPositioningElement: C,
+    SVGTitleElement: C,
+    SVGTransform: C,
+    SVGTransformList: C,
+    SVGTSpanElement: C,
+    SVGUnitTypes: C,
+    SVGUseElement: C,
+    SVGViewElement: C,
+    TaskAttributionTiming: C,
+    Text: C,
+    TextEvent: C,
+    TextMetrics: C,
+    TextTrack: C,
+    TextTrackCue: C,
+    TextTrackCueList: C,
+    TextTrackList: C,
+    TimeRanges: C,
+    toolbar: O,
+    top: O,
+    Touch: C,
+    TouchEvent: C,
+    TouchList: C,
+    TrackEvent: C,
+    TransitionEvent: C,
+    TreeWalker: C,
+    UIEvent: C,
+    ValidityState: C,
+    visualViewport: O,
+    VisualViewport: C,
+    VTTCue: C,
+    WaveShaperNode: C,
+    WebAssembly: O,
+    WebGL2RenderingContext: C,
+    WebGLActiveInfo: C,
+    WebGLBuffer: C,
+    WebGLContextEvent: C,
+    WebGLFramebuffer: C,
+    WebGLProgram: C,
+    WebGLQuery: C,
+    WebGLRenderbuffer: C,
+    WebGLRenderingContext: C,
+    WebGLSampler: C,
+    WebGLShader: C,
+    WebGLShaderPrecisionFormat: C,
+    WebGLSync: C,
+    WebGLTexture: C,
+    WebGLTransformFeedback: C,
+    WebGLUniformLocation: C,
+    WebGLVertexArrayObject: C,
+    WebSocket: C,
+    WheelEvent: C,
+    Window: C,
+    Worker: C,
+    WritableStream: C,
+    XMLDocument: C,
+    XMLHttpRequest: C,
+    XMLHttpRequestEventTarget: C,
+    XMLHttpRequestUpload: C,
+    XMLSerializer: C,
+    XPathEvaluator: C,
+    XPathExpression: C,
+    XPathResult: C,
+    XSLTProcessor: C
+};
+for (const global of ['window', 'global', 'self', 'globalThis']) {
+    knownGlobals[global] = knownGlobals;
+}
+function getGlobalAtPath(path) {
+    let currentGlobal = knownGlobals;
+    for (const pathSegment of path) {
+        if (typeof pathSegment !== 'string') {
+            return null;
+        }
+        currentGlobal = currentGlobal[pathSegment];
+        if (!currentGlobal) {
+            return null;
+        }
+    }
+    return currentGlobal[ValueProperties];
+}
+
+class GlobalVariable extends Variable {
+    constructor(name) {
+        super(name);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
+        this.markReassigned();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        switch (interaction.type) {
+            // While there is no point in testing these cases as at the moment, they
+            // are also covered via other means, we keep them for completeness
+            case INTERACTION_ACCESSED:
+            case INTERACTION_ASSIGNED: {
+                if (!getGlobalAtPath([this.name, ...path].slice(0, -1))) {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                if (globalAtPath) {
+                    globalAtPath.deoptimizeArgumentsOnCall(interaction);
+                }
+                else {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+        }
+    }
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return globalAtPath ? globalAtPath.getLiteralValue() : UnknownValue;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (path.length === 0) {
+                    // Technically, "undefined" is a global variable of sorts
+                    return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+                }
+                return !getGlobalAtPath([this.name, ...path].slice(0, -1));
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
+            }
+        }
+    }
+}
+
+class LocalVariable extends Variable {
+    constructor(name, declarator, init, context, kind) {
+        super(name);
+        this.init = init;
+        this.calledFromTryStatement = false;
+        this.additionalInitializers = null;
+        this.expressionsToBeDeoptimized = [];
+        this.declarations = declarator ? [declarator] : [];
+        this.deoptimizationTracker = context.deoptimizationTracker;
+        this.module = context.module;
+        this.kind = kind;
+    }
+    addDeclaration(identifier, init) {
+        this.declarations.push(identifier);
+        this.markInitializersForDeoptimization().push(init);
+    }
+    consolidateInitializers() {
+        if (this.additionalInitializers) {
+            for (const initializer of this.additionalInitializers) {
+                initializer.deoptimizePath(UNKNOWN_PATH);
+            }
+            this.additionalInitializers = null;
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.isReassigned) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker), undefined);
+    }
+    deoptimizePath(path) {
+        if (this.isReassigned ||
+            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        if (path.length === 0) {
+            this.markReassigned();
+            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            this.init.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.init.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (this.isReassigned)
+                    return true;
+                return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                if (this.included)
+                    return true;
+                if (path.length === 0)
+                    return false;
+                if (this.isReassigned)
+                    return true;
+                return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_CALLED: {
+                if (this.isReassigned)
+                    return true;
+                return (!(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.included) {
+            super.include();
+            for (const declaration of this.declarations) {
+                // If node is a default export, it can save a tree-shaking run to include the full declaration now
+                if (!declaration.included)
+                    declaration.include(createInclusionContext(), false);
+                let node = declaration.parent;
+                while (!node.included) {
+                    // We do not want to properly include parents in case they are part of a dead branch
+                    // in which case .include() might pull in more dead code
+                    node.included = true;
+                    if (node.type === Program$1)
+                        break;
+                    node = node.parent;
+                }
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.isReassigned || context.includedCallArguments.has(this.init)) {
+            for (const argument of parameters) {
+                argument.include(context, false);
+            }
+        }
+        else {
+            context.includedCallArguments.add(this.init);
+            this.init.includeCallArguments(context, parameters);
+            context.includedCallArguments.delete(this.init);
+        }
+    }
+    markCalledFromTryStatement() {
+        this.calledFromTryStatement = true;
+    }
+    markInitializersForDeoptimization() {
+        if (this.additionalInitializers === null) {
+            this.additionalInitializers = [this.init];
+            this.init = UNKNOWN_EXPRESSION;
+            this.markReassigned();
+        }
+        return this.additionalInitializers;
+    }
+}
+
+const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
+class IdentifierBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.isVariableReference = false;
+    }
+    get isTDZAccess() {
+        if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
+            return null;
+        }
+        return isFlagSet(this.flags, 8 /* Flag.tdzAccess */);
+    }
+    set isTDZAccess(value) {
+        this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
+        this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        // We keep conditional chaining because an unknown Node could have an
+        // Identifier as property that might be deoptimized by default
+        this.variable?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return [expression, isPure || this.isPureFunction(path)];
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
+        }
+        return (this.scope.context.options.treeshake
+            .unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            !this.isPureFunction(EMPTY_PATH) &&
+            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return (this.variable !== null &&
+                    !this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            case INTERACTION_CALLED: {
+                return (!this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
+    }
+    isPossibleTDZ() {
+        // return cached value to avoid issues with the next tree-shaking pass
+        const cachedTdzAccess = this.isTDZAccess;
+        if (cachedTdzAccess !== null)
+            return cachedTdzAccess;
+        if (!(this.variable instanceof LocalVariable &&
+            this.variable.kind &&
+            tdzVariableKinds.has(this.variable.kind) &&
+            // We ignore modules that did not receive a treeshaking pass yet as that
+            // causes many false positives due to circular dependencies or disabled
+            // moduleSideEffects.
+            this.variable.module.hasTreeShakingPassStarted)) {
+            return (this.isTDZAccess = false);
+        }
+        let decl_id;
+        if (this.variable.declarations &&
+            this.variable.declarations.length === 1 &&
+            (decl_id = this.variable.declarations[0]) &&
+            this.start < decl_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            // a variable accessed before its declaration
+            // in the same function or at top level of module
+            return (this.isTDZAccess = true);
+        }
+        if (!this.variable.initReached) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
+        }
+        return (this.isTDZAccess = false);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable instanceof LocalVariable) {
+            // When accessing a variable from a module without side effects, this
+            // means we use an export of that module and therefore need to potentially
+            // include it in the bundle.
+            if (!this.variable.module.isExecuted) {
+                markModuleAndImpureDependenciesAsExecuted(this.variable.module);
+            }
+            this.variable.consolidateInitializers();
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.isVariableReference) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    disallowImportReassignment() {
+        return this.scope.context.error(logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+    }
+    getVariableRespectingTDZ() {
+        if (this.isPossibleTDZ()) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return this.variable;
+    }
+    isPureFunction(path) {
+        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
+        for (const segment of path) {
+            if (currentPureFunction) {
+                if (currentPureFunction[PureFunctionKey]) {
+                    return true;
+                }
+                currentPureFunction = currentPureFunction[segment];
+            }
+            else {
+                return false;
+            }
+        }
+        return currentPureFunction?.[PureFunctionKey];
+    }
+}
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
+}
+
+class Identifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (!this.variable && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+            this.isVariableReference = true;
+        }
+    }
+    declare(kind, init) {
+        let variable;
+        const { treeshake } = this.scope.context.options;
+        switch (kind) {
+            case 'var': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
+            }
+            case 'function': {
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'let':
+            case 'const':
+            case 'using':
+            case 'await using':
+            case 'class': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'parameter': {
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            }
+            /* istanbul ignore next */
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+            }
+        }
+        return [(this.variable = variable)];
+    }
+    markDeclarationReached() {
+        this.variable.initReached = true;
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = BLANK) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, `${this.name}: `);
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === CallExpression$1 &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+}
+
+const chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const base = 64;
+function toBase64(value) {
+    let outString = '';
+    do {
+        const currentDigit = value % base;
+        value = (value / base) | 0;
+        outString = chars[currentDigit] + outString;
+    } while (value !== 0);
+    return outString;
+}
+
+function getSafeName(baseName, usedNames, forbiddenNames) {
+    let safeName = baseName;
+    let count = 1;
+    while (usedNames.has(safeName) || RESERVED_NAMES.has(safeName) || forbiddenNames?.has(safeName)) {
+        safeName = `${baseName}$${toBase64(count++)}`;
+    }
+    usedNames.add(safeName);
+    return safeName;
+}
+
+class Scope {
+    constructor() {
+        this.children = [];
+        this.variables = new Map();
+    }
+    /*
+    Redeclaration rules:
+    - var can redeclare var
+    - in function scopes, function and var can redeclare function and var
+    - var is hoisted across scopes, function remains in the scope it is declared
+    - var and function can redeclare function parameters, but parameters cannot redeclare parameters
+    - function cannot redeclare catch scope parameters
+    - var can redeclare catch scope parameters in a way
+        - if the parameter is an identifier and not a pattern
+        - then the variable is still declared in the hoisted outer scope, but the initializer is assigned to the parameter
+    - const, let, class, and function except in the cases above cannot redeclare anything
+     */
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if (kind === 'var' && existingKind === 'var') {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(logRedeclarationError(name), identifier.start);
+        }
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
+    }
+    addHoistedVariable(name, variable) {
+        (this.hoistedVariables ||= new Map()).set(name, variable);
+    }
+    contains(name) {
+        return this.variables.has(name);
+    }
+    findVariable(_name) {
+        /* istanbul ignore next */
+        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
+    }
+}
+
+class ChildScope extends Scope {
+    constructor(parent, context) {
+        super();
+        this.parent = parent;
+        this.context = context;
+        this.accessedOutsideVariables = new Map();
+        parent.children.push(this);
+    }
+    addAccessedDynamicImport(importExpression) {
+        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedDynamicImport(importExpression);
+        }
+    }
+    addAccessedGlobals(globals, accessedGlobalsByScope) {
+        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
+        for (const name of globals) {
+            accessedGlobals.add(name);
+        }
+        accessedGlobalsByScope.set(this, accessedGlobals);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
+        }
+    }
+    addNamespaceMemberAccess(name, variable) {
+        this.accessedOutsideVariables.set(name, variable);
+        this.parent.addNamespaceMemberAccess(name, variable);
+    }
+    addReturnExpression(expression) {
+        if (this.parent instanceof ChildScope) {
+            this.parent.addReturnExpression(expression);
+        }
+    }
+    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
+        for (const variable of this.accessedOutsideVariables.values()) {
+            if (variable.included) {
+                usedNames.add(variable.getBaseVariableName());
+                if (format === 'system' && exportNamesByVariable.has(variable)) {
+                    usedNames.add('exports');
+                }
+            }
+        }
+        const accessedGlobals = accessedGlobalsByScope.get(this);
+        if (accessedGlobals) {
+            for (const name of accessedGlobals) {
+                usedNames.add(name);
+            }
+        }
+    }
+    contains(name) {
+        return this.variables.has(name) || this.parent.contains(name);
+    }
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        const usedNames = new Set();
+        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+        if (this.accessedDynamicImports) {
+            for (const importExpression of this.accessedDynamicImports) {
+                if (importExpression.inlineNamespace) {
+                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
+                }
+            }
+        }
+        for (const [name, variable] of this.variables) {
+            if (variable.included || variable.alwaysRendered) {
+                variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
+            }
+        }
+        for (const scope of this.children) {
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+        }
+    }
+    findLexicalBoundary() {
+        return this.parent.findLexicalBoundary();
+    }
+    findGlobal(name) {
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
+        }
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
+}
+
+function checkEffectForNodes(nodes, context) {
+    for (const node of nodes) {
+        if (node.hasEffects(context)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+class MethodBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.accessedValue = null;
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        if (interaction.type === INTERACTION_ASSIGNED && this.kind === 'set' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        this.getAccessedValue()[0].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    // As getter properties directly receive their values from fixed function
+    // expressions, there is no known situation where a getter is deoptimized.
+    deoptimizeCache() { }
+    deoptimizePath(path) {
+        this.getAccessedValue()[0].deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        return this.key.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.kind === 'get' && interaction.type === INTERACTION_ACCESSED && path.length === 0) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        // setters are only called for empty paths
+        if (this.kind === 'set' && interaction.type === INTERACTION_ASSIGNED) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() { }
+    getAccessedValue() {
+        if (this.accessedValue === null) {
+            if (this.kind === 'get') {
+                this.accessedValue = UNKNOWN_RETURN_EXPRESSION;
+                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
+            }
+            else {
+                return (this.accessedValue = [this.value, false]);
+            }
+        }
+        return this.accessedValue;
+    }
+}
+
+class MethodDefinition extends MethodBase {
+    hasEffects(context) {
+        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    applyDeoptimizations() { }
+}
+
+class BlockScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                if (existingVariable.kind === 'var' ||
+                    (kind === 'var' && existingVariable.kind === 'parameter')) {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(logRedeclarationError(name), identifier.start);
+            }
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+class StaticBlock extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
+            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+function isStaticBlock(statement) {
+    return statement.type === StaticBlock$1;
+}
+
+class ObjectMember extends ExpressionEntity {
+    constructor(object, key) {
+        super();
+        this.object = object;
+        this.key = key;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.object.deoptimizePath([this.key, ...path]);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
+    }
+}
+
+class ClassNode extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new ChildScope(parentScope, parentScope.context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        this.getObjectEntity().deoptimizeAllProperties();
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.superClass?.hasEffects(context) || this.body.hasEffects(context);
+        this.id?.markDeclarationReached();
+        return initEffect || super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return interaction.type === INTERACTION_CALLED && path.length === 0
+            ? !interaction.withNew ||
+                (this.classConstructor === null
+                    ? this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)
+                    : this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
+                false
+            : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.superClass?.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
+        for (const decorator of this.decorators)
+            decorator.include(context, includeChildrenRecursively);
+        if (this.id) {
+            this.id.markDeclarationReached();
+            this.id.include();
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.id?.declare('class', this);
+        for (const method of this.body.body) {
+            if (method instanceof MethodDefinition && method.kind === 'constructor') {
+                this.classConstructor = method;
+                return;
+            }
+        }
+        this.classConstructor = null;
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const definition of this.body.body) {
+            if (!isStaticBlock(definition) &&
+                !(definition.static ||
+                    (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+                // Calls to methods are not tracked, ensure that the return value is deoptimized
+                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        const staticProperties = [];
+        const dynamicMethods = [];
+        for (const definition of this.body.body) {
+            if (isStaticBlock(definition))
+                continue;
+            const properties = definition.static ? staticProperties : dynamicMethods;
+            const definitionKind = definition.kind;
+            // Note that class fields do not end up on the prototype
+            if (properties === dynamicMethods && !definitionKind)
+                continue;
+            const kind = definitionKind === 'set' || definitionKind === 'get' ? definitionKind : 'init';
+            let key;
+            if (definition.computed) {
+                const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                if (typeof keyValue === 'symbol') {
+                    properties.push({ key: UnknownKey, kind, property: definition });
+                    continue;
+                }
+                else {
+                    key = String(keyValue);
+                }
+            }
+            else {
+                key =
+                    definition.key instanceof Identifier
+                        ? definition.key.name
+                        : String(definition.key.value);
+            }
+            properties.push({ key, kind, property: definition });
+        }
+        staticProperties.unshift({
+            key: 'prototype',
+            kind: 'init',
+            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, 'prototype') : OBJECT_PROTOTYPE)
+        });
+        return (this.objectEntity = new ObjectEntity(staticProperties, this.superClass || OBJECT_PROTOTYPE));
+    }
+}
+
+class ClassDeclaration extends ClassNode {
+    initialise() {
+        super.initialise();
+        if (this.id !== null) {
+            this.id.variable.isId = true;
+        }
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, format, snippets: { _, getPropertyAccess } } = options;
+        if (this.id) {
+            const { variable, name } = this.id;
+            if (format === 'system' && exportNamesByVariable.has(variable)) {
+                code.appendLeft(this.end, `${_}${getSystemExportStatement([variable], options)};`);
+            }
+            const renderedVariable = variable.getName(getPropertyAccess);
+            if (renderedVariable !== name) {
+                this.decorators.map(decorator => decorator.render(code, options));
+                this.superClass?.render(code, options);
+                this.body.render(code, {
+                    ...options,
+                    useOriginalName: (_variable) => _variable === variable
+                });
+                code.prependRight(this.start, `let ${renderedVariable}${_}=${_}`);
+                code.prependLeft(this.end, ';');
+                return;
+            }
+        }
+        super.render(code, options);
+    }
+    applyDeoptimizations() {
+        super.applyDeoptimizations();
+        const { id, scope } = this;
+        if (id) {
+            const { name, variable } = id;
+            for (const accessedVariable of scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+
+class ArgumentsVariable extends LocalVariable {
+    constructor(context) {
+        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
+        this.deoptimizedArguments = [];
+    }
+    addArgumentToBeDeoptimized(argument) {
+        if (this.included) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.deoptimizedArguments.push(argument);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    include() {
+        super.include();
+        for (const argument of this.deoptimizedArguments) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.deoptimizedArguments.length = 0;
+    }
+}
+
+const MAX_TRACKED_INTERACTIONS = 20;
+const NO_INTERACTIONS = EMPTY_ARRAY;
+const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
+const EMPTY_PATH_TRACKER = new PathTracker();
+const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
+class ParameterVariable extends LocalVariable {
+    constructor(name, declarator, context) {
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
+        this.deoptimizationInteractions = [];
+        this.deoptimizations = new PathTracker();
+        this.deoptimizedFields = new Set();
+        this.entitiesToBeDeoptimized = new Set();
+        this.expressionsUseTheKnownValue = [];
+        this.knownValue = null;
+        this.knownValueLiteral = UnknownValue;
+        this.frozenValue = null;
+    }
+    addEntityToBeDeoptimized(entity) {
+        if (entity === UNKNOWN_EXPRESSION) {
+            // As unknown expressions fully deoptimize all interactions, we can clear
+            // the interaction cache at this point provided we keep this optimization
+            // in mind when adding new interactions
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
+                for (const { interaction } of this.deoptimizationInteractions) {
+                    deoptimizeInteraction(interaction);
+                }
+                this.deoptimizationInteractions = NO_INTERACTIONS;
+            }
+        }
+        else if (this.deoptimizedFields.has(UnknownKey)) {
+            // This means that we already deoptimized all interactions and no longer
+            // track them
+            entity.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.entitiesToBeDeoptimized.has(entity)) {
+            this.entitiesToBeDeoptimized.add(entity);
+            for (const field of this.deoptimizedFields) {
+                entity.deoptimizePath([field]);
+            }
+            for (const { interaction, path } of this.deoptimizationInteractions) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+        }
+    }
+    markReassigned() {
+        if (this.isReassigned) {
+            return;
+        }
+        super.markReassigned();
+        for (const expression of this.expressionsUseTheKnownValue) {
+            expression.deoptimizeCache();
+        }
+        this.expressionsUseTheKnownValue = EMPTY_ARRAY;
+    }
+    deoptimizeCache() {
+        this.markReassigned();
+    }
+    /**
+     * Update the known value of the parameter variable.
+     * Must be called for every function call, so it can track all the arguments,
+     * and deoptimizeCache itself to mark reassigned if the argument is changed.
+     * @param argument The argument of the function call
+     */
+    updateKnownValue(argument) {
+        if (this.isReassigned) {
+            return;
+        }
+        if (this.knownValue === null) {
+            this.knownValue = argument;
+            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return;
+        }
+        // the same literal or identifier, do nothing
+        if (this.knownValue === argument ||
+            (this.knownValue instanceof Identifier &&
+                argument instanceof Identifier &&
+                this.knownValue.variable === argument.variable)) {
+            return;
+        }
+        const oldValue = this.knownValueLiteral;
+        if (typeof oldValue === 'symbol') {
+            this.markReassigned();
+            return;
+        }
+        // add tracking for the new argument
+        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        if (newValue !== oldValue) {
+            this.markReassigned();
+        }
+    }
+    /**
+     * This function freezes the known value of the parameter variable,
+     * so the optimization starts with a certain ExpressionEntity.
+     * The optimization can be undone by calling `markReassigned`.
+     * @returns the frozen value
+     */
+    getKnownValue() {
+        if (this.frozenValue === null) {
+            this.frozenValue = this.knownValue || UNKNOWN_EXPRESSION;
+        }
+        return this.frozenValue;
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        const knownValue = this.getKnownValue();
+        this.expressionsUseTheKnownValue.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
+            return super.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        const knownValue = this.getKnownValue();
+        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        // For performance reasons, we fully deoptimize all deeper interactions
+        if (path.length >= 2 ||
+            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
+            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
+            (path.length === 1 &&
+                (this.deoptimizedFields.has(UnknownKey) ||
+                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
+            for (const entity of this.entitiesToBeDeoptimized) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.deoptimizationInteractions.push({
+                    interaction,
+                    path
+                });
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.markReassigned();
+            return;
+        }
+        if (this.deoptimizedFields.has(UnknownKey)) {
+            return;
+        }
+        const key = path[0];
+        if (this.deoptimizedFields.has(key)) {
+            return;
+        }
+        this.deoptimizedFields.add(key);
+        for (const entity of this.entitiesToBeDeoptimized) {
+            // We do not need a recursion tracker here as we already track whether
+            // this field is deoptimized
+            entity.deoptimizePath([key]);
+        }
+        if (key === UnknownKey) {
+            // save some memory
+            this.deoptimizationInteractions = NO_INTERACTIONS;
+            this.deoptimizations = EMPTY_PATH_TRACKER;
+            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
+            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        // We deoptimize everything that is called as that will trivially deoptimize
+        // the corresponding return expressions as well and avoid badly performing
+        // and complicated alternatives
+        if (path.length === 0) {
+            this.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.deoptimizedFields.has(path[0])) {
+            this.deoptimizePath([path[0]]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+}
+
+class ThisVariable extends ParameterVariable {
+    constructor(context) {
+        super('this', null, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION).hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+}
+
+class CatchBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+        this.parent = parent;
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                const existingKind = existingVariable.kind;
+                if (existingKind === 'parameter' &&
+                    // If this is a destructured parameter, it is forbidden to redeclare
+                    existingVariable.declarations[0].parent.type === CatchClause$1) {
+                    // If this is a var with the same name as the catch scope parameter,
+                    // the assignment actually goes to the parameter and the var is
+                    // hoisted without assignment. Locally, it is shadowed by the
+                    // parameter
+                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, kind);
+                    // To avoid the need to rewrite the declaration, we link the variable
+                    // names. If we ever implement a logic that splits initialization and
+                    // assignment for hoisted vars, the "renderLikeHoisted" logic can be
+                    // removed again.
+                    // We do not need to check whether there already is a linked
+                    // variable because then declaredVariable would be that linked
+                    // variable.
+                    existingVariable.renderLikeHoisted(declaredVariable);
+                    this.addHoistedVariable(name, declaredVariable);
+                    return declaredVariable;
+                }
+                if (existingKind === 'var') {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(logRedeclarationError(name), identifier.start);
+            }
+            // We only add parameters to parameter scopes
+            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+class FunctionBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+    }
+    // There is stuff that is only allowed in function scopes, i.e. functions can
+    // be redeclared, functions and var can redeclare each other
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if ((kind === 'var' || kind === 'function') &&
+                (existingKind === 'var' || existingKind === 'function' || existingKind === 'parameter')) {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(logRedeclarationError(name), identifier.start);
+        }
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
+    }
+}
+
+class ParameterScope extends ChildScope {
+    constructor(parent, isCatchScope) {
+        super(parent, parent.context);
+        this.parameters = [];
+        this.hasRest = false;
+        this.bodyScope = isCatchScope ? new CatchBodyScope(this) : new FunctionBodyScope(this);
+    }
+    /**
+     * Adds a parameter to this scope. Parameters must be added in the correct
+     * order, i.e. from left to right.
+     */
+    addParameterDeclaration(identifier) {
+        const { name, start } = identifier;
+        const existingParameter = this.variables.get(name);
+        if (existingParameter) {
+            return this.context.error(logDuplicateArgumentNameError(name), start);
+        }
+        const variable = new ParameterVariable(name, identifier, this.context);
+        this.variables.set(name, variable);
+        // We also add it to the body scope to detect name conflicts with local
+        // variables. We still need the intermediate scope, though, as parameter
+        // defaults are NOT taken from the body scope but from the parameters or
+        // outside scope.
+        this.bodyScope.addHoistedVariable(name, variable);
+        return variable;
+    }
+    addParameterVariables(parameters, hasRest) {
+        this.parameters = parameters;
+        for (const parameterList of parameters) {
+            for (const parameter of parameterList) {
+                parameter.alwaysRendered = true;
+            }
+        }
+        this.hasRest = hasRest;
+    }
+    includeCallArguments(context, parameters) {
+        let calledFromTryStatement = false;
+        let argumentIncluded = false;
+        const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
+        for (const checkedArgument of parameters) {
+            if (checkedArgument instanceof SpreadElement) {
+                for (const argument of parameters) {
+                    argument.include(context, false);
+                }
+                break;
+            }
+        }
+        for (let index = parameters.length - 1; index >= 0; index--) {
+            const parameterVariables = this.parameters[index] || restParameter;
+            const argument = parameters[index];
+            if (parameterVariables) {
+                calledFromTryStatement = false;
+                if (parameterVariables.length === 0) {
+                    // handle empty destructuring
+                    argumentIncluded = true;
+                }
+                else {
+                    for (const variable of parameterVariables) {
+                        if (variable.included) {
+                            argumentIncluded = true;
+                        }
+                        if (variable.calledFromTryStatement) {
+                            calledFromTryStatement = true;
+                        }
+                    }
+                }
+            }
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
+                argumentIncluded = true;
+            }
+            if (argumentIncluded) {
+                argument.include(context, calledFromTryStatement);
+            }
+        }
+    }
+}
+
+class ReturnValueScope extends ParameterScope {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.returnExpressions = [];
+    }
+    addReturnExpression(expression) {
+        this.returnExpressions.push(expression);
+    }
+    getReturnExpression() {
+        if (this.returnExpression === null)
+            this.updateReturnExpression();
+        return this.returnExpression;
+    }
+    updateReturnExpression() {
+        if (this.returnExpressions.length === 1) {
+            this.returnExpression = this.returnExpressions[0];
+        }
+        else {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            for (const expression of this.returnExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
+}
+
+class FunctionScope extends ReturnValueScope {
+    constructor(parent) {
+        const { context } = parent;
+        super(parent, false);
+        this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
+        this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+    includeCallArguments(context, parameters) {
+        super.includeCallArguments(context, parameters);
+        if (this.argumentsVariable.included) {
+            for (const argument of parameters) {
+                if (!argument.included) {
+                    argument.include(context, false);
+                }
+            }
+        }
+    }
+}
+
+class ExpressionStatement extends NodeBase {
+    initialise() {
+        super.initialise();
+        if (this.directive &&
+            this.directive !== 'use strict' &&
+            this.parent.type === Program$1) {
+            this.scope.context.log(LOGLEVEL_WARN, 
+            // This is necessary, because either way (deleting or not) can lead to errors.
+            logModuleLevelDirective(this.directive, this.scope.context.module.id), this.start);
+        }
+    }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
+    render(code, options) {
+        super.render(code, options);
+        if (code.original[this.end - 1] !== ';') {
+            code.appendLeft(this.end, ';');
+        }
+    }
+    shouldBeIncluded(context) {
+        if (this.directive && this.directive !== 'use strict')
+            return this.parent.type !== Program$1;
+        return super.shouldBeIncluded(context);
+    }
+    applyDeoptimizations() { }
+}
+
+class BlockStatement extends NodeBase {
+    get deoptimizeBody() {
+        return isFlagSet(this.flags, 32768 /* Flag.deoptimizeBody */);
+    }
+    set deoptimizeBody(value) {
+        this.flags = setFlag(this.flags, 32768 /* Flag.deoptimizeBody */, value);
+    }
+    get directlyIncluded() {
+        return isFlagSet(this.flags, 16384 /* Flag.directlyIncluded */);
+    }
+    set directlyIncluded(value) {
+        this.flags = setFlag(this.flags, 16384 /* Flag.directlyIncluded */, value);
+    }
+    addImplicitReturnExpressionToScope() {
+        const lastStatement = this.body[this.body.length - 1];
+        if (!lastStatement || lastStatement.type !== ReturnStatement$1) {
+            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
+        }
+    }
+    createScope(parentScope) {
+        this.scope = this.parent.preventChildBlockScope
+            ? parentScope
+            : new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.deoptimizeBody)
+            return true;
+        for (const node of this.body) {
+            if (context.brokenFlow)
+                break;
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!(this.deoptimizeBody && this.directlyIncluded)) {
+            this.included = true;
+            this.directlyIncluded = true;
+            if (this.deoptimizeBody)
+                includeChildrenRecursively = true;
+            for (const node of this.body) {
+                if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                    node.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        const firstBodyStatement = this.body[0];
+        this.deoptimizeBody =
+            firstBodyStatement instanceof ExpressionStatement &&
+                firstBodyStatement.directive === 'use asm';
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
+class RestElement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.argument.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.argument.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 ||
+            this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
+    markDeclarationReached() {
+        this.argument.markDeclarationReached();
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class FunctionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+        this.parameterVariableValuesDeoptimized = false;
+    }
+    get async() {
+        return isFlagSet(this.flags, 256 /* Flag.async */);
+    }
+    set async(value) {
+        this.flags = setFlag(this.flags, 256 /* Flag.async */, value);
+    }
+    get deoptimizedReturn() {
+        return isFlagSet(this.flags, 512 /* Flag.deoptimizedReturn */);
+    }
+    set deoptimizedReturn(value) {
+        this.flags = setFlag(this.flags, 512 /* Flag.deoptimizedReturn */, value);
+    }
+    get generator() {
+        return isFlagSet(this.flags, 4194304 /* Flag.generator */);
+    }
+    set generator(value) {
+        this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
+    }
+    updateParameterVariableValues(_arguments) {
+        for (let position = 0; position < this.params.length; position++) {
+            const parameter = this.params[position];
+            if (!(parameter instanceof Identifier)) {
+                continue;
+            }
+            const parameterVariable = parameter.variable;
+            const argument = _arguments[position + 1] ?? UNDEFINED_EXPRESSION;
+            parameterVariable.updateKnownValue(argument);
+        }
+    }
+    deoptimizeParameterVariableValues() {
+        for (const parameter of this.params) {
+            if (parameter instanceof Identifier) {
+                const parameterVariable = parameter.variable;
+                parameterVariable.markReassigned();
+            }
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_CALLED) {
+            const { parameters } = this.scope;
+            const { args } = interaction;
+            let hasRest = false;
+            for (let position = 0; position < args.length - 1; position++) {
+                const parameter = this.params[position];
+                // Only the "this" argument arg[0] can be null
+                const argument = args[position + 1];
+                if (argument instanceof SpreadElement) {
+                    this.deoptimizeParameterVariableValues();
+                }
+                if (hasRest || parameter instanceof RestElement) {
+                    hasRest = true;
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else if (parameter instanceof Identifier) {
+                    parameters[position][0].addEntityToBeDeoptimized(argument);
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+                else if (parameter) {
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else {
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+            }
+            this.updateParameterVariableValues(args);
+        }
+        else {
+            this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+        if (path.length === 1 && path[0] === UnknownKey) {
+            // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
+            // which means the return expression and parameters need to be reassigned
+            this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+            for (const parameterList of this.scope.parameters) {
+                for (const parameter of parameterList) {
+                    parameter.deoptimizePath(UNKNOWN_PATH);
+                    parameter.markReassigned();
+                }
+            }
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (path.length > 0) {
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        if (this.async) {
+            if (!this.deoptimizedReturn) {
+                this.deoptimizedReturn = true;
+                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+                this.scope.context.requestTreeshakingPass();
+            }
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return [this.scope.getReturnExpression(), false];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length > 0 || interaction.type !== INTERACTION_CALLED) {
+            return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (this.async) {
+            const { propertyReadSideEffects } = this.scope.context.options
+                .treeshake;
+            const returnExpression = this.scope.getReturnExpression();
+            if (returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_CALL, context) ||
+                (propertyReadSideEffects &&
+                    (propertyReadSideEffects === 'always' ||
+                        returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_ACCESS, context)))) {
+                return true;
+            }
+        }
+        for (const parameter of this.params) {
+            if (parameter.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * If the function (expression or declaration) is only used as function calls
+     */
+    onlyFunctionCallUsed() {
+        let variable = null;
+        if (this.parent.type === VariableDeclarator$1) {
+            variable = this.parent.id.variable ?? null;
+        }
+        if (this.parent.type === ExportDefaultDeclaration$1) {
+            variable = this.parent.variable;
+        }
+        return variable?.getOnlyFunctionCallUsed() ?? false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.parameterVariableValuesDeoptimized && !this.onlyFunctionCallUsed()) {
+            this.parameterVariableValuesDeoptimized = true;
+            this.deoptimizeParameterVariableValues();
+        }
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        const { brokenFlow } = context;
+        context.brokenFlow = false;
+        this.body.include(context, includeChildrenRecursively);
+        context.brokenFlow = brokenFlow;
+    }
+    includeCallArguments(context, parameters) {
+        this.scope.includeCallArguments(context, parameters);
+    }
+    initialise() {
+        super.initialise();
+        if (this.body instanceof BlockStatement) {
+            this.body.addImplicitReturnExpressionToScope();
+        }
+        else {
+            this.scope.addReturnExpression(this.body);
+        }
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationNoSideEffects = this.annotations.some(comment => comment.type === 'noSideEffects');
+        }
+    }
+    parseNode(esTreeNode) {
+        const { body, params } = esTreeNode;
+        const { scope } = this;
+        const { bodyScope, context } = scope;
+        // We need to ensure that parameters are declared before the body is parsed
+        // so that the scope already knows all parameters and can detect conflicts
+        // when parsing the body.
+        const parameters = (this.params = params.map((parameter) => new (context.getNodeConstructor(parameter.type))(this, scope).parseNode(parameter)));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        this.body = new (context.getNodeConstructor(body.type))(this, bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
+    }
+    addArgumentToBeDeoptimized(_argument) { }
+    applyDeoptimizations() { }
+}
+FunctionBase.prototype.preventChildBlockScope = true;
+
+class FunctionNode extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new FunctionScope(parentScope);
+        this.constructedEntity = new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE);
+        // This makes sure that all deoptimizations of "this" are applied to the
+        // constructed entity.
+        this.scope.thisVariable.addEntityToBeDeoptimized(this.constructedEntity);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        if (interaction.type === INTERACTION_CALLED && path.length === 0 && interaction.args[0]) {
+            // args[0] is the "this" argument
+            this.scope.thisVariable.addEntityToBeDeoptimized(interaction.args[0]);
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        return !!this.id?.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
+            return true;
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (interaction.type === INTERACTION_CALLED) {
+            const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
+            context.replacedVariableInits.set(this.scope.thisVariable, interaction.withNew ? this.constructedEntity : UNKNOWN_EXPRESSION);
+            const { brokenFlow, ignore, replacedVariableInits } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true,
+                this: interaction.withNew
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.brokenFlow = brokenFlow;
+            if (thisInit) {
+                replacedVariableInits.set(this.scope.thisVariable, thisInit);
+            }
+            else {
+                replacedVariableInits.delete(this.scope.thisVariable);
+            }
+            context.ignore = ignore;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        this.id?.include();
+        const hasArguments = this.scope.argumentsVariable.included;
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier) || hasArguments) {
+                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.id?.declare('function', this);
+    }
+    addArgumentToBeDeoptimized(argument) {
+        this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([
+            {
+                key: 'prototype',
+                kind: 'init',
+                property: new ObjectEntity([], OBJECT_PROTOTYPE)
+            }
+        ], OBJECT_PROTOTYPE));
+    }
+}
+
+class FunctionDeclaration extends FunctionNode {
+    initialise() {
+        super.initialise();
+        if (this.id !== null) {
+            this.id.variable.isId = true;
+        }
+    }
+    onlyFunctionCallUsed() {
+        // call super.onlyFunctionCallUsed for export default anonymous function
+        return this.id?.variable.getOnlyFunctionCallUsed() ?? super.onlyFunctionCallUsed();
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+}
+
+// The header ends at the first non-white-space after "default"
+function getDeclarationStart(code, start) {
+    return findNonWhiteSpace(code, findFirstOccurrenceOutsideComment(code, 'default', start) + 7);
+}
+function getFunctionIdInsertPosition(code, start) {
+    const declarationEnd = findFirstOccurrenceOutsideComment(code, 'function', start) + 'function'.length;
+    code = code.slice(declarationEnd, findFirstOccurrenceOutsideComment(code, '(', declarationEnd));
+    const generatorStarPos = findFirstOccurrenceOutsideComment(code, '*');
+    if (generatorStarPos === -1) {
+        return declarationEnd;
+    }
+    return declarationEnd + generatorStarPos + 1;
+}
+class ExportDefaultDeclaration extends NodeBase {
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        if (includeChildrenRecursively) {
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+    initialise() {
+        super.initialise();
+        const declaration = this.declaration;
+        this.declarationName =
+            (declaration.id && declaration.id.name) || this.declaration.name;
+        this.variable = this.scope.addExportDefaultDeclaration(this.declarationName || this.scope.context.getModuleName(), this, this.scope.context);
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        const declarationStart = getDeclarationStart(code.original, this.start);
+        if (this.declaration instanceof FunctionDeclaration) {
+            this.renderNamedDeclaration(code, declarationStart, this.declaration.id === null
+                ? getFunctionIdInsertPosition(code.original, declarationStart)
+                : null, options);
+        }
+        else if (this.declaration instanceof ClassDeclaration) {
+            this.renderNamedDeclaration(code, declarationStart, this.declaration.id === null
+                ? findFirstOccurrenceOutsideComment(code.original, 'class', start) + 'class'.length
+                : null, options);
+        }
+        else if (this.variable.getOriginalVariable() !== this.variable) {
+            // Remove altogether to prevent re-declaring the same variable
+            treeshakeNode(this, code, start, end);
+            return;
+        }
+        else if (this.variable.included) {
+            this.renderVariableDeclaration(code, declarationStart, options);
+        }
+        else {
+            code.remove(this.start, declarationStart);
+            this.declaration.render(code, options, {
+                renderedSurroundingElement: ExpressionStatement$1
+            });
+            if (code.original[this.end - 1] !== ';') {
+                code.appendLeft(this.end, ';');
+            }
+            return;
+        }
+        this.declaration.render(code, options);
+    }
+    applyDeoptimizations() { }
+    renderNamedDeclaration(code, declarationStart, idInsertPosition, options) {
+        const { exportNamesByVariable, format, snippets: { getPropertyAccess } } = options;
+        const name = this.variable.getName(getPropertyAccess);
+        // Remove `export default`
+        code.remove(this.start, declarationStart);
+        if (idInsertPosition !== null) {
+            code.appendLeft(idInsertPosition, ` ${name}`);
+        }
+        if (format === 'system' &&
+            this.declaration instanceof ClassDeclaration &&
+            exportNamesByVariable.has(this.variable)) {
+            code.appendLeft(this.end, ` ${getSystemExportStatement([this.variable], options)};`);
+        }
+    }
+    renderVariableDeclaration(code, declarationStart, { format, exportNamesByVariable, snippets: { cnst, getPropertyAccess } }) {
+        const hasTrailingSemicolon = code.original.charCodeAt(this.end - 1) === 59; /*";"*/
+        const systemExportNames = format === 'system' && exportNamesByVariable.get(this.variable);
+        if (systemExportNames) {
+            code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = exports(${JSON.stringify(systemExportNames[0])}, `);
+            code.appendRight(hasTrailingSemicolon ? this.end - 1 : this.end, ')' + (hasTrailingSemicolon ? '' : ';'));
+        }
+        else {
+            code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = `);
+            if (!hasTrailingSemicolon) {
+                code.appendLeft(this.end, ';');
+            }
+        }
+    }
+}
+ExportDefaultDeclaration.prototype.needsBoundaries = true;
+
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+    if (!needsEscapeRegEx.test(id))
+        return id;
+    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
+}
+
+const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
+const INTEROP_DEFAULT_COMPAT_VARIABLE = '_interopDefaultCompat';
+const INTEROP_NAMESPACE_VARIABLE = '_interopNamespace';
+const INTEROP_NAMESPACE_COMPAT_VARIABLE = '_interopNamespaceCompat';
+const INTEROP_NAMESPACE_DEFAULT_VARIABLE = '_interopNamespaceDefault';
+const INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE = '_interopNamespaceDefaultOnly';
+const MERGE_NAMESPACES_VARIABLE = '_mergeNamespaces';
+const DOCUMENT_CURRENT_SCRIPT = '_documentCurrentScript';
+const defaultInteropHelpersByInteropType = {
+    auto: INTEROP_DEFAULT_VARIABLE,
+    compat: INTEROP_DEFAULT_COMPAT_VARIABLE,
+    default: null,
+    defaultOnly: null,
+    esModule: null
+};
+const isDefaultAProperty = (interopType, externalLiveBindings) => interopType === 'esModule' ||
+    (externalLiveBindings && (interopType === 'auto' || interopType === 'compat'));
+const namespaceInteropHelpersByInteropType = {
+    auto: INTEROP_NAMESPACE_VARIABLE,
+    compat: INTEROP_NAMESPACE_COMPAT_VARIABLE,
+    default: INTEROP_NAMESPACE_DEFAULT_VARIABLE,
+    defaultOnly: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE,
+    esModule: null
+};
+const canDefaultBeTakenFromNamespace = (interopType, externalLiveBindings) => interopType !== 'esModule' && isDefaultAProperty(interopType, externalLiveBindings);
+const getHelpersBlock = (additionalHelpers, accessedGlobals, indent, snippets, liveBindings, freeze, symbols) => {
+    const usedHelpers = new Set(additionalHelpers);
+    for (const variable of HELPER_NAMES) {
+        if (accessedGlobals.has(variable)) {
+            usedHelpers.add(variable);
+        }
+    }
+    return HELPER_NAMES.map(variable => usedHelpers.has(variable)
+        ? HELPER_GENERATORS[variable](indent, snippets, liveBindings, freeze, symbols, usedHelpers)
+        : '').join('');
+};
+const HELPER_GENERATORS = {
+    [DOCUMENT_CURRENT_SCRIPT](_t, { _, n }) {
+        return `var ${DOCUMENT_CURRENT_SCRIPT}${_}=${_}typeof document${_}!==${_}'undefined'${_}?${_}document.currentScript${_}:${_}null;${n}`;
+    },
+    [INTEROP_DEFAULT_COMPAT_VARIABLE](_t, snippets, liveBindings) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_DEFAULT_COMPAT_VARIABLE
+        });
+        return (`${left}${getIsCompatNamespace(snippets)}${_}?${_}` +
+            `${liveBindings ? getDefaultLiveBinding(snippets) : getDefaultStatic(snippets)}${right}${n}${n}`);
+    },
+    [INTEROP_DEFAULT_VARIABLE](_t, snippets, liveBindings) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_DEFAULT_VARIABLE
+        });
+        return (`${left}e${_}&&${_}e.__esModule${_}?${_}` +
+            `${liveBindings ? getDefaultLiveBinding(snippets) : getDefaultStatic(snippets)}${right}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_COMPAT_VARIABLE](t, snippets, liveBindings, freeze, symbols, usedHelpers) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        if (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)) {
+            const [left, right] = getDirectReturnFunction(['e'], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: INTEROP_NAMESPACE_COMPAT_VARIABLE
+            });
+            return `${left}${getIsCompatNamespace(snippets)}${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${right}${n}${n}`;
+        }
+        return (`function ${INTEROP_NAMESPACE_COMPAT_VARIABLE}(e)${_}{${n}` +
+            `${t}if${_}(${getIsCompatNamespace(snippets)})${_}return e;${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE](_t, snippets, _liveBindings, freeze, symbols) {
+        const { getDirectReturnFunction, getObject, n, _ } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE
+        });
+        return `${left}${getFrozen(freeze, getWithToStringTag(symbols, getObject([
+            [null, `__proto__:${_}null`],
+            ['default', 'e']
+        ], { lineBreakIndent: null }), snippets))}${right}${n}${n}`;
+    },
+    [INTEROP_NAMESPACE_DEFAULT_VARIABLE](t, snippets, liveBindings, freeze, symbols) {
+        const { _, n } = snippets;
+        return (`function ${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${_}{${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_VARIABLE](t, snippets, liveBindings, freeze, symbols, usedHelpers) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        if (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)) {
+            const [left, right] = getDirectReturnFunction(['e'], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: INTEROP_NAMESPACE_VARIABLE
+            });
+            return `${left}e${_}&&${_}e.__esModule${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${right}${n}${n}`;
+        }
+        return (`function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
+            `${t}if${_}(e${_}&&${_}e.__esModule)${_}return e;${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [MERGE_NAMESPACES_VARIABLE](t, snippets, liveBindings, freeze, symbols) {
+        const { _, cnst, n } = snippets;
+        const useForEach = cnst === 'var' && liveBindings;
+        return (`function ${MERGE_NAMESPACES_VARIABLE}(n, m)${_}{${n}` +
+            `${t}${loopOverNamespaces(`{${n}` +
+                `${t}${t}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!(k in n))${_}{${n}` +
+                (liveBindings
+                    ? useForEach
+                        ? copyOwnPropertyLiveBinding
+                        : copyPropertyLiveBinding
+                    : copyPropertyStatic)(t, t + t + t + t, snippets) +
+                `${t}${t}${t}}${n}` +
+                `${t}${t}}`, useForEach, t, snippets)}${n}` +
+            `${t}return ${getFrozen(freeze, getWithToStringTag(symbols, 'n', snippets))};${n}` +
+            `}${n}${n}`);
+    }
+};
+const getDefaultLiveBinding = ({ _, getObject }) => `e${_}:${_}${getObject([['default', 'e']], { lineBreakIndent: null })}`;
+const getDefaultStatic = ({ _, getPropertyAccess }) => `e${getPropertyAccess('default')}${_}:${_}e`;
+const getIsCompatNamespace = ({ _ }) => `e${_}&&${_}typeof e${_}===${_}'object'${_}&&${_}'default'${_}in e`;
+const createNamespaceObject = (t, index, snippets, liveBindings, freeze, symbols) => {
+    const { _, cnst, getObject, getPropertyAccess, n, s } = snippets;
+    const copyProperty = `{${n}` +
+        (liveBindings ? copyNonDefaultOwnPropertyLiveBinding : copyPropertyStatic)(t, index + t + t, snippets) +
+        `${index}${t}}`;
+    return (`${index}${cnst} n${_}=${_}Object.create(null${symbols ? `,${_}{${_}[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}${_}}` : ''});${n}` +
+        `${index}if${_}(e)${_}{${n}` +
+        `${index}${t}${loopOverKeys(copyProperty, !liveBindings, snippets)}${n}` +
+        `${index}}${n}` +
+        `${index}n${getPropertyAccess('default')}${_}=${_}e;${n}` +
+        `${index}return ${getFrozen(freeze, 'n')}${s}${n}`);
+};
+const loopOverKeys = (body, allowVariableLoopVariable, { _, cnst, getFunctionIntro, s }) => cnst !== 'var' || allowVariableLoopVariable
+    ? `for${_}(${cnst} k in e)${_}${body}`
+    : `Object.keys(e).forEach(${getFunctionIntro(['k'], {
+        isAsync: false,
+        name: null
+    })}${body})${s}`;
+const loopOverNamespaces = (body, useForEach, t, { _, cnst, getDirectReturnFunction, getFunctionIntro, n }) => {
+    if (useForEach) {
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: false,
+            lineBreakIndent: { base: t, t },
+            name: null
+        });
+        return (`m.forEach(${left}` +
+            `e${_}&&${_}typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e)${_}&&${_}Object.keys(e).forEach(${getFunctionIntro(['k'], {
+                isAsync: false,
+                name: null
+            })}${body})${right});`);
+    }
+    return (`for${_}(var i${_}=${_}0;${_}i${_}<${_}m.length;${_}i++)${_}{${n}` +
+        `${t}${t}${cnst} e${_}=${_}m[i];${n}` +
+        `${t}${t}if${_}(typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e))${_}{${_}for${_}(${cnst} k in e)${_}${body}${_}}${n}${t}}`);
+};
+const copyNonDefaultOwnPropertyLiveBinding = (t, index, snippets) => {
+    const { _, n } = snippets;
+    return (`${index}if${_}(k${_}!==${_}'default')${_}{${n}` +
+        copyOwnPropertyLiveBinding(t, index + t, snippets) +
+        `${index}}${n}`);
+};
+const copyOwnPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
+    const [left, right] = getDirectReturnFunction([], {
+        functionReturn: true,
+        lineBreakIndent: null,
+        name: null
+    });
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}enumerable:${_}true,${n}` +
+        `${index}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}});${n}`);
+};
+const copyPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
+    const [left, right] = getDirectReturnFunction([], {
+        functionReturn: true,
+        lineBreakIndent: null,
+        name: null
+    });
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}if${_}(d)${_}{${n}` +
+        `${index}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}${t}enumerable:${_}true,${n}` +
+        `${index}${t}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}${t}});${n}` +
+        `${index}}${n}`);
+};
+const copyPropertyStatic = (_t, index, { _, n }) => `${index}n[k]${_}=${_}e[k];${n}`;
+const getFrozen = (freeze, fragment) => freeze ? `Object.freeze(${fragment})` : fragment;
+const getWithToStringTag = (symbols, fragment, { _, getObject }) => symbols
+    ? `Object.defineProperty(${fragment},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`
+    : fragment;
+const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
+function getToStringTagValue(getObject) {
+    return getObject([['value', "'Module'"]], {
+        lineBreakIndent: null
+    });
+}
+
+class Literal extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath() { }
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 ||
+            // unknown literals can also be null but do not start with an "n"
+            (this.value === null && this.scope.context.code.charCodeAt(this.start) !== 110) ||
+            typeof this.value === 'bigint' ||
+            // to support shims for regular expressions
+            this.scope.context.code.charCodeAt(this.start) === 47) {
+            return UnknownValue;
+        }
+        return this.value;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1)
+            return UNKNOWN_RETURN_EXPRESSION;
+        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return path.length > (this.value === null ? 0 : 1);
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                if (this.included &&
+                    this.value instanceof RegExp &&
+                    (this.value.global || this.value.sticky)) {
+                    return true;
+                }
+                return (path.length !== 1 ||
+                    hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.members = getLiteralMembersForValue(this.value);
+    }
+    parseNode(esTreeNode) {
+        this.value = esTreeNode.value;
+        this.regex = esTreeNode.regex;
+        return super.parseNode(esTreeNode);
+    }
+    render(code) {
+        if (typeof this.value === 'string') {
+            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
+        }
+    }
+}
+
+function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
+    if ('getLiteralValueAtPathAsChainElement' in object) {
+        const calleeValue = object.getLiteralValueAtPathAsChainElement(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin);
+        if (calleeValue === IS_SKIPPED_CHAIN || (element.optional && calleeValue == null)) {
+            return IS_SKIPPED_CHAIN;
+        }
+    }
+    else if (element.optional &&
+        object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null) {
+        return IS_SKIPPED_CHAIN;
+    }
+    return element.getLiteralValueAtPath(path, recursionTracker, origin);
+}
+
+// To avoid infinite recursions
+const MAX_PATH_DEPTH = 7;
+function getResolvablePropertyKey(memberExpression) {
+    return memberExpression.computed
+        ? getResolvableComputedPropertyKey(memberExpression.property)
+        : memberExpression.property.name;
+}
+function getResolvableComputedPropertyKey(propertyKey) {
+    if (propertyKey instanceof Literal) {
+        return String(propertyKey.value);
+    }
+    return null;
+}
+function getPathIfNotComputed(memberExpression) {
+    const nextPathKey = memberExpression.propertyKey;
+    const object = memberExpression.object;
+    if (typeof nextPathKey === 'string') {
+        if (object instanceof Identifier) {
+            return [
+                { key: object.name, pos: object.start },
+                { key: nextPathKey, pos: memberExpression.property.start }
+            ];
+        }
+        if (object instanceof MemberExpression) {
+            const parentPath = getPathIfNotComputed(object);
+            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
+        }
+    }
+    return null;
+}
+function getStringFromPath(path) {
+    let pathString = path[0].key;
+    for (let index = 1; index < path.length; index++) {
+        pathString += '.' + path[index].key;
+    }
+    return pathString;
+}
+class MemberExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.expressionsToBeDeoptimized = [];
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    get assignmentDeoptimized() {
+        return isFlagSet(this.flags, 16 /* Flag.assignmentDeoptimized */);
+    }
+    set assignmentDeoptimized(value) {
+        this.flags = setFlag(this.flags, 16 /* Flag.assignmentDeoptimized */, value);
+    }
+    get bound() {
+        return isFlagSet(this.flags, 32 /* Flag.bound */);
+    }
+    set bound(value) {
+        this.flags = setFlag(this.flags, 32 /* Flag.bound */, value);
+    }
+    get isUndefined() {
+        return isFlagSet(this.flags, 64 /* Flag.isUndefined */);
+    }
+    set isUndefined(value) {
+        this.flags = setFlag(this.flags, 64 /* Flag.isUndefined */, value);
+    }
+    bind() {
+        this.bound = true;
+        const path = getPathIfNotComputed(this);
+        const baseVariable = path && this.scope.findVariable(path[0].key);
+        if (baseVariable?.isNamespace) {
+            const resolvedVariable = resolveNamespaceVariables(baseVariable, path.slice(1), this.scope.context);
+            if (!resolvedVariable) {
+                super.bind();
+            }
+            else if (resolvedVariable === 'undefined') {
+                this.isUndefined = true;
+            }
+            else {
+                this.variable = resolvedVariable;
+                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
+            }
+        }
+        else {
+            super.bind();
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.variable) {
+            this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+        else if (!this.isUndefined) {
+            if (path.length < MAX_PATH_DEPTH) {
+                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizeCache() {
+        const { expressionsToBeDeoptimized, object } = this;
+        this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+        this.propertyKey = UnknownKey;
+        object.deoptimizePath(UNKNOWN_PATH);
+        for (const expression of expressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0)
+            this.disallowNamespaceReassignment();
+        if (this.variable) {
+            this.variable.deoptimizePath(path);
+        }
+        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizePath([
+                propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                ...path
+            ]);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+        }
+        return UnknownValue;
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        return getChainElementLiteralValueAtPath(this, this.object, path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return [UNDEFINED_EXPRESSION, false];
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            this.hasAccessEffect(context));
+    }
+    hasEffectsAsChainElement(context) {
+        if (this.variable || this.isUndefined)
+            return this.hasEffects(context);
+        const objectHasEffects = 'hasEffectsAsChainElement' in this.object
+            ? this.object.hasEffectsAsChainElement(context)
+            : this.object.hasEffects(context);
+        if (objectHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return objectHasEffects || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return objectHasEffects || this.property.hasEffects(context) || this.hasAccessEffect(context);
+    }
+    hasEffectsAsAssignmentTarget(context, checkAccess) {
+        if (checkAccess && !this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            (checkAccess && this.hasAccessEffect(context)) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.variable) {
+            return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        if (this.isUndefined) {
+            return true;
+        }
+        if (path.length < MAX_PATH_DEPTH) {
+            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
+        }
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.includeProperties(context, includeChildrenRecursively);
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        if (deoptimizeAccess) {
+            this.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.includeProperties(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.variable) {
+            this.variable.includeCallArguments(context, parameters);
+        }
+        else {
+            super.includeCallArguments(context, parameters);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.propertyKey = getResolvablePropertyKey(this);
+        this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = BLANK) {
+        if (this.variable || this.isUndefined) {
+            const { snippets: { getPropertyAccess } } = options;
+            let replacement = this.variable ? this.variable.getName(getPropertyAccess) : 'undefined';
+            if (renderedParentType && isCalleeOfRenderedParent)
+                replacement = '0, ' + replacement;
+            code.overwrite(this.start, this.end, replacement, {
+                contentOnly: true,
+                storeName: true
+            });
+        }
+        else {
+            if (renderedParentType && isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+            this.object.render(code, options, { renderedSurroundingElement });
+            this.property.render(code, options);
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = {
+            args: [this.object, value],
+            type: INTERACTION_ASSIGNED
+        };
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.variable) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    applyAssignmentDeoptimization() {
+        this.assignmentDeoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    disallowNamespaceReassignment() {
+        if (this.object instanceof Identifier) {
+            const variable = this.scope.findVariable(this.object.name);
+            if (variable.isNamespace) {
+                if (this.variable) {
+                    this.scope.context.includeVariableInModule(this.variable);
+                }
+                this.scope.context.log(LOGLEVEL_WARN, logIllegalImportReassignment(this.object.name, this.scope.context.module.id), this.start);
+            }
+        }
+    }
+    getPropertyKey() {
+        if (this.propertyKey === null) {
+            this.propertyKey = UnknownKey;
+            const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return (this.propertyKey =
+                value === SymbolToStringTag
+                    ? value
+                    : typeof value === 'symbol'
+                        ? UnknownKey
+                        : String(value));
+        }
+        return this.propertyKey;
+    }
+    hasAccessEffect(context) {
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (!(this.variable || this.isUndefined) &&
+            propertyReadSideEffects &&
+            (propertyReadSideEffects === 'always' ||
+                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
+    includeProperties(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
+    }
+}
+function resolveNamespaceVariables(baseVariable, path, astContext) {
+    if (path.length === 0)
+        return baseVariable;
+    if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
+        return null;
+    const exportName = path[0].key;
+    const variable = baseVariable.context.traceExport(exportName);
+    if (!variable) {
+        if (path.length === 1) {
+            const fileName = baseVariable.context.fileName;
+            astContext.log(LOGLEVEL_WARN, logMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
+            return 'undefined';
+        }
+        return null;
+    }
+    return resolveNamespaceVariables(variable, path.slice(1), astContext);
+}
+
+const FILE_PREFIX = 'ROLLUP_FILE_URL_';
+const IMPORT = 'import';
+class MetaProperty extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.metaProperty = null;
+        this.preliminaryChunkId = null;
+        this.referenceId = null;
+    }
+    getReferencedFileName(outputPluginDriver) {
+        const { meta: { name }, metaProperty } = this;
+        if (name === IMPORT && metaProperty?.startsWith(FILE_PREFIX)) {
+            return outputPluginDriver.getFileName(metaProperty.slice(FILE_PREFIX.length));
+        }
+        return null;
+    }
+    hasEffects() {
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            if (this.meta.name === IMPORT) {
+                this.scope.context.addImportMeta(this);
+                const parent = this.parent;
+                const metaProperty = (this.metaProperty =
+                    parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
+                        ? parent.propertyKey
+                        : null);
+                if (metaProperty?.startsWith(FILE_PREFIX)) {
+                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+                }
+            }
+        }
+    }
+    render(code, renderOptions) {
+        const { format, pluginDriver, snippets } = renderOptions;
+        const { scope: { context: { module } }, meta: { name }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
+        const { id: moduleId } = module;
+        if (name !== IMPORT)
+            return;
+        const chunkId = preliminaryChunkId;
+        if (referenceId) {
+            const fileName = pluginDriver.getFileName(referenceId);
+            const relativePath = normalize(relative(dirname(chunkId), fileName));
+            const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
+                { chunkId, fileName, format, moduleId, referenceId, relativePath }
+            ]) || relativeUrlMechanisms[format](relativePath);
+            code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            return;
+        }
+        let replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
+            metaProperty,
+            { chunkId, format, moduleId }
+        ]);
+        if (!replacement) {
+            replacement = importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
+            renderOptions.accessedDocumentCurrentScript ||=
+                formatsMaybeAccessDocumentCurrentScript.includes(format) && replacement !== 'undefined';
+        }
+        if (typeof replacement === 'string') {
+            if (parent instanceof MemberExpression) {
+                code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            }
+            else {
+                code.overwrite(start, end, replacement, { contentOnly: true });
+            }
+        }
+    }
+    setResolution(format, accessedGlobalsByScope, preliminaryChunkId) {
+        this.preliminaryChunkId = preliminaryChunkId;
+        const accessedGlobals = (this.metaProperty?.startsWith(FILE_PREFIX) ? accessedFileUrlGlobals : accessedMetaUrlGlobals)[format];
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+}
+const formatsMaybeAccessDocumentCurrentScript = ['cjs', 'iife', 'umd'];
+const accessedMetaUrlGlobals = {
+    amd: ['document', 'module', 'URL'],
+    cjs: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    es: [],
+    iife: ['document', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    system: ['module'],
+    umd: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT]
+};
+const accessedFileUrlGlobals = {
+    amd: ['document', 'require', 'URL'],
+    cjs: ['document', 'require', 'URL'],
+    es: [],
+    iife: ['document', 'URL'],
+    system: ['module', 'URL'],
+    umd: ['document', 'require', 'URL']
+};
+const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(relativePath)}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`);
+const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
+    const urlMechanism = getUrl(chunkId);
+    return property === null
+        ? `({ url: ${urlMechanism} })`
+        : property === 'url'
+            ? urlMechanism
+            : 'undefined';
+};
+const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
+const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
+const getUrlFromDocument = (chunkId, umd = false) => `${umd ? `typeof document === 'undefined' ? location.href : ` : ''}(${DOCUMENT_CURRENT_SCRIPT} && ${DOCUMENT_CURRENT_SCRIPT}.tagName.toUpperCase() === 'SCRIPT' && ${DOCUMENT_CURRENT_SCRIPT}.src || new URL('${escapeId(chunkId)}', document.baseURI).href)`;
+const relativeUrlMechanisms = {
+    amd: relativePath => {
+        if (relativePath[0] !== '.')
+            relativePath = './' + relativePath;
+        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
+    },
+    cjs: relativePath => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
+    es: relativePath => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
+    iife: relativePath => getRelativeUrlFromDocument(relativePath),
+    system: relativePath => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
+    umd: relativePath => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`
+};
+const importMetaMechanisms = {
+    amd: getGenericImportMetaMechanism(() => getResolveUrl(`module.uri, document.baseURI`)),
+    cjs: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId)})`),
+    iife: getGenericImportMetaMechanism(chunkId => getUrlFromDocument(chunkId)),
+    system: (property, { snippets: { getPropertyAccess } }) => property === null ? `module.meta` : `module.meta${getPropertyAccess(property)}`,
+    umd: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId, true)})`)
+};
+
+class UndefinedVariable extends Variable {
+    constructor() {
+        super('undefined');
+    }
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+}
+
+class ExportDefaultVariable extends LocalVariable {
+    constructor(name, exportDefaultDeclaration, context) {
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
+        this.hasId = false;
+        this.originalId = null;
+        this.originalVariable = null;
+        const declaration = exportDefaultDeclaration.declaration;
+        if ((declaration instanceof FunctionDeclaration || declaration instanceof ClassDeclaration) &&
+            declaration.id) {
+            this.hasId = true;
+            this.originalId = declaration.id;
+        }
+        else if (declaration instanceof Identifier) {
+            this.originalId = declaration;
+        }
+    }
+    addReference(identifier) {
+        if (!this.hasId) {
+            this.name = identifier.name;
+        }
+    }
+    addUsedPlace(usedPlace) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.addUsedPlace(usedPlace);
+        }
+        else {
+            original.addUsedPlace(usedPlace);
+        }
+    }
+    forbidName(name) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.forbidName(name);
+        }
+        else {
+            original.forbidName(name);
+        }
+    }
+    getAssignedVariableName() {
+        return (this.originalId && this.originalId.name) || null;
+    }
+    getBaseVariableName() {
+        const original = this.getOriginalVariable();
+        return original === this ? super.getBaseVariableName() : original.getBaseVariableName();
+    }
+    getDirectOriginalVariable() {
+        return this.originalId &&
+            (this.hasId ||
+                !(this.originalId.isPossibleTDZ() ||
+                    this.originalId.variable.isReassigned ||
+                    this.originalId.variable instanceof UndefinedVariable ||
+                    // this avoids a circular dependency
+                    'syntheticNamespace' in this.originalId.variable))
+            ? this.originalId.variable
+            : null;
+    }
+    getName(getPropertyAccess) {
+        const original = this.getOriginalVariable();
+        return original === this
+            ? super.getName(getPropertyAccess)
+            : original.getName(getPropertyAccess);
+    }
+    getOriginalVariable() {
+        if (this.originalVariable)
+            return this.originalVariable;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let original = this;
+        let currentVariable;
+        const checkedVariables = new Set();
+        do {
+            checkedVariables.add(original);
+            currentVariable = original;
+            original = currentVariable.getDirectOriginalVariable();
+        } while (original instanceof ExportDefaultVariable && !checkedVariables.has(original));
+        return (this.originalVariable = original || currentVariable);
+    }
+}
+
+class NamespaceVariable extends Variable {
+    constructor(context) {
+        super(context.getModuleName());
+        this.memberVariables = null;
+        this.mergedNamespaces = [];
+        this.referencedEarly = false;
+        this.references = [];
+        this.context = context;
+        this.module = context.module;
+    }
+    addReference(identifier) {
+        this.references.push(identifier);
+        this.name = identifier.name;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 1 || (path.length === 1 && interaction.type === INTERACTION_CALLED)) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length > 1) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizePath(path.slice(1));
+            }
+        }
+    }
+    getLiteralValueAtPath(path) {
+        if (path[0] === SymbolToStringTag) {
+            return 'Module';
+        }
+        return UnknownValue;
+    }
+    getMemberVariables() {
+        if (this.memberVariables) {
+            return this.memberVariables;
+        }
+        const memberVariables = Object.create(null);
+        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
+        for (const name of sortedExports) {
+            if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
+                const exportedVariable = this.context.traceExport(name);
+                if (exportedVariable) {
+                    memberVariables[name] = exportedVariable;
+                }
+            }
+        }
+        return (this.memberVariables = memberVariables);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (path.length === 0) {
+            // This can only be a call anyway
+            return true;
+        }
+        if (path.length === 1 && type !== INTERACTION_CALLED) {
+            return type === INTERACTION_ASSIGNED;
+        }
+        const key = path[0];
+        if (typeof key !== 'string') {
+            return true;
+        }
+        const memberVariable = this.getMemberVariables()[key];
+        return (!memberVariable ||
+            memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
+    }
+    include() {
+        super.include();
+        this.context.includeAllExports();
+    }
+    prepare(accessedGlobalsByScope) {
+        if (this.mergedNamespaces.length > 0) {
+            this.module.scope.addAccessedGlobals([MERGE_NAMESPACES_VARIABLE], accessedGlobalsByScope);
+        }
+    }
+    renderBlock(options) {
+        const { exportNamesByVariable, format, freeze, indent: t, symbols, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
+        const memberVariables = this.getMemberVariables();
+        const members = Object.entries(memberVariables)
+            .filter(([_, variable]) => variable.included)
+            .map(([name, variable]) => {
+            if (this.referencedEarly || variable.isReassigned || variable === this) {
+                return [
+                    null,
+                    `get ${stringifyObjectKeyIfNeeded(name)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
+                ];
+            }
+            return [name, variable.getName(getPropertyAccess)];
+        });
+        members.unshift([null, `__proto__:${_}null`]);
+        let output = getObject(members, { lineBreakIndent: { base: '', t } });
+        if (this.mergedNamespaces.length > 0) {
+            const assignmentArguments = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
+            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArguments.join(`,${_}`)}])`;
+        }
+        else {
+            // The helper to merge namespaces will also take care of freezing and toStringTag
+            if (symbols) {
+                output = `/*#__PURE__*/Object.defineProperty(${output},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`;
+            }
+            if (freeze) {
+                output = `/*#__PURE__*/Object.freeze(${output})`;
+            }
+        }
+        const name = this.getName(getPropertyAccess);
+        output = `${cnst} ${name}${_}=${_}${output};`;
+        if (format === 'system' && exportNamesByVariable.has(this)) {
+            output += `${n}${getSystemExportStatement([this], options)};`;
+        }
+        return output;
+    }
+    renderFirst() {
+        return this.referencedEarly;
+    }
+    setMergedNamespaces(mergedNamespaces) {
+        this.mergedNamespaces = mergedNamespaces;
+        const moduleExecIndex = this.context.getModuleExecIndex();
+        for (const identifier of this.references) {
+            const { context } = identifier.scope;
+            if (context.getModuleExecIndex() <= moduleExecIndex) {
+                this.referencedEarly = true;
+                break;
+            }
+        }
+    }
+}
+NamespaceVariable.prototype.isNamespace = true;
+
+class SyntheticNamedExportVariable extends Variable {
+    constructor(context, name, syntheticNamespace) {
+        super(name);
+        this.baseVariable = null;
+        this.context = context;
+        this.module = context.module;
+        this.syntheticNamespace = syntheticNamespace;
+    }
+    getBaseVariable() {
+        if (this.baseVariable)
+            return this.baseVariable;
+        let baseVariable = this.syntheticNamespace;
+        while (baseVariable instanceof ExportDefaultVariable ||
+            baseVariable instanceof SyntheticNamedExportVariable) {
+            if (baseVariable instanceof ExportDefaultVariable) {
+                const original = baseVariable.getOriginalVariable();
+                if (original === baseVariable)
+                    break;
+                baseVariable = original;
+            }
+            if (baseVariable instanceof SyntheticNamedExportVariable) {
+                baseVariable = baseVariable.syntheticNamespace;
+            }
+        }
+        return (this.baseVariable = baseVariable);
+    }
+    getBaseVariableName() {
+        return this.syntheticNamespace.getBaseVariableName();
+    }
+    getName(getPropertyAccess) {
+        return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
+    }
+    include() {
+        super.include();
+        this.context.includeVariableInModule(this.syntheticNamespace);
+    }
+    setRenderNames(baseName, name) {
+        super.setRenderNames(baseName, name);
+    }
+}
+
+class ExternalChunk {
+    constructor(module, options, inputBase) {
+        this.options = options;
+        this.inputBase = inputBase;
+        this.defaultVariableName = '';
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.fileName = null;
+        this.importAttributes = null;
+        this.id = module.id;
+        this.moduleInfo = module.info;
+        this.renormalizeRenderPath = module.renormalizeRenderPath;
+        this.suggestedVariableName = module.suggestedVariableName;
+    }
+    getFileName() {
+        if (this.fileName) {
+            return this.fileName;
+        }
+        const { paths } = this.options;
+        return (this.fileName =
+            (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
+                (this.renormalizeRenderPath ? normalize(relative(this.inputBase, this.id)) : this.id));
+    }
+    getImportAttributes(snippets) {
+        return (this.importAttributes ||= formatAttributes(this.options.format === 'es' &&
+            this.options.externalImportAttributes &&
+            this.moduleInfo.attributes, snippets));
+    }
+    getImportPath(importer) {
+        return escapeId(this.renormalizeRenderPath
+            ? getImportPath(importer, this.getFileName(), this.options.format === 'amd', false)
+            : this.getFileName());
+    }
+}
+function formatAttributes(attributes, { getObject }) {
+    if (!attributes) {
+        return null;
+    }
+    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, `'${value}'`]);
+    if (assertionEntries.length > 0) {
+        return getObject(assertionEntries, { lineBreakIndent: null });
+    }
+    return null;
+}
+
+function removeJsExtension(name) {
+    return name.endsWith('.js') ? name.slice(0, -3) : name;
+}
+
+function getCompleteAmdId(options, chunkId) {
+    if (options.autoId) {
+        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
+    }
+    return options.id ?? '';
+}
+
+function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, mechanism = 'return ') {
+    const { _, getDirectReturnFunction, getFunctionIntro, getPropertyAccess, n, s } = snippets;
+    if (!namedExportsMode) {
+        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
+    }
+    let exportBlock = '';
+    if (namedExportsMode) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported !== '*') {
+                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (specifier.imported !== '*' && specifier.needsLiveBinding) {
+                        const [left, right] = getDirectReturnFunction([], {
+                            functionReturn: true,
+                            lineBreakIndent: null,
+                            name: null
+                        });
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}get:${_}${left}${importName}${right}${n}});`;
+                    }
+                    else if (specifier.reexported === '__proto__') {
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}value:${_}${importName}${n}});`;
+                    }
+                    else {
+                        exportBlock += `exports${getPropertyAccess(specifier.reexported)}${_}=${_}${importName};`;
+                    }
+                }
+            }
+        }
+    }
+    for (const { exported, local } of exports) {
+        const lhs = `exports${getPropertyAccess(exported)}`;
+        const rhs = local;
+        if (lhs !== rhs) {
+            if (exportBlock)
+                exportBlock += n;
+            exportBlock +=
+                exported === '__proto__'
+                    ? `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                        `${t}enumerable:${_}true,${n}` +
+                        `${t}value:${_}${rhs}${n}});`
+                    : `${lhs}${_}=${_}${rhs};`;
+        }
+    }
+    if (namedExportsMode) {
+        for (const { name, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (!specifier.needsLiveBinding && reexportProtoFromExternal) {
+                        const protoString = "'__proto__'";
+                        exportBlock +=
+                            `Object.prototype.hasOwnProperty.call(${name},${_}${protoString})${_}&&${n}` +
+                                `${t}!Object.prototype.hasOwnProperty.call(exports,${_}${protoString})${_}&&${n}` +
+                                `${t}Object.defineProperty(exports,${_}${protoString},${_}{${n}` +
+                                `${t}${t}enumerable:${_}true,${n}` +
+                                `${t}${t}value:${_}${name}[${protoString}]${n}` +
+                                `${t}});${n}${n}`;
+                    }
+                    const copyPropertyIfNecessary = `{${n}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!Object.prototype.hasOwnProperty.call(exports,${_}k))${_}${getDefineProperty(name, specifier.needsLiveBinding, t, snippets)}${s}${n}}`;
+                    exportBlock += `Object.keys(${name}).forEach(${getFunctionIntro(['k'], {
+                        isAsync: false,
+                        name: null
+                    })}${copyPropertyIfNecessary});`;
+                }
+            }
+        }
+    }
+    if (exportBlock) {
+        return `${n}${n}${exportBlock}`;
+    }
+    return '';
+}
+function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess) {
+    if (exports.length > 0) {
+        return exports[0].local;
+    }
+    else {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (reexports) {
+                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+            }
+        }
+    }
+}
+function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
+    if (imported === 'default') {
+        if (!isChunk) {
+            const moduleInterop = interop(moduleId);
+            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                ? defaultVariableName
+                : moduleVariableName;
+            return isDefaultAProperty(moduleInterop, externalLiveBindings)
+                ? `${variableName}${getPropertyAccess('default')}`
+                : variableName;
+        }
+        return depNamedExportsMode
+            ? `${moduleVariableName}${getPropertyAccess('default')}`
+            : moduleVariableName;
+    }
+    if (imported === '*') {
+        return (isChunk ? !depNamedExportsMode : namespaceInteropHelpersByInteropType[interop(moduleId)])
+            ? namespaceVariableName
+            : moduleVariableName;
+    }
+    return `${moduleVariableName}${getPropertyAccess(imported)}`;
+}
+function getEsModuleValue(getObject) {
+    return getObject([['value', 'true']], {
+        lineBreakIndent: null
+    });
+}
+function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, { _, getObject }) {
+    if (hasNamedExports) {
+        if (addEsModule) {
+            if (addNamespaceToStringTag) {
+                return `Object.defineProperties(exports,${_}${getObject([
+                    ['__esModule', getEsModuleValue(getObject)],
+                    [null, `[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}`]
+                ], {
+                    lineBreakIndent: null
+                })});`;
+            }
+            return `Object.defineProperty(exports,${_}'__esModule',${_}${getEsModuleValue(getObject)});`;
+        }
+        if (addNamespaceToStringTag) {
+            return `Object.defineProperty(exports,${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)});`;
+        }
+    }
+    return '';
+}
+const getDefineProperty = (name, needsLiveBinding, t, { _, getDirectReturnFunction, n }) => {
+    if (needsLiveBinding) {
+        const [left, right] = getDirectReturnFunction([], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: null
+        });
+        return (`Object.defineProperty(exports,${_}k,${_}{${n}` +
+            `${t}${t}enumerable:${_}true,${n}` +
+            `${t}${t}get:${_}${left}${name}[k]${right}${n}${t}})`);
+    }
+    return `exports[k]${_}=${_}${name}[k]`;
+};
+
+function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, indent, snippets) {
+    const { _, cnst, n } = snippets;
+    const neededInteropHelpers = new Set();
+    const interopStatements = [];
+    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
+        neededInteropHelpers.add(helper);
+        interopStatements.push(`${cnst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
+    };
+    for (const { defaultVariableName, imports, importPath, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        if (isChunk) {
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                if (imported === '*' && reexported !== '*') {
+                    if (!namedExportsMode) {
+                        addInteropStatement(namespaceVariableName, INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE, name);
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            const moduleInterop = interop(importPath);
+            let hasDefault = false;
+            let hasNamespace = false;
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                let helper;
+                let variableName;
+                if (imported === 'default') {
+                    if (!hasDefault) {
+                        hasDefault = true;
+                        if (defaultVariableName !== namespaceVariableName) {
+                            variableName = defaultVariableName;
+                            helper = defaultInteropHelpersByInteropType[moduleInterop];
+                        }
+                    }
+                }
+                else if (imported === '*' && reexported !== '*' && !hasNamespace) {
+                    hasNamespace = true;
+                    helper = namespaceInteropHelpersByInteropType[moduleInterop];
+                    variableName = namespaceVariableName;
+                }
+                if (helper) {
+                    addInteropStatement(variableName, helper, name);
+                }
+            }
+        }
+    }
+    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, symbols)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
+}
+
+function addJsExtension(name) {
+    return name.endsWith('.js') ? name : name + '.js';
+}
+
+// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
+// The assumption is that this makes sense for all relative ids:
+// https://requirejs.org/docs/api.html#jsfiles
+function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
+    if (id[0] !== '.') {
+        return id;
+    }
+    return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
+}
+
+const builtinModules = [
+	"assert",
+	"assert/strict",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"inspector/promises",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"readline/promises",
+	"repl",
+	"stream",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"util/types",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+];
+
+const nodeBuiltins = new Set(builtinModules);
+function warnOnBuiltins(log, dependencies) {
+    const externalBuiltins = dependencies
+        .map(({ importPath }) => importPath)
+        .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
+    if (externalBuiltins.length === 0)
+        return;
+    log(LOGLEVEL_WARN, logMissingNodeBuiltins(externalBuiltins));
+}
+
+function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, generatedCode: { symbols }, interop, reexportProtoFromExternal, strict }) {
+    warnOnBuiltins(log, dependencies);
+    const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const parameters = dependencies.map(m => m.name);
+    const { n, getNonArrowFunctionIntro, _ } = snippets;
+    if (namedExportsMode && hasExports) {
+        parameters.unshift(`exports`);
+        deps.unshift(`'exports'`);
+    }
+    if (accessedGlobals.has('require')) {
+        parameters.unshift('require');
+        deps.unshift(`'require'`);
+    }
+    if (accessedGlobals.has('module')) {
+        parameters.unshift('module');
+        deps.unshift(`'module'`);
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const defineParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (deps.length > 0 ? `[${deps.join(`,${_}`)}],${_}` : ``);
+    const useStrict = strict ? `${_}'use strict';` : '';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        .prepend(`${amd.define}(${defineParameters}(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${useStrict}${n}${n}`)
+        .append(`${n}${n}}));`);
+}
+
+function cjs(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
+    const { _, n } = snippets;
+    const useStrict = strict ? `'use strict';${n}${n}` : '';
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers += n + n;
+    }
+    const importBlock = getImportBlock$1(dependencies, snippets, compact);
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, `module.exports${_}=${_}`);
+    magicString.append(`${exportBlock}${outro}`);
+}
+function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
+    let importBlock = '';
+    let definingVariable = false;
+    for (const { importPath, name, reexports, imports } of dependencies) {
+        if (!reexports && !imports) {
+            if (importBlock) {
+                importBlock += compact && !definingVariable ? ',' : `;${n}`;
+            }
+            definingVariable = false;
+            importBlock += `require('${importPath}')`;
+        }
+        else {
+            importBlock += compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${cnst} `;
+            definingVariable = true;
+            importBlock += `${name}${_}=${_}require('${importPath}')`;
+        }
+    }
+    if (importBlock) {
+        return `${importBlock};${n}${n}`;
+    }
+    return '';
+}
+
+function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols }, importAttributesKey }) {
+    const { n } = snippets;
+    const importBlock = getImportBlock(dependencies, importAttributesKey, snippets);
+    if (importBlock.length > 0)
+        intro += importBlock.join(n) + n + n;
+    intro += getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols);
+    if (intro)
+        magicString.prepend(intro);
+    const exportBlock = getExportBlock(exports, snippets);
+    if (exportBlock.length > 0)
+        magicString.append(n + n + exportBlock.join(n).trim());
+    if (outro)
+        magicString.append(outro);
+    magicString.trim();
+}
+function getImportBlock(dependencies, importAttributesKey, { _ }) {
+    const importBlock = [];
+    for (const { importPath, reexports, imports, name, attributes } of dependencies) {
+        const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
+        const pathWithAssertion = `'${importPath}'${assertion};`;
+        if (!reexports && !imports) {
+            importBlock.push(`import${_}${pathWithAssertion}`);
+            continue;
+        }
+        if (imports) {
+            let defaultImport = null;
+            let starImport = null;
+            const importedNames = [];
+            for (const specifier of imports) {
+                if (specifier.imported === 'default') {
+                    defaultImport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    starImport = specifier;
+                }
+                else {
+                    importedNames.push(specifier);
+                }
+            }
+            if (starImport) {
+                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}${pathWithAssertion}`);
+            }
+            if (defaultImport && importedNames.length === 0) {
+                importBlock.push(`import ${defaultImport.local} from${_}${pathWithAssertion}`);
+            }
+            else if (importedNames.length > 0) {
+                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
+                    .map(specifier => specifier.imported === specifier.local
+                    ? specifier.imported
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+        if (reexports) {
+            let starExport = null;
+            const namespaceReexports = [];
+            const namedReexports = [];
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    starExport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    namespaceReexports.push(specifier);
+                }
+                else {
+                    namedReexports.push(specifier);
+                }
+            }
+            if (starExport) {
+                importBlock.push(`export${_}*${_}from${_}${pathWithAssertion}`);
+            }
+            if (namespaceReexports.length > 0) {
+                if (!imports ||
+                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
+                    importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
+                }
+                for (const specifier of namespaceReexports) {
+                    importBlock.push(`export${_}{${_}${name === specifier.reexported
+                        ? name
+                        : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
+                }
+            }
+            if (namedReexports.length > 0) {
+                importBlock.push(`export${_}{${_}${namedReexports
+                    .map(specifier => specifier.imported === specifier.reexported
+                    ? stringifyIdentifierIfNeeded(specifier.imported)
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+    }
+    return importBlock;
+}
+function getExportBlock(exports, { _, cnst }) {
+    const exportBlock = [];
+    const exportDeclaration = [];
+    for (const specifier of exports) {
+        if (specifier.expression) {
+            exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
+        }
+        exportDeclaration.push(specifier.exported === specifier.local
+            ? specifier.local
+            : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
+    }
+    if (exportDeclaration.length > 0) {
+        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
+    }
+    return exportBlock;
+}
+
+const keypath = (keypath, getPropertyAccess) => keypath.split('.').map(getPropertyAccess).join('');
+
+function setupNamespace(name, root, globals, { _, getPropertyAccess, s }, compact, log) {
+    const parts = name.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(LOGLEVEL_WARN, logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    parts.pop();
+    let propertyPath = root;
+    return (parts
+        .map(part => {
+        propertyPath += getPropertyAccess(part);
+        return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}${s}`;
+    })
+        .join(compact ? ',' : '\n') + (compact && parts.length > 0 ? ';' : '\n'));
+}
+function assignToDeepVariable(deepName, root, globals, assignment, { _, getPropertyAccess }, log) {
+    const parts = deepName.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(LOGLEVEL_WARN, logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    const last = parts.pop();
+    let propertyPath = root;
+    let deepAssignment = [
+        ...parts.map(part => {
+            propertyPath += getPropertyAccess(part);
+            return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
+        }),
+        `${propertyPath}${getPropertyAccess(last)}`
+    ].join(`,${_}`) + `${_}=${_}${assignment}`;
+    if (parts.length > 0) {
+        deepAssignment = `(${deepAssignment})`;
+    }
+    return deepAssignment;
+}
+
+function trimEmptyImports(dependencies) {
+    let index = dependencies.length;
+    while (index--) {
+        const { imports, reexports } = dependencies[index];
+        if (imports || reexports) {
+            return dependencies.slice(0, index + 1);
+        }
+    }
+    return [];
+}
+
+function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
+    const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
+    const isNamespaced = name && name.includes('.');
+    const useVariableAssignment = !extend && !isNamespaced;
+    if (name && useVariableAssignment && !isLegal(name)) {
+        return error(logIllegalIdentifierAsName(name));
+    }
+    warnOnBuiltins(log, dependencies);
+    const external = trimEmptyImports(dependencies);
+    const deps = external.map(dep => dep.globalName || 'null');
+    const parameters = external.map(m => m.name);
+    if (hasExports && !name) {
+        log(LOGLEVEL_WARN, logMissingNameOptionForIifeExport());
+    }
+    if (namedExportsMode && hasExports) {
+        if (extend) {
+            deps.unshift(`this${keypath(name, getPropertyAccess)}${_}=${_}this${keypath(name, getPropertyAccess)}${_}||${_}{}`);
+            parameters.unshift('exports');
+        }
+        else {
+            deps.unshift('{}');
+            parameters.unshift('exports');
+        }
+    }
+    const useStrict = strict ? `${t}'use strict';${n}` : '';
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${intro}${interopBlock}`);
+    let wrapperIntro = `(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${n}${useStrict}${n}`;
+    if (hasExports) {
+        if (name && !(extend && namedExportsMode)) {
+            wrapperIntro =
+                (useVariableAssignment ? `var ${name}` : `this${keypath(name, getPropertyAccess)}`) +
+                    `${_}=${_}${wrapperIntro}`;
+        }
+        if (isNamespaced) {
+            wrapperIntro = setupNamespace(name, 'this', globals, snippets, compact, log) + wrapperIntro;
+        }
+    }
+    let wrapperOutro = `${n}${n}})(${deps.join(`,${_}`)});`;
+    if (hasExports && !extend && namedExportsMode) {
+        wrapperOutro = `${n}${n}${t}return exports;${wrapperOutro}`;
+    }
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        .prepend(wrapperIntro)
+        .append(wrapperOutro);
+}
+
+const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
+
+function system(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
+    const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
+    const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports, t, snippets);
+    const registeredName = name ? `'${name}',${_}` : '';
+    const wrapperParameters = accessedGlobals.has('module')
+        ? ['exports', 'module']
+        : hasExports
+            ? ['exports']
+            : [];
+    // factory function should be wrapped by parentheses to avoid lazy parsing,
+    // cf. https://v8.dev/blog/preparser#pife
+    let wrapperStart = `System.register(${registeredName}[` +
+        dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
+        `],${_}(${getNonArrowFunctionIntro(wrapperParameters, {
+            isAsync: false,
+            name: null
+        })}{${n}${t}${strict ? "'use strict';" : ''}` +
+        getStarExcludesBlock(starExcludes, t, snippets) +
+        getImportBindingsBlock(importBindings, t, snippets) +
+        `${n}${t}return${_}{${setters.length > 0
+            ? `${n}${t}${t}setters:${_}[${setters
+                .map(setter => setter
+                ? `${getFunctionIntro(['module'], {
+                    isAsync: false,
+                    name: null
+                })}{${n}${t}${t}${t}${setter}${n}${t}${t}}`
+                : systemNullSetters
+                    ? `null`
+                    : `${getFunctionIntro([], { isAsync: false, name: null })}{}`)
+                .join(`,${_}`)}],`
+            : ''}${n}`;
+    wrapperStart += `${t}${t}execute:${_}(${getNonArrowFunctionIntro([], {
+        isAsync: usesTopLevelAwait,
+        name: null
+    })}{${n}${n}`;
+    const wrapperEnd = `${t}${t}})${n}${t}}${s}${n}}));`;
+    magicString
+        .prepend(intro +
+        getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols) +
+        getHoistedExportsBlock(exports, t, snippets))
+        .append(`${outro}${n}${n}` +
+        getSyntheticExportsBlock(exports, t, snippets) +
+        getMissingExportsBlock(exports, t, snippets))
+        .indent(`${t}${t}${t}`)
+        .append(wrapperEnd)
+        .prepend(wrapperStart);
+}
+function analyzeDependencies(dependencies, exports, t, { _, cnst, getObject, getPropertyAccess, n }) {
+    const importBindings = [];
+    const setters = [];
+    let starExcludes = null;
+    for (const { imports, reexports } of dependencies) {
+        const setter = [];
+        if (imports) {
+            for (const specifier of imports) {
+                importBindings.push(specifier.local);
+                if (specifier.imported === '*') {
+                    setter.push(`${specifier.local}${_}=${_}module;`);
+                }
+                else {
+                    setter.push(`${specifier.local}${_}=${_}module${getPropertyAccess(specifier.imported)};`);
+                }
+            }
+        }
+        if (reexports) {
+            const reexportedNames = [];
+            let hasStarReexport = false;
+            for (const { imported, reexported } of reexports) {
+                if (reexported === '*') {
+                    hasStarReexport = true;
+                }
+                else {
+                    reexportedNames.push([
+                        reexported,
+                        imported === '*' ? 'module' : `module${getPropertyAccess(imported)}`
+                    ]);
+                }
+            }
+            if (reexportedNames.length > 1 || hasStarReexport) {
+                if (hasStarReexport) {
+                    if (!starExcludes) {
+                        starExcludes = getStarExcludes({ dependencies, exports });
+                    }
+                    reexportedNames.unshift([null, `__proto__:${_}null`]);
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`${cnst} setter${_}=${_}${exportMapping};`, `for${_}(${cnst} name in module)${_}{`, `${t}if${_}(!_starExcludes[name])${_}setter[name]${_}=${_}module[name];`, '}', 'exports(setter);');
+                }
+                else {
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`exports(${exportMapping});`);
+                }
+            }
+            else {
+                const [key, value] = reexportedNames[0];
+                setter.push(`exports(${JSON.stringify(key)},${_}${value});`);
+            }
+        }
+        setters.push(setter.join(`${n}${t}${t}${t}`));
+    }
+    return { importBindings, setters, starExcludes };
+}
+const getStarExcludes = ({ dependencies, exports }) => {
+    const starExcludes = new Set(exports.map(expt => expt.exported));
+    starExcludes.add('default');
+    for (const { reexports } of dependencies) {
+        if (reexports) {
+            for (const reexport of reexports) {
+                if (reexport.reexported !== '*')
+                    starExcludes.add(reexport.reexported);
+            }
+        }
+    }
+    return starExcludes;
+};
+const getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n }) => {
+    if (starExcludes) {
+        const fields = [...starExcludes].map(property => [
+            property,
+            '1'
+        ]);
+        fields.unshift([null, `__proto__:${_}null`]);
+        return `${n}${t}${cnst} _starExcludes${_}=${_}${getObject(fields, {
+            lineBreakIndent: { base: t, t }
+        })};`;
+    }
+    return '';
+};
+const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length > 0 ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
+const getHoistedExportsBlock = (exports, t, snippets) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+function getExportsBlock(exports, t, { _, n }) {
+    if (exports.length === 0) {
+        return '';
+    }
+    if (exports.length === 1) {
+        return `exports(${JSON.stringify(exports[0].name)},${_}${exports[0].value});${n}${n}`;
+    }
+    return (`exports({${n}` +
+        exports
+            .map(({ name, value }) => `${t}${stringifyObjectKeyIfNeeded(name)}:${_}${value}`)
+            .join(`,${n}`) +
+        `${n}});${n}${n}`);
+}
+const getSyntheticExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.expression)
+    .map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+const getMissingExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
+    .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
+
+function globalProperty(name, globalVariable, getPropertyAccess) {
+    if (!name)
+        return 'null';
+    return `${globalVariable}${keypath(name, getPropertyAccess)}`;
+}
+function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
+    let propertyPath = globalVariable;
+    return name
+        .split('.')
+        .map(part => (propertyPath += getPropertyAccess(part)))
+        .join(`${_}&&${_}`);
+}
+function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, generatedCode: { symbols }, globals, noConflict, reexportProtoFromExternal, strict }) {
+    const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
+    const factoryVariable = compact ? 'f' : 'factory';
+    const globalVariable = compact ? 'g' : 'global';
+    if (hasExports && !name) {
+        return error(logMissingNameOptionForUmdExport());
+    }
+    warnOnBuiltins(log, dependencies);
+    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
+    const trimmedImports = trimEmptyImports(dependencies);
+    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
+    const factoryParameters = trimmedImports.map(m => m.name);
+    if (namedExportsMode && (hasExports || noConflict)) {
+        amdDeps.unshift(`'exports'`);
+        cjsDeps.unshift(`exports`);
+        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets, log));
+        factoryParameters.unshift('exports');
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
+    const define = amd.define;
+    const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
+    const useStrict = strict ? `${_}'use strict';${n}` : ``;
+    let iifeExport;
+    if (noConflict) {
+        const noConflictExportsVariable = compact ? 'e' : 'exports';
+        let factory;
+        if (!namedExportsMode && hasExports) {
+            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets, log)};`;
+        }
+        else {
+            const module = globalDeps.shift();
+            factory =
+                `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
+                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
+        }
+        iifeExport =
+            `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
+                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVariable, snippets)};${n}` +
+                `${t}${t}${factory}${n}` +
+                `${t}${t}${noConflictExportsVariable}.noConflict${_}=${_}${getFunctionIntro([], {
+                    isAsync: false,
+                    name: null
+                })}{${_}` +
+                `${globalProperty(name, globalVariable, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVariable}${s}${_}};${n}` +
+                `${t}})()`;
+    }
+    else {
+        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
+        if (!namedExportsMode && hasExports) {
+            iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets, log);
+        }
+    }
+    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
+    const wrapperParameters = [factoryVariable];
+    if (iifeNeedsGlobal) {
+        wrapperParameters.unshift(globalVariable);
+    }
+    const globalArgument = iifeNeedsGlobal ? `this,${_}` : '';
+    const iifeStart = iifeNeedsGlobal
+        ? `(${globalVariable}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVariable}${_}||${_}self,${_}`
+        : '';
+    const iifeEnd = iifeNeedsGlobal ? ')' : '';
+    const cjsIntro = iifeNeedsGlobal
+        ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
+            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
+        : '';
+    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
+        cjsIntro +
+        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParameters}${factoryVariable})${_}:${n}` +
+        `${t}${iifeStart}${iifeExport}${iifeEnd};${n}` +
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        `})(${globalArgument}(${getNonArrowFunctionIntro(factoryParameters, {
+            isAsync: false,
+            name: null
+        })}{${useStrict}${n}`;
+    const wrapperOutro = n + n + '}));';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .trim()
+        .indent(t)
+        .append(wrapperOutro)
+        .prepend(wrapperIntro);
+}
+
+const finalisers = { amd, cjs, es, iife, system, umd };
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var utils = {};
+
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	const path = require$$0;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+
+		const path = require$$0;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var scan_1;
+var hasRequiredScan;
+
+function requireScan () {
+	if (hasRequiredScan) return scan_1;
+	hasRequiredScan = 1;
+
+	const utils = /*@__PURE__*/ requireUtils();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1 = scan;
+	return scan_1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const constants = /*@__PURE__*/ requireConstants();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+var picomatch_1;
+var hasRequiredPicomatch$1;
+
+function requirePicomatch$1 () {
+	if (hasRequiredPicomatch$1) return picomatch_1;
+	hasRequiredPicomatch$1 = 1;
+
+	const path = require$$0;
+	const scan = /*@__PURE__*/ requireScan();
+	const parse = /*@__PURE__*/ requireParse();
+	const utils = /*@__PURE__*/ requireUtils();
+	const constants = /*@__PURE__*/ requireConstants();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1 = picomatch;
+	return picomatch_1;
+}
+
+var picomatch;
+var hasRequiredPicomatch;
+
+function requirePicomatch () {
+	if (hasRequiredPicomatch) return picomatch;
+	hasRequiredPicomatch = 1;
+
+	picomatch = /*@__PURE__*/ requirePicomatch$1();
+	return picomatch;
+}
+
+var picomatchExports = /*@__PURE__*/ requirePicomatch();
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
+
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray$1(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+const normalizePathRegExp = new RegExp(`\\${win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath(resolve(resolutionBase || ''))
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return posix.join(basePath, normalizePath(id));
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray$1(include).map(getMatcher);
+    const excludeMatchers = ensureArray$1(exclude).map(getMatcher);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+
+class ArrayPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const element of this.elements) {
+            element?.addExportedVariables(variables, exportNamesByVariable);
+        }
+    }
+    declare(kind) {
+        const variables = [];
+        for (const element of this.elements) {
+            if (element !== null) {
+                variables.push(...element.declare(kind, UNKNOWN_EXPRESSION));
+            }
+        }
+        return variables;
+    }
+    // Patterns can only be deoptimized at the empty path at the moment
+    deoptimizePath() {
+        for (const element of this.elements) {
+            element?.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    // Patterns are only checked at the empty path at the moment
+    hasEffectsOnInteractionAtPath(_path, interaction, context) {
+        for (const element of this.elements) {
+            if (element?.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const element of this.elements) {
+            element?.markDeclarationReached();
+        }
+    }
+}
+
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    get expression() {
+        return isFlagSet(this.flags, 8388608 /* Flag.expression */);
+    }
+    set expression(value) {
+        this.flags = setFlag(this.flags, 8388608 /* Flag.expression */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, false);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context)) {
+            return true;
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (interaction.type === INTERACTION_CALLED) {
+            const { ignore, brokenFlow } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true,
+                this: false
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.ignore = ignore;
+            context.brokenFlow = brokenFlow;
+        }
+        return false;
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === CallExpression$1 &&
+            this.parent.callee === this;
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier)) {
+                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
+
+class ObjectPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const property of this.properties) {
+            if (property.type === Property$1) {
+                property.value.addExportedVariables(variables, exportNamesByVariable);
+            }
+            else {
+                property.argument.addExportedVariables(variables, exportNamesByVariable);
+            }
+        }
+    }
+    declare(kind, init) {
+        const variables = [];
+        for (const property of this.properties) {
+            variables.push(...property.declare(kind, init));
+        }
+        return variables;
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            for (const property of this.properties) {
+                property.deoptimizePath(path);
+            }
+        }
+    }
+    hasEffectsOnInteractionAtPath(
+    // At the moment, this is only triggered for assignment left-hand sides,
+    // where the path is empty
+    _path, interaction, context) {
+        for (const property of this.properties) {
+            if (property.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const property of this.properties) {
+            property.markDeclarationReached();
+        }
+    }
+}
+
+class AssignmentExpression extends NodeBase {
+    hasEffects(context) {
+        const { deoptimized, left, operator, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        // MemberExpressions do not access the property before assignments if the
+        // operator is '='.
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, left, right, operator } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        if (includeChildrenRecursively ||
+            operator !== '=' ||
+            left.included ||
+            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
+            left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
+        }
+        right.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        if (this.left instanceof Identifier) {
+            const variable = this.scope.variables.get(this.left.name);
+            if (variable?.kind === 'const') {
+                this.scope.context.error(logConstVariableReassignError(), this.left.start);
+            }
+        }
+        this.left.setAssignedValue(this.right);
+    }
+    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+        const { left, right, start, end, parent } = this;
+        if (left.included) {
+            left.render(code, options);
+            right.render(code, options);
+        }
+        else {
+            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', left.end) + 1);
+            code.remove(start, inclusionStart);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, right.start);
+            }
+            right.render(code, options, {
+                renderedParentType: renderedParentType || parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || parent.type
+            });
+        }
+        if (options.format === 'system') {
+            if (left instanceof Identifier) {
+                const variable = left.variable;
+                const exportNames = options.exportNamesByVariable.get(variable);
+                if (exportNames) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, start, end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== ExpressionStatement$1, code, options);
+                    }
+                    return;
+                }
+            }
+            else {
+                const systemPatternExports = [];
+                left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
+                if (systemPatternExports.length > 0) {
+                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === ExpressionStatement$1, code, options);
+                    return;
+                }
+            }
+        }
+        if (left.included &&
+            left instanceof ObjectPattern &&
+            (renderedSurroundingElement === ExpressionStatement$1 ||
+                renderedSurroundingElement === ArrowFunctionExpression$1)) {
+            code.appendRight(start, '(');
+            code.prependLeft(end, ')');
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class AssignmentPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        return this.left.declare(kind, init);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.left.deoptimizePath(path);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
+    markDeclarationReached() {
+        this.left.markDeclarationReached();
+    }
+    render(code, options, { isShorthandProperty } = BLANK) {
+        this.left.render(code, options, { isShorthandProperty });
+        this.right.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class AwaitExpression extends NodeBase {
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
+                let parent = this.parent;
+                do {
+                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
+                        break checkTopLevelAwait;
+                } while ((parent = parent.parent));
+                this.scope.context.usesTopLevelAwait = true;
+            }
+        }
+        this.argument.include(context, includeChildrenRecursively);
+    }
+}
+
+const binaryOperators = {
+    '!=': (left, right) => left != right,
+    '!==': (left, right) => left !== right,
+    '%': (left, right) => left % right,
+    '&': (left, right) => left & right,
+    '*': (left, right) => left * right,
+    // At the moment, "**" will be transpiled to Math.pow
+    '**': (left, right) => left ** right,
+    '+': (left, right) => left + right,
+    '-': (left, right) => left - right,
+    '/': (left, right) => left / right,
+    '<': (left, right) => left < right,
+    '<<': (left, right) => left << right,
+    '<=': (left, right) => left <= right,
+    '==': (left, right) => left == right,
+    '===': (left, right) => left === right,
+    '>': (left, right) => left > right,
+    '>=': (left, right) => left >= right,
+    '>>': (left, right) => left >> right,
+    '>>>': (left, right) => left >>> right,
+    '^': (left, right) => left ^ right,
+    '|': (left, right) => left | right
+    // We use the fallback for cases where we return something unknown
+    // in: () => UnknownValue,
+    // instanceof: () => UnknownValue,
+};
+class BinaryExpression extends NodeBase {
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length > 0)
+            return UnknownValue;
+        const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof leftValue === 'symbol')
+            return UnknownValue;
+        const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof rightValue === 'symbol')
+            return UnknownValue;
+        const operatorFunction = binaryOperators[this.operator];
+        if (!operatorFunction)
+            return UnknownValue;
+        return operatorFunction(leftValue, rightValue);
+    }
+    hasEffects(context) {
+        // support some implicit type coercion runtime errors
+        if (this.operator === '+' &&
+            this.parent instanceof ExpressionStatement &&
+            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '') {
+            return true;
+        }
+        return super.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        this.left.render(code, options, { renderedSurroundingElement });
+        this.right.render(code, options);
+    }
+}
+
+class BreakStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.breaks)
+                return true;
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+
+function renderCallArguments(code, options, node) {
+    if (node.arguments.length > 0) {
+        if (node.arguments[node.arguments.length - 1].included) {
+            for (const argument of node.arguments) {
+                argument.render(code, options);
+            }
+        }
+        else {
+            let lastIncludedIndex = node.arguments.length - 2;
+            while (lastIncludedIndex >= 0 && !node.arguments[lastIncludedIndex].included) {
+                lastIncludedIndex--;
+            }
+            if (lastIncludedIndex >= 0) {
+                for (let index = 0; index <= lastIncludedIndex; index++) {
+                    node.arguments[index].render(code, options);
+                }
+                code.remove(findFirstOccurrenceOutsideComment(code.original, ',', node.arguments[lastIncludedIndex].end), node.end - 1);
+            }
+            else {
+                code.remove(findFirstOccurrenceOutsideComment(code.original, '(', node.callee.end) + 1, node.end - 1);
+            }
+        }
+    }
+}
+
+class CallExpressionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.deoptimizableDependentExpressions = [];
+        this.expressionsToBeDeoptimized = new Set();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        const { args } = interaction;
+        const [returnExpression, isPure] = this.getReturnExpression(recursionTracker);
+        if (isPure)
+            return;
+        const deoptimizedExpressions = args.filter(expression => !!expression && expression !== UNKNOWN_EXPRESSION);
+        if (deoptimizedExpressions.length === 0)
+            return;
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            for (const expression of deoptimizedExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        else {
+            recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+                for (const expression of deoptimizedExpressions) {
+                    this.expressionsToBeDeoptimized.add(expression);
+                }
+                returnExpression.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+            }, null);
+        }
+    }
+    deoptimizeCache() {
+        if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = EMPTY_SET;
+            this.deoptimizableDependentExpressions = EMPTY_ARRAY;
+            for (const expression of deoptimizableDependentExpressions) {
+                expression.deoptimizeCache();
+            }
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 ||
+            this.scope.context.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        const [returnExpression] = this.getReturnExpression();
+        if (returnExpression !== UNKNOWN_EXPRESSION) {
+            returnExpression.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const [returnExpression] = this.getReturnExpression(recursionTracker);
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const returnExpression = this.getReturnExpression(recursionTracker);
+        if (returnExpression[0] === UNKNOWN_EXPRESSION) {
+            return returnExpression;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            const [expression, isPure] = returnExpression[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+            return [expression, isPure || returnExpression[1]];
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (type === INTERACTION_CALLED) {
+            const { args, withNew } = interaction;
+            if ((withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, args, this)) {
+                return false;
+            }
+        }
+        else if ((type === INTERACTION_ASSIGNED
+            ? context.assigned
+            : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
+            return false;
+        }
+        const [returnExpression, isPure] = this.getReturnExpression();
+        return ((type === INTERACTION_ASSIGNED || !isPure) &&
+            returnExpression.hasEffectsOnInteractionAtPath(path, interaction, context));
+    }
+}
+
+class CallExpression extends CallExpressionBase {
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    bind() {
+        super.bind();
+        if (this.callee instanceof Identifier) {
+            const variable = this.scope.findVariable(this.callee.name);
+            if (variable.isNamespace) {
+                this.scope.context.log(LOGLEVEL_WARN, logCannotCallNamespace(this.callee.name), this.start);
+            }
+            if (this.callee.name === 'eval') {
+                this.scope.context.log(LOGLEVEL_WARN, logEval(this.scope.context.module.id), this.start);
+            }
+        }
+        this.interaction = {
+            args: [
+                this.callee instanceof MemberExpression && !this.callee.variable
+                    ? this.callee.object
+                    : null,
+                ...this.arguments
+            ],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        return getChainElementLiteralValueAtPath(this, this.callee, path, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        if (this.annotationPure) {
+            return false;
+        }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    hasEffectsAsChainElement(context) {
+        const calleeHasEffects = 'hasEffectsAsChainElement' in this.callee
+            ? this.callee.hasEffectsAsChainElement(context)
+            : this.callee.hasEffects(context);
+        if (calleeHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return (!this.annotationPure && calleeHasEffects) || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (!this.annotationPure &&
+            (calleeHasEffects ||
+                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context)));
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+            if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
+                this.callee instanceof Identifier &&
+                this.callee.variable) {
+                this.callee.variable.markCalledFromTryStatement();
+            }
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
+    initialise() {
+        super.initialise();
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        this.callee.render(code, options, {
+            isCalleeOfRenderedParent: true,
+            renderedSurroundingElement
+        });
+        renderCallArguments(code, options, this);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
+}
+
+class CatchClause extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ParameterScope(parentScope, true);
+    }
+    parseNode(esTreeNode) {
+        const { body, param, type } = esTreeNode;
+        this.type = type;
+        if (param) {
+            this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
+            this.param.declare('parameter', UNKNOWN_EXPRESSION);
+        }
+        this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
+    }
+}
+CatchClause.prototype.preventChildBlockScope = true;
+
+class ChainExpression extends NodeBase {
+    // deoptimizations are not relevant as we are not caching values
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const literalValue = this.expression.getLiteralValueAtPathAsChainElement(path, recursionTracker, origin);
+        return literalValue === IS_SKIPPED_CHAIN ? undefined : literalValue;
+    }
+    hasEffects(context) {
+        return this.expression.hasEffectsAsChainElement(context) === true;
+    }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
+    applyDeoptimizations() { }
+}
+
+class ClassBodyScope extends ChildScope {
+    constructor(parent, classNode) {
+        const { context } = parent;
+        super(parent, context);
+        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, 'other')));
+        this.instanceScope = new ChildScope(this, context);
+        this.instanceScope.variables.set('this', new ThisVariable(context));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+}
+
+class ClassBody extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ClassBodyScope(parentScope, this.parent);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.scope.context.includeVariableInModule(this.scope.thisVariable);
+        for (const definition of this.body) {
+            definition.include(context, includeChildrenRecursively);
+        }
+    }
+    parseNode(esTreeNode) {
+        const body = (this.body = []);
+        for (const definition of esTreeNode.body) {
+            body.push(new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition));
+        }
+        return super.parseNode(esTreeNode);
+    }
+    applyDeoptimizations() { }
+}
+
+class ClassExpression extends ClassNode {
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === ExpressionStatement$1) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+
+class MultiExpression extends ExpressionEntity {
+    constructor(expressions) {
+        super();
+        this.expressions = expressions;
+    }
+    deoptimizePath(path) {
+        for (const expression of this.expressions) {
+            expression.deoptimizePath(path);
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return [
+            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
+            false
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        for (const expression of this.expressions) {
+            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
+                return true;
+        }
+        return false;
+    }
+}
+
+class ConditionalExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.expressionsToBeDeoptimized = [];
+        this.usedBranch = null;
+    }
+    get isBranchResolutionAnalysed() {
+        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
+    set isBranchResolutionAnalysed(value) {
+        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.consequent.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        if (this.usedBranch !== null) {
+            const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+    }
+    deoptimizePath(path) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
+        }
+        else {
+            this.consequent.deoptimizePath(path);
+            this.alternate.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return this.consequent.hasEffects(context) || this.alternate.hasEffects(context);
+        }
+        return usedBranch.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return (this.consequent.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.alternate.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const usedBranch = this.getUsedBranch();
+        if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
+            this.test.include(context, includeChildrenRecursively);
+            this.consequent.include(context, includeChildrenRecursively);
+            this.alternate.include(context, includeChildrenRecursively);
+        }
+        else {
+            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.includeCallArguments(context, parameters);
+        }
+        else {
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
+        }
+    }
+    removeAnnotations(code) {
+        this.test.removeAnnotations(code);
+    }
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+        const usedBranch = this.getUsedBranch();
+        if (this.test.included) {
+            this.test.render(code, options, { renderedSurroundingElement });
+            this.consequent.render(code, options);
+            this.alternate.render(code, options);
+        }
+        else {
+            const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
+            const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
+                ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
+                : colonPos) + 1);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, usedBranch.start);
+            }
+            code.remove(this.start, inclusionStart);
+            if (this.consequent.included) {
+                code.remove(colonPos, this.end);
+            }
+            this.test.removeAnnotations(code);
+            usedBranch.render(code, options, {
+                isCalleeOfRenderedParent,
+                preventASI: true,
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            });
+        }
+    }
+    getUsedBranch() {
+        if (this.isBranchResolutionAnalysed) {
+            return this.usedBranch;
+        }
+        this.isBranchResolutionAnalysed = true;
+        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        return typeof testValue === 'symbol'
+            ? null
+            : (this.usedBranch = testValue ? this.consequent : this.alternate);
+    }
+}
+
+class ContinueStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.continues)
+                return true;
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+
+class DebuggerStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+}
+
+class Decorator extends NodeBase {
+    hasEffects(context) {
+        return (this.expression.hasEffects(context) ||
+            this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
+    }
+}
+
+function hasLoopBodyEffects(context, body) {
+    const { brokenFlow, hasBreak, hasContinue, ignore } = context;
+    const { breaks, continues } = ignore;
+    ignore.breaks = true;
+    ignore.continues = true;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    if (body.hasEffects(context))
+        return true;
+    ignore.breaks = breaks;
+    ignore.continues = continues;
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+    return false;
+}
+function includeLoopBody(context, body, includeChildrenRecursively) {
+    const { brokenFlow, hasBreak, hasContinue } = context;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    body.include(context, includeChildrenRecursively, { asSingleStatement: true });
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+}
+
+class DoWhileStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
+
+class EmptyStatement extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+}
+
+class ExportAllDeclaration extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ExportAllDeclaration.prototype.needsBoundaries = true;
+
+class ExportNamedDeclaration extends NodeBase {
+    bind() {
+        // Do not bind specifiers
+        this.declaration?.bind();
+    }
+    hasEffects(context) {
+        return !!this.declaration?.hasEffects(context);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration?.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        if (this.declaration === null) {
+            code.remove(start, end);
+        }
+        else {
+            code.remove(this.start, this.declaration.start);
+            this.declaration.render(code, options, { end, start });
+        }
+    }
+    applyDeoptimizations() { }
+}
+ExportNamedDeclaration.prototype.needsBoundaries = true;
+
+class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class ForInStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, body);
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "in" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 110 /* n */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ForOfStatement extends NodeBase {
+    get await() {
+        return isFlagSet(this.flags, 131072 /* Flag.await */);
+    }
+    set await(value) {
+        this.flags = setFlag(this.flags, 131072 /* Flag.await */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        // Placeholder until proper Symbol.Iterator support
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "of" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 102 /* f */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ForStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.init?.hasEffects(context) ||
+            this.test?.hasEffects(context) ||
+            this.update?.hasEffects(context)) {
+            return true;
+        }
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        this.test?.include(context, includeChildrenRecursively);
+        this.update?.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+    render(code, options) {
+        this.init?.render(code, options, NO_SEMICOLON);
+        this.test?.render(code, options, NO_SEMICOLON);
+        this.update?.render(code, options, NO_SEMICOLON);
+        this.body.render(code, options);
+    }
+}
+
+class FunctionExpression extends FunctionNode {
+    createScope(parentScope) {
+        super.createScope((this.idScope = new ChildScope(parentScope, parentScope.context)));
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.idScope).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === CallExpression$1 &&
+            this.parent.callee === this &&
+            (this.id === null || this.id.variable.getOnlyFunctionCallUsed());
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === ExpressionStatement$1) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+
+class TrackingScope extends BlockScope {
+    constructor() {
+        super(...arguments);
+        this.hoistedDeclarations = [];
+    }
+    addDeclaration(identifier, context, init, kind) {
+        this.hoistedDeclarations.push(identifier);
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+const unset = Symbol('unset');
+class IfStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.testValue = unset;
+    }
+    deoptimizeCache() {
+        this.testValue = UnknownValue;
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context)) {
+            return true;
+        }
+        const testValue = this.getTestValue();
+        if (typeof testValue === 'symbol') {
+            const { brokenFlow } = context;
+            if (this.consequent.hasEffects(context))
+                return true;
+            const consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+            if (this.alternate === null)
+                return false;
+            if (this.alternate.hasEffects(context))
+                return true;
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+            return false;
+        }
+        return testValue ? this.consequent.hasEffects(context) : !!this.alternate?.hasEffects(context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        if (includeChildrenRecursively) {
+            this.includeRecursively(includeChildrenRecursively, context);
+        }
+        else {
+            const testValue = this.getTestValue();
+            if (typeof testValue === 'symbol') {
+                this.includeUnknownTest(context);
+            }
+            else {
+                this.includeKnownTest(context, testValue);
+            }
+        }
+    }
+    parseNode(esTreeNode) {
+        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(this, (this.consequentScope = new TrackingScope(this.scope))).parseNode(esTreeNode.consequent);
+        if (esTreeNode.alternate) {
+            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(this, (this.alternateScope = new TrackingScope(this.scope))).parseNode(esTreeNode.alternate);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { getPropertyAccess } } = options;
+        // Note that unknown test values are always included
+        const testValue = this.getTestValue();
+        const hoistedDeclarations = [];
+        const includesIfElse = this.test.included;
+        const noTreeshake = !this.scope.context.options.treeshake;
+        if (includesIfElse) {
+            this.test.render(code, options);
+        }
+        else {
+            code.remove(this.start, this.consequent.start);
+        }
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
+            this.consequent.render(code, options);
+        }
+        else {
+            code.overwrite(this.consequent.start, this.consequent.end, includesIfElse ? ';' : '');
+            hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
+        }
+        if (this.alternate) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
+                if (includesIfElse) {
+                    if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
+                        code.prependLeft(this.alternate.start, ' ');
+                    }
+                }
+                else {
+                    code.remove(this.consequent.end, this.alternate.start);
+                }
+                this.alternate.render(code, options);
+            }
+            else {
+                if (includesIfElse && this.shouldKeepAlternateBranch()) {
+                    code.overwrite(this.alternate.start, this.end, ';');
+                }
+                else {
+                    code.remove(this.consequent.end, this.end);
+                }
+                hoistedDeclarations.push(...this.alternateScope.hoistedDeclarations);
+            }
+        }
+        this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
+    }
+    applyDeoptimizations() { }
+    getTestValue() {
+        if (this.testValue === unset) {
+            return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        }
+        return this.testValue;
+    }
+    includeKnownTest(context, testValue) {
+        if (this.test.shouldBeIncluded(context)) {
+            this.test.include(context, false);
+        }
+        if (testValue && this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+        }
+        if (!testValue && this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+        }
+    }
+    includeRecursively(includeChildrenRecursively, context) {
+        this.test.include(context, includeChildrenRecursively);
+        this.consequent.include(context, includeChildrenRecursively);
+        this.alternate?.include(context, includeChildrenRecursively);
+    }
+    includeUnknownTest(context) {
+        this.test.include(context, false);
+        const { brokenFlow } = context;
+        let consequentBrokenFlow = false;
+        if (this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+            consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+        }
+    }
+    renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess) {
+        const hoistedVariables = [
+            ...new Set(hoistedDeclarations.map(identifier => {
+                const variable = identifier.variable;
+                return variable.included ? variable.getName(getPropertyAccess) : '';
+            }))
+        ]
+            .filter(Boolean)
+            .join(', ');
+        if (hoistedVariables) {
+            const parentType = this.parent.type;
+            const needsBraces = parentType !== Program$1 && parentType !== BlockStatement$1;
+            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
+            if (needsBraces) {
+                code.appendLeft(this.end, ` }`);
+            }
+        }
+    }
+    shouldKeepAlternateBranch() {
+        let currentParent = this.parent;
+        do {
+            if (currentParent instanceof IfStatement && currentParent.alternate) {
+                return true;
+            }
+            if (currentParent instanceof BlockStatement) {
+                return false;
+            }
+            currentParent = currentParent.parent;
+        } while (currentParent);
+        return false;
+    }
+}
+
+class ImportAttribute extends NodeBase {
+}
+
+class ImportDeclaration extends NodeBase {
+    // Do not bind specifiers or attributes
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addImport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ImportDeclaration.prototype.needsBoundaries = true;
+
+class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+function isReassignedExportsMember(variable, exportNamesByVariable) {
+    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
+}
+
+class VariableDeclarator extends NodeBase {
+    declareDeclarator(kind, isUsingDeclaration) {
+        this.isUsingDeclaration = isUsingDeclaration;
+        this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        this.id.deoptimizePath(path);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.init?.hasEffects(context);
+        this.id.markDeclarationReached();
+        return initEffect || this.id.hasEffects(context) || this.isUsingDeclaration;
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, id, init } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        init?.include(context, includeChildrenRecursively);
+        id.markDeclarationReached();
+        if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
+            id.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.init?.removeAnnotations(code);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
+        const { end, id, init, start } = this;
+        const renderId = id.included || this.isUsingDeclaration;
+        if (renderId) {
+            id.render(code, options);
+        }
+        else {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
+            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
+        }
+        if (init) {
+            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+                const renderedVariable = id.variable.getName(getPropertyAccess);
+                if (renderedVariable !== id.name) {
+                    code.appendLeft(init.start + 5, ` ${id.name}`);
+                }
+            }
+            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
+        }
+        else if (id instanceof Identifier &&
+            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
+            code.appendLeft(end, `${_}=${_}void 0`);
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { id, init } = this;
+        if (init && id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+            const { name, variable } = id;
+            for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+
+class ImportExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.inlineNamespace = null;
+        this.attributes = null;
+        this.mechanism = null;
+        this.namespaceExportName = undefined;
+        this.resolution = null;
+        this.resolutionString = null;
+    }
+    // Do not bind attributes
+    bind() {
+        this.source.bind();
+    }
+    /**
+     * Get imported variables for deterministic usage, valid cases are:
+     *
+     * - `const { foo } = await import('bar')`.
+     * - `(await import('bar')).foo`
+     * - `import('bar').then(({ foo }) => {})`
+     *
+     * Returns empty array if it's side-effect only import.
+     * Returns undefined if it's not fully deterministic.
+     */
+    getDeterministicImportedNames() {
+        const parent1 = this.parent;
+        // Side-effect only: import('bar')
+        if (parent1 instanceof ExpressionStatement) {
+            return EMPTY_ARRAY;
+        }
+        if (parent1 instanceof AwaitExpression) {
+            const parent2 = parent1.parent;
+            // Side-effect only: await import('bar')
+            if (parent2 instanceof ExpressionStatement) {
+                return EMPTY_ARRAY;
+            }
+            // Case 1: const { foo } = await import('bar')
+            if (parent2 instanceof VariableDeclarator) {
+                const declaration = parent2.id;
+                return declaration instanceof ObjectPattern
+                    ? getDeterministicObjectDestructure(declaration)
+                    : undefined;
+            }
+            // Case 2: (await import('bar')).foo
+            if (parent2 instanceof MemberExpression) {
+                const id = parent2.property;
+                if (!parent2.computed && id instanceof Identifier) {
+                    return [id.name];
+                }
+            }
+            return;
+        }
+        // Case 3: import('bar').then(({ foo }) => {})
+        if (parent1 instanceof MemberExpression) {
+            const callExpression = parent1.parent;
+            const property = parent1.property;
+            if (!(callExpression instanceof CallExpression) || !(property instanceof Identifier)) {
+                return;
+            }
+            const memberName = property.name;
+            // side-effect only, when only chaining .catch or .finally
+            if (callExpression.parent instanceof ExpressionStatement &&
+                ['catch', 'finally'].includes(memberName)) {
+                return EMPTY_ARRAY;
+            }
+            if (memberName !== 'then')
+                return;
+            // Side-effect only: import('bar').then()
+            if (callExpression.arguments.length === 0) {
+                return EMPTY_ARRAY;
+            }
+            const argument = callExpression.arguments[0];
+            if (callExpression.arguments.length !== 1 ||
+                !(argument instanceof ArrowFunctionExpression || argument instanceof FunctionExpression)) {
+                return;
+            }
+            // Side-effect only: import('bar').then(() => {})
+            if (argument.params.length === 0) {
+                return EMPTY_ARRAY;
+            }
+            const declaration = argument.params[0];
+            if (argument.params.length === 1 && declaration instanceof ObjectPattern) {
+                return getDeterministicObjectDestructure(declaration);
+            }
+            return;
+        }
+    }
+    hasEffects() {
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeDynamicImport(this);
+            this.scope.addAccessedDynamicImport(this);
+        }
+        this.source.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addDynamicImport(this);
+    }
+    parseNode(esTreeNode) {
+        this.sourceAstNode = esTreeNode.source;
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { _, getDirectReturnFunction, getObject, getPropertyAccess } } = options;
+        if (this.inlineNamespace) {
+            const [left, right] = getDirectReturnFunction([], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: null
+            });
+            code.overwrite(this.start, this.end, `Promise.resolve().then(${left}${this.inlineNamespace.getName(getPropertyAccess)}${right})`);
+            return;
+        }
+        if (this.mechanism) {
+            code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, this.mechanism.left);
+            code.overwrite(this.end - 1, this.end, this.mechanism.right);
+        }
+        if (this.resolutionString) {
+            code.overwrite(this.source.start, this.source.end, this.resolutionString);
+            if (this.namespaceExportName) {
+                const [left, right] = getDirectReturnFunction(['n'], {
+                    functionReturn: true,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                code.prependLeft(this.end, `.then(${left}n.${this.namespaceExportName}${right})`);
+            }
+        }
+        else {
+            this.source.render(code, options);
+        }
+        if (this.attributes !== true) {
+            if (this.options) {
+                code.overwrite(this.source.end, this.end - 1, '', { contentOnly: true });
+            }
+            if (this.attributes) {
+                code.appendLeft(this.end - 1, `,${_}${getObject([['assert', this.attributes]], {
+                    lineBreakIndent: null
+                })}`);
+            }
+        }
+    }
+    setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName, attributes) {
+        const { format } = options;
+        this.inlineNamespace = null;
+        this.resolution = resolution;
+        this.resolutionString = resolutionString;
+        this.namespaceExportName = namespaceExportName;
+        this.attributes = attributes;
+        const accessedGlobals = [...(accessedImportGlobals[format] || [])];
+        let helper;
+        ({ helper, mechanism: this.mechanism } = this.getDynamicImportMechanismAndHelper(resolution, exportMode, options, snippets, pluginDriver));
+        if (helper) {
+            accessedGlobals.push(helper);
+        }
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+    setInternalResolution(inlineNamespace) {
+        this.inlineNamespace = inlineNamespace;
+    }
+    applyDeoptimizations() { }
+    getDynamicImportMechanismAndHelper(resolution, exportMode, { compact, dynamicImportInCjs, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver) {
+        const mechanism = pluginDriver.hookFirstSync('renderDynamicImport', [
+            {
+                customResolution: typeof this.resolution === 'string' ? this.resolution : null,
+                format,
+                moduleId: this.scope.context.module.id,
+                targetModuleId: this.resolution && typeof this.resolution !== 'string' ? this.resolution.id : null
+            }
+        ]);
+        if (mechanism) {
+            return { helper: null, mechanism };
+        }
+        const hasDynamicTarget = !this.resolution || typeof this.resolution === 'string';
+        switch (format) {
+            case 'cjs': {
+                if (dynamicImportInCjs &&
+                    (!resolution || typeof resolution === 'string' || resolution instanceof ExternalModule)) {
+                    return { helper: null, mechanism: null };
+                }
+                const helper = getInteropHelper(resolution, exportMode, interop);
+                let left = `require(`;
+                let right = `)`;
+                if (helper) {
+                    left = `/*#__PURE__*/${helper}(${left}`;
+                    right += ')';
+                }
+                const [functionLeft, functionRight] = getDirectReturnFunction([], {
+                    functionReturn: true,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                left = `Promise.resolve().then(${functionLeft}${left}`;
+                right += `${functionRight})`;
+                if (!arrowFunctions && hasDynamicTarget) {
+                    left = getDirectReturnIifeLeft(['t'], `${left}t${right}`, {
+                        needsArrowReturnParens: false,
+                        needsWrappedFunction: true
+                    });
+                    right = ')';
+                }
+                return {
+                    helper,
+                    mechanism: { left, right }
+                };
+            }
+            case 'amd': {
+                const resolve = compact ? 'c' : 'resolve';
+                const reject = compact ? 'e' : 'reject';
+                const helper = getInteropHelper(resolution, exportMode, interop);
+                const [resolveLeft, resolveRight] = getDirectReturnFunction(['m'], {
+                    functionReturn: false,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                const resolveNamespace = helper
+                    ? `${resolveLeft}${resolve}(/*#__PURE__*/${helper}(m))${resolveRight}`
+                    : resolve;
+                const [handlerLeft, handlerRight] = getDirectReturnFunction([resolve, reject], {
+                    functionReturn: false,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                let left = `new Promise(${handlerLeft}require([`;
+                let right = `],${_}${resolveNamespace},${_}${reject})${handlerRight})`;
+                if (!arrowFunctions && hasDynamicTarget) {
+                    left = getDirectReturnIifeLeft(['t'], `${left}t${right}`, {
+                        needsArrowReturnParens: false,
+                        needsWrappedFunction: true
+                    });
+                    right = ')';
+                }
+                return {
+                    helper,
+                    mechanism: { left, right }
+                };
+            }
+            case 'system': {
+                return {
+                    helper: null,
+                    mechanism: {
+                        left: 'module.import(',
+                        right: ')'
+                    }
+                };
+            }
+        }
+        return { helper: null, mechanism: null };
+    }
+}
+function getInteropHelper(resolution, exportMode, interop) {
+    return exportMode === 'external'
+        ? namespaceInteropHelpersByInteropType[interop(resolution instanceof ExternalModule ? resolution.id : null)]
+        : exportMode === 'default'
+            ? INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE
+            : null;
+}
+const accessedImportGlobals = {
+    amd: ['require'],
+    cjs: ['require'],
+    system: ['module']
+};
+function getDeterministicObjectDestructure(objectPattern) {
+    const variables = [];
+    for (const property of objectPattern.properties) {
+        if (property.type === 'RestElement' || property.computed || property.key.type !== 'Identifier')
+            return;
+        variables.push(property.key.name);
+    }
+    return variables;
+}
+
+class ImportNamespaceSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class ImportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class JSXIdentifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.isNativeElement = false;
+    }
+    bind() {
+        const type = this.getType();
+        if (type === 0 /* IdentifierType.Reference */) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+        }
+        else if (type === 1 /* IdentifierType.NativeElementName */) {
+            this.isNativeElement = true;
+        }
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+            }
+        }
+        else if (this.isNativeElement &&
+            this.scope.context.options.jsx.mode !== 'preserve') {
+            code.update(this.start, this.end, JSON.stringify(this.name));
+        }
+    }
+    getType() {
+        switch (this.parent.type) {
+            case 'JSXOpeningElement':
+            case 'JSXClosingElement': {
+                return this.name.startsWith(this.name.charAt(0).toUpperCase())
+                    ? 0 /* IdentifierType.Reference */
+                    : 1 /* IdentifierType.NativeElementName */;
+            }
+            case 'JSXMemberExpression': {
+                return this.parent.object === this
+                    ? 0 /* IdentifierType.Reference */
+                    : 2 /* IdentifierType.Other */;
+            }
+            case 'JSXAttribute':
+            case 'JSXNamespacedName': {
+                return 2 /* IdentifierType.Other */;
+            }
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Unexpected parent node type for JSXIdentifier: ${this.parent.type}`);
+            }
+        }
+    }
+}
+
+class JSXAttribute extends NodeBase {
+    render(code, options, { jsxMode } = BLANK) {
+        super.render(code, options);
+        if (['classic', 'automatic'].includes(jsxMode)) {
+            const { name, value } = this;
+            const key = name instanceof JSXIdentifier ? name.name : `${name.namespace.name}:${name.name.name}`;
+            if (!(jsxMode === 'automatic' && key === 'key')) {
+                const safeKey = stringifyObjectKeyIfNeeded(key);
+                if (key !== safeKey) {
+                    code.overwrite(name.start, name.end, safeKey, { contentOnly: true });
+                }
+                if (value) {
+                    code.overwrite(name.end, value.start, ': ', { contentOnly: true });
+                }
+                else {
+                    code.appendLeft(name.end, ': true');
+                }
+            }
+        }
+    }
+}
+
+class JSXClosingBase extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, ')', { contentOnly: true });
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
+class JSXClosingElement extends JSXClosingBase {
+}
+
+class JSXClosingFragment extends JSXClosingBase {
+}
+
+class JSXSpreadAttribute extends NodeBase {
+    render(code, options) {
+        this.argument.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.argument.start, '', { contentOnly: true });
+            code.overwrite(this.argument.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXEmptyExpression extends NodeBase {
+}
+
+class JSXExpressionContainer extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.remove(this.start, this.expression.start);
+            code.remove(this.expression.end, this.end);
+        }
+        this.expression.render(code, options);
+    }
+}
+
+function getRenderedJsxChildren(children) {
+    let renderedChildren = 0;
+    for (const child of children) {
+        if (!(child instanceof JSXExpressionContainer && child.expression instanceof JSXEmptyExpression)) {
+            renderedChildren++;
+        }
+    }
+    return renderedChildren;
+}
+
+function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
+    const [baseName, nestedName] = factory.split('.');
+    let factoryVariable;
+    if (importSource) {
+        factoryVariable = node.scope.context.getImportedJsxFactoryVariable(nestedName ? 'default' : baseName, node.start, importSource);
+        if (preserve) {
+            // This pretends we are accessing an included global variable of the same name
+            const globalVariable = node.scope.findGlobal(baseName);
+            globalVariable.include();
+            // This excludes this variable from renaming
+            factoryVariable.globalName = baseName;
+        }
+    }
+    else {
+        factoryVariable = node.scope.findGlobal(baseName);
+    }
+    node.scope.context.includeVariableInModule(factoryVariable);
+    if (factoryVariable instanceof LocalVariable) {
+        factoryVariable.consolidateInitializers();
+        factoryVariable.addUsedPlace(node);
+        node.scope.context.requestTreeshakingPass();
+    }
+    return factoryVariable;
+}
+
+class JSXElementBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.factoryVariable = null;
+        this.factory = null;
+    }
+    initialise() {
+        super.initialise();
+        const { importSource } = (this.jsxMode = this.getRenderingMode());
+        if (importSource) {
+            this.scope.context.addImportSource(importSource);
+        }
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const { factory, importSource, mode } = this.jsxMode;
+            if (factory) {
+                this.factory = factory;
+                this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this);
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    applyDeoptimizations() { }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            return {
+                factory: getRenderedJsxChildren(this.children) > 1 ? 'jsxs' : 'jsx',
+                importSource: jsx.jsxImportSource,
+                mode
+            };
+        }
+        return { factory, importSource, mode };
+    }
+    renderChildren(code, options, openingEnd) {
+        const { children } = this;
+        let hasMultipleChildren = false;
+        let childrenEnd = openingEnd;
+        let firstChild = null;
+        for (const child of children) {
+            if (child instanceof JSXExpressionContainer &&
+                child.expression instanceof JSXEmptyExpression) {
+                code.remove(childrenEnd, child.end);
+            }
+            else {
+                code.appendLeft(childrenEnd, ', ');
+                child.render(code, options);
+                if (firstChild) {
+                    hasMultipleChildren = true;
+                }
+                else {
+                    firstChild = child;
+                }
+            }
+            childrenEnd = child.end;
+        }
+        return { childrenEnd, firstChild, hasMultipleChildren };
+    }
+}
+
+class JSXElement extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            // In the case there is a key after a spread attribute, we fall back to
+            // classic mode, see https://github.com/facebook/react/issues/20031#issuecomment-710346866
+            // for reasoning.
+            let hasSpread = false;
+            for (const attribute of this.openingElement.attributes) {
+                if (attribute instanceof JSXSpreadAttribute) {
+                    hasSpread = true;
+                }
+                else if (hasSpread && attribute.name.name === 'key') {
+                    return { factory, importSource, mode: 'classic' };
+                }
+            }
+        }
+        return super.getRenderingMode();
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factory, factoryVariable, openingElement: { end: openingEnd, selfClosing } } = this;
+        const [, ...nestedName] = factory.split('.');
+        const { firstAttribute, hasAttributes, hasSpread, inObject, previousEnd } = this.renderAttributes(code, options, [factoryVariable.getName(getPropertyAccess, useOriginalName), ...nestedName].join('.'), false);
+        this.wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, 'null', previousEnd);
+        this.renderChildren(code, options, openingEnd);
+        if (selfClosing) {
+            code.appendLeft(end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factoryVariable, openingElement: { end: openindEnd, selfClosing } } = this;
+        let { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd } = this.renderAttributes(code, options, factoryVariable.getName(getPropertyAccess, useOriginalName), true);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openindEnd);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `children: ${hasMultipleChildren ? '[' : ''}`);
+            if (!inObject) {
+                code.prependRight(firstChild.start, '{ ');
+                inObject = true;
+            }
+            previousEnd = closingElement.start;
+            if (hasMultipleChildren) {
+                code.appendLeft(previousEnd, ']');
+            }
+        }
+        this.wrapAttributes(code, inObject, hasAttributes || !!firstChild, hasSpread, firstAttribute || firstChild, '{}', childrenEnd);
+        if (keyAttribute) {
+            const { value } = keyAttribute;
+            // This will appear to the left of the moved code...
+            code.appendLeft(childrenEnd, ', ');
+            if (value) {
+                code.move(value.start, value.end, childrenEnd);
+            }
+            else {
+                code.appendLeft(childrenEnd, 'true');
+            }
+        }
+        if (selfClosing) {
+            // Moving the key attribute will also move the parenthesis to the right position
+            code.appendLeft(keyAttribute?.value?.end || end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAttributes(code, options, factoryName, extractKeyAttribute) {
+        const { jsxMode: { mode }, openingElement } = this;
+        const { attributes, end: openingEnd, start: openingStart, name: { start: nameStart, end: nameEnd } } = openingElement;
+        code.update(openingStart, nameStart, `/*#__PURE__*/${factoryName}(`);
+        openingElement.render(code, options, { jsxMode: mode });
+        let keyAttribute = null;
+        let hasSpread = false;
+        let inObject = false;
+        let previousEnd = nameEnd;
+        let hasAttributes = false;
+        let firstAttribute = null;
+        for (const attribute of attributes) {
+            if (attribute instanceof JSXAttribute) {
+                if (extractKeyAttribute && attribute.name.name === 'key') {
+                    keyAttribute = attribute;
+                    code.remove(previousEnd, attribute.value?.start || attribute.end);
+                    continue;
+                }
+                code.appendLeft(previousEnd, ',');
+                if (!inObject) {
+                    code.prependRight(attribute.start, '{ ');
+                    inObject = true;
+                }
+                hasAttributes = true;
+            }
+            else {
+                if (inObject) {
+                    if (hasAttributes) {
+                        code.appendLeft(previousEnd, ' ');
+                    }
+                    code.appendLeft(previousEnd, '},');
+                    inObject = false;
+                }
+                else {
+                    code.appendLeft(previousEnd, ',');
+                }
+                hasSpread = true;
+            }
+            previousEnd = attribute.end;
+            if (!firstAttribute) {
+                firstAttribute = attribute;
+            }
+        }
+        code.remove(attributes.at(-1)?.end || previousEnd, openingEnd);
+        return { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd };
+    }
+    wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, missingAttributesFallback, attributesEnd) {
+        if (inObject) {
+            code.appendLeft(attributesEnd, ' }');
+        }
+        if (hasSpread) {
+            if (hasAttributes) {
+                const { start } = firstAttribute;
+                if (firstAttribute instanceof JSXSpreadAttribute) {
+                    code.prependRight(start, '{}, ');
+                }
+                code.prependRight(start, 'Object.assign(');
+                code.appendLeft(attributesEnd, ')');
+            }
+        }
+        else if (!hasAttributes) {
+            code.appendLeft(attributesEnd, `, ${missingAttributesFallback}`);
+        }
+    }
+}
+
+class JSXFragment extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factory, factoryVariable, openingFragment, start } = this;
+        const [, ...nestedName] = factory.split('.');
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${[
+            factoryVariable.getName(getPropertyAccess, useOriginalName),
+            ...nestedName
+        ].join('.')}(`);
+        code.appendLeft(openingFragment.end, ', null');
+        this.renderChildren(code, options, openingFragment.end);
+        closingFragment.render(code, options);
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factoryVariable, openingFragment, start } = this;
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${factoryVariable.getName(getPropertyAccess, useOriginalName)}(`);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openingFragment.end);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `{ children: ${hasMultipleChildren ? '[' : ''}`);
+            if (hasMultipleChildren) {
+                code.appendLeft(closingFragment.start, ']');
+            }
+            code.appendLeft(childrenEnd, ' }');
+        }
+        else {
+            code.appendLeft(openingFragment.end, ', {}');
+        }
+        closingFragment.render(code, options);
+    }
+}
+
+class JSXMemberExpression extends NodeBase {
+}
+
+class JSXNamespacedName extends NodeBase {
+}
+
+class JSXOpeningElement extends NodeBase {
+    render(code, options, { jsxMode = this.scope.context.options.jsx.mode } = {}) {
+        this.name.render(code, options);
+        for (const attribute of this.attributes) {
+            attribute.render(code, options, { jsxMode });
+        }
+    }
+}
+
+class JSXOpeningFragment extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.fragment = null;
+        this.fragmentVariable = null;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const jsx = this.scope.context.options.jsx;
+            if (jsx.mode === 'automatic') {
+                this.fragment = 'Fragment';
+                this.fragmentVariable = getAndIncludeFactoryVariable('Fragment', false, jsx.jsxImportSource, this);
+            }
+            else {
+                const { fragment, importSource, mode } = jsx;
+                if (fragment != null) {
+                    this.fragment = fragment;
+                    this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === 'preserve', importSource, this);
+                }
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            const { snippets: { getPropertyAccess }, useOriginalName } = options;
+            const [, ...nestedFragment] = this.fragment.split('.');
+            const fragment = [
+                this.fragmentVariable.getName(getPropertyAccess, useOriginalName),
+                ...nestedFragment
+            ].join('.');
+            code.update(this.start, this.end, fragment);
+        }
+    }
+}
+
+class JSXSpreadChild extends NodeBase {
+    render(code, options) {
+        super.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.expression.start, '...', { contentOnly: true });
+            code.overwrite(this.expression.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXText extends NodeBase {
+    render(code) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, JSON.stringify(this.value), {
+                contentOnly: true
+            });
+        }
+    }
+}
+
+class LabeledStatement extends NodeBase {
+    hasEffects(context) {
+        const { brokenFlow, includedLabels } = context;
+        context.ignore.labels.add(this.label.name);
+        context.includedLabels = new Set();
+        let bodyHasEffects = false;
+        if (this.body.hasEffects(context)) {
+            bodyHasEffects = true;
+        }
+        else {
+            context.ignore.labels.delete(this.label.name);
+            if (context.includedLabels.has(this.label.name)) {
+                context.includedLabels.delete(this.label.name);
+                context.brokenFlow = brokenFlow;
+            }
+        }
+        context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
+        return bodyHasEffects;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const { brokenFlow, includedLabels } = context;
+        context.includedLabels = new Set();
+        this.body.include(context, includeChildrenRecursively);
+        if (includeChildrenRecursively || context.includedLabels.has(this.label.name)) {
+            this.label.include();
+            context.includedLabels.delete(this.label.name);
+            context.brokenFlow = brokenFlow;
+        }
+        context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
+    }
+    render(code, options) {
+        if (this.label.included) {
+            this.label.render(code, options);
+        }
+        else {
+            code.remove(this.start, findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1));
+        }
+        this.body.render(code, options);
+    }
+}
+
+class LogicalExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        // We collect deoptimization information if usedBranch !== null
+        this.expressionsToBeDeoptimized = [];
+        this.usedBranch = null;
+    }
+    //private isBranchResolutionAnalysed = false;
+    get isBranchResolutionAnalysed() {
+        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
+    set isBranchResolutionAnalysed(value) {
+        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.left.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        this.right.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        if (this.usedBranch) {
+            const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { scope: { context }, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            // Request another pass because we need to ensure "include" runs again if
+            // it is rendered
+            context.requestTreeshakingPass();
+        }
+    }
+    deoptimizePath(path) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
+        }
+        else {
+            this.left.deoptimizePath(path);
+            this.right.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (this.left.hasEffects(context)) {
+            return true;
+        }
+        if (this.getUsedBranch() !== this.left) {
+            return this.right.hasEffects(context);
+        }
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return (this.left.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.right.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const usedBranch = this.getUsedBranch();
+        if (includeChildrenRecursively ||
+            (usedBranch === this.right && this.left.shouldBeIncluded(context)) ||
+            !usedBranch) {
+            this.left.include(context, includeChildrenRecursively);
+            this.right.include(context, includeChildrenRecursively);
+        }
+        else {
+            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
+        if (!this.left.included || !this.right.included) {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
+            if (this.right.included) {
+                const removePos = findNonWhiteSpace(code.original, operatorPos + 2);
+                code.remove(this.start, removePos);
+                if (preventASI) {
+                    removeLineBreaks(code, removePos, this.right.start);
+                }
+                this.left.removeAnnotations(code);
+            }
+            else {
+                code.remove(findLastWhiteSpaceReverse(code.original, this.left.end, operatorPos), this.end);
+            }
+            this.getUsedBranch().render(code, options, {
+                isCalleeOfRenderedParent,
+                preventASI,
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            });
+        }
+        else {
+            this.left.render(code, options, {
+                preventASI,
+                renderedSurroundingElement
+            });
+            this.right.render(code, options);
+        }
+    }
+    getUsedBranch() {
+        if (!this.isBranchResolutionAnalysed) {
+            this.isBranchResolutionAnalysed = true;
+            const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            if (typeof leftValue === 'symbol') {
+                return null;
+            }
+            else {
+                this.usedBranch =
+                    (this.operator === '||' && leftValue) ||
+                        (this.operator === '&&' && !leftValue) ||
+                        (this.operator === '??' && leftValue != null)
+                        ? this.left
+                        : this.right;
+            }
+        }
+        return this.usedBranch;
+    }
+}
+
+class NewExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        if (this.annotationPure) {
+            return false;
+        }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 0 || type !== INTERACTION_ACCESSED;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
+    initialise() {
+        super.initialise();
+        this.interaction = {
+            args: [null, ...this.arguments],
+            type: INTERACTION_CALLED,
+            withNew: true
+        };
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
+    render(code, options) {
+        this.callee.render(code, options);
+        renderCallArguments(code, options, this);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ObjectExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        this.getObjectEntity().deoptimizeAllProperties();
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    render(code, options, { renderedSurroundingElement } = BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === ExpressionStatement$1 ||
+            renderedSurroundingElement === ArrowFunctionExpression$1) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+    applyDeoptimizations() { }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        let prototype = OBJECT_PROTOTYPE;
+        const properties = [];
+        for (const property of this.properties) {
+            if (property instanceof SpreadElement) {
+                properties.push({ key: UnknownKey, kind: 'init', property });
+                continue;
+            }
+            let key;
+            if (property.computed) {
+                const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                if (typeof keyValue === 'symbol') {
+                    properties.push({ key: UnknownKey, kind: property.kind, property });
+                    continue;
+                }
+                else {
+                    key = String(keyValue);
+                }
+            }
+            else {
+                key =
+                    property.key instanceof Identifier
+                        ? property.key.name
+                        : String(property.key.value);
+                if (key === '__proto__' && property.kind === 'init') {
+                    prototype =
+                        property.value instanceof Literal && property.value.value === null
+                            ? null
+                            : property.value;
+                    continue;
+                }
+            }
+            properties.push({ key, kind: property.kind, property });
+        }
+        return (this.objectEntity = new ObjectEntity(properties, prototype));
+    }
+}
+
+class PanicError extends NodeBase {
+    initialise() {
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = getRollupError(logParseError(this.message));
+        const moduleParseError = logModuleParseError(parseError, id);
+        return error(moduleParseError);
+    }
+}
+
+class ParseError extends NodeBase {
+    initialise() {
+        const pos = this.start;
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = getRollupError(logParseError(this.message, pos));
+        const moduleParseError = logModuleParseError(parseError, id);
+        this.scope.context.error(moduleParseError, pos);
+    }
+}
+
+class PrivateIdentifier extends NodeBase {
+}
+
+class Program extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.hasCachedEffect = null;
+        this.hasLoggedEffect = false;
+    }
+    hasCachedEffects() {
+        if (!this.included) {
+            return false;
+        }
+        return this.hasCachedEffect === null
+            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
+            : this.hasCachedEffect;
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context)) {
+                if (this.scope.context.options.experimentalLogSideEffects && !this.hasLoggedEffect) {
+                    this.hasLoggedEffect = true;
+                    const { code, log, module } = this.scope.context;
+                    log(LOGLEVEL_INFO, logFirstSideEffect(code, module.id, locate(code, node.start, { offsetLine: 1 })), node.start);
+                }
+                return (this.hasCachedEffect = true);
+            }
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context)) {
+                node.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        if (this.invalidAnnotations)
+            for (const { start, end, type } of this.invalidAnnotations) {
+                this.scope.context.magicString.remove(start, end);
+                if (type === 'pure' || type === 'noSideEffects') {
+                    this.scope.context.log(LOGLEVEL_WARN, logInvalidAnnotation(this.scope.context.code.slice(start, end), this.scope.context.module.id, type), start);
+                }
+            }
+    }
+    render(code, options) {
+        let start = this.start;
+        if (code.original.startsWith('#!')) {
+            start = Math.min(code.original.indexOf('\n') + 1, this.end);
+            code.remove(0, start);
+        }
+        if (this.body.length > 0) {
+            // Keep all consecutive lines that start with a comment
+            while (code.original[start] === '/' && /[*/]/.test(code.original[start + 1])) {
+                const firstLineBreak = findFirstLineBreakOutsideComment(code.original.slice(start, this.body[0].start));
+                if (firstLineBreak[0] === -1) {
+                    break;
+                }
+                start += firstLineBreak[1];
+            }
+            renderStatementList(this.body, code, start, this.end, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+    applyDeoptimizations() { }
+}
+
+class Property extends MethodBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
+    //declare method: boolean;
+    get method() {
+        return isFlagSet(this.flags, 262144 /* Flag.method */);
+    }
+    set method(value) {
+        this.flags = setFlag(this.flags, 262144 /* Flag.method */, value);
+    }
+    //declare shorthand: boolean;
+    get shorthand() {
+        return isFlagSet(this.flags, 524288 /* Flag.shorthand */);
+    }
+    set shorthand(value) {
+        this.flags = setFlag(this.flags, 524288 /* Flag.shorthand */, value);
+    }
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.value.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const propertyReadSideEffects = this.scope.context.options.treeshake.propertyReadSideEffects;
+        return ((this.parent.type === 'ObjectPattern' && propertyReadSideEffects === 'always') ||
+            this.key.hasEffects(context) ||
+            this.value.hasEffects(context));
+    }
+    markDeclarationReached() {
+        this.value.markDeclarationReached();
+    }
+    render(code, options) {
+        if (!this.shorthand) {
+            this.key.render(code, options);
+        }
+        this.value.render(code, options, { isShorthandProperty: this.shorthand });
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class PropertyDefinition extends NodeBase {
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.value?.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.value?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.value
+            ? this.value.getLiteralValueAtPath(path, recursionTracker, origin)
+            : UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.value
+            ? this.value.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
+            : UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffects(context) {
+        return (this.key.hasEffects(context) ||
+            (this.static && !!this.value?.hasEffects(context)) ||
+            checkEffectForNodes(this.decorators, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return !this.value || this.value.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() { }
+}
+
+class ReturnStatement extends NodeBase {
+    hasEffects(context) {
+        if (!context.ignore.returnYield || this.argument?.hasEffects(context))
+            return true;
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.argument?.include(context, includeChildrenRecursively);
+        context.brokenFlow = true;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.addReturnExpression(this.argument || UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        if (this.argument) {
+            this.argument.render(code, options, { preventASI: true });
+            if (this.argument.start === this.start + 6 /* 'return'.length */) {
+                code.prependLeft(this.start + 6, ' ');
+            }
+        }
+    }
+}
+
+class SequenceExpression extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.expressions[this.expressions.length - 1].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.expressions[this.expressions.length - 1].deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.expressions[this.expressions.length - 1].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        for (const expression of this.expressions) {
+            if (expression.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.expressions[this.expressions.length - 1].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const lastExpression = this.expressions[this.expressions.length - 1];
+        for (const expression of this.expressions) {
+            if (includeChildrenRecursively ||
+                (expression === lastExpression && !(this.parent instanceof ExpressionStatement)) ||
+                expression.shouldBeIncluded(context))
+                expression.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.expressions[0].removeAnnotations(code);
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
+        let includedNodes = 0;
+        let lastSeparatorPos = null;
+        const lastNode = this.expressions[this.expressions.length - 1];
+        for (const { node, separator, start, end } of getCommaSeparatedNodesWithBoundaries(this.expressions, code, this.start, this.end)) {
+            if (!node.included) {
+                treeshakeNode(node, code, start, end);
+                continue;
+            }
+            includedNodes++;
+            lastSeparatorPos = separator;
+            if (includedNodes === 1 && preventASI) {
+                removeLineBreaks(code, start, node.start);
+            }
+            if (includedNodes === 1) {
+                const parentType = renderedParentType || this.parent.type;
+                node.render(code, options, {
+                    isCalleeOfRenderedParent: isCalleeOfRenderedParent && node === lastNode,
+                    renderedParentType: parentType,
+                    renderedSurroundingElement: parentType
+                });
+            }
+            else {
+                node.render(code, options);
+            }
+        }
+        if (lastSeparatorPos) {
+            code.remove(lastSeparatorPos, this.end);
+        }
+    }
+}
+
+class Super extends NodeBase {
+    bind() {
+        this.variable = this.scope.findVariable('this');
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.variable.deoptimizePath(path);
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+}
+
+class SwitchCase extends NodeBase {
+    hasEffects(context) {
+        if (this.test?.hasEffects(context))
+            return true;
+        for (const node of this.consequent) {
+            if (context.brokenFlow)
+                break;
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test?.include(context, includeChildrenRecursively);
+        for (const node of this.consequent) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options, nodeRenderOptions) {
+        if (this.consequent.length > 0) {
+            if (this.test) {
+                this.test.render(code, options);
+            }
+            const testEnd = this.test
+                ? this.test.end
+                : findFirstOccurrenceOutsideComment(code.original, 'default', this.start) + 7;
+            const consequentStart = findFirstOccurrenceOutsideComment(code.original, ':', testEnd) + 1;
+            renderStatementList(this.consequent, code, consequentStart, nodeRenderOptions.end, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+SwitchCase.prototype.needsBoundaries = true;
+
+class SwitchStatement extends NodeBase {
+    createScope(parentScope) {
+        this.parentScope = parentScope;
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.discriminant.hasEffects(context))
+            return true;
+        const { brokenFlow, hasBreak, ignore } = context;
+        const { breaks } = ignore;
+        ignore.breaks = true;
+        context.hasBreak = false;
+        let onlyHasBrokenFlow = true;
+        for (const switchCase of this.cases) {
+            if (switchCase.hasEffects(context))
+                return true;
+            onlyHasBrokenFlow &&= context.brokenFlow && !context.hasBreak;
+            context.hasBreak = false;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.defaultCase !== null) {
+            context.brokenFlow = onlyHasBrokenFlow;
+        }
+        ignore.breaks = breaks;
+        context.hasBreak = hasBreak;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.discriminant.include(context, includeChildrenRecursively);
+        const { brokenFlow, hasBreak } = context;
+        context.hasBreak = false;
+        let onlyHasBrokenFlow = true;
+        let isCaseIncluded = includeChildrenRecursively ||
+            (this.defaultCase !== null && this.defaultCase < this.cases.length - 1);
+        for (let caseIndex = this.cases.length - 1; caseIndex >= 0; caseIndex--) {
+            const switchCase = this.cases[caseIndex];
+            if (switchCase.included) {
+                isCaseIncluded = true;
+            }
+            if (!isCaseIncluded) {
+                const hasEffectsContext = createHasEffectsContext();
+                hasEffectsContext.ignore.breaks = true;
+                isCaseIncluded = switchCase.hasEffects(hasEffectsContext);
+            }
+            if (isCaseIncluded) {
+                switchCase.include(context, includeChildrenRecursively);
+                onlyHasBrokenFlow &&= context.brokenFlow && !context.hasBreak;
+                context.hasBreak = false;
+                context.brokenFlow = brokenFlow;
+            }
+            else {
+                onlyHasBrokenFlow = brokenFlow;
+            }
+        }
+        if (isCaseIncluded && this.defaultCase !== null) {
+            context.brokenFlow = onlyHasBrokenFlow;
+        }
+        context.hasBreak = hasBreak;
+    }
+    initialise() {
+        super.initialise();
+        for (let caseIndex = 0; caseIndex < this.cases.length; caseIndex++) {
+            if (this.cases[caseIndex].test === null) {
+                this.defaultCase = caseIndex;
+                return;
+            }
+        }
+        this.defaultCase = null;
+    }
+    parseNode(esTreeNode) {
+        this.discriminant = new (this.scope.context.getNodeConstructor(esTreeNode.discriminant.type))(this, this.parentScope).parseNode(esTreeNode.discriminant);
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        this.discriminant.render(code, options);
+        if (this.cases.length > 0) {
+            renderStatementList(this.cases, code, this.cases[0].start, this.end - 1, options);
+        }
+    }
+}
+
+class TaggedTemplateExpression extends CallExpressionBase {
+    bind() {
+        super.bind();
+        if (this.tag.type === Identifier$1) {
+            const name = this.tag.name;
+            const variable = this.scope.findVariable(name);
+            if (variable.isNamespace) {
+                this.scope.context.log(LOGLEVEL_WARN, logCannotCallNamespace(name), this.start);
+            }
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.quasi.expressions) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (this.tag.hasEffects(context) ||
+            this.tag.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.tag.include(context, includeChildrenRecursively);
+            this.quasi.include(context, includeChildrenRecursively);
+        }
+        this.tag.includeCallArguments(context, this.args);
+        const [returnExpression] = this.getReturnExpression();
+        if (!returnExpression.included) {
+            returnExpression.include(context, false);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.args = [UNKNOWN_EXPRESSION, ...this.quasi.expressions];
+        this.interaction = {
+            args: [
+                this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
+                ...this.args
+            ],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
+    }
+    render(code, options) {
+        this.tag.render(code, options, { isCalleeOfRenderedParent: true });
+        this.quasi.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.tag.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
+}
+
+class TemplateElement extends NodeBase {
+    get tail() {
+        return isFlagSet(this.flags, 1048576 /* Flag.tail */);
+    }
+    set tail(value) {
+        this.flags = setFlag(this.flags, 1048576 /* Flag.tail */, value);
+    }
+    // Do not try to bind value
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    include() {
+        this.included = true;
+    }
+    parseNode(esTreeNode) {
+        this.value = esTreeNode.value;
+        return super.parseNode(esTreeNode);
+    }
+    render() { }
+}
+
+class TemplateLiteral extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath() { }
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 || this.quasis.length !== 1) {
+            return UnknownValue;
+        }
+        return this.quasis[0].value.cooked;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+    render(code, options) {
+        code.indentExclusionRanges.push([this.start, this.end]);
+        super.render(code, options);
+    }
+}
+
+class ModuleScope extends ChildScope {
+    constructor(parent, context) {
+        super(parent, context);
+        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, 'other'));
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (this.context.module.importDescriptions.has(identifier.name)) {
+            context.error(logRedeclarationError(identifier.name), identifier.start);
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+    addExportDefaultDeclaration(name, exportDefaultDeclaration, context) {
+        const variable = new ExportDefaultVariable(name, exportDefaultDeclaration, context);
+        this.variables.set('default', variable);
+        return variable;
+    }
+    addNamespaceMemberAccess() { }
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        // all module level variables are already deconflicted when deconflicting the chunk
+        for (const scope of this.children)
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
+        }
+        const variable = this.context.traceVariable(name) || this.parent.findVariable(name);
+        if (variable instanceof GlobalVariable) {
+            this.accessedOutsideVariables.set(name, variable);
+        }
+        return variable;
+    }
+}
+
+class ThisExpression extends NodeBase {
+    bind() {
+        this.variable = this.scope.findVariable('this');
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.variable.deoptimizePath(path);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length === 0) {
+            return interaction.type !== INTERACTION_ACCESSED;
+        }
+        return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.alias =
+            this.scope.findLexicalBoundary() instanceof ModuleScope
+                ? this.scope.context.moduleContext
+                : null;
+        if (this.alias === 'undefined') {
+            this.scope.context.log(LOGLEVEL_WARN, logThisIsUndefined(), this.start);
+        }
+    }
+    render(code) {
+        if (this.alias !== null) {
+            code.overwrite(this.start, this.end, this.alias, {
+                contentOnly: false,
+                storeName: true
+            });
+        }
+    }
+}
+
+class ThrowStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.argument.include(context, includeChildrenRecursively);
+        context.brokenFlow = true;
+    }
+    render(code, options) {
+        this.argument.render(code, options, { preventASI: true });
+        if (this.argument.start === this.start + 5 /* 'throw'.length */) {
+            code.prependLeft(this.start + 5, ' ');
+        }
+    }
+}
+
+class TryStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.directlyIncluded = false;
+        this.includedLabelsAfterBlock = null;
+    }
+    hasEffects(context) {
+        return ((this.scope.context.options.treeshake.tryCatchDeoptimization
+            ? this.block.body.length > 0
+            : this.block.hasEffects(context)) || !!this.finalizer?.hasEffects(context));
+    }
+    include(context, includeChildrenRecursively) {
+        const tryCatchDeoptimization = this.scope.context.options.treeshake?.tryCatchDeoptimization;
+        const { brokenFlow, includedLabels } = context;
+        if (!this.directlyIncluded || !tryCatchDeoptimization) {
+            this.included = true;
+            this.directlyIncluded = true;
+            this.block.include(context, tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively);
+            if (includedLabels.size > 0) {
+                this.includedLabelsAfterBlock = [...includedLabels];
+            }
+            context.brokenFlow = brokenFlow;
+        }
+        else if (this.includedLabelsAfterBlock) {
+            for (const label of this.includedLabelsAfterBlock) {
+                includedLabels.add(label);
+            }
+        }
+        if (this.handler !== null) {
+            this.handler.include(context, includeChildrenRecursively);
+            context.brokenFlow = brokenFlow;
+        }
+        this.finalizer?.include(context, includeChildrenRecursively);
+    }
+}
+
+const unaryOperators = {
+    '!': value => !value,
+    '+': value => +value,
+    '-': value => -value,
+    delete: () => UnknownValue,
+    typeof: value => typeof value,
+    void: () => undefined,
+    '~': value => ~value
+};
+class UnaryExpression extends NodeBase {
+    get prefix() {
+        return isFlagSet(this.flags, 2097152 /* Flag.prefix */);
+    }
+    set prefix(value) {
+        this.flags = setFlag(this.flags, 2097152 /* Flag.prefix */, value);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length > 0)
+            return UnknownValue;
+        const argumentValue = this.argument.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof argumentValue === 'symbol')
+            return UnknownValue;
+        return unaryOperators[this.operator](argumentValue);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.operator === 'typeof' && this.argument instanceof Identifier)
+            return false;
+        return (this.argument.hasEffects(context) ||
+            (this.operator === 'delete' &&
+                this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)));
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.operator === 'void' ? 0 : 1);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.operator === 'delete') {
+            this.argument.deoptimizePath(EMPTY_PATH);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class UpdateExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return this.argument.hasEffectsAsAssignmentTarget(context, true);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
+    }
+    initialise() {
+        super.initialise();
+        this.argument.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, format, snippets: { _ } } = options;
+        this.argument.render(code, options);
+        if (format === 'system') {
+            const variable = this.argument.variable;
+            const exportNames = exportNamesByVariable.get(variable);
+            if (exportNames) {
+                if (this.prefix) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, this.start, this.end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options);
+                    }
+                }
+                else {
+                    const operator = this.operator[0];
+                    renderSystemExportSequenceBeforeExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options, `${_}${operator}${_}1`);
+                }
+            }
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.argument.deoptimizePath(EMPTY_PATH);
+        if (this.argument instanceof Identifier) {
+            const variable = this.scope.findVariable(this.argument.name);
+            variable.markReassigned();
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
+    for (const declarator of declarations) {
+        if (!declarator.id.included)
+            return false;
+        if (declarator.id.type === Identifier$1) {
+            if (exportNamesByVariable.has(declarator.id.variable))
+                return false;
+        }
+        else {
+            const exportedVariables = [];
+            declarator.id.addExportedVariables(exportedVariables, exportNamesByVariable);
+            if (exportedVariables.length > 0)
+                return false;
+        }
+    }
+    return true;
+}
+class VariableDeclaration extends NodeBase {
+    deoptimizePath() {
+        for (const declarator of this.declarations) {
+            declarator.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    hasEffectsOnInteractionAtPath() {
+        return false;
+    }
+    include(context, includeChildrenRecursively, { asSingleStatement } = BLANK) {
+        this.included = true;
+        for (const declarator of this.declarations) {
+            if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
+                declarator.include(context, includeChildrenRecursively);
+            const { id, init } = declarator;
+            if (asSingleStatement) {
+                id.include(context, includeChildrenRecursively);
+            }
+            if (init &&
+                id.included &&
+                !init.included &&
+                (id instanceof ObjectPattern || id instanceof ArrayPattern)) {
+                init.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.isUsingDeclaration = this.kind === 'await using' || this.kind === 'using';
+        for (const declarator of this.declarations) {
+            declarator.declareDeclarator(this.kind, this.isUsingDeclaration);
+        }
+    }
+    removeAnnotations(code) {
+        this.declarations[0].removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions = BLANK) {
+        if (this.isUsingDeclaration ||
+            areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
+            for (const declarator of this.declarations) {
+                declarator.render(code, options);
+            }
+            if (!nodeRenderOptions.isNoStatement &&
+                code.original.charCodeAt(this.end - 1) !== 59 /*";"*/) {
+                code.appendLeft(this.end, ';');
+            }
+        }
+        else {
+            this.renderReplacedDeclarations(code, options);
+        }
+    }
+    applyDeoptimizations() { }
+    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
+        if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
+            code.remove(this.end - 1, this.end);
+        }
+        separatorString += ';';
+        if (lastSeparatorPos === null) {
+            code.appendLeft(renderedContentEnd, separatorString);
+        }
+        else {
+            if (code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/ &&
+                (code.original.charCodeAt(this.end) === 10 /*"\n"*/ ||
+                    code.original.charCodeAt(this.end) === 13) /*"\r"*/) {
+                actualContentEnd--;
+                if (code.original.charCodeAt(actualContentEnd) === 13 /*"\r"*/) {
+                    actualContentEnd--;
+                }
+            }
+            if (actualContentEnd === lastSeparatorPos + 1) {
+                code.overwrite(lastSeparatorPos, renderedContentEnd, separatorString);
+            }
+            else {
+                code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
+                code.remove(actualContentEnd, renderedContentEnd);
+            }
+        }
+        if (systemPatternExports.length > 0) {
+            code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
+        }
+    }
+    renderReplacedDeclarations(code, options) {
+        const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.declarations, code, this.start + this.kind.length, this.end - (code.original.charCodeAt(this.end - 1) === 59 /*";"*/ ? 1 : 0));
+        let actualContentEnd, renderedContentEnd;
+        renderedContentEnd = findNonWhiteSpace(code.original, this.start + this.kind.length);
+        let lastSeparatorPos = renderedContentEnd - 1;
+        code.remove(this.start, lastSeparatorPos);
+        let isInDeclaration = false;
+        let hasRenderedContent = false;
+        let separatorString = '', leadingString, nextSeparatorString;
+        const aggregatedSystemExports = [];
+        const singleSystemExport = gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports);
+        for (const { node, start, separator, contentEnd, end } of separatedNodes) {
+            if (!node.included) {
+                code.remove(start, end);
+                node.removeAnnotations(code);
+                continue;
+            }
+            node.render(code, options);
+            leadingString = '';
+            nextSeparatorString = '';
+            if (!node.id.included ||
+                (node.id instanceof Identifier &&
+                    isReassignedExportsMember(node.id.variable, options.exportNamesByVariable))) {
+                if (hasRenderedContent) {
+                    separatorString += ';';
+                }
+                isInDeclaration = false;
+            }
+            else {
+                if (singleSystemExport && singleSystemExport === node.id.variable) {
+                    const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', node.id.end);
+                    renderSystemExportExpression(singleSystemExport, findNonWhiteSpace(code.original, operatorPos + 1), separator === null ? contentEnd : separator, code, options);
+                }
+                if (isInDeclaration) {
+                    separatorString += ',';
+                }
+                else {
+                    if (hasRenderedContent) {
+                        separatorString += ';';
+                    }
+                    leadingString += `${this.kind} `;
+                    isInDeclaration = true;
+                }
+            }
+            if (renderedContentEnd === lastSeparatorPos + 1) {
+                code.overwrite(lastSeparatorPos, renderedContentEnd, separatorString + leadingString);
+            }
+            else {
+                code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
+                code.appendLeft(renderedContentEnd, leadingString);
+            }
+            actualContentEnd = contentEnd;
+            renderedContentEnd = end;
+            hasRenderedContent = true;
+            lastSeparatorPos = separator;
+            separatorString = nextSeparatorString;
+        }
+        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, aggregatedSystemExports, options);
+    }
+}
+function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports) {
+    let singleSystemExport = null;
+    if (options.format === 'system') {
+        for (const { node } of separatedNodes) {
+            if (node.id instanceof Identifier &&
+                node.init &&
+                aggregatedSystemExports.length === 0 &&
+                options.exportNamesByVariable.get(node.id.variable)?.length === 1) {
+                singleSystemExport = node.id.variable;
+                aggregatedSystemExports.push(singleSystemExport);
+            }
+            else {
+                node.id.addExportedVariables(aggregatedSystemExports, options.exportNamesByVariable);
+            }
+        }
+        if (aggregatedSystemExports.length > 1) {
+            singleSystemExport = null;
+        }
+        else if (singleSystemExport) {
+            aggregatedSystemExports.length = 0;
+        }
+    }
+    return singleSystemExport;
+}
+
+class WhileStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
+
+class YieldExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return !(context.ignore.returnYield && !this.argument?.hasEffects(context));
+    }
+    render(code, options) {
+        if (this.argument) {
+            this.argument.render(code, options, { preventASI: true });
+            if (this.argument.start === this.start + 5 /* 'yield'.length */) {
+                code.prependLeft(this.start + 5, ' ');
+            }
+        }
+    }
+}
+
+// This file is generated by scripts/generate-buffer-parsers.js.
+// Do not edit this file directly.
+function convertProgram(buffer, parent, parentScope) {
+    return convertNode(parent, parentScope, 0, getAstBuffer(buffer));
+}
+const nodeTypeStrings = [
+    'PanicError',
+    'ParseError',
+    'ArrayExpression',
+    'ArrayPattern',
+    'ArrowFunctionExpression',
+    'AssignmentExpression',
+    'AssignmentPattern',
+    'AwaitExpression',
+    'BinaryExpression',
+    'BlockStatement',
+    'BreakStatement',
+    'CallExpression',
+    'CatchClause',
+    'ChainExpression',
+    'ClassBody',
+    'ClassDeclaration',
+    'ClassExpression',
+    'ConditionalExpression',
+    'ContinueStatement',
+    'DebuggerStatement',
+    'Decorator',
+    'ExpressionStatement',
+    'DoWhileStatement',
+    'EmptyStatement',
+    'ExportAllDeclaration',
+    'ExportDefaultDeclaration',
+    'ExportNamedDeclaration',
+    'ExportSpecifier',
+    'ExpressionStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'ForStatement',
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'Identifier',
+    'IfStatement',
+    'ImportAttribute',
+    'ImportDeclaration',
+    'ImportDefaultSpecifier',
+    'ImportExpression',
+    'ImportNamespaceSpecifier',
+    'ImportSpecifier',
+    'JSXAttribute',
+    'JSXClosingElement',
+    'JSXClosingFragment',
+    'JSXElement',
+    'JSXEmptyExpression',
+    'JSXExpressionContainer',
+    'JSXFragment',
+    'JSXIdentifier',
+    'JSXMemberExpression',
+    'JSXNamespacedName',
+    'JSXOpeningElement',
+    'JSXOpeningFragment',
+    'JSXSpreadAttribute',
+    'JSXSpreadChild',
+    'JSXText',
+    'LabeledStatement',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'LogicalExpression',
+    'MemberExpression',
+    'MetaProperty',
+    'MethodDefinition',
+    'NewExpression',
+    'ObjectExpression',
+    'ObjectPattern',
+    'PrivateIdentifier',
+    'Program',
+    'Property',
+    'PropertyDefinition',
+    'RestElement',
+    'ReturnStatement',
+    'SequenceExpression',
+    'SpreadElement',
+    'StaticBlock',
+    'Super',
+    'SwitchCase',
+    'SwitchStatement',
+    'TaggedTemplateExpression',
+    'TemplateElement',
+    'TemplateLiteral',
+    'ThisExpression',
+    'ThrowStatement',
+    'TryStatement',
+    'UnaryExpression',
+    'UpdateExpression',
+    'VariableDeclaration',
+    'VariableDeclarator',
+    'WhileStatement',
+    'YieldExpression'
+];
+const nodeConstructors$1 = [
+    PanicError,
+    ParseError,
+    ArrayExpression,
+    ArrayPattern,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    AssignmentPattern,
+    AwaitExpression,
+    BinaryExpression,
+    BlockStatement,
+    BreakStatement,
+    CallExpression,
+    CatchClause,
+    ChainExpression,
+    ClassBody,
+    ClassDeclaration,
+    ClassExpression,
+    ConditionalExpression,
+    ContinueStatement,
+    DebuggerStatement,
+    Decorator,
+    ExpressionStatement,
+    DoWhileStatement,
+    EmptyStatement,
+    ExportAllDeclaration,
+    ExportDefaultDeclaration,
+    ExportNamedDeclaration,
+    ExportSpecifier,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    FunctionExpression,
+    Identifier,
+    IfStatement,
+    ImportAttribute,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    ImportExpression,
+    ImportNamespaceSpecifier,
+    ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
+    LabeledStatement,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    MetaProperty,
+    MethodDefinition,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
+    RestElement,
+    ReturnStatement,
+    SequenceExpression,
+    SpreadElement,
+    StaticBlock,
+    Super,
+    SwitchCase,
+    SwitchStatement,
+    TaggedTemplateExpression,
+    TemplateElement,
+    TemplateLiteral,
+    ThisExpression,
+    ThrowStatement,
+    TryStatement,
+    UnaryExpression,
+    UpdateExpression,
+    VariableDeclaration,
+    VariableDeclarator,
+    WhileStatement,
+    YieldExpression
+];
+const bufferParsers = [
+    function panicError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
+    },
+    function parseError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
+    },
+    function arrayExpression(node, position, buffer) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function arrayPattern(node, position, buffer) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function arrowFunctionExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.expression = (flags & 2) === 2;
+        node.generator = (flags & 4) === 4;
+        const annotations = (node.annotations = convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer);
+    },
+    function assignmentExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function assignmentPattern(node, position, buffer) {
+        const { scope } = node;
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function awaitExpression(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function binaryExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function blockStatement(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function breakStatement(node, position, buffer) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
+    },
+    function callExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.optional = (flags & 1) === 1;
+        node.annotations = convertAnnotations(buffer[position + 1], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 2], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 3], buffer);
+    },
+    function catchClause(node, position, buffer) {
+        const { scope } = node;
+        const parameterPosition = buffer[position];
+        const parameter = (node.param =
+            parameterPosition === 0 ? null : convertNode(node, scope, parameterPosition, buffer));
+        parameter?.declare('parameter', UNKNOWN_EXPRESSION);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer);
+    },
+    function chainExpression(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function classBody(node, position, buffer) {
+        const { scope } = node;
+        const bodyPosition = buffer[position];
+        const body = (node.body = []);
+        if (bodyPosition) {
+            const length = buffer[bodyPosition];
+            for (let index = 0; index < length; index++) {
+                const nodePosition = buffer[bodyPosition + 1 + index];
+                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer));
+            }
+        }
+    },
+    function classDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
+        node.id =
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
+        node.superClass =
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function classExpression(node, position, buffer) {
+        const { scope } = node;
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
+        node.id = idPosition === 0 ? null : convertNode(node, scope, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
+        node.superClass =
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function conditionalExpression(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, scope, buffer[position + 1], buffer);
+        node.alternate = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function continueStatement(node, position, buffer) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
+    },
+    function debuggerStatement() { },
+    function decorator(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function directive(node, position, buffer) {
+        const { scope } = node;
+        node.directive = buffer.convertString(buffer[position]);
+        node.expression = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function doWhileStatement(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNode(node, scope, buffer[position], buffer);
+        node.test = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function emptyStatement() { },
+    function exportAllDeclaration(node, position, buffer) {
+        const { scope } = node;
+        const exportedPosition = buffer[position];
+        node.exported =
+            exportedPosition === 0 ? null : convertNode(node, scope, exportedPosition, buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function exportDefaultDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.declaration = convertNode(node, scope, buffer[position], buffer);
+    },
+    function exportNamedDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
+        const sourcePosition = buffer[position + 1];
+        node.source = sourcePosition === 0 ? null : convertNode(node, scope, sourcePosition, buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+        const declarationPosition = buffer[position + 3];
+        node.declaration =
+            declarationPosition === 0 ? null : convertNode(node, scope, declarationPosition, buffer);
+    },
+    function exportSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+        const exportedPosition = buffer[position + 1];
+        node.exported =
+            exportedPosition === 0 ? node.local : convertNode(node, scope, exportedPosition, buffer);
+    },
+    function expressionStatement(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function forInStatement(node, position, buffer) {
+        const { scope } = node;
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function forOfStatement(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.await = (flags & 1) === 1;
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function forStatement(node, position, buffer) {
+        const { scope } = node;
+        const initPosition = buffer[position];
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
+        const testPosition = buffer[position + 1];
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
+        const updatePosition = buffer[position + 2];
+        node.update = updatePosition === 0 ? null : convertNode(node, scope, updatePosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function functionDeclaration(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const annotations = (node.annotations = convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
+        node.id =
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
+    },
+    function functionExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const annotations = (node.annotations = convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
+        node.id = idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
+    },
+    function identifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function ifStatement(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position + 1], buffer);
+        const alternatePosition = buffer[position + 2];
+        node.alternate =
+            alternatePosition === 0
+                ? null
+                : convertNode(node, (node.alternateScope = new TrackingScope(scope)), alternatePosition, buffer);
+    },
+    function importAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.key = convertNode(node, scope, buffer[position], buffer);
+        node.value = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function importDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function importDefaultSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+    },
+    function importExpression(node, position, buffer) {
+        const { scope } = node;
+        node.source = convertNode(node, scope, buffer[position], buffer);
+        node.sourceAstNode = convertNode$1(buffer[position], buffer);
+        const optionsPosition = buffer[position + 1];
+        node.options = optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer);
+    },
+    function importNamespaceSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+    },
+    function importSpecifier(node, position, buffer) {
+        const { scope } = node;
+        const importedPosition = buffer[position];
+        node.local = convertNode(node, scope, buffer[position + 1], buffer);
+        node.imported =
+            importedPosition === 0 ? node.local : convertNode(node, scope, importedPosition, buffer);
+    },
+    function jsxAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+        const valuePosition = buffer[position + 1];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
+    },
+    function jsxClosingElement(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxClosingFragment() { },
+    function jsxElement(node, position, buffer) {
+        const { scope } = node;
+        node.openingElement = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        const closingElementPosition = buffer[position + 2];
+        node.closingElement =
+            closingElementPosition === 0
+                ? null
+                : convertNode(node, scope, closingElementPosition, buffer);
+    },
+    function jsxEmptyExpression() { },
+    function jsxExpressionContainer(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxFragment(node, position, buffer) {
+        const { scope } = node;
+        node.openingFragment = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.closingFragment = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function jsxMemberExpression(node, position, buffer) {
+        const { scope } = node;
+        node.object = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxNamespacedName(node, position, buffer) {
+        const { scope } = node;
+        node.namespace = convertNode(node, scope, buffer[position], buffer);
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxOpeningElement(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.selfClosing = (flags & 1) === 1;
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxOpeningFragment(node) {
+        node.attributes = [];
+        node.selfClosing = false;
+    },
+    function jsxSpreadAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxSpreadChild(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxText(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
+        node.raw = buffer.convertString(buffer[position + 1]);
+    },
+    function labeledStatement(node, position, buffer) {
+        const { scope } = node;
+        node.label = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function literalBigInt(node, position, buffer) {
+        const bigint = (node.bigint = buffer.convertString(buffer[position]));
+        node.raw = buffer.convertString(buffer[position + 1]);
+        node.value = BigInt(bigint);
+    },
+    function literalBoolean(node, position, buffer) {
+        const flags = buffer[position];
+        const value = (node.value = (flags & 1) === 1);
+        node.raw = value ? 'true' : 'false';
+    },
+    function literalNull(node) {
+        node.value = null;
+    },
+    function literalNumber(node, position, buffer) {
+        const rawPosition = buffer[position];
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
+        node.value = new DataView(buffer.buffer).getFloat64((position + 1) << 2, true);
+    },
+    function literalRegExp(node, position, buffer) {
+        const flags = buffer.convertString(buffer[position]);
+        const pattern = buffer.convertString(buffer[position + 1]);
+        node.raw = `/${pattern}/${flags}`;
+        node.regex = { flags, pattern };
+        node.value = new RegExp(pattern, flags);
+    },
+    function literalString(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
+        const rawPosition = buffer[position + 1];
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
+    },
+    function logicalExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function memberExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.computed = (flags & 1) === 1;
+        node.optional = (flags & 2) === 2;
+        node.object = convertNode(node, scope, buffer[position + 1], buffer);
+        node.property = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function metaProperty(node, position, buffer) {
+        const { scope } = node;
+        node.meta = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function methodDefinition(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        node.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        node.value = convertNode(node, scope, buffer[position + 3], buffer);
+        node.kind = FIXED_STRINGS[buffer[position + 4]];
+    },
+    function newExpression(node, position, buffer) {
+        const { scope } = node;
+        node.annotations = convertAnnotations(buffer[position], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 1], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function objectExpression(node, position, buffer) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function objectPattern(node, position, buffer) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function privateIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function program(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+        node.invalidAnnotations = convertAnnotations(buffer[position + 1], buffer);
+    },
+    function property(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.method = (flags & 1) === 1;
+        node.shorthand = (flags & 2) === 2;
+        node.computed = (flags & 4) === 4;
+        const keyPosition = buffer[position + 1];
+        node.value = convertNode(node, scope, buffer[position + 2], buffer);
+        node.kind = FIXED_STRINGS[buffer[position + 3]];
+        node.key = keyPosition === 0 ? node.value : convertNode(node, scope, keyPosition, buffer);
+    },
+    function propertyDefinition(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        node.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        const valuePosition = buffer[position + 3];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
+    },
+    function restElement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function returnStatement(node, position, buffer) {
+        const { scope } = node;
+        const argumentPosition = buffer[position];
+        node.argument =
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
+    },
+    function sequenceExpression(node, position, buffer) {
+        const { scope } = node;
+        node.expressions = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function spreadElement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function staticBlock(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function superElement() { },
+    function switchCase(node, position, buffer) {
+        const { scope } = node;
+        const testPosition = buffer[position];
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
+        node.consequent = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function switchStatement(node, position, buffer) {
+        const { scope } = node;
+        node.discriminant = convertNode(node, node.parentScope, buffer[position], buffer);
+        node.cases = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function taggedTemplateExpression(node, position, buffer) {
+        const { scope } = node;
+        node.tag = convertNode(node, scope, buffer[position], buffer);
+        node.quasi = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function templateElement(node, position, buffer) {
+        const flags = buffer[position];
+        node.tail = (flags & 1) === 1;
+        const cookedPosition = buffer[position + 1];
+        const cooked = cookedPosition === 0 ? undefined : buffer.convertString(cookedPosition);
+        const raw = buffer.convertString(buffer[position + 2]);
+        node.value = { cooked, raw };
+    },
+    function templateLiteral(node, position, buffer) {
+        const { scope } = node;
+        node.quasis = convertNodeList(node, scope, buffer[position], buffer);
+        node.expressions = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function thisExpression() { },
+    function throwStatement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function tryStatement(node, position, buffer) {
+        const { scope } = node;
+        node.block = convertNode(node, scope, buffer[position], buffer);
+        const handlerPosition = buffer[position + 1];
+        node.handler = handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer);
+        const finalizerPosition = buffer[position + 2];
+        node.finalizer =
+            finalizerPosition === 0 ? null : convertNode(node, scope, finalizerPosition, buffer);
+    },
+    function unaryExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = FIXED_STRINGS[buffer[position]];
+        node.argument = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function updateExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.prefix = (flags & 1) === 1;
+        node.operator = FIXED_STRINGS[buffer[position + 1]];
+        node.argument = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function variableDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.kind = FIXED_STRINGS[buffer[position]];
+        node.declarations = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function variableDeclarator(node, position, buffer) {
+        const { scope } = node;
+        node.id = convertNode(node, scope, buffer[position], buffer);
+        const initPosition = buffer[position + 1];
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
+    },
+    function whileStatement(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function yieldExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.delegate = (flags & 1) === 1;
+        const argumentPosition = buffer[position + 1];
+        node.argument =
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
+    }
+];
+function convertNode(parent, parentScope, position, buffer) {
+    const nodeType = buffer[position];
+    const NodeConstructor = nodeConstructors$1[nodeType];
+    /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
+    if (!NodeConstructor) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    const node = new NodeConstructor(parent, parentScope);
+    node.type = nodeTypeStrings[nodeType];
+    node.start = buffer[position + 1];
+    node.end = buffer[position + 2];
+    bufferParsers[nodeType](node, position + 3, buffer);
+    node.initialise();
+    return node;
+}
+function convertNodeList(parent, parentScope, position, buffer) {
+    if (position === 0)
+        return EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null);
+    }
+    return list;
+}
+
+class UnknownNode extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+    include(context) {
+        super.include(context, true);
+    }
+}
+
+// This file is generated by scripts/generate-node-index.js.
+// Do not edit this file directly.
+const nodeConstructors = {
+    ArrayExpression,
+    ArrayPattern,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    AssignmentPattern,
+    AwaitExpression,
+    BinaryExpression,
+    BlockStatement,
+    BreakStatement,
+    CallExpression,
+    CatchClause,
+    ChainExpression,
+    ClassBody,
+    ClassDeclaration,
+    ClassExpression,
+    ConditionalExpression,
+    ContinueStatement,
+    DebuggerStatement,
+    Decorator,
+    DoWhileStatement,
+    EmptyStatement,
+    ExportAllDeclaration,
+    ExportDefaultDeclaration,
+    ExportNamedDeclaration,
+    ExportSpecifier,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    FunctionExpression,
+    Identifier,
+    IfStatement,
+    ImportAttribute,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    ImportExpression,
+    ImportNamespaceSpecifier,
+    ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
+    LabeledStatement,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    MetaProperty,
+    MethodDefinition,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    PanicError,
+    ParseError,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
+    RestElement,
+    ReturnStatement,
+    SequenceExpression,
+    SpreadElement,
+    StaticBlock,
+    Super,
+    SwitchCase,
+    SwitchStatement,
+    TaggedTemplateExpression,
+    TemplateElement,
+    TemplateLiteral,
+    ThisExpression,
+    ThrowStatement,
+    TryStatement,
+    UnaryExpression,
+    UnknownNode,
+    UpdateExpression,
+    VariableDeclaration,
+    VariableDeclarator,
+    WhileStatement,
+    YieldExpression
+};
+
+class ExportShimVariable extends Variable {
+    constructor(module) {
+        super(MISSING_EXPORT_SHIM_VARIABLE);
+        this.module = module;
+    }
+    include() {
+        super.include();
+        this.module.needsExportShim = true;
+    }
+}
+
+var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
+    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
+    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
+})(BuildPhase || (BuildPhase = {}));
+
+const sourceMapCache = new WeakMap();
+/**
+ * This clears the decoded array and falls back to the encoded string form.
+ * Sourcemap mappings arrays can be very large and holding on to them for longer
+ * than is necessary leads to poor heap utilization.
+ */
+function resetCacheToEncoded(cache) {
+    if (cache.encodedMappings === undefined && cache.decodedMappings) {
+        cache.encodedMappings = encode(cache.decodedMappings);
+    }
+    cache.decodedMappings = undefined;
+}
+function resetSourcemapCache(map, sourcemapChain) {
+    if (map) {
+        const cache = sourceMapCache.get(map);
+        if (cache) {
+            resetCacheToEncoded(cache);
+        }
+    }
+    if (!sourcemapChain) {
+        return;
+    }
+    for (const map of sourcemapChain) {
+        if (map.missing)
+            continue;
+        resetSourcemapCache(map);
+    }
+}
+function decodedSourcemap(map) {
+    if (!map)
+        return null;
+    if (typeof map === 'string') {
+        map = JSON.parse(map);
+    }
+    if (!map.mappings) {
+        return {
+            mappings: [],
+            names: [],
+            sources: [],
+            version: 3
+        };
+    }
+    const originalMappings = map.mappings;
+    const isAlreadyDecoded = Array.isArray(originalMappings);
+    const cache = {
+        decodedMappings: isAlreadyDecoded ? originalMappings : undefined,
+        encodedMappings: isAlreadyDecoded ? undefined : originalMappings
+    };
+    const decodedMap = {
+        ...map,
+        // By moving mappings behind an accessor, we can avoid unneeded computation for cases
+        // where the mappings field is never actually accessed. This appears to greatly reduce
+        // the overhead of sourcemap decoding in terms of both compute time and memory usage.
+        get mappings() {
+            if (cache.decodedMappings) {
+                return cache.decodedMappings;
+            }
+            // If decodedMappings doesn't exist then encodedMappings should.
+            // The only scenario where cache.encodedMappings should be undefined is if the map
+            // this was constructed from was already decoded, or if mappings was set to a new
+            // decoded string. In either case, this line shouldn't get hit.
+            cache.decodedMappings = cache.encodedMappings ? decode(cache.encodedMappings) : [];
+            cache.encodedMappings = undefined;
+            return cache.decodedMappings;
+        }
+    };
+    sourceMapCache.set(decodedMap, cache);
+    return decodedMap;
+}
+
+function getId(m) {
+    return m.id;
+}
+
+function getOriginalLocation(sourcemapChain, location) {
+    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !sourcemap.missing);
+    traceSourcemap: while (filteredSourcemapChain.length > 0) {
+        const sourcemap = filteredSourcemapChain.pop();
+        const line = sourcemap.mappings[location.line - 1];
+        if (line) {
+            const filteredLine = line.filter((segment) => segment.length > 1);
+            const lastSegment = filteredLine[filteredLine.length - 1];
+            for (const segment of filteredLine) {
+                if (segment[0] >= location.column || segment === lastSegment) {
+                    location = {
+                        column: segment[3],
+                        line: segment[2] + 1
+                    };
+                    continue traceSourcemap;
+                }
+            }
+        }
+        throw new Error("Can't resolve original location of error.");
+    }
+    return location;
+}
+
+const ATTRIBUTE_KEYWORDS = new Set(['assert', 'with']);
+function getAttributesFromImportExpression(node) {
+    const { scope: { context }, options, start } = node;
+    if (!(options instanceof ObjectExpression)) {
+        if (options) {
+            context.module.log(LOGLEVEL_WARN, logImportAttributeIsInvalid(context.module.id), start);
+        }
+        return EMPTY_OBJECT;
+    }
+    const assertProperty = options.properties.find((property) => ATTRIBUTE_KEYWORDS.has(getPropertyKey(property)))?.value;
+    if (!assertProperty) {
+        return EMPTY_OBJECT;
+    }
+    if (!(assertProperty instanceof ObjectExpression)) {
+        context.module.log(LOGLEVEL_WARN, logImportOptionsAreInvalid(context.module.id), start);
+        return EMPTY_OBJECT;
+    }
+    const assertFields = assertProperty.properties
+        .map(property => {
+        const key = getPropertyKey(property);
+        if (typeof key === 'string' &&
+            typeof property.value.value === 'string') {
+            return [key, property.value.value];
+        }
+        context.module.log(LOGLEVEL_WARN, logImportAttributeIsInvalid(context.module.id), property.start);
+        return null;
+    })
+        .filter((property) => !!property);
+    if (assertFields.length > 0) {
+        return Object.fromEntries(assertFields);
+    }
+    return EMPTY_OBJECT;
+}
+const getPropertyKey = (property) => {
+    const key = property.key;
+    return (key &&
+        !property.computed &&
+        (key.name || key.value));
+};
+function getAttributesFromImportExportDeclaration(attributes) {
+    return attributes?.length
+        ? Object.fromEntries(attributes.map(assertion => [getPropertyKey(assertion), assertion.value.value]))
+        : EMPTY_OBJECT;
+}
+function doAttributesDiffer(assertionA, assertionB) {
+    const keysA = Object.keys(assertionA);
+    return (keysA.length !== Object.keys(assertionB).length ||
+        keysA.some(key => assertionA[key] !== assertionB[key]));
+}
+
+let timers = new Map();
+function getPersistedLabel(label, level) {
+    switch (level) {
+        case 1: {
+            return `# ${label}`;
+        }
+        case 2: {
+            return `## ${label}`;
+        }
+        case 3: {
+            return label;
+        }
+        default: {
+            return `- ${label}`;
+        }
+    }
+}
+function timeStartImpl(label, level = 3) {
+    label = getPersistedLabel(label, level);
+    const startMemory = process$1.memoryUsage().heapUsed;
+    const startTime = performance.now();
+    const timer = timers.get(label);
+    if (timer === undefined) {
+        timers.set(label, {
+            memory: 0,
+            startMemory,
+            startTime,
+            time: 0,
+            totalMemory: 0
+        });
+    }
+    else {
+        timer.startMemory = startMemory;
+        timer.startTime = startTime;
+    }
+}
+function timeEndImpl(label, level = 3) {
+    label = getPersistedLabel(label, level);
+    const timer = timers.get(label);
+    if (timer !== undefined) {
+        const currentMemory = process$1.memoryUsage().heapUsed;
+        timer.memory += currentMemory - timer.startMemory;
+        timer.time += performance.now() - timer.startTime;
+        timer.totalMemory = Math.max(timer.totalMemory, currentMemory);
+    }
+}
+function getTimings() {
+    const newTimings = {};
+    for (const [label, { memory, time, totalMemory }] of timers) {
+        newTimings[label] = [time, memory, totalMemory];
+    }
+    return newTimings;
+}
+let timeStart = doNothing;
+let timeEnd = doNothing;
+const TIMED_PLUGIN_HOOKS = [
+    'augmentChunkHash',
+    'buildEnd',
+    'buildStart',
+    'generateBundle',
+    'load',
+    'moduleParsed',
+    'options',
+    'outputOptions',
+    'renderChunk',
+    'renderDynamicImport',
+    'renderStart',
+    'resolveDynamicImport',
+    'resolveFileUrl',
+    'resolveId',
+    'resolveImportMeta',
+    'shouldTransformCachedModule',
+    'transform',
+    'writeBundle'
+];
+function getPluginWithTimers(plugin, index) {
+    if (plugin._hasTimer)
+        return plugin;
+    plugin._hasTimer = true;
+    for (const hook of TIMED_PLUGIN_HOOKS) {
+        if (hook in plugin) {
+            let timerLabel = `plugin ${index}`;
+            if (plugin.name) {
+                timerLabel += ` (${plugin.name})`;
+            }
+            timerLabel += ` - ${hook}`;
+            const handler = function (...parameters) {
+                timeStart(timerLabel, 4);
+                const result = hookFunction.apply(this, parameters);
+                timeEnd(timerLabel, 4);
+                return result;
+            };
+            let hookFunction;
+            if (typeof plugin[hook].handler === 'function') {
+                hookFunction = plugin[hook].handler;
+                plugin[hook].handler = handler;
+            }
+            else {
+                hookFunction = plugin[hook];
+                plugin[hook] = handler;
+            }
+        }
+    }
+    return plugin;
+}
+function initialiseTimers(inputOptions) {
+    if (inputOptions.perf) {
+        timers = new Map();
+        timeStart = timeStartImpl;
+        timeEnd = timeEndImpl;
+        inputOptions.plugins = inputOptions.plugins.map(getPluginWithTimers);
+    }
+    else {
+        timeStart = doNothing;
+        timeEnd = doNothing;
+    }
+}
+
+const MISSING_EXPORT_SHIM_DESCRIPTION = {
+    identifier: null,
+    localName: MISSING_EXPORT_SHIM_VARIABLE
+};
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map()) {
+    const searchedModules = searchedNamesAndModules.get(name);
+    if (searchedModules) {
+        if (searchedModules.has(target)) {
+            return isExportAllSearch ? [null] : error(logCircularReexport(name, target.id));
+        }
+        searchedModules.add(target);
+    }
+    else {
+        searchedNamesAndModules.set(name, new Set([target]));
+    }
+    return target.getVariableForExportName(name, {
+        importerForSideEffects,
+        isExportAllSearch,
+        searchedNamesAndModules
+    });
+}
+function getAndExtendSideEffectModules(variable, module) {
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, (getNewSet));
+    let currentVariable = variable;
+    const referencedVariables = new Set([currentVariable]);
+    while (true) {
+        const importingModule = currentVariable.module;
+        currentVariable =
+            currentVariable instanceof ExportDefaultVariable
+                ? currentVariable.getDirectOriginalVariable()
+                : currentVariable instanceof SyntheticNamedExportVariable
+                    ? currentVariable.syntheticNamespace
+                    : null;
+        if (!currentVariable || referencedVariables.has(currentVariable)) {
+            break;
+        }
+        referencedVariables.add(currentVariable);
+        sideEffectModules.add(importingModule);
+        const originalSideEffects = importingModule.sideEffectDependenciesByVariable.get(currentVariable);
+        if (originalSideEffects) {
+            for (const module of originalSideEffects) {
+                sideEffectModules.add(module);
+            }
+        }
+    }
+    return sideEffectModules;
+}
+class Module {
+    constructor(graph, id, options, isEntry, moduleSideEffects, syntheticNamedExports, meta, attributes) {
+        this.graph = graph;
+        this.id = id;
+        this.options = options;
+        this.alternativeReexportModules = new Map();
+        this.chunkFileNames = new Set();
+        this.chunkNames = [];
+        this.cycles = new Set();
+        this.dependencies = new Set();
+        this.dynamicDependencies = new Set();
+        this.dynamicImporters = [];
+        this.dynamicImports = [];
+        this.execIndex = Infinity;
+        this.hasTreeShakingPassStarted = false;
+        this.implicitlyLoadedAfter = new Set();
+        this.implicitlyLoadedBefore = new Set();
+        this.importDescriptions = new Map();
+        this.importMetas = [];
+        this.importedFromNotTreeshaken = false;
+        this.importers = [];
+        this.includedDynamicImporters = [];
+        this.includedImports = new Set();
+        this.isExecuted = false;
+        this.isUserDefinedEntryPoint = false;
+        this.needsExportShim = false;
+        this.sideEffectDependenciesByVariable = new Map();
+        this.sourcesWithAttributes = new Map();
+        this.allExportNames = null;
+        this.ast = null;
+        this.exportAllModules = [];
+        this.exportAllSources = new Set();
+        this.exportNamesByVariable = null;
+        this.exportShimVariable = new ExportShimVariable(this);
+        this.exports = new Map();
+        this.namespaceReexportsByName = new Map();
+        this.reexportDescriptions = new Map();
+        this.relevantDependencies = null;
+        this.syntheticExports = new Map();
+        this.syntheticNamespace = null;
+        this.transformDependencies = [];
+        this.transitiveReexports = null;
+        this.excludeFromSourcemap = /\0/.test(id);
+        this.context = options.moduleContext(id);
+        this.preserveSignature = this.options.preserveEntrySignatures;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const module = this;
+        const { dynamicImports, dynamicImporters, exportAllSources, exports, implicitlyLoadedAfter, implicitlyLoadedBefore, importers, reexportDescriptions, sourcesWithAttributes } = this;
+        this.info = {
+            ast: null,
+            attributes,
+            code: null,
+            get dynamicallyImportedIdResolutions() {
+                return dynamicImports
+                    .map(({ argument }) => typeof argument === 'string' && module.resolvedIds[argument])
+                    .filter(Boolean);
+            },
+            get dynamicallyImportedIds() {
+                // We cannot use this.dynamicDependencies because this is needed before
+                // dynamicDependencies are populated
+                return dynamicImports.map(({ id }) => id).filter((id) => id != null);
+            },
+            get dynamicImporters() {
+                return dynamicImporters.sort();
+            },
+            get exportedBindings() {
+                const exportBindings = { '.': [...exports.keys()] };
+                for (const [name, { source }] of reexportDescriptions) {
+                    (exportBindings[source] ??= []).push(name);
+                }
+                for (const source of exportAllSources) {
+                    (exportBindings[source] ??= []).push('*');
+                }
+                return exportBindings;
+            },
+            get exports() {
+                return [
+                    ...exports.keys(),
+                    ...reexportDescriptions.keys(),
+                    ...[...exportAllSources].map(() => '*')
+                ];
+            },
+            get hasDefaultExport() {
+                // This information is only valid after parsing
+                if (!module.ast) {
+                    return null;
+                }
+                return module.exports.has('default') || reexportDescriptions.has('default');
+            },
+            id,
+            get implicitlyLoadedAfterOneOf() {
+                return Array.from(implicitlyLoadedAfter, getId).sort();
+            },
+            get implicitlyLoadedBefore() {
+                return Array.from(implicitlyLoadedBefore, getId).sort();
+            },
+            get importedIdResolutions() {
+                return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]).filter(Boolean);
+            },
+            get importedIds() {
+                // We cannot use this.dependencies because this is needed before
+                // dependencies are populated
+                return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]?.id).filter(Boolean);
+            },
+            get importers() {
+                return importers.sort();
+            },
+            isEntry,
+            isExternal: false,
+            get isIncluded() {
+                if (graph.phase !== BuildPhase.GENERATE) {
+                    return null;
+                }
+                return module.isIncluded();
+            },
+            meta: { ...meta },
+            moduleSideEffects,
+            syntheticNamedExports
+        };
+    }
+    basename() {
+        const base = basename(this.id);
+        const extension = extname(this.id);
+        return makeLegal(extension ? base.slice(0, -extension.length) : base);
+    }
+    bindReferences() {
+        this.ast.bind();
+    }
+    cacheInfoGetters() {
+        cacheObjectGetters(this.info, [
+            'dynamicallyImportedIdResolutions',
+            'dynamicallyImportedIds',
+            'dynamicImporters',
+            'exportedBindings',
+            'exports',
+            'hasDefaultExport',
+            'implicitlyLoadedAfterOneOf',
+            'implicitlyLoadedBefore',
+            'importedIdResolutions',
+            'importedIds',
+            'importers'
+        ]);
+    }
+    error(properties, pos) {
+        if (pos !== undefined) {
+            this.addLocationToLogProps(properties, pos);
+        }
+        return error(properties);
+    }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
+    getAllExportNames() {
+        if (this.allExportNames) {
+            return this.allExportNames;
+        }
+        this.allExportNames = new Set([...this.exports.keys(), ...this.reexportDescriptions.keys()]);
+        for (const module of this.exportAllModules) {
+            if (module instanceof ExternalModule) {
+                this.allExportNames.add(`*${module.id}`);
+                continue;
+            }
+            for (const name of module.getAllExportNames()) {
+                if (name !== 'default')
+                    this.allExportNames.add(name);
+            }
+        }
+        // We do not count the synthetic namespace as a regular export to hide it
+        // from entry signatures and namespace objects
+        if (typeof this.info.syntheticNamedExports === 'string') {
+            this.allExportNames.delete(this.info.syntheticNamedExports);
+        }
+        return this.allExportNames;
+    }
+    getDependenciesToBeIncluded() {
+        if (this.relevantDependencies)
+            return this.relevantDependencies;
+        this.relevantDependencies = new Set();
+        const necessaryDependencies = new Set();
+        const alwaysCheckedDependencies = new Set();
+        const dependencyVariables = new Set(this.includedImports);
+        if (this.info.isEntry ||
+            this.includedDynamicImporters.length > 0 ||
+            this.namespace.included ||
+            this.implicitlyLoadedAfter.size > 0) {
+            for (const exportName of [...this.getReexports(), ...this.getExports()]) {
+                const [exportedVariable] = this.getVariableForExportName(exportName);
+                if (exportedVariable?.included) {
+                    dependencyVariables.add(exportedVariable);
+                }
+            }
+        }
+        for (let variable of dependencyVariables) {
+            const sideEffectDependencies = this.sideEffectDependenciesByVariable.get(variable);
+            if (sideEffectDependencies) {
+                for (const module of sideEffectDependencies) {
+                    alwaysCheckedDependencies.add(module);
+                }
+            }
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            else if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            necessaryDependencies.add(variable.module);
+        }
+        if (!this.options.treeshake || this.info.moduleSideEffects === 'no-treeshake') {
+            for (const dependency of this.dependencies) {
+                this.relevantDependencies.add(dependency);
+            }
+        }
+        else {
+            this.addRelevantSideEffectDependencies(this.relevantDependencies, necessaryDependencies, alwaysCheckedDependencies);
+        }
+        for (const dependency of necessaryDependencies) {
+            this.relevantDependencies.add(dependency);
+        }
+        return this.relevantDependencies;
+    }
+    getExportNamesByVariable() {
+        if (this.exportNamesByVariable) {
+            return this.exportNamesByVariable;
+        }
+        const exportNamesByVariable = new Map();
+        for (const exportName of this.getAllExportNames()) {
+            let [tracedVariable] = this.getVariableForExportName(exportName);
+            if (tracedVariable instanceof ExportDefaultVariable) {
+                tracedVariable = tracedVariable.getOriginalVariable();
+            }
+            if (!tracedVariable ||
+                !(tracedVariable.included || tracedVariable instanceof ExternalVariable)) {
+                continue;
+            }
+            const existingExportNames = exportNamesByVariable.get(tracedVariable);
+            if (existingExportNames) {
+                existingExportNames.push(exportName);
+            }
+            else {
+                exportNamesByVariable.set(tracedVariable, [exportName]);
+            }
+        }
+        return (this.exportNamesByVariable = exportNamesByVariable);
+    }
+    getExports() {
+        return [...this.exports.keys()];
+    }
+    getReexports() {
+        if (this.transitiveReexports) {
+            return this.transitiveReexports;
+        }
+        // to avoid infinite recursion when using circular `export * from X`
+        this.transitiveReexports = [];
+        const reexports = new Set(this.reexportDescriptions.keys());
+        for (const module of this.exportAllModules) {
+            if (module instanceof ExternalModule) {
+                reexports.add(`*${module.id}`);
+            }
+            else {
+                for (const name of [...module.getReexports(), ...module.getExports()]) {
+                    if (name !== 'default')
+                        reexports.add(name);
+                }
+            }
+        }
+        return (this.transitiveReexports = [...reexports]);
+    }
+    getRenderedExports() {
+        // only direct exports are counted here, not reexports at all
+        const renderedExports = [];
+        const removedExports = [];
+        for (const exportName of this.exports.keys()) {
+            const [variable] = this.getVariableForExportName(exportName);
+            (variable?.included ? renderedExports : removedExports).push(exportName);
+        }
+        return { removedExports, renderedExports };
+    }
+    getSyntheticNamespace() {
+        if (this.syntheticNamespace === null) {
+            this.syntheticNamespace = undefined;
+            [this.syntheticNamespace] = this.getVariableForExportName(typeof this.info.syntheticNamedExports === 'string'
+                ? this.info.syntheticNamedExports
+                : 'default', { onlyExplicit: true });
+        }
+        if (!this.syntheticNamespace) {
+            return error(logSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
+        }
+        return this.syntheticNamespace;
+    }
+    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, onlyExplicit, searchedNamesAndModules } = EMPTY_OBJECT) {
+        if (name[0] === '*') {
+            if (name.length === 1) {
+                // export * from './other'
+                return [this.namespace];
+            }
+            // export * from 'external'
+            const module = this.graph.modulesById.get(name.slice(1));
+            return module.getVariableForExportName('*');
+        }
+        // export { foo } from './other'
+        const reexportDeclaration = this.reexportDescriptions.get(name);
+        if (reexportDeclaration) {
+            const [variable] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
+            if (!variable) {
+                return this.error(logMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
+            }
+            if (importerForSideEffects) {
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+                if (this.info.moduleSideEffects) {
+                    getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
+                }
+            }
+            return [variable];
+        }
+        const exportDeclaration = this.exports.get(name);
+        if (exportDeclaration) {
+            if (exportDeclaration === MISSING_EXPORT_SHIM_DESCRIPTION) {
+                return [this.exportShimVariable];
+            }
+            const name = exportDeclaration.localName;
+            const variable = this.traceVariable(name, {
+                importerForSideEffects,
+                searchedNamesAndModules
+            });
+            if (importerForSideEffects) {
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
+            }
+            return [variable];
+        }
+        if (onlyExplicit) {
+            return [null];
+        }
+        if (name !== 'default') {
+            const foundNamespaceReexport = this.namespaceReexportsByName.get(name) ??
+                this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules);
+            this.namespaceReexportsByName.set(name, foundNamespaceReexport);
+            if (foundNamespaceReexport[0]) {
+                return foundNamespaceReexport;
+            }
+        }
+        if (this.info.syntheticNamedExports) {
+            return [
+                getOrCreate(this.syntheticExports, name, () => new SyntheticNamedExportVariable(this.astContext, name, this.getSyntheticNamespace()))
+            ];
+        }
+        // we don't want to create shims when we are just
+        // probing export * modules for exports
+        if (!isExportAllSearch && this.options.shimMissingExports) {
+            this.shimMissingExport(name);
+            return [this.exportShimVariable];
+        }
+        return [null];
+    }
+    hasEffects() {
+        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
+    }
+    include() {
+        const context = createInclusionContext();
+        if (this.ast.shouldBeIncluded(context))
+            this.ast.include(context, false);
+    }
+    includeAllExports(includeNamespaceMembers) {
+        if (!this.isExecuted) {
+            markModuleAndImpureDependenciesAsExecuted(this);
+            this.graph.needsTreeshakingPass = true;
+        }
+        for (const exportName of this.exports.keys()) {
+            if (includeNamespaceMembers || exportName !== this.info.syntheticNamedExports) {
+                const variable = this.getVariableForExportName(exportName)[0];
+                if (!variable) {
+                    return error(logMissingEntryExport(exportName, this.id));
+                }
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+            }
+        }
+        for (const name of this.getReexports()) {
+            const [variable] = this.getVariableForExportName(name);
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+                if (variable instanceof ExternalVariable) {
+                    variable.module.reexported = true;
+                }
+            }
+        }
+        if (includeNamespaceMembers) {
+            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
+    includeAllInBundle() {
+        this.ast.include(createInclusionContext(), true);
+        this.includeAllExports(false);
+    }
+    includeExportsByNames(names) {
+        if (!this.isExecuted) {
+            markModuleAndImpureDependenciesAsExecuted(this);
+            this.graph.needsTreeshakingPass = true;
+        }
+        let includeNamespaceMembers = false;
+        for (const name of names) {
+            const variable = this.getVariableForExportName(name)[0];
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+            }
+            if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
+                includeNamespaceMembers = true;
+            }
+        }
+        if (includeNamespaceMembers) {
+            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
+    isIncluded() {
+        // Modules where this.ast is missing have been loaded via this.load and are
+        // not yet fully processed, hence they cannot be included.
+        return (this.ast &&
+            (this.ast.included ||
+                this.namespace.included ||
+                this.importedFromNotTreeshaken ||
+                this.exportShimVariable.included));
+    }
+    linkImports() {
+        this.addModulesToImportDescriptions(this.importDescriptions);
+        this.addModulesToImportDescriptions(this.reexportDescriptions);
+        const externalExportAllModules = [];
+        for (const source of this.exportAllSources) {
+            const module = this.graph.modulesById.get(this.resolvedIds[source].id);
+            if (module instanceof ExternalModule) {
+                externalExportAllModules.push(module);
+                continue;
+            }
+            this.exportAllModules.push(module);
+        }
+        this.exportAllModules.push(...externalExportAllModules);
+    }
+    log(level, properties, pos) {
+        this.addLocationToLogProps(properties, pos);
+        this.options.onLog(level, properties);
+    }
+    render(options) {
+        const source = this.magicString.clone();
+        this.ast.render(source, options);
+        source.trim();
+        const { usesTopLevelAwait } = this.astContext;
+        if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
+            return error(logInvalidFormatForTopLevelAwait(this.id, options.format));
+        }
+        return { source, usesTopLevelAwait };
+    }
+    async setSource({ ast, code, customTransformCache, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles, ...moduleOptions }) {
+        timeStart('generate ast', 3);
+        if (code.startsWith('#!')) {
+            const shebangEndPosition = code.indexOf('\n');
+            this.shebang = code.slice(2, shebangEndPosition);
+        }
+        this.info.code = code;
+        this.originalCode = originalCode;
+        // We need to call decodedSourcemap on the input in case they were hydrated from json in the cache and don't
+        // have the lazy evaluation cache configured. Right now this isn't enforced by the type system because the
+        // RollupCache stores `ExistingDecodedSourcemap` instead of `ExistingRawSourcemap`
+        this.originalSourcemap = decodedSourcemap(originalSourcemap);
+        this.sourcemapChain = sourcemapChain.map(mapOrMissing => mapOrMissing.missing ? mapOrMissing : decodedSourcemap(mapOrMissing));
+        // If coming from cache and this value is already fully decoded, we want to re-encode here to save memory.
+        resetSourcemapCache(this.originalSourcemap, this.sourcemapChain);
+        if (transformFiles) {
+            this.transformFiles = transformFiles;
+        }
+        this.transformDependencies = transformDependencies;
+        this.customTransformCache = customTransformCache;
+        this.updateOptions(moduleOptions);
+        this.resolvedIds = resolvedIds ?? Object.create(null);
+        // By default, `id` is the file name. Custom resolvers and loaders
+        // can change that, but it makes sense to use it for the source file name
+        const fileName = this.id;
+        this.magicString = new MagicString(code, {
+            filename: (this.excludeFromSourcemap ? null : fileName), // don't include plugin helpers in sourcemap
+            indentExclusionRanges: []
+        });
+        this.astContext = {
+            addDynamicImport: this.addDynamicImport.bind(this),
+            addExport: this.addExport.bind(this),
+            addImport: this.addImport.bind(this),
+            addImportMeta: this.addImportMeta.bind(this),
+            addImportSource: this.addImportSource.bind(this),
+            code, // Only needed for debugging
+            deoptimizationTracker: this.graph.deoptimizationTracker,
+            error: this.error.bind(this),
+            fileName, // Needed for warnings
+            getExports: this.getExports.bind(this),
+            getImportedJsxFactoryVariable: this.getImportedJsxFactoryVariable.bind(this),
+            getModuleExecIndex: () => this.execIndex,
+            getModuleName: this.basename.bind(this),
+            getNodeConstructor: (name) => nodeConstructors[name] || nodeConstructors.UnknownNode,
+            getReexports: this.getReexports.bind(this),
+            importDescriptions: this.importDescriptions,
+            includeAllExports: () => this.includeAllExports(true),
+            includeDynamicImport: this.includeDynamicImport.bind(this),
+            includeVariableInModule: this.includeVariableInModule.bind(this),
+            log: this.log.bind(this),
+            magicString: this.magicString,
+            manualPureFunctions: this.graph.pureFunctions,
+            module: this,
+            moduleContext: this.context,
+            options: this.options,
+            requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
+            traceExport: (name) => this.getVariableForExportName(name)[0],
+            traceVariable: this.traceVariable.bind(this),
+            usesTopLevelAwait: false
+        };
+        this.scope = new ModuleScope(this.graph.scope, this.astContext);
+        this.namespace = new NamespaceVariable(this.astContext);
+        const programParent = { context: this.astContext, type: 'Module' };
+        if (ast) {
+            this.ast = new nodeConstructors[ast.type](programParent, this.scope).parseNode(ast);
+            this.info.ast = ast;
+        }
+        else {
+            // Measuring asynchronous code does not provide reasonable results
+            timeEnd('generate ast', 3);
+            const astBuffer = await parseAsync(code, false, this.options.jsx !== false);
+            timeStart('generate ast', 3);
+            this.ast = convertProgram(astBuffer, programParent, this.scope);
+            // Make lazy and apply LRU cache to not hog the memory
+            Object.defineProperty(this.info, 'ast', {
+                get: () => {
+                    if (this.graph.astLru.has(fileName)) {
+                        return this.graph.astLru.get(fileName);
+                    }
+                    else {
+                        const parsedAst = this.tryParse();
+                        // If the cache is not disabled, we need to keep the AST in memory
+                        // until the end when the cache is generated
+                        if (this.options.cache !== false) {
+                            Object.defineProperty(this.info, 'ast', {
+                                value: parsedAst
+                            });
+                            return parsedAst;
+                        }
+                        // Otherwise, we keep it in a small LRU cache to not hog too much
+                        // memory but allow the same AST to be requested several times.
+                        this.graph.astLru.set(fileName, parsedAst);
+                        return parsedAst;
+                    }
+                }
+            });
+        }
+        timeEnd('generate ast', 3);
+    }
+    toJSON() {
+        return {
+            ast: this.info.ast,
+            attributes: this.info.attributes,
+            code: this.info.code,
+            customTransformCache: this.customTransformCache,
+            dependencies: Array.from(this.dependencies, getId),
+            id: this.id,
+            meta: this.info.meta,
+            moduleSideEffects: this.info.moduleSideEffects,
+            originalCode: this.originalCode,
+            originalSourcemap: this.originalSourcemap,
+            resolvedIds: this.resolvedIds,
+            sourcemapChain: this.sourcemapChain,
+            syntheticNamedExports: this.info.syntheticNamedExports,
+            transformDependencies: this.transformDependencies,
+            transformFiles: this.transformFiles
+        };
+    }
+    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = EMPTY_OBJECT) {
+        const localVariable = this.scope.variables.get(name);
+        if (localVariable) {
+            return localVariable;
+        }
+        const importDescription = this.importDescriptions.get(name);
+        if (importDescription) {
+            const otherModule = importDescription.module;
+            if (otherModule instanceof Module && importDescription.name === '*') {
+                return otherModule.namespace;
+            }
+            const [declaration] = getVariableForExportNameRecursive(otherModule, importDescription.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules);
+            if (!declaration) {
+                return this.error(logMissingExport(importDescription.name, this.id, otherModule.id), importDescription.start);
+            }
+            return declaration;
+        }
+        return null;
+    }
+    updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
+        if (moduleSideEffects != null) {
+            this.info.moduleSideEffects = moduleSideEffects;
+        }
+        if (syntheticNamedExports != null) {
+            this.info.syntheticNamedExports = syntheticNamedExports;
+        }
+        if (meta != null) {
+            Object.assign(this.info.meta, meta);
+        }
+    }
+    addDynamicImport(node) {
+        let argument = node.sourceAstNode;
+        if (argument.type === TemplateLiteral$1) {
+            if (argument.quasis.length === 1 &&
+                typeof argument.quasis[0].value.cooked === 'string') {
+                argument = argument.quasis[0].value.cooked;
+            }
+        }
+        else if (argument.type === Literal$1 &&
+            typeof argument.value === 'string') {
+            argument = argument.value;
+        }
+        this.dynamicImports.push({ argument, id: null, node, resolution: null });
+    }
+    assertUniqueExportName(name, nodeStart) {
+        if (this.exports.has(name) || this.reexportDescriptions.has(name)) {
+            this.error(logDuplicateExportError(name), nodeStart);
+        }
+    }
+    addExport(node) {
+        if (node instanceof ExportDefaultDeclaration) {
+            // export default foo;
+            this.assertUniqueExportName('default', node.start);
+            this.exports.set('default', {
+                identifier: node.variable.getAssignedVariableName(),
+                localName: 'default'
+            });
+        }
+        else if (node instanceof ExportAllDeclaration) {
+            const source = node.source.value;
+            this.addSource(source, node);
+            if (node.exported) {
+                // export * as name from './other'
+                const name = node.exported instanceof Literal ? node.exported.value : node.exported.name;
+                this.assertUniqueExportName(name, node.exported.start);
+                this.reexportDescriptions.set(name, {
+                    localName: '*',
+                    module: null, // filled in later,
+                    source,
+                    start: node.start
+                });
+            }
+            else {
+                // export * from './other'
+                this.exportAllSources.add(source);
+            }
+        }
+        else if (node.source instanceof Literal) {
+            // export { name } from './other'
+            const source = node.source.value;
+            this.addSource(source, node);
+            for (const { exported, local, start } of node.specifiers) {
+                const name = exported instanceof Literal ? exported.value : exported.name;
+                this.assertUniqueExportName(name, start);
+                this.reexportDescriptions.set(name, {
+                    localName: local instanceof Literal ? local.value : local.name,
+                    module: null, // filled in later,
+                    source,
+                    start
+                });
+            }
+        }
+        else if (node.declaration) {
+            const declaration = node.declaration;
+            if (declaration instanceof VariableDeclaration) {
+                // export var { foo, bar } = ...
+                // export var foo = 1, bar = 2;
+                for (const declarator of declaration.declarations) {
+                    for (const localName of extractAssignedNames(declarator.id)) {
+                        this.assertUniqueExportName(localName, declarator.id.start);
+                        this.exports.set(localName, { identifier: null, localName });
+                    }
+                }
+            }
+            else {
+                // export function foo () {}
+                const localName = declaration.id.name;
+                this.assertUniqueExportName(localName, declaration.id.start);
+                this.exports.set(localName, { identifier: null, localName });
+            }
+        }
+        else {
+            // export { foo, bar, baz }
+            for (const { local, exported } of node.specifiers) {
+                // except for reexports, local must be an Identifier
+                const localName = local.name;
+                const exportedName = exported instanceof Identifier ? exported.name : exported.value;
+                this.assertUniqueExportName(exportedName, exported.start);
+                this.exports.set(exportedName, { identifier: null, localName });
+            }
+        }
+    }
+    addImport(node) {
+        const source = node.source.value;
+        this.addSource(source, node);
+        for (const specifier of node.specifiers) {
+            const localName = specifier.local.name;
+            if (this.scope.variables.has(localName) || this.importDescriptions.has(localName)) {
+                this.error(logRedeclarationError(localName), specifier.local.start);
+            }
+            const name = specifier instanceof ImportDefaultSpecifier
+                ? 'default'
+                : specifier instanceof ImportNamespaceSpecifier
+                    ? '*'
+                    : specifier.imported instanceof Identifier
+                        ? specifier.imported.name
+                        : specifier.imported.value;
+            this.importDescriptions.set(localName, {
+                module: null, // filled in later
+                name,
+                source,
+                start: specifier.start
+            });
+        }
+    }
+    addImportSource(importSource) {
+        if (importSource && !this.sourcesWithAttributes.has(importSource)) {
+            this.sourcesWithAttributes.set(importSource, EMPTY_OBJECT);
+        }
+    }
+    addImportMeta(node) {
+        this.importMetas.push(node);
+    }
+    addLocationToLogProps(properties, pos) {
+        properties.id = this.id;
+        properties.pos = pos;
+        let code = this.info.code;
+        const location = locate(code, pos, { offsetLine: 1 });
+        if (location) {
+            let { column, line } = location;
+            try {
+                ({ column, line } = getOriginalLocation(this.sourcemapChain, { column, line }));
+                code = this.originalCode;
+            }
+            catch (error_) {
+                this.options.onLog(LOGLEVEL_WARN, logInvalidSourcemapForError(error_, this.id, column, line, pos));
+            }
+            augmentCodeLocation(properties, { column, line }, code, this.id);
+        }
+    }
+    addModulesToImportDescriptions(importDescription) {
+        for (const specifier of importDescription.values()) {
+            const { id } = this.resolvedIds[specifier.source];
+            specifier.module = this.graph.modulesById.get(id);
+        }
+    }
+    addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies) {
+        const handledDependencies = new Set();
+        const addSideEffectDependencies = (possibleDependencies) => {
+            for (const dependency of possibleDependencies) {
+                if (handledDependencies.has(dependency)) {
+                    continue;
+                }
+                handledDependencies.add(dependency);
+                if (necessaryDependencies.has(dependency)) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                if (!(dependency.info.moduleSideEffects || alwaysCheckedDependencies.has(dependency))) {
+                    continue;
+                }
+                if (dependency instanceof ExternalModule || dependency.hasEffects()) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                addSideEffectDependencies(dependency.dependencies);
+            }
+        };
+        addSideEffectDependencies(this.dependencies);
+        addSideEffectDependencies(alwaysCheckedDependencies);
+    }
+    addSource(source, declaration) {
+        const parsedAttributes = getAttributesFromImportExportDeclaration(declaration.attributes);
+        const existingAttributes = this.sourcesWithAttributes.get(source);
+        if (existingAttributes) {
+            if (doAttributesDiffer(existingAttributes, parsedAttributes)) {
+                this.log(LOGLEVEL_WARN, logInconsistentImportAttributes(existingAttributes, parsedAttributes, source, this.id), declaration.start);
+            }
+        }
+        else {
+            this.sourcesWithAttributes.set(source, parsedAttributes);
+        }
+    }
+    getImportedJsxFactoryVariable(baseName, nodeStart, importSource) {
+        const { id } = this.resolvedIds[importSource];
+        const module = this.graph.modulesById.get(id);
+        const [variable] = module.getVariableForExportName(baseName);
+        if (!variable) {
+            return this.error(logMissingJsxExport(baseName, id, this.id), nodeStart);
+        }
+        return variable;
+    }
+    getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules) {
+        let foundSyntheticDeclaration = null;
+        const foundInternalDeclarations = new Map();
+        const foundExternalDeclarations = new Set();
+        for (const module of this.exportAllModules) {
+            // Synthetic namespaces should not hide "regular" exports of the same name
+            if (module.info.syntheticNamedExports === name) {
+                continue;
+            }
+            const [variable, indirectExternal] = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, 
+            // We are creating a copy to handle the case where the same binding is
+            // imported through different namespace reexports gracefully
+            copyNameToModulesMap(searchedNamesAndModules));
+            if (module instanceof ExternalModule || indirectExternal) {
+                foundExternalDeclarations.add(variable);
+            }
+            else if (variable instanceof SyntheticNamedExportVariable) {
+                if (!foundSyntheticDeclaration) {
+                    foundSyntheticDeclaration = variable;
+                }
+            }
+            else if (variable) {
+                foundInternalDeclarations.set(variable, module);
+            }
+        }
+        if (foundInternalDeclarations.size > 0) {
+            const foundDeclarationList = [...foundInternalDeclarations];
+            const usedDeclaration = foundDeclarationList[0][0];
+            if (foundDeclarationList.length === 1) {
+                return [usedDeclaration];
+            }
+            this.options.onLog(LOGLEVEL_WARN, logNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
+            // TODO we are pretending it was not found while it should behave like "undefined"
+            return [null];
+        }
+        if (foundExternalDeclarations.size > 0) {
+            const foundDeclarationList = [...foundExternalDeclarations];
+            const usedDeclaration = foundDeclarationList[0];
+            if (foundDeclarationList.length > 1) {
+                this.options.onLog(LOGLEVEL_WARN, logAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
+            }
+            return [usedDeclaration, true];
+        }
+        if (foundSyntheticDeclaration) {
+            return [foundSyntheticDeclaration];
+        }
+        return [null];
+    }
+    includeAndGetAdditionalMergedNamespaces() {
+        const externalNamespaces = new Set();
+        const syntheticNamespaces = new Set();
+        for (const module of [this, ...this.exportAllModules]) {
+            if (module instanceof ExternalModule) {
+                const [externalVariable] = module.getVariableForExportName('*');
+                externalVariable.include();
+                this.includedImports.add(externalVariable);
+                externalNamespaces.add(externalVariable);
+            }
+            else if (module.info.syntheticNamedExports) {
+                const syntheticNamespace = module.getSyntheticNamespace();
+                syntheticNamespace.include();
+                this.includedImports.add(syntheticNamespace);
+                syntheticNamespaces.add(syntheticNamespace);
+            }
+        }
+        return [...syntheticNamespaces, ...externalNamespaces];
+    }
+    includeDynamicImport(node) {
+        const resolution = this.dynamicImports.find(dynamicImport => dynamicImport.node === node).resolution;
+        if (resolution instanceof Module) {
+            resolution.includedDynamicImporters.push(this);
+            const importedNames = this.options.treeshake
+                ? node.getDeterministicImportedNames()
+                : undefined;
+            if (importedNames) {
+                resolution.includeExportsByNames(importedNames);
+            }
+            else {
+                resolution.includeAllExports(true);
+            }
+        }
+    }
+    includeVariable(variable) {
+        const variableModule = variable.module;
+        if (variable.included) {
+            if (variableModule instanceof Module && variableModule !== this) {
+                getAndExtendSideEffectModules(variable, this);
+            }
+        }
+        else {
+            variable.include();
+            this.graph.needsTreeshakingPass = true;
+            if (variableModule instanceof Module) {
+                if (!variableModule.isExecuted) {
+                    markModuleAndImpureDependenciesAsExecuted(variableModule);
+                }
+                if (variableModule !== this) {
+                    const sideEffectModules = getAndExtendSideEffectModules(variable, this);
+                    for (const module of sideEffectModules) {
+                        if (!module.isExecuted) {
+                            markModuleAndImpureDependenciesAsExecuted(module);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    includeVariableInModule(variable) {
+        this.includeVariable(variable);
+        const variableModule = variable.module;
+        if (variableModule && variableModule !== this) {
+            this.includedImports.add(variable);
+        }
+    }
+    shimMissingExport(name) {
+        this.options.onLog(LOGLEVEL_WARN, logShimmedExport(this.id, name));
+        this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
+    }
+    tryParse() {
+        try {
+            return parseAst(this.info.code, { jsx: this.options.jsx !== false });
+        }
+        catch (error_) {
+            return this.error(logModuleParseError(error_, this.id), error_.pos);
+        }
+    }
+}
+// if there is a cyclic import in the reexport chain, we should not
+// import from the original module but from the cyclic module to not
+// mess up execution order.
+function setAlternativeExporterIfCyclic(variable, importer, reexporter) {
+    if (variable.module instanceof Module && variable.module !== reexporter) {
+        const exporterCycles = variable.module.cycles;
+        if (exporterCycles.size > 0) {
+            const importerCycles = reexporter.cycles;
+            for (const cycleSymbol of importerCycles) {
+                if (exporterCycles.has(cycleSymbol)) {
+                    importer.alternativeReexportModules.set(variable, reexporter);
+                    break;
+                }
+            }
+        }
+    }
+}
+const copyNameToModulesMap = (searchedNamesAndModules) => searchedNamesAndModules &&
+    new Map(Array.from(searchedNamesAndModules, ([name, modules]) => [name, new Set(modules)]));
+
+const concatSeparator = (out, next) => (next ? `${out}\n${next}` : out);
+const concatDblSeparator = (out, next) => (next ? `${out}\n\n${next}` : out);
+async function createAddons(options, outputPluginDriver, chunk) {
+    try {
+        let [banner, footer, intro, outro] = await Promise.all([
+            outputPluginDriver.hookReduceValue('banner', options.banner(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('footer', options.footer(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('intro', options.intro(chunk), [chunk], concatDblSeparator),
+            outputPluginDriver.hookReduceValue('outro', options.outro(chunk), [chunk], concatDblSeparator)
+        ]);
+        if (intro)
+            intro += '\n\n';
+        if (outro)
+            outro = `\n\n${outro}`;
+        if (banner)
+            banner += '\n';
+        if (footer)
+            footer = '\n' + footer;
+        return { banner, footer, intro, outro };
+    }
+    catch (error_) {
+        return error(logAddonNotGenerated(error_.message, error_.hook, error_.plugin));
+    }
+}
+
+const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
+    amd: deconflictImportsOther,
+    cjs: deconflictImportsOther,
+    es: deconflictImportsEsmOrSystem,
+    iife: deconflictImportsOther,
+    system: deconflictImportsEsmOrSystem,
+    umd: deconflictImportsOther
+};
+function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
+    const reversedModules = [...modules].reverse();
+    for (const module of reversedModules) {
+        module.scope.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+    deconflictTopLevelVariables(usedNames, reversedModules, includedNamespaces);
+    DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](usedNames, imports, dependenciesToBeDeconflicted, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports);
+    for (const module of reversedModules) {
+        module.scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+}
+function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconflicted, _interop, preserveModules, _externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports) {
+    // This is needed for namespace reexports
+    for (const dependency of dependenciesToBeDeconflicted.dependencies) {
+        if (preserveModules || dependency instanceof ExternalChunk) {
+            dependency.variableName = getSafeName(dependency.suggestedVariableName, usedNames, null);
+        }
+    }
+    for (const variable of imports) {
+        const module = variable.module;
+        const name = variable.name;
+        if (variable.isNamespace && (preserveModules || module instanceof ExternalModule)) {
+            variable.setRenderNames(null, (module instanceof ExternalModule
+                ? externalChunkByModule.get(module)
+                : chunkByModule.get(module)).variableName);
+        }
+        else if (module instanceof ExternalModule && name === 'default') {
+            variable.setRenderNames(null, getSafeName([...module.exportedVariables].some(([exportedVariable, exportedName]) => exportedName === '*' && exportedVariable.included)
+                ? module.suggestedVariableName + '__default'
+                : module.suggestedVariableName, usedNames, variable.forbiddenNames));
+        }
+        else {
+            variable.setRenderNames(null, getSafeName(makeLegal(name), usedNames, variable.forbiddenNames));
+        }
+    }
+    for (const variable of syntheticExports) {
+        variable.setRenderNames(null, getSafeName(variable.name, usedNames, variable.forbiddenNames));
+    }
+}
+function deconflictImportsOther(usedNames, imports, { deconflictedDefault, deconflictedNamespace, dependencies }, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule) {
+    for (const chunk of dependencies) {
+        chunk.variableName = getSafeName(chunk.suggestedVariableName, usedNames, null);
+    }
+    for (const chunk of deconflictedNamespace) {
+        chunk.namespaceVariableName = getSafeName(`${chunk.suggestedVariableName}__namespace`, usedNames, null);
+    }
+    for (const externalModule of deconflictedDefault) {
+        externalModule.defaultVariableName =
+            deconflictedNamespace.has(externalModule) &&
+                canDefaultBeTakenFromNamespace(interop(externalModule.id), externalLiveBindings)
+                ? externalModule.namespaceVariableName
+                : getSafeName(`${externalModule.suggestedVariableName}__default`, usedNames, null);
+    }
+    for (const variable of imports) {
+        const module = variable.module;
+        if (module instanceof ExternalModule) {
+            const chunk = externalChunkByModule.get(module);
+            const name = variable.name;
+            if (name === 'default') {
+                const moduleInterop = interop(module.id);
+                const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                    ? chunk.defaultVariableName
+                    : chunk.variableName;
+                if (isDefaultAProperty(moduleInterop, externalLiveBindings)) {
+                    variable.setRenderNames(variableName, 'default');
+                }
+                else {
+                    variable.setRenderNames(null, variableName);
+                }
+            }
+            else if (name === '*') {
+                variable.setRenderNames(null, namespaceInteropHelpersByInteropType[interop(module.id)]
+                    ? chunk.namespaceVariableName
+                    : chunk.variableName);
+            }
+            else {
+                // if the second parameter is `null`, it uses its "name" for the property name
+                variable.setRenderNames(chunk.variableName, null);
+            }
+        }
+        else {
+            const chunk = chunkByModule.get(module);
+            if (preserveModules && variable.isNamespace) {
+                variable.setRenderNames(null, chunk.exportMode === 'default' ? chunk.namespaceVariableName : chunk.variableName);
+            }
+            else if (chunk.exportMode === 'default') {
+                variable.setRenderNames(null, chunk.variableName);
+            }
+            else {
+                variable.setRenderNames(chunk.variableName, chunk.getVariableExportName(variable));
+            }
+        }
+    }
+}
+function deconflictTopLevelVariables(usedNames, modules, includedNamespaces) {
+    for (const module of modules) {
+        for (const variable of module.scope.variables.values()) {
+            if (variable.included &&
+                // this will only happen for exports in some formats
+                !(variable.renderBaseName ||
+                    (variable instanceof ExportDefaultVariable && variable.getOriginalVariable() !== variable))) {
+                variable.setRenderNames(null, getSafeName(variable.name, usedNames, variable.forbiddenNames));
+            }
+        }
+        if (includedNamespaces.has(module)) {
+            const namespace = module.namespace;
+            namespace.setRenderNames(null, getSafeName(namespace.name, usedNames, namespace.forbiddenNames));
+        }
+    }
+}
+
+function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
+    let nameIndex = 0;
+    for (const variable of exports) {
+        let [exportName] = variable.name;
+        if (exportsByName.has(exportName)) {
+            do {
+                exportName = toBase64(++nameIndex);
+                // skip past leading number identifiers
+                if (exportName.charCodeAt(0) === 49 /* '1' */) {
+                    nameIndex += 9 * 64 ** (exportName.length - 1);
+                    exportName = toBase64(nameIndex);
+                }
+            } while (RESERVED_NAMES.has(exportName) || exportsByName.has(exportName));
+        }
+        exportsByName.set(exportName, variable);
+        exportNamesByVariable.set(variable, [exportName]);
+    }
+}
+function assignExportsToNames(exports, exportsByName, exportNamesByVariable) {
+    for (const variable of exports) {
+        let nameIndex = 0;
+        let exportName = variable.name;
+        while (exportsByName.has(exportName)) {
+            exportName = variable.name + '$' + ++nameIndex;
+        }
+        exportsByName.set(exportName, variable);
+        exportNamesByVariable.set(variable, [exportName]);
+    }
+}
+
+function getExportMode(chunk, { exports: exportMode, name, format }, facadeModuleId, log) {
+    const exportKeys = chunk.getExportNames();
+    if (exportMode === 'default') {
+        if (exportKeys.length !== 1 || exportKeys[0] !== 'default') {
+            return error(logIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
+        }
+    }
+    else if (exportMode === 'none' && exportKeys.length > 0) {
+        return error(logIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
+    }
+    if (exportMode === 'auto') {
+        if (exportKeys.length === 0) {
+            exportMode = 'none';
+        }
+        else if (exportKeys.length === 1 && exportKeys[0] === 'default') {
+            exportMode = 'default';
+        }
+        else {
+            if (format !== 'es' && format !== 'system' && exportKeys.includes('default')) {
+                log(LOGLEVEL_WARN, logMixedExport(facadeModuleId, name));
+            }
+            exportMode = 'named';
+        }
+    }
+    return exportMode;
+}
+
+function guessIndentString(code) {
+    const lines = code.split('\n');
+    const tabbed = lines.filter(line => /^\t+/.test(line));
+    const spaced = lines.filter(line => /^ {2,}/.test(line));
+    if (tabbed.length === 0 && spaced.length === 0) {
+        return null;
+    }
+    // More lines tabbed than spaced? Assume tabs, and
+    // default to tabs in the case of a tie (or nothing
+    // to go on)
+    if (tabbed.length >= spaced.length) {
+        return '\t';
+    }
+    // Otherwise, we need to guess the multiple
+    const min = spaced.reduce((previous, current) => {
+        const numberSpaces = /^ +/.exec(current)[0].length;
+        return Math.min(numberSpaces, previous);
+    }, Infinity);
+    return ' '.repeat(min);
+}
+function getIndentString(modules, options) {
+    if (options.indent !== true)
+        return options.indent;
+    for (const module of modules) {
+        const indent = guessIndentString(module.originalCode);
+        if (indent !== null)
+            return indent;
+    }
+    return '\t';
+}
+
+function getStaticDependencies(chunk, orderedModules, chunkByModule, externalChunkByModule) {
+    const staticDependencyBlocks = [];
+    const handledDependencies = new Set();
+    for (let modulePos = orderedModules.length - 1; modulePos >= 0; modulePos--) {
+        const module = orderedModules[modulePos];
+        if (!handledDependencies.has(module)) {
+            const staticDependencies = [];
+            addStaticDependencies(module, staticDependencies, handledDependencies, chunk, chunkByModule, externalChunkByModule);
+            staticDependencyBlocks.unshift(staticDependencies);
+        }
+    }
+    const dependencies = new Set();
+    for (const block of staticDependencyBlocks) {
+        for (const dependency of block) {
+            dependencies.add(dependency);
+        }
+    }
+    return dependencies;
+}
+function addStaticDependencies(module, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule) {
+    const dependencies = module.getDependenciesToBeIncluded();
+    for (const dependency of dependencies) {
+        if (dependency instanceof ExternalModule) {
+            staticDependencies.push(externalChunkByModule.get(dependency));
+            continue;
+        }
+        const dependencyChunk = chunkByModule.get(dependency);
+        if (dependencyChunk !== chunk) {
+            staticDependencies.push(dependencyChunk);
+            continue;
+        }
+        if (!handledModules.has(dependency)) {
+            handledModules.add(dependency);
+            addStaticDependencies(dependency, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule);
+        }
+    }
+}
+
+// Four random characters from the private use area to minimize risk of
+// conflicts
+const hashPlaceholderLeft = '!~{';
+const hashPlaceholderRight = '}~';
+const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
+// This is the size of a 128-bits xxhash with base64url encoding
+const MAX_HASH_SIZE = 22;
+const DEFAULT_HASH_SIZE = 8;
+const getHashPlaceholderGenerator = () => {
+    let nextIndex = 0;
+    return (optionName, hashSize) => {
+        if (hashSize > MAX_HASH_SIZE) {
+            return error(logFailedValidation(`Hashes cannot be longer than ${MAX_HASH_SIZE} characters, received ${hashSize}. Check the "${optionName}" option.`));
+        }
+        const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
+        if (placeholder.length > hashSize) {
+            return error(logFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
+        }
+        return placeholder;
+    };
+};
+const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${MAX_HASH_SIZE - hashPlaceholderOverhead}}${hashPlaceholderRight}`, 'g');
+const replacePlaceholders = (code, hashesByPlaceholder) => code.replace(REPLACER_REGEX, placeholder => hashesByPlaceholder.get(placeholder) || placeholder);
+const replaceSinglePlaceholder = (code, placeholder, value) => code.replace(REPLACER_REGEX, match => (match === placeholder ? value : match));
+const replacePlaceholdersWithDefaultAndGetContainedPlaceholders = (code, placeholders) => {
+    const containedPlaceholders = new Set();
+    const transformedCode = code.replace(REPLACER_REGEX, placeholder => {
+        if (placeholders.has(placeholder)) {
+            containedPlaceholders.add(placeholder);
+            return `${hashPlaceholderLeft}${'0'.repeat(placeholder.length - hashPlaceholderOverhead)}${hashPlaceholderRight}`;
+        }
+        return placeholder;
+    });
+    return { containedPlaceholders, transformedCode };
+};
+
+const lowercaseBundleKeys = Symbol('bundleKeys');
+const FILE_PLACEHOLDER = {
+    type: 'placeholder'
+};
+const getOutputBundle = (outputBundleBase) => {
+    const reservedLowercaseBundleKeys = new Set();
+    return new Proxy(outputBundleBase, {
+        deleteProperty(target, key) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.delete(key.toLowerCase());
+            }
+            return Reflect.deleteProperty(target, key);
+        },
+        get(target, key) {
+            if (key === lowercaseBundleKeys) {
+                return reservedLowercaseBundleKeys;
+            }
+            return Reflect.get(target, key);
+        },
+        set(target, key, value) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.add(key.toLowerCase());
+            }
+            return Reflect.set(target, key, value);
+        }
+    });
+};
+const removeUnreferencedAssets = (outputBundle) => {
+    const unreferencedAssets = new Set();
+    const bundleEntries = Object.values(outputBundle);
+    for (const asset of bundleEntries) {
+        if (asset.type === 'asset' && asset.needsCodeReference) {
+            unreferencedAssets.add(asset.fileName);
+        }
+    }
+    for (const chunk of bundleEntries) {
+        if (chunk.type === 'chunk') {
+            for (const referencedFile of chunk.referencedFiles) {
+                if (unreferencedAssets.has(referencedFile)) {
+                    unreferencedAssets.delete(referencedFile);
+                }
+            }
+        }
+    }
+    for (const file of unreferencedAssets) {
+        delete outputBundle[file];
+    }
+};
+
+function renderNamePattern(pattern, patternName, replacements) {
+    if (isPathFragment(pattern))
+        return error(logFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
+    return pattern.replace(/\[(\w+)(:\d+)?]/g, (_match, type, size) => {
+        if (!replacements.hasOwnProperty(type) || (size && type !== 'hash')) {
+            return error(logFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
+        }
+        const replacement = replacements[type](size && Number.parseInt(size.slice(1)));
+        if (isPathFragment(replacement))
+            return error(logFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
+        return replacement;
+    });
+}
+function makeUnique(name, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
+    if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
+        return name;
+    const extension = extname(name);
+    name = name.slice(0, Math.max(0, name.length - extension.length));
+    let uniqueName, uniqueIndex = 1;
+    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + extension).toLowerCase()))
+        ;
+    return uniqueName;
+}
+
+const NON_ASSET_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+]);
+function getGlobalName(chunk, globals, hasExports, log) {
+    const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
+    if (globalName) {
+        return globalName;
+    }
+    if (hasExports) {
+        log(LOGLEVEL_WARN, logMissingGlobalName(chunk.id, chunk.variableName));
+        return chunk.variableName;
+    }
+}
+class Chunk {
+    constructor(orderedModules, inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, manualChunkAlias, getPlaceholder, bundle, inputBase, snippets) {
+        this.orderedModules = orderedModules;
+        this.inputOptions = inputOptions;
+        this.outputOptions = outputOptions;
+        this.unsetOptions = unsetOptions;
+        this.pluginDriver = pluginDriver;
+        this.modulesById = modulesById;
+        this.chunkByModule = chunkByModule;
+        this.externalChunkByModule = externalChunkByModule;
+        this.facadeChunkByModule = facadeChunkByModule;
+        this.includedNamespaces = includedNamespaces;
+        this.manualChunkAlias = manualChunkAlias;
+        this.getPlaceholder = getPlaceholder;
+        this.bundle = bundle;
+        this.inputBase = inputBase;
+        this.snippets = snippets;
+        this.entryModules = [];
+        this.exportMode = 'named';
+        this.facadeModule = null;
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.accessedGlobalsByScope = new Map();
+        this.dependencies = new Set();
+        this.dynamicEntryModules = [];
+        this.dynamicName = null;
+        this.exportNamesByVariable = new Map();
+        this.exports = new Set();
+        this.exportsByName = new Map();
+        this.fileName = null;
+        this.implicitEntryModules = [];
+        this.implicitlyLoadedBefore = new Set();
+        this.imports = new Set();
+        this.includedDynamicImports = null;
+        this.includedReexportsByModule = new Map();
+        // This may be updated in the constructor
+        this.isEmpty = true;
+        this.name = null;
+        this.needsExportsShim = false;
+        this.preRenderedChunkInfo = null;
+        this.preliminaryFileName = null;
+        this.preliminarySourcemapFileName = null;
+        this.renderedChunkInfo = null;
+        this.renderedDependencies = null;
+        this.renderedModules = Object.create(null);
+        this.sortedExportNames = null;
+        this.strictFacade = false;
+        this.execIndex = orderedModules.length > 0 ? orderedModules[0].execIndex : Infinity;
+        const chunkModules = new Set(orderedModules);
+        for (const module of orderedModules) {
+            chunkByModule.set(module, this);
+            if (module.namespace.included && !outputOptions.preserveModules) {
+                includedNamespaces.add(module);
+            }
+            if (this.isEmpty && module.isIncluded()) {
+                this.isEmpty = false;
+            }
+            if (module.info.isEntry || outputOptions.preserveModules) {
+                this.entryModules.push(module);
+            }
+            for (const importer of module.includedDynamicImporters) {
+                if (!chunkModules.has(importer)) {
+                    this.dynamicEntryModules.push(module);
+                    // Modules with synthetic exports need an artificial namespace for dynamic imports
+                    if (module.info.syntheticNamedExports) {
+                        includedNamespaces.add(module);
+                        this.exports.add(module.namespace);
+                    }
+                }
+            }
+            if (module.implicitlyLoadedAfter.size > 0) {
+                this.implicitEntryModules.push(module);
+            }
+        }
+        this.suggestedVariableName = makeLegal(this.generateVariableName());
+    }
+    static generateFacade(inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, facadedModule, facadeName, getPlaceholder, bundle, inputBase, snippets) {
+        const chunk = new Chunk([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, null, getPlaceholder, bundle, inputBase, snippets);
+        chunk.assignFacadeName(facadeName, facadedModule);
+        if (!facadeChunkByModule.has(facadedModule)) {
+            facadeChunkByModule.set(facadedModule, chunk);
+        }
+        for (const dependency of facadedModule.getDependenciesToBeIncluded()) {
+            chunk.dependencies.add(dependency instanceof Module
+                ? chunkByModule.get(dependency)
+                : externalChunkByModule.get(dependency));
+        }
+        if (!chunk.dependencies.has(chunkByModule.get(facadedModule)) &&
+            facadedModule.info.moduleSideEffects &&
+            facadedModule.hasEffects()) {
+            chunk.dependencies.add(chunkByModule.get(facadedModule));
+        }
+        chunk.ensureReexportsAreAvailableForModule(facadedModule);
+        chunk.facadeModule = facadedModule;
+        chunk.strictFacade = true;
+        return chunk;
+    }
+    canModuleBeFacade(module, exposedVariables) {
+        const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
+        for (const exposedVariable of this.exports) {
+            if (!moduleExportNamesByVariable.has(exposedVariable)) {
+                return false;
+            }
+        }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
+        for (const exposedVariable of exposedVariables) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    finalizeChunk(code, map, sourcemapFileName, hashesByPlaceholder) {
+        const renderedChunkInfo = this.getRenderedChunkInfo();
+        const finalize = (code) => replacePlaceholders(code, hashesByPlaceholder);
+        const preliminaryFileName = renderedChunkInfo.fileName;
+        const fileName = (this.fileName = finalize(preliminaryFileName));
+        return {
+            ...renderedChunkInfo,
+            code,
+            dynamicImports: renderedChunkInfo.dynamicImports.map(finalize),
+            fileName,
+            implicitlyLoadedBefore: renderedChunkInfo.implicitlyLoadedBefore.map(finalize),
+            importedBindings: Object.fromEntries(Object.entries(renderedChunkInfo.importedBindings).map(([fileName, bindings]) => [
+                finalize(fileName),
+                bindings
+            ])),
+            imports: renderedChunkInfo.imports.map(finalize),
+            map,
+            preliminaryFileName,
+            referencedFiles: renderedChunkInfo.referencedFiles.map(finalize),
+            sourcemapFileName
+        };
+    }
+    generateExports() {
+        this.sortedExportNames = null;
+        const remainingExports = new Set(this.exports);
+        if (this.facadeModule !== null &&
+            (this.facadeModule.preserveSignature !== false || this.strictFacade)) {
+            const exportNamesByVariable = this.facadeModule.getExportNamesByVariable();
+            for (const [variable, exportNames] of exportNamesByVariable) {
+                this.exportNamesByVariable.set(variable, [...exportNames]);
+                for (const exportName of exportNames) {
+                    this.exportsByName.set(exportName, variable);
+                }
+                remainingExports.delete(variable);
+            }
+        }
+        if (this.outputOptions.minifyInternalExports) {
+            assignExportsToMangledNames(remainingExports, this.exportsByName, this.exportNamesByVariable);
+        }
+        else {
+            assignExportsToNames(remainingExports, this.exportsByName, this.exportNamesByVariable);
+        }
+        if (this.outputOptions.preserveModules || (this.facadeModule && this.facadeModule.info.isEntry))
+            this.exportMode = getExportMode(this, this.outputOptions, this.facadeModule.id, this.inputOptions.onLog);
+    }
+    generateFacades() {
+        const facades = [];
+        const entryModules = new Set([...this.entryModules, ...this.implicitEntryModules]);
+        const exposedVariables = new Set(this.dynamicEntryModules.map(({ namespace }) => namespace));
+        for (const module of entryModules) {
+            if (module.preserveSignature) {
+                for (const exportedVariable of module.getExportNamesByVariable().keys()) {
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
+                }
+            }
+        }
+        for (const module of entryModules) {
+            const requiredFacades = Array.from(new Set(module.chunkNames.filter(({ isUserDefined }) => isUserDefined).map(({ name }) => name)), 
+            // mapping must run after Set 'name' dedupe
+            name => ({
+                name
+            }));
+            if (requiredFacades.length === 0 && module.isUserDefinedEntryPoint) {
+                requiredFacades.push({});
+            }
+            requiredFacades.push(...Array.from(module.chunkFileNames, fileName => ({ fileName })));
+            if (requiredFacades.length === 0) {
+                requiredFacades.push({});
+            }
+            if (!this.facadeModule) {
+                const needsStrictFacade = !this.outputOptions.preserveModules &&
+                    (module.preserveSignature === 'strict' ||
+                        (module.preserveSignature === 'exports-only' &&
+                            module.getExportNamesByVariable().size > 0));
+                if (!needsStrictFacade || this.canModuleBeFacade(module, exposedVariables)) {
+                    this.facadeModule = module;
+                    this.facadeChunkByModule.set(module, this);
+                    if (module.preserveSignature) {
+                        this.strictFacade = needsStrictFacade;
+                    }
+                    this.assignFacadeName(requiredFacades.shift(), module, this.outputOptions.preserveModules);
+                }
+            }
+            for (const facadeName of requiredFacades) {
+                facades.push(Chunk.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName, this.getPlaceholder, this.bundle, this.inputBase, this.snippets));
+            }
+        }
+        for (const module of this.dynamicEntryModules) {
+            if (module.info.syntheticNamedExports)
+                continue;
+            if (!this.facadeModule && this.canModuleBeFacade(module, exposedVariables)) {
+                this.facadeModule = module;
+                this.facadeChunkByModule.set(module, this);
+                this.strictFacade = true;
+                this.dynamicName = getChunkNameFromModule(module);
+            }
+            else if (this.facadeModule === module &&
+                !this.strictFacade &&
+                this.canModuleBeFacade(module, exposedVariables)) {
+                this.strictFacade = true;
+            }
+            else if (!this.facadeChunkByModule.get(module)?.strictFacade) {
+                this.includedNamespaces.add(module);
+                this.exports.add(module.namespace);
+            }
+        }
+        if (!this.outputOptions.preserveModules) {
+            this.addNecessaryImportsForFacades();
+        }
+        return facades;
+    }
+    getChunkName() {
+        return (this.name ??= this.outputOptions.sanitizeFileName(this.getFallbackChunkName()));
+    }
+    getExportNames() {
+        return (this.sortedExportNames ??= [...this.exportsByName.keys()].sort());
+    }
+    getFileName() {
+        return this.fileName || this.getPreliminaryFileName().fileName;
+    }
+    getImportPath(importer) {
+        return escapeId(getImportPath(importer, this.getFileName(), this.outputOptions.format === 'amd' && !this.outputOptions.amd.forceJsExtensionForImports, true));
+    }
+    getPreliminaryFileName() {
+        if (this.preliminaryFileName) {
+            return this.preliminaryFileName;
+        }
+        let fileName;
+        let hashPlaceholder = null;
+        const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
+        if (file) {
+            fileName = basename(file);
+        }
+        else if (this.fileName === null) {
+            const [pattern, patternName] = preserveModules || this.facadeModule?.isUserDefinedEntryPoint
+                ? [entryFileNames, 'output.entryFileNames']
+                : [chunkFileNames, 'output.chunkFileNames'];
+            fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
+                format: () => format,
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
+                name: () => this.getChunkName()
+            });
+            if (!hashPlaceholder) {
+                fileName = makeUnique(fileName, this.bundle);
+            }
+        }
+        else {
+            fileName = this.fileName;
+        }
+        if (!hashPlaceholder) {
+            this.bundle[fileName] = FILE_PLACEHOLDER;
+        }
+        // Caching is essential to not conflict with the file name reservation above
+        return (this.preliminaryFileName = { fileName, hashPlaceholder });
+    }
+    getPreliminarySourcemapFileName() {
+        if (this.preliminarySourcemapFileName) {
+            return this.preliminarySourcemapFileName;
+        }
+        let sourcemapFileName = null;
+        let hashPlaceholder = null;
+        const { sourcemapFileNames, format } = this.outputOptions;
+        if (sourcemapFileNames) {
+            const [pattern, patternName] = [sourcemapFileNames, 'output.sourcemapFileNames'];
+            sourcemapFileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
+                chunkhash: () => this.getPreliminaryFileName().hashPlaceholder || '',
+                format: () => format,
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
+                name: () => this.getChunkName()
+            });
+            if (!hashPlaceholder) {
+                sourcemapFileName = makeUnique(sourcemapFileName, this.bundle);
+            }
+        }
+        else {
+            return null;
+        }
+        return (this.preliminarySourcemapFileName = { fileName: sourcemapFileName, hashPlaceholder });
+    }
+    getRenderedChunkInfo() {
+        if (this.renderedChunkInfo) {
+            return this.renderedChunkInfo;
+        }
+        return (this.renderedChunkInfo = {
+            ...this.getPreRenderedChunkInfo(),
+            dynamicImports: this.getDynamicDependencies().map(resolveFileName),
+            fileName: this.getFileName(),
+            implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, resolveFileName),
+            importedBindings: getImportedBindingsPerDependency(this.getRenderedDependencies(), resolveFileName),
+            imports: Array.from(this.dependencies, resolveFileName),
+            modules: this.renderedModules,
+            referencedFiles: this.getReferencedFiles()
+        });
+    }
+    getVariableExportName(variable) {
+        if (this.outputOptions.preserveModules && variable instanceof NamespaceVariable) {
+            return '*';
+        }
+        return this.exportNamesByVariable.get(variable)[0];
+    }
+    link() {
+        this.dependencies = getStaticDependencies(this, this.orderedModules, this.chunkByModule, this.externalChunkByModule);
+        for (const module of this.orderedModules) {
+            this.addImplicitlyLoadedBeforeFromModule(module);
+            this.setUpChunkImportsAndExportsForModule(module);
+        }
+    }
+    async render() {
+        const { dependencies, exportMode, facadeModule, inputOptions: { onLog }, outputOptions, pluginDriver, snippets } = this;
+        const { format, hoistTransitiveImports, preserveModules } = outputOptions;
+        // for static and dynamic entry points, add transitive dependencies to this
+        // chunk's dependencies to avoid loading latency
+        if (hoistTransitiveImports && !preserveModules && facadeModule !== null) {
+            for (const dep of dependencies) {
+                if (dep instanceof Chunk)
+                    this.inlineChunkDependencies(dep);
+            }
+        }
+        const preliminaryFileName = this.getPreliminaryFileName();
+        const preliminarySourcemapFileName = this.getPreliminarySourcemapFileName();
+        const { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait } = this.renderModules(preliminaryFileName.fileName);
+        const renderedDependencies = [...this.getRenderedDependencies().values()];
+        const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
+        let hasExports = renderedExports.length > 0;
+        let hasDefaultExport = false;
+        for (const renderedDependency of renderedDependencies) {
+            const { reexports } = renderedDependency;
+            if (reexports?.length) {
+                hasExports = true;
+                if (!hasDefaultExport && reexports.some(reexport => reexport.reexported === 'default')) {
+                    hasDefaultExport = true;
+                }
+                if (format === 'es') {
+                    renderedDependency.reexports = reexports.filter(({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
+                }
+            }
+        }
+        if (!hasDefaultExport) {
+            for (const { exported } of renderedExports) {
+                if (exported === 'default') {
+                    hasDefaultExport = true;
+                    break;
+                }
+            }
+        }
+        const { intro, outro, banner, footer } = await createAddons(outputOptions, pluginDriver, this.getRenderedChunkInfo());
+        finalisers[format](renderedSource, {
+            accessedGlobals,
+            dependencies: renderedDependencies,
+            exports: renderedExports,
+            hasDefaultExport,
+            hasExports,
+            id: preliminaryFileName.fileName,
+            indent,
+            intro,
+            isEntryFacade: preserveModules || (facadeModule !== null && facadeModule.info.isEntry),
+            isModuleFacade: facadeModule !== null,
+            log: onLog,
+            namedExportsMode: exportMode !== 'default',
+            outro,
+            snippets,
+            usesTopLevelAwait
+        }, outputOptions);
+        if (banner)
+            magicString.prepend(banner);
+        if (format === 'es' || format === 'cjs') {
+            const shebang = facadeModule !== null && facadeModule.info.isEntry && facadeModule.shebang;
+            if (shebang) {
+                magicString.prepend(`#!${shebang}\n`);
+            }
+        }
+        if (footer)
+            magicString.append(footer);
+        return {
+            chunk: this,
+            magicString,
+            preliminaryFileName,
+            preliminarySourcemapFileName,
+            usedModules
+        };
+    }
+    addImplicitlyLoadedBeforeFromModule(baseModule) {
+        const { chunkByModule, implicitlyLoadedBefore } = this;
+        for (const module of baseModule.implicitlyLoadedBefore) {
+            const chunk = chunkByModule.get(module);
+            if (chunk && chunk !== this) {
+                implicitlyLoadedBefore.add(chunk);
+            }
+        }
+    }
+    addNecessaryImportsForFacades() {
+        for (const [module, variables] of this.includedReexportsByModule) {
+            if (this.includedNamespaces.has(module)) {
+                for (const variable of variables) {
+                    this.imports.add(variable);
+                }
+            }
+        }
+    }
+    assignFacadeName({ fileName, name }, facadedModule, preservePath) {
+        if (fileName) {
+            this.fileName = fileName;
+        }
+        else {
+            this.name = this.outputOptions.sanitizeFileName(name ||
+                (preservePath
+                    ? this.getPreserveModulesChunkNameFromModule(facadedModule)
+                    : getChunkNameFromModule(facadedModule)));
+        }
+    }
+    checkCircularDependencyImport(variable, importingModule) {
+        const variableModule = variable.module;
+        if (variableModule instanceof Module) {
+            const exportChunk = this.chunkByModule.get(variableModule);
+            let alternativeReexportModule;
+            do {
+                alternativeReexportModule = importingModule.alternativeReexportModules.get(variable);
+                if (alternativeReexportModule) {
+                    const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
+                    if (exportingChunk !== exportChunk) {
+                        this.inputOptions.onLog(LOGLEVEL_WARN, logCyclicCrossChunkReexport(
+                        // Namespaces do not have an export name
+                        variableModule.getExportNamesByVariable().get(variable)?.[0] || '*', variableModule.id, alternativeReexportModule.id, importingModule.id, this.outputOptions.preserveModules));
+                    }
+                    importingModule = alternativeReexportModule;
+                }
+            } while (alternativeReexportModule);
+        }
+    }
+    ensureReexportsAreAvailableForModule(module) {
+        const includedReexports = [];
+        const map = module.getExportNamesByVariable();
+        for (const exportedVariable of map.keys()) {
+            const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
+            const importedVariable = isSynthetic ? exportedVariable.getBaseVariable() : exportedVariable;
+            this.checkCircularDependencyImport(importedVariable, module);
+            // When preserving modules, we do not create namespace objects but directly
+            // use the actual namespaces, which would be broken by this logic.
+            if (!(importedVariable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+                const exportingModule = importedVariable.module;
+                if (exportingModule instanceof Module) {
+                    const chunk = this.chunkByModule.get(exportingModule);
+                    if (chunk && chunk !== this) {
+                        chunk.exports.add(importedVariable);
+                        includedReexports.push(importedVariable);
+                        if (isSynthetic) {
+                            this.imports.add(importedVariable);
+                        }
+                    }
+                }
+            }
+        }
+        if (includedReexports.length > 0) {
+            this.includedReexportsByModule.set(module, includedReexports);
+        }
+    }
+    generateVariableName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
+        }
+        const moduleForNaming = this.entryModules[0] ||
+            this.implicitEntryModules[0] ||
+            this.dynamicEntryModules[0] ||
+            this.orderedModules[this.orderedModules.length - 1];
+        if (moduleForNaming) {
+            return getChunkNameFromModule(moduleForNaming);
+        }
+        return 'chunk';
+    }
+    getChunkExportDeclarations(format) {
+        const exports = [];
+        for (const exportName of this.getExportNames()) {
+            if (exportName[0] === '*')
+                continue;
+            const variable = this.exportsByName.get(exportName);
+            if (!(variable instanceof SyntheticNamedExportVariable)) {
+                const module = variable.module;
+                if (module) {
+                    const chunk = this.chunkByModule.get(module);
+                    if (chunk !== this) {
+                        if (!chunk || format !== 'es') {
+                            continue;
+                        }
+                        const chunkDep = this.renderedDependencies.get(chunk);
+                        if (!chunkDep) {
+                            continue;
+                        }
+                        const { imports, reexports } = chunkDep;
+                        const importedByReexported = reexports?.find(({ reexported }) => reexported === exportName);
+                        const isImported = imports?.find(({ imported }) => imported === importedByReexported?.imported);
+                        if (!isImported) {
+                            continue;
+                        }
+                    }
+                }
+            }
+            let expression = null;
+            let hoisted = false;
+            let local = variable.getName(this.snippets.getPropertyAccess);
+            if (variable instanceof LocalVariable) {
+                for (const declaration of variable.declarations) {
+                    if (declaration.parent instanceof FunctionDeclaration ||
+                        (declaration instanceof ExportDefaultDeclaration &&
+                            declaration.declaration instanceof FunctionDeclaration)) {
+                        hoisted = true;
+                        break;
+                    }
+                }
+            }
+            else if (variable instanceof SyntheticNamedExportVariable) {
+                expression = local;
+                if (format === 'es') {
+                    local = variable.renderName;
+                }
+            }
+            exports.push({
+                exported: exportName,
+                expression,
+                hoisted,
+                local
+            });
+        }
+        return exports;
+    }
+    getDependenciesToBeDeconflicted(addNonNamespacesAndInteropHelpers, addDependenciesWithoutBindings, interop) {
+        const dependencies = new Set();
+        const deconflictedDefault = new Set();
+        const deconflictedNamespace = new Set();
+        for (const variable of [...this.exportNamesByVariable.keys(), ...this.imports]) {
+            if (addNonNamespacesAndInteropHelpers || variable.isNamespace) {
+                const module = variable.module;
+                if (module instanceof ExternalModule) {
+                    const chunk = this.externalChunkByModule.get(module);
+                    dependencies.add(chunk);
+                    if (addNonNamespacesAndInteropHelpers) {
+                        if (variable.name === 'default') {
+                            if (defaultInteropHelpersByInteropType[interop(module.id)]) {
+                                deconflictedDefault.add(chunk);
+                            }
+                        }
+                        else if (variable.isNamespace &&
+                            namespaceInteropHelpersByInteropType[interop(module.id)] &&
+                            (this.imports.has(variable) ||
+                                !this.exportNamesByVariable.get(variable)?.every(name => name.startsWith('*')))) {
+                            // We only need to deconflict it if the namespace is actually
+                            // created as a variable, i.e. because it is used internally or
+                            // because it is reexported as an object
+                            deconflictedNamespace.add(chunk);
+                        }
+                    }
+                }
+                else {
+                    const chunk = this.chunkByModule.get(module);
+                    if (chunk !== this) {
+                        dependencies.add(chunk);
+                        if (addNonNamespacesAndInteropHelpers &&
+                            chunk.exportMode === 'default' &&
+                            variable.isNamespace) {
+                            deconflictedNamespace.add(chunk);
+                        }
+                    }
+                }
+            }
+        }
+        if (addDependenciesWithoutBindings) {
+            for (const dependency of this.dependencies) {
+                dependencies.add(dependency);
+            }
+        }
+        return { deconflictedDefault, deconflictedNamespace, dependencies };
+    }
+    getDynamicDependencies() {
+        return this.getIncludedDynamicImports()
+            .map(resolvedDynamicImport => resolvedDynamicImport.facadeChunk ||
+            resolvedDynamicImport.chunk ||
+            resolvedDynamicImport.externalChunk ||
+            resolvedDynamicImport.resolution)
+            .filter((resolution) => resolution !== this &&
+            (resolution instanceof Chunk || resolution instanceof ExternalChunk));
+    }
+    getDynamicImportStringAndAttributes(resolution, fileName) {
+        if (resolution instanceof ExternalModule) {
+            const chunk = this.externalChunkByModule.get(resolution);
+            return [`'${chunk.getImportPath(fileName)}'`, chunk.getImportAttributes(this.snippets)];
+        }
+        return [
+            resolution || '',
+            (this.outputOptions.format === 'es' && this.outputOptions.externalImportAttributes) || null
+        ];
+    }
+    getFallbackChunkName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
+        }
+        if (this.dynamicName) {
+            return this.dynamicName;
+        }
+        if (this.fileName) {
+            return getAliasName(this.fileName);
+        }
+        return getAliasName(this.orderedModules[this.orderedModules.length - 1].id);
+    }
+    getImportSpecifiers() {
+        const { interop } = this.outputOptions;
+        const importsByDependency = new Map();
+        for (const variable of this.imports) {
+            const module = variable.module;
+            let dependency;
+            let imported;
+            if (module instanceof ExternalModule) {
+                dependency = this.externalChunkByModule.get(module);
+                imported = variable.name;
+                if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
+                    return error(logUnexpectedNamedImport(module.id, imported, false));
+                }
+            }
+            else {
+                dependency = this.chunkByModule.get(module);
+                imported = dependency.getVariableExportName(variable);
+            }
+            getOrCreate(importsByDependency, dependency, getNewArray).push({
+                imported,
+                local: variable.getName(this.snippets.getPropertyAccess)
+            });
+        }
+        return importsByDependency;
+    }
+    getIncludedDynamicImports() {
+        if (this.includedDynamicImports) {
+            return this.includedDynamicImports;
+        }
+        const includedDynamicImports = [];
+        for (const module of this.orderedModules) {
+            for (const { node, resolution } of module.dynamicImports) {
+                if (!node.included) {
+                    continue;
+                }
+                includedDynamicImports.push(resolution instanceof Module
+                    ? {
+                        chunk: this.chunkByModule.get(resolution),
+                        externalChunk: null,
+                        facadeChunk: this.facadeChunkByModule.get(resolution),
+                        node,
+                        resolution
+                    }
+                    : resolution instanceof ExternalModule
+                        ? {
+                            chunk: null,
+                            externalChunk: this.externalChunkByModule.get(resolution),
+                            facadeChunk: null,
+                            node,
+                            resolution
+                        }
+                        : { chunk: null, externalChunk: null, facadeChunk: null, node, resolution });
+            }
+        }
+        return (this.includedDynamicImports = includedDynamicImports);
+    }
+    getPreRenderedChunkInfo() {
+        if (this.preRenderedChunkInfo) {
+            return this.preRenderedChunkInfo;
+        }
+        const { dynamicEntryModules, facadeModule, implicitEntryModules, orderedModules } = this;
+        return (this.preRenderedChunkInfo = {
+            exports: this.getExportNames(),
+            facadeModuleId: facadeModule && facadeModule.id,
+            isDynamicEntry: dynamicEntryModules.length > 0,
+            isEntry: !!facadeModule?.info.isEntry,
+            isImplicitEntry: implicitEntryModules.length > 0,
+            moduleIds: orderedModules.map(({ id }) => id),
+            name: this.getChunkName(),
+            type: 'chunk'
+        });
+    }
+    getPreserveModulesChunkNameFromModule(module) {
+        const predefinedChunkName = getPredefinedChunkNameFromModule(module);
+        if (predefinedChunkName)
+            return predefinedChunkName;
+        const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
+        const sanitizedId = sanitizeFileName(normalize(module.id.split(QUERY_HASH_REGEX, 1)[0]));
+        const extensionName = extname(sanitizedId);
+        const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
+            ? sanitizedId.slice(0, -extensionName.length)
+            : sanitizedId;
+        if (isAbsolute$1(idWithoutExtension)) {
+            if (preserveModulesRoot && resolve$1(idWithoutExtension).startsWith(preserveModulesRoot)) {
+                return idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '');
+            }
+            else {
+                // handle edge case in Windows
+                if (this.inputBase === '/' && !idWithoutExtension.startsWith('/')) {
+                    return relative$1(this.inputBase, idWithoutExtension.replace(/^[a-zA-Z]:[/\\]/, '/'));
+                }
+                return relative$1(this.inputBase, idWithoutExtension);
+            }
+        }
+        else {
+            return (this.outputOptions.virtualDirname.replace(/\/$/, '') + '/' + basename(idWithoutExtension));
+        }
+    }
+    getReexportSpecifiers() {
+        const { externalLiveBindings, interop } = this.outputOptions;
+        const reexportSpecifiers = new Map();
+        for (let exportName of this.getExportNames()) {
+            let dependency;
+            let imported;
+            let needsLiveBinding = false;
+            if (exportName[0] === '*') {
+                const id = exportName.slice(1);
+                if (interop(id) === 'defaultOnly') {
+                    this.inputOptions.onLog(LOGLEVEL_WARN, logUnexpectedNamespaceReexport(id));
+                }
+                needsLiveBinding = externalLiveBindings;
+                dependency = this.externalChunkByModule.get(this.modulesById.get(id));
+                imported = exportName = '*';
+            }
+            else {
+                const variable = this.exportsByName.get(exportName);
+                if (variable instanceof SyntheticNamedExportVariable)
+                    continue;
+                const module = variable.module;
+                if (module instanceof Module) {
+                    dependency = this.chunkByModule.get(module);
+                    if (dependency === this)
+                        continue;
+                    imported = dependency.getVariableExportName(variable);
+                    needsLiveBinding = variable.isReassigned;
+                }
+                else {
+                    dependency = this.externalChunkByModule.get(module);
+                    imported = variable.name;
+                    if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
+                        return error(logUnexpectedNamedImport(module.id, imported, true));
+                    }
+                    needsLiveBinding =
+                        externalLiveBindings &&
+                            (imported !== 'default' || isDefaultAProperty(interop(module.id), true));
+                }
+            }
+            getOrCreate(reexportSpecifiers, dependency, getNewArray).push({
+                imported,
+                needsLiveBinding,
+                reexported: exportName
+            });
+        }
+        return reexportSpecifiers;
+    }
+    getReferencedFiles() {
+        const referencedFiles = new Set();
+        for (const module of this.orderedModules) {
+            for (const meta of module.importMetas) {
+                const fileName = meta.getReferencedFileName(this.pluginDriver);
+                if (fileName) {
+                    referencedFiles.add(fileName);
+                }
+            }
+        }
+        return [...referencedFiles];
+    }
+    getRenderedDependencies() {
+        if (this.renderedDependencies) {
+            return this.renderedDependencies;
+        }
+        const importSpecifiers = this.getImportSpecifiers();
+        const reexportSpecifiers = this.getReexportSpecifiers();
+        const renderedDependencies = new Map();
+        const fileName = this.getFileName();
+        for (const dependency of this.dependencies) {
+            const imports = importSpecifiers.get(dependency) || null;
+            const reexports = reexportSpecifiers.get(dependency) || null;
+            const namedExportsMode = dependency instanceof ExternalChunk || dependency.exportMode !== 'default';
+            const importPath = dependency.getImportPath(fileName);
+            renderedDependencies.set(dependency, {
+                attributes: dependency instanceof ExternalChunk
+                    ? dependency.getImportAttributes(this.snippets)
+                    : null,
+                defaultVariableName: dependency.defaultVariableName,
+                globalName: dependency instanceof ExternalChunk &&
+                    (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
+                    getGlobalName(dependency, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
+                importPath,
+                imports,
+                isChunk: dependency instanceof Chunk,
+                name: dependency.variableName,
+                namedExportsMode,
+                namespaceVariableName: dependency.namespaceVariableName,
+                reexports
+            });
+        }
+        return (this.renderedDependencies = renderedDependencies);
+    }
+    inlineChunkDependencies(chunk) {
+        for (const dep of chunk.dependencies) {
+            if (this.dependencies.has(dep))
+                continue;
+            this.dependencies.add(dep);
+            if (dep instanceof Chunk) {
+                this.inlineChunkDependencies(dep);
+            }
+        }
+    }
+    // This method changes properties on the AST before rendering and must not be async
+    renderModules(fileName) {
+        const { accessedGlobalsByScope, dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onLog }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
+        const { compact, format, freeze, generatedCode: { symbols } } = outputOptions;
+        const { _, cnst, n } = snippets;
+        this.setDynamicImportResolutions(fileName);
+        this.setImportMetaResolutions(fileName);
+        this.setIdentifierRenderResolutions();
+        const magicString = new Bundle$1({ separator: `${n}${n}` });
+        const indent = getIndentString(orderedModules, outputOptions);
+        const usedModules = [];
+        let hoistedSource = '';
+        const accessedGlobals = new Set();
+        const renderedModuleSources = new Map();
+        const renderOptions = {
+            accessedDocumentCurrentScript: false,
+            exportNamesByVariable,
+            format,
+            freeze,
+            indent,
+            pluginDriver,
+            snippets,
+            symbols,
+            useOriginalName: null
+        };
+        let usesTopLevelAwait = false;
+        for (const module of orderedModules) {
+            let renderedLength = 0;
+            let source;
+            if (module.isIncluded() || includedNamespaces.has(module)) {
+                const rendered = module.render(renderOptions);
+                if (!renderOptions.accessedDocumentCurrentScript &&
+                    formatsMaybeAccessDocumentCurrentScript.includes(format)) {
+                    this.accessedGlobalsByScope.get(module.scope)?.delete(DOCUMENT_CURRENT_SCRIPT);
+                }
+                renderOptions.accessedDocumentCurrentScript = false;
+                ({ source } = rendered);
+                usesTopLevelAwait ||= rendered.usesTopLevelAwait;
+                renderedLength = source.length();
+                if (renderedLength) {
+                    if (compact && source.lastLine().includes('//'))
+                        source.append('\n');
+                    renderedModuleSources.set(module, source);
+                    magicString.addSource(source);
+                    usedModules.push(module);
+                }
+                const namespace = module.namespace;
+                if (includedNamespaces.has(module)) {
+                    const rendered = namespace.renderBlock(renderOptions);
+                    if (namespace.renderFirst())
+                        hoistedSource += n + rendered;
+                    else
+                        magicString.addSource(new MagicString(rendered));
+                }
+                const accessedGlobalVariables = accessedGlobalsByScope.get(module.scope);
+                if (accessedGlobalVariables) {
+                    for (const name of accessedGlobalVariables) {
+                        accessedGlobals.add(name);
+                    }
+                }
+            }
+            const { renderedExports, removedExports } = module.getRenderedExports();
+            renderedModules[module.id] = {
+                get code() {
+                    return source?.toString() ?? null;
+                },
+                originalLength: module.originalCode.length,
+                removedExports,
+                renderedExports,
+                renderedLength
+            };
+        }
+        if (hoistedSource)
+            magicString.prepend(hoistedSource + n + n);
+        if (this.needsExportsShim) {
+            magicString.prepend(`${n}${cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
+        }
+        const renderedSource = compact ? magicString : magicString.trim();
+        if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
+            onLog(LOGLEVEL_WARN, logEmptyChunk(this.getChunkName()));
+        }
+        return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
+    }
+    setDynamicImportResolutions(fileName) {
+        const { accessedGlobalsByScope, outputOptions, pluginDriver, snippets } = this;
+        for (const resolvedDynamicImport of this.getIncludedDynamicImports()) {
+            if (resolvedDynamicImport.chunk) {
+                const { chunk, facadeChunk, node, resolution } = resolvedDynamicImport;
+                if (chunk === this) {
+                    node.setInternalResolution(resolution.namespace);
+                }
+                else {
+                    node.setExternalResolution((facadeChunk || chunk).exportMode, resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, `'${(facadeChunk || chunk).getImportPath(fileName)}'`, !facadeChunk?.strictFacade && chunk.exportNamesByVariable.get(resolution.namespace)[0], null);
+                }
+            }
+            else {
+                const { node, resolution } = resolvedDynamicImport;
+                const [resolutionString, attributes] = this.getDynamicImportStringAndAttributes(resolution, fileName);
+                node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, attributes);
+            }
+        }
+    }
+    setIdentifierRenderResolutions() {
+        const { format, generatedCode: { symbols }, interop, preserveModules, externalLiveBindings } = this.outputOptions;
+        const syntheticExports = new Set();
+        for (const exportName of this.getExportNames()) {
+            const exportVariable = this.exportsByName.get(exportName);
+            if (format !== 'es' &&
+                format !== 'system' &&
+                exportVariable.isReassigned &&
+                !exportVariable.isId) {
+                exportVariable.setRenderNames('exports', exportName);
+            }
+            else if (exportVariable instanceof SyntheticNamedExportVariable) {
+                syntheticExports.add(exportVariable);
+            }
+            else {
+                exportVariable.setRenderNames(null, null);
+            }
+        }
+        for (const module of this.orderedModules) {
+            if (module.needsExportShim) {
+                this.needsExportsShim = true;
+                break;
+            }
+        }
+        const usedNames = new Set(['Object', 'Promise']);
+        if (this.needsExportsShim) {
+            usedNames.add(MISSING_EXPORT_SHIM_VARIABLE);
+        }
+        if (symbols) {
+            usedNames.add('Symbol');
+        }
+        switch (format) {
+            case 'system': {
+                usedNames.add('module').add('exports');
+                break;
+            }
+            case 'es': {
+                break;
+            }
+            case 'cjs': {
+                usedNames.add('module').add('require').add('__filename').add('__dirname');
+            }
+            // fallthrough
+            default: {
+                usedNames.add('exports');
+                for (const helper of HELPER_NAMES) {
+                    usedNames.add(helper);
+                }
+            }
+        }
+        deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, preserveModules, externalLiveBindings, this.chunkByModule, this.externalChunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
+    }
+    setImportMetaResolutions(fileName) {
+        const { accessedGlobalsByScope, includedNamespaces, orderedModules, outputOptions: { format } } = this;
+        for (const module of orderedModules) {
+            for (const importMeta of module.importMetas) {
+                importMeta.setResolution(format, accessedGlobalsByScope, fileName);
+            }
+            if (includedNamespaces.has(module)) {
+                module.namespace.prepare(accessedGlobalsByScope);
+            }
+        }
+    }
+    setUpChunkImportsAndExportsForModule(module) {
+        const moduleImports = new Set(module.includedImports);
+        // when we are not preserving modules, we need to make all namespace variables available for
+        // rendering the namespace object
+        if (!this.outputOptions.preserveModules && this.includedNamespaces.has(module)) {
+            const memberVariables = module.namespace.getMemberVariables();
+            for (const variable of Object.values(memberVariables)) {
+                if (variable.included) {
+                    moduleImports.add(variable);
+                }
+            }
+        }
+        for (let variable of moduleImports) {
+            if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            const chunk = this.chunkByModule.get(variable.module);
+            if (chunk !== this) {
+                this.imports.add(variable);
+                if (variable.module instanceof Module) {
+                    this.checkCircularDependencyImport(variable, module);
+                    // When preserving modules, we do not create namespace objects but directly
+                    // use the actual namespaces, which would be broken by this logic.
+                    if (!(variable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+                        chunk.exports.add(variable);
+                    }
+                }
+            }
+        }
+        if (this.includedNamespaces.has(module) ||
+            (module.info.isEntry && module.preserveSignature !== false) ||
+            module.includedDynamicImporters.some(importer => this.chunkByModule.get(importer) !== this)) {
+            this.ensureReexportsAreAvailableForModule(module);
+        }
+        for (const { node, resolution } of module.dynamicImports) {
+            if (node.included &&
+                resolution instanceof Module &&
+                this.chunkByModule.get(resolution) === this &&
+                !this.includedNamespaces.has(resolution)) {
+                this.includedNamespaces.add(resolution);
+                this.ensureReexportsAreAvailableForModule(resolution);
+            }
+        }
+    }
+}
+function getChunkNameFromModule(module) {
+    return getPredefinedChunkNameFromModule(module) ?? getAliasName(module.id);
+}
+function getPredefinedChunkNameFromModule(module) {
+    return (module.chunkNames.find(({ isUserDefined }) => isUserDefined)?.name ?? module.chunkNames[0]?.name);
+}
+function getImportedBindingsPerDependency(renderedDependencies, resolveFileName) {
+    const importedBindingsPerDependency = {};
+    for (const [dependency, declaration] of renderedDependencies) {
+        const specifiers = new Set();
+        if (declaration.imports) {
+            for (const { imported } of declaration.imports) {
+                specifiers.add(imported);
+            }
+        }
+        if (declaration.reexports) {
+            for (const { imported } of declaration.reexports) {
+                specifiers.add(imported);
+            }
+        }
+        importedBindingsPerDependency[resolveFileName(dependency)] = [...specifiers];
+    }
+    return importedBindingsPerDependency;
+}
+const QUERY_HASH_REGEX = /[#?]/;
+const resolveFileName = (dependency) => dependency.getFileName();
+
+/**
+ * Concatenate a number of iterables to a new iterable without fully evaluating
+ * their iterators. Useful when e.g. working with large sets or lists and when
+ * there is a chance that the iterators will not be fully exhausted.
+ */
+function* concatLazy(iterables) {
+    for (const iterable of iterables) {
+        yield* iterable;
+    }
+}
+
+/**
+ * At its core, the algorithm first starts from each static or dynamic entry
+ * point and then assigns that entry point to all modules than can be reached
+ * via static imports. We call this the *dependent entry points* of that
+ * module.
+ *
+ * Then we group all modules with the same dependent entry points into chunks
+ * as those modules will always be loaded together.
+ *
+ * One non-trivial optimization we can apply is that dynamic entries are
+ * different from static entries in so far as when a dynamic import occurs,
+ * some modules are already in memory. If some of these modules are also
+ * dependencies of the dynamic entry, then it does not make sense to create a
+ * separate chunk for them. Instead, the dynamic import target can load them
+ * from the importing chunk.
+ *
+ * With regard to chunking, if B is implicitly loaded after A, then this can be
+ * handled the same way as if there was a dynamic import A => B.
+ *
+ * Example:
+ * Assume A -> B (A imports B), A => C (A dynamically imports C) and C -> B.
+ * Then the initial algorithm would assign A into the A chunk, C into the C
+ * chunk and B into the AC chunk, i.e. the chunk with the dependent entry
+ * points A and C.
+ * However we know that C can only be loaded from A, so A and its dependency B
+ * must already be in memory when C is loaded. So it is enough to create only
+ * two chunks A containing [AB] and C containing [C].
+ *
+ * So we do not assign the dynamic entry C as dependent entry point to modules
+ * that are already loaded.
+ *
+ * In a more complex example, let us assume that we have entry points X and Y.
+ * Further, let us assume
+ * X -> A, X -> B, X -> C,
+ * Y -> A, Y -> B,
+ * A => D,
+ * D -> B, D -> C
+ * So without dynamic import optimization, the dependent entry points are
+ * A: XY, B: DXY, C: DX, D: D, X: X, Y: Y, so we would for now create six
+ * chunks.
+ *
+ * Now D is loaded only after A is loaded. But A is loaded if either X is
+ * loaded or Y is loaded. So the modules that are already in memory when D is
+ * loaded are the intersection of all modules that X depends on with all
+ * modules that Y depends on, which in this case are the modules A and B.
+ * We could also say they are all modules that have both X and Y as dependent
+ * entry points.
+ *
+ * So we can remove D as dependent entry point from A and B, which means they
+ * both now have only XY as dependent entry points and can be merged into the
+ * same chunk.
+ *
+ * Now let us extend this to the most general case where we have several
+ * dynamic importers for one dynamic entry point.
+ *
+ * In the most general form, it works like this:
+ * For each dynamic entry point, we have a number of dynamic importers, which
+ * are the modules importing it. Using the previous ideas, we can determine
+ * the modules already in memory for each dynamic importer by looking for all
+ * modules that have all the dependent entry points of the dynamic importer as
+ * dependent entry points.
+ * So the modules that are guaranteed to be in memory when the dynamic entry
+ * point is loaded are the intersection of the modules already in memory for
+ * each dynamic importer.
+ *
+ * Assuming that A => D and B => D and A has dependent entry points XY and B
+ * has dependent entry points YZ, then the modules guaranteed to be in memory
+ * are all modules that have at least XYZ as dependent entry points.
+ * We call XYZ the *dynamically dependent entry points* of D.
+ *
+ * Now there is one last case to consider: If one of the dynamically dependent
+ * entries is itself a dynamic entry, then any module is in memory that either
+ * is a dependency of that dynamic entry or again has the dynamic dependent
+ * entries of that dynamic entry as dependent entry points.
+ *
+ * A naive algorithm for this proved to be costly as it contained an O(n^3)
+ * complexity with regard to dynamic entries that blew up for very large
+ * projects.
+ *
+ * If we have an efficient way to do Set operations, an alternative approach
+ * would be to instead collect already loaded modules per dynamic entry. And as
+ * all chunks from the initial grouping would behave the same, we can instead
+ * collect already loaded chunks for a performance improvement.
+ *
+ * To do that efficiently, need
+ * - a Map of dynamic imports per dynamic entry, which contains all dynamic
+ *   imports that can be triggered by a dynamic entry
+ * - a Map of static dependencies per entry
+ * - a Map of already loaded chunks per entry that we initially populate with
+ *   empty Sets for static entries and Sets containing all entries for dynamic
+ *   entries
+ *
+ * For efficient operations, we assign each entry a numerical index and
+ * represent Sets of Chunks as BigInt values where each chunk corresponds to a
+ * bit index. Then the last two maps can be represented as arrays of BigInt
+ * values.
+ *
+ * Then we iterate through each dynamic entry. We set the already loaded modules
+ * to the intersection of the previously already loaded modules with the union
+ * of the already loaded modules of that chunk with its static dependencies.
+ *
+ * If the already loaded modules changed, then we use the Map of dynamic imports
+ * per dynamic entry to marks all dynamic entry dependencies as "dirty" and put
+ * them back into the iteration. As an additional optimization, we note for
+ * each dynamic entry which dynamic dependent entries have changed and only
+ * intersect those entries again on subsequent interations.
+ *
+ * Then we remove the dynamic entries from the list of dependent entries for
+ * those chunks that are already loaded for that dynamic entry and create
+ * another round of chunks.
+ */
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log) {
+    const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
+    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
+    // Each chunk is identified by its position in this array
+    const chunkAtoms = getChunksWithSameDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
+    const staticDependencyAtomsByEntry = getStaticDependencyAtomsByEntry(allEntries, chunkAtoms);
+    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+    // If we no longer want this, we should make a copy here.
+    const alreadyLoadedAtomsByEntry = getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+    // This mutates the dependentEntries in chunkAtoms
+    removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry);
+    const { chunks, sideEffectAtoms, sizeByAtom } = getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize);
+    chunkDefinitions.push(...getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
+    return chunkDefinitions;
+}
+function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
+    const chunkDefinitions = [];
+    const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
+    const manualChunkModulesByAlias = Object.create(null);
+    for (const [entry, alias] of manualChunkAliasByEntry) {
+        addStaticDependenciesToManualChunk(entry, (manualChunkModulesByAlias[alias] ||= []), modulesInManualChunks);
+    }
+    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
+        chunkDefinitions.push({ alias, modules });
+    }
+    return { chunkDefinitions, modulesInManualChunks };
+}
+function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        modulesInManualChunks.add(module);
+        manualChunkModules.push(module);
+        for (const dependency of module.dependencies) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
+            }
+        }
+    }
+}
+function analyzeModuleGraph(entries) {
+    const dynamicEntryModules = new Set();
+    const dependentEntriesByModule = new Map();
+    const dynamicImportModulesByEntry = [];
+    const allEntriesSet = new Set(entries);
+    let entryIndex = 0;
+    for (const currentEntry of allEntriesSet) {
+        const dynamicImportsForCurrentEntry = new Set();
+        dynamicImportModulesByEntry.push(dynamicImportsForCurrentEntry);
+        const modulesToHandle = new Set([currentEntry]);
+        for (const module of modulesToHandle) {
+            getOrCreate(dependentEntriesByModule, module, (getNewSet)).add(entryIndex);
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    modulesToHandle.add(dependency);
+                }
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module &&
+                    resolution.includedDynamicImporters.length > 0 &&
+                    !allEntriesSet.has(resolution)) {
+                    dynamicEntryModules.add(resolution);
+                    allEntriesSet.add(resolution);
+                    dynamicImportsForCurrentEntry.add(resolution);
+                }
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                if (!allEntriesSet.has(dependency)) {
+                    dynamicEntryModules.add(dependency);
+                    allEntriesSet.add(dependency);
+                }
+            }
+        }
+        entryIndex++;
+    }
+    const allEntries = [...allEntriesSet];
+    const { dynamicEntries, dynamicImportsByEntry } = getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry);
+    return {
+        allEntries,
+        dependentEntriesByModule,
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries),
+        dynamicImportsByEntry
+    };
+}
+function getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry) {
+    const entryIndexByModule = new Map();
+    const dynamicEntries = new Set();
+    for (const [entryIndex, entry] of allEntries.entries()) {
+        entryIndexByModule.set(entry, entryIndex);
+        if (dynamicEntryModules.has(entry)) {
+            dynamicEntries.add(entryIndex);
+        }
+    }
+    const dynamicImportsByEntry = [];
+    for (const dynamicImportModules of dynamicImportModulesByEntry) {
+        const dynamicImports = new Set();
+        for (const dynamicEntry of dynamicImportModules) {
+            dynamicImports.add(entryIndexByModule.get(dynamicEntry));
+        }
+        dynamicImportsByEntry.push(dynamicImports);
+    }
+    return { dynamicEntries, dynamicImportsByEntry };
+}
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries) {
+    const dynamicallyDependentEntriesByDynamicEntry = new Map();
+    for (const dynamicEntryIndex of dynamicEntries) {
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntryIndex, (getNewSet));
+        const dynamicEntry = allEntries[dynamicEntryIndex];
+        for (const importer of concatLazy([
+            dynamicEntry.includedDynamicImporters,
+            dynamicEntry.implicitlyLoadedAfter
+        ])) {
+            for (const entry of dependentEntriesByModule.get(importer)) {
+                dynamicallyDependentEntries.add(entry);
+            }
+        }
+    }
+    return dynamicallyDependentEntriesByDynamicEntry;
+}
+function getChunksWithSameDependentEntries(modulesWithDependentEntries) {
+    const chunkModules = Object.create(null);
+    for (const { dependentEntries, modules } of modulesWithDependentEntries) {
+        let chunkSignature = 0n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+        }
+        (chunkModules[String(chunkSignature)] ||= {
+            dependentEntries: new Set(dependentEntries),
+            modules: []
+        }).modules.push(...modules);
+    }
+    return Object.values(chunkModules);
+}
+function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
+    for (const [module, dependentEntries] of dependentEntriesByModule) {
+        if (!modulesInManualChunks.has(module)) {
+            yield { dependentEntries, modules: [module] };
+        }
+    }
+}
+function getStaticDependencyAtomsByEntry(allEntries, chunkAtoms) {
+    // The indices correspond to the indices in allEntries. The atoms correspond
+    // to bits in the bigint values where chunk 0 is the lowest bit.
+    const staticDependencyAtomsByEntry = allEntries.map(() => 0n);
+    // This toggles the bits for each atom that is a dependency of an entry
+    let atomMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
+        for (const entryIndex of dependentEntries) {
+            staticDependencyAtomsByEntry[entryIndex] |= atomMask;
+        }
+        atomMask <<= 1n;
+    }
+    return staticDependencyAtomsByEntry;
+}
+// Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+function getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+    // Dynamic entries have all atoms as already loaded initially because we then
+    // intersect with the static dependency atoms of all dynamic importers.
+    // Static entries cannot have already loaded atoms.
+    const alreadyLoadedAtomsByEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+    for (const [dynamicEntryIndex, dynamicallyDependentEntries] of dynamicallyDependentEntriesByDynamicEntry) {
+        // We delete here so that they can be added again if necessary to be handled
+        // again by the loop
+        dynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const knownLoadedAtoms = alreadyLoadedAtomsByEntry[dynamicEntryIndex];
+        let updatedLoadedAtoms = knownLoadedAtoms;
+        for (const entryIndex of dynamicallyDependentEntries) {
+            updatedLoadedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        // If the knownLoadedAtoms changed, all dependent dynamic entries need to be
+        // updated again
+        if (updatedLoadedAtoms !== knownLoadedAtoms) {
+            alreadyLoadedAtomsByEntry[dynamicEntryIndex] = updatedLoadedAtoms;
+            for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
+                // If this adds an entry that was deleted before, it will be handled
+                // again. This is the reason why we delete every entry from this map
+                // that we processed.
+                getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
+            }
+        }
+    }
+    return alreadyLoadedAtomsByEntry;
+}
+/**
+ * This removes all unnecessary dynamic entries from the dependentEntries in its
+ * first argument if a chunk is already loaded without that entry.
+ */
+function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry) {
+    // Remove entries from dependent entries if a chunk is already loaded without
+    // that entry.
+    let chunkMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
+        for (const entryIndex of dependentEntries) {
+            if ((alreadyLoadedAtomsByEntry[entryIndex] & chunkMask) === chunkMask) {
+                dependentEntries.delete(entryIndex);
+            }
+        }
+        chunkMask <<= 1n;
+    }
+}
+function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
+    const chunksBySignature = Object.create(null);
+    const chunkByModule = new Map();
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let atomMask = 1n;
+    for (const { dependentEntries, modules } of chunkAtoms) {
+        let chunkSignature = 0n;
+        let correlatedAtoms = -1n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+            // Correlated atoms are the atoms that are guaranteed to be loaded as
+            // well when a given atom is loaded. It is the intersection of the already
+            // loaded modules of each chunk merged with its static dependencies.
+            correlatedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        const chunk = (chunksBySignature[String(chunkSignature)] ||= {
+            containedAtoms: 0n,
+            correlatedAtoms,
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            dependentEntries: new Set(dependentEntries),
+            modules: [],
+            pure: true,
+            size: 0
+        });
+        let atomSize = 0;
+        let pure = true;
+        for (const module of modules) {
+            chunkByModule.set(module, chunk);
+            // Unfortunately, we cannot take tree-shaking into account here because
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure &&= !module.hasEffects();
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                atomSize += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
+        }
+        if (!pure) {
+            sideEffectAtoms |= atomMask;
+        }
+        sizeByAtom.push(atomSize);
+        chunk.containedAtoms |= atomMask;
+        chunk.modules.push(...modules);
+        chunk.pure &&= pure;
+        chunk.size += atomSize;
+        atomMask <<= 1n;
+    }
+    const chunks = Object.values(chunksBySignature);
+    sideEffectAtoms |= addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, atomMask);
+    return { chunks, sideEffectAtoms, sizeByAtom };
+}
+function addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, nextAvailableAtomMask) {
+    const signatureByExternalModule = new Map();
+    let externalSideEffectAtoms = 0n;
+    for (const chunk of chunks) {
+        const { dependencies, modules } = chunk;
+        for (const module of modules) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (dependency instanceof ExternalModule) {
+                    if (dependency.info.moduleSideEffects) {
+                        const signature = getOrCreate(signatureByExternalModule, dependency, () => {
+                            const signature = nextAvailableAtomMask;
+                            nextAvailableAtomMask <<= 1n;
+                            externalSideEffectAtoms |= signature;
+                            return signature;
+                        });
+                        chunk.containedAtoms |= signature;
+                        chunk.correlatedAtoms |= signature;
+                    }
+                }
+                else {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
+                }
+            }
+        }
+    }
+    return externalSideEffectAtoms;
+}
+/**
+ * This function tries to get rid of small chunks by merging them with other
+ * chunks.
+ *
+ * We can only merge chunks safely if after the merge, loading any entry point
+ * in any allowed order will not trigger side effects that should not have been
+ * triggered. While side effects are usually things like global function calls,
+ * global variable mutations or potentially thrown errors, details do not
+ * matter here, and we just discern chunks without side effects (pure chunks)
+ * from other chunks.
+ *
+ * As a first step, we assign each pre-generated chunk with side effects a
+ * label. I.e. we have side effect "A" if the non-pure chunk "A" is loaded.
+ *
+ * Now to determine the side effects of loading a chunk, one also has to take
+ * the side effects of its dependencies into account. So if A depends on B
+ * (A -> B) and both have side effects, loading A triggers effects AB.
+ *
+ * Now from the previous step we know that each chunk is uniquely determine by
+ * the entry points that depend on it and cause it to load, which we will call
+ * its dependent entry points.
+ *
+ * E.g. if X -> A and Y -> A, then the dependent entry points of A are XY.
+ * Starting from that idea, we can determine a set of chunks—and thus a set
+ * of side effects—that must have been triggered if a certain chunk has been
+ * loaded. Basically, it is the intersection of all chunks loaded by the
+ * dependent entry points of a given chunk. We call the corresponding side
+ * effects the correlated side effects of that chunk.
+ *
+ * Example:
+ * X -> ABC, Y -> ADE, A-> F, B -> D
+ * Then taking dependencies into account, X -> ABCDF, Y -> ADEF
+ * The intersection is ADF. So we know that when A is loaded, D and F must also
+ * be in memory even though neither D nor A is a dependency of the other.
+ * If all have side effects, we call ADF the correlated side effects of A. The
+ * correlated side effects need to remain constant when merging chunks.
+ *
+ * In contrast, we have the dependency side effects of A, which represents
+ * the side effects we trigger if we directly load A. In this example, the
+ * dependency side effects are AF.
+ * For entry chunks, dependency and correlated side effects are the same.
+ *
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
+ * a) the dependency side effects of each chunk are a subset of the correlated
+ *    side effects of the other chunk, so no additional side effects are
+ *    triggered for any entry, or
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
+ *
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
+ * that too much additional code is loaded. This is achieved when the dependent
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
+ * chunk. Because then when the small chunk is loaded, the other chunk was
+ * loaded/in memory anyway, so at most when the other chunk is loaded, the
+ * additional size of the small chunk is loaded unnecessarily.
+ *
+ * So the algorithm performs merges in two passes:
+ *
+ * 1. First we try to merge small chunks A only into other chunks B if the
+ *    dependent entries of A are a subset of the dependent entries of B and the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B.
+ * 2. Only then for all remaining small chunks, we look for arbitrary merges
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
+ */
+function getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log) {
+    timeStart('optimize chunks', 3);
+    const chunkPartition = getPartitionedChunks(chunks, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return chunks; // the actual modules
+    }
+    if (minChunkSize > 1) {
+        log('info', logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, 'Initially'));
+    }
+    mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
+    if (minChunkSize > 1) {
+        log('info', logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
+    }
+    timeEnd('optimize chunks', 3);
+    return [...chunkPartition.small, ...chunkPartition.big];
+}
+function getPartitionedChunks(chunks, minChunkSize) {
+    const smallChunks = [];
+    const bigChunks = [];
+    for (const chunk of chunks) {
+        (chunk.size < minChunkSize ? smallChunks : bigChunks).push(chunk);
+    }
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    smallChunks.sort(compareChunkSize);
+    bigChunks.sort(compareChunkSize);
+    return {
+        big: new Set(bigChunks),
+        small: new Set(smallChunks)
+    };
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, sideEffectAtoms, sizeByAtom, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure &&= pure;
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function findBestMergeTarget(mergedChunk, { big, small }, sideEffectAtoms, sizeByAtom, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
+        }
+    }
+    return bestTargetChunk;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * Merging will not produce cycles if none of the direct non-merged
+ * dependencies of a chunk have the other chunk as a transitive dependency.
+ */
+function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
+    const chunksToCheck = new Set(dependentChunk.dependencies);
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
+        for (const dependency of dependencies) {
+            if (dependency === dependencyChunk) {
+                return Infinity;
+            }
+            chunksToCheck.add(dependency);
+        }
+    }
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
+}
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
+        }
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
+        }
+    }
+    return size;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+
+// ported from https://github.com/substack/node-commondir
+function commondir(files) {
+    if (files.length === 0)
+        return '/';
+    if (files.length === 1)
+        return dirname(files[0]);
+    const commonSegments = files.slice(1).reduce((commonSegments, file) => {
+        const pathSegments = file.split(/\/+|\\+/);
+        let index;
+        for (index = 0; commonSegments[index] === pathSegments[index] &&
+            index < Math.min(commonSegments.length, pathSegments.length); index++)
+            ;
+        return commonSegments.slice(0, index);
+    }, files[0].split(/\/+|\\+/));
+    // Windows correctly handles paths with forward-slashes
+    return commonSegments.length > 1 ? commonSegments.join('/') : '/';
+}
+
+const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
+function sortByExecutionOrder(units) {
+    units.sort(compareExecIndex);
+}
+// This process is currently faulty in so far as it only takes the first entry
+// module into account and assumes that dynamic imports are imported in a
+// certain order.
+// A better algorithm would follow every possible execution path and mark which
+// modules are executed before or after which other modules. THen the chunking
+// would need to take care that in each chunk, all modules are always executed
+// in the same sequence.
+function analyseModuleExecution(entryModules) {
+    let nextExecIndex = 0;
+    const cyclePaths = [];
+    const analysedModules = new Set();
+    const dynamicImports = new Set();
+    const parents = new Map();
+    const orderedModules = [];
+    const analyseModule = (module) => {
+        if (module instanceof Module) {
+            for (const dependency of module.dependencies) {
+                if (parents.has(dependency)) {
+                    if (!analysedModules.has(dependency)) {
+                        cyclePaths.push(getCyclePath(dependency, module, parents));
+                    }
+                    continue;
+                }
+                parents.set(dependency, module);
+                analyseModule(dependency);
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                dynamicImports.add(dependency);
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module) {
+                    dynamicImports.add(resolution);
+                }
+            }
+            orderedModules.push(module);
+        }
+        module.execIndex = nextExecIndex++;
+        analysedModules.add(module);
+    };
+    for (const currentEntry of entryModules) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
+        }
+    }
+    for (const currentEntry of dynamicImports) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
+        }
+    }
+    return { cyclePaths, orderedModules };
+}
+function getCyclePath(module, parent, parents) {
+    const cycleSymbol = Symbol(module.id);
+    const path = [module.id];
+    let nextModule = parent;
+    module.cycles.add(cycleSymbol);
+    while (nextModule !== module) {
+        nextModule.cycles.add(cycleSymbol);
+        path.push(nextModule.id);
+        nextModule = parents.get(nextModule);
+    }
+    path.push(path[0]);
+    path.reverse();
+    return path;
+}
+
+function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, constBindings, objectShorthand, reservedNamesAsProps } }) {
+    const { _, n, s } = compact ? { _: '', n: '', s: '' } : { _: ' ', n: '\n', s: ';' };
+    const cnst = constBindings ? 'const' : 'var';
+    const getNonArrowFunctionIntro = (parameters, { isAsync, name }) => `${isAsync ? `async ` : ''}function${name ? ` ${name}` : ''}${_}(${parameters.join(`,${_}`)})${_}`;
+    const getFunctionIntro = arrowFunctions
+        ? (parameters, { isAsync, name }) => {
+            const singleParameter = parameters.length === 1;
+            const asyncString = isAsync ? `async${singleParameter ? ' ' : _}` : '';
+            return `${name ? `${cnst} ${name}${_}=${_}` : ''}${asyncString}${singleParameter ? parameters[0] : `(${parameters.join(`,${_}`)})`}${_}=>${_}`;
+        }
+        : getNonArrowFunctionIntro;
+    const getDirectReturnFunction = (parameters, { functionReturn, lineBreakIndent, name }) => [
+        `${getFunctionIntro(parameters, {
+            isAsync: false,
+            name
+        })}${arrowFunctions
+            ? lineBreakIndent
+                ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}`
+                : ''
+            : `{${lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _}${functionReturn ? 'return ' : ''}`}`,
+        arrowFunctions
+            ? `${name ? ';' : ''}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : ''}`
+            : `${s}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`
+    ];
+    const isValidPropertyName = reservedNamesAsProps
+        ? (name) => VALID_IDENTIFIER_REGEXP.test(name)
+        : (name) => !RESERVED_NAMES.has(name) && VALID_IDENTIFIER_REGEXP.test(name);
+    return {
+        _,
+        cnst,
+        getDirectReturnFunction,
+        getDirectReturnIifeLeft: (parameters, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
+            const [left, right] = getDirectReturnFunction(parameters, {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: null
+            });
+            return `${wrapIfNeeded(`${left}${wrapIfNeeded(returned, arrowFunctions && needsArrowReturnParens)}${right}`, arrowFunctions || needsWrappedFunction)}(`;
+        },
+        getFunctionIntro,
+        getNonArrowFunctionIntro,
+        getObject(fields, { lineBreakIndent }) {
+            const prefix = lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _;
+            return `{${fields
+                .map(([key, value]) => {
+                if (key === null)
+                    return `${prefix}${value}`;
+                const keyInObject = stringifyObjectKeyIfNeeded(key);
+                return key === value && objectShorthand && key === keyInObject
+                    ? prefix + key
+                    : `${prefix}${keyInObject}:${_}${value}`;
+            })
+                .join(`,`)}${fields.length === 0 ? '' : lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`;
+        },
+        getPropertyAccess: (name) => isValidPropertyName(name) ? `.${name}` : `[${JSON.stringify(name)}]`,
+        n,
+        s
+    };
+}
+const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
+
+class Source {
+    constructor(filename, content) {
+        this.isOriginal = true;
+        this.filename = filename;
+        this.content = content;
+    }
+    traceSegment(line, column, name) {
+        return { column, line, name, source: this };
+    }
+}
+class Link {
+    constructor(map, sources) {
+        this.sources = sources;
+        this.names = map.names;
+        this.mappings = map.mappings;
+    }
+    traceMappings() {
+        const sources = [];
+        const sourceIndexMap = new Map();
+        const sourcesContent = [];
+        const names = [];
+        const nameIndexMap = new Map();
+        const mappings = [];
+        for (const line of this.mappings) {
+            const tracedLine = [];
+            for (const segment of line) {
+                if (segment.length === 1)
+                    continue;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    continue;
+                const traced = source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : '');
+                if (traced) {
+                    const { column, line, name, source: { content, filename } } = traced;
+                    let sourceIndex = sourceIndexMap.get(filename);
+                    if (sourceIndex === undefined) {
+                        sourceIndex = sources.length;
+                        sources.push(filename);
+                        sourceIndexMap.set(filename, sourceIndex);
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (sourcesContent[sourceIndex] == null) {
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (content != null && sourcesContent[sourceIndex] !== content) {
+                        return error(logConflictingSourcemapSources(filename));
+                    }
+                    const tracedSegment = [segment[0], sourceIndex, line, column];
+                    if (name) {
+                        let nameIndex = nameIndexMap.get(name);
+                        if (nameIndex === undefined) {
+                            nameIndex = names.length;
+                            names.push(name);
+                            nameIndexMap.set(name, nameIndex);
+                        }
+                        tracedSegment[4] = nameIndex;
+                    }
+                    tracedLine.push(tracedSegment);
+                }
+            }
+            mappings.push(tracedLine);
+        }
+        return { mappings, names, sources, sourcesContent };
+    }
+    traceSegment(line, column, name) {
+        const segments = this.mappings[line];
+        if (!segments)
+            return null;
+        // binary search through segments for the given column
+        let searchStart = 0;
+        let searchEnd = segments.length - 1;
+        while (searchStart <= searchEnd) {
+            const m = (searchStart + searchEnd) >> 1;
+            const segment = segments[m];
+            // If a sourcemap does not have sufficient resolution to contain a
+            // necessary mapping, e.g. because it only contains line information, we
+            // use the best approximation we could find
+            if (segment[0] === column || searchStart === searchEnd) {
+                if (segment.length == 1)
+                    return null;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    return null;
+                return source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : name);
+            }
+            if (segment[0] > column) {
+                searchEnd = m - 1;
+            }
+            else {
+                searchStart = m + 1;
+            }
+        }
+        return null;
+    }
+}
+function getLinkMap(log) {
+    return function linkMap(source, map) {
+        if (!map.missing) {
+            return new Link(map, [source]);
+        }
+        log(LOGLEVEL_WARN, logSourcemapBroken(map.plugin));
+        return new Link({
+            mappings: [],
+            names: []
+        }, [source]);
+    };
+}
+function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, linkMap) {
+    let source;
+    if (originalSourcemap) {
+        const sources = originalSourcemap.sources;
+        const sourcesContent = originalSourcemap.sourcesContent || [];
+        const directory = dirname(id) || '.';
+        const sourceRoot = originalSourcemap.sourceRoot || '.';
+        const baseSources = sources.map((source, index) => new Source(resolve$1(directory, sourceRoot, source), sourcesContent[index]));
+        source = new Link(originalSourcemap, baseSources);
+    }
+    else {
+        source = new Source(id, originalCode);
+    }
+    return sourcemapChain.reduce(linkMap, source);
+}
+function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, log) {
+    const linkMap = getLinkMap(log);
+    const moduleSources = modules
+        .filter(module => !module.excludeFromSourcemap)
+        .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
+    const link = new Link(map, moduleSources);
+    const source = bundleSourcemapChain.reduce(linkMap, link);
+    let { sources, sourcesContent, names, mappings } = source.traceMappings();
+    if (file) {
+        const directory = dirname(file);
+        sources = sources.map((source) => relative(directory, source));
+        file = basename(file);
+    }
+    sourcesContent = (excludeContent ? null : sourcesContent);
+    for (const module of modules) {
+        resetSourcemapCache(module.originalSourcemap, module.sourcemapChain);
+    }
+    return new SourceMap({ file, mappings, names, sources, sourcesContent });
+}
+function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log) {
+    if (sourcemapChain.length === 0) {
+        return originalSourcemap;
+    }
+    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(log));
+    const map = source.traceMappings();
+    return decodedSourcemap({ version: 3, ...map });
+}
+
+let textEncoder;
+const getHash64 = input => xxhashBase64Url(ensureBuffer(input));
+const getHash36 = input => xxhashBase36(ensureBuffer(input));
+const getHash16 = input => xxhashBase16(ensureBuffer(input));
+const hasherByType = {
+    base36: getHash36,
+    base64: getHash64,
+    hex: getHash16
+};
+function ensureBuffer(input) {
+    if (typeof input === 'string') {
+        if (typeof Buffer === 'undefined') {
+            textEncoder ??= new TextEncoder();
+            return textEncoder.encode(input);
+        }
+        return Buffer.from(input);
+    }
+    return input;
+}
+
+// this looks ridiculous, but it prevents sourcemap tooling from mistaking
+// this for an actual sourceMappingURL
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+
+async function renderChunks(chunks, bundle, pluginDriver, outputOptions, log) {
+    timeStart('render chunks', 2);
+    reserveEntryChunksInBundle(chunks);
+    const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
+    timeEnd('render chunks', 2);
+    timeStart('transform chunks', 2);
+    const getHash = hasherByType[outputOptions.hashCharacters];
+    const chunkGraph = getChunkGraph(chunks);
+    const { hashDependenciesByPlaceholder, initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, placeholders, renderedChunksByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
+    timeEnd('transform chunks', 2);
+}
+function reserveEntryChunksInBundle(chunks) {
+    for (const chunk of chunks) {
+        if (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint) {
+            // reserves name in bundle as side effect if it does not contain a hash
+            chunk.getPreliminaryFileName();
+        }
+    }
+}
+function getChunkGraph(chunks) {
+    return Object.fromEntries(chunks.map(chunk => {
+        const renderedChunkInfo = chunk.getRenderedChunkInfo();
+        return [renderedChunkInfo.fileName, renderedChunkInfo];
+    }));
+}
+async function transformChunk(magicString, fileName, usedModules, chunkGraph, options, outputPluginDriver, log) {
+    let map = null;
+    const sourcemapChain = [];
+    let code = await outputPluginDriver.hookReduceArg0('renderChunk', [magicString.toString(), chunkGraph[fileName], options, { chunks: chunkGraph }], (code, result, plugin) => {
+        if (result == null)
+            return code;
+        if (typeof result === 'string')
+            result = {
+                code: result,
+                map: undefined
+            };
+        // strict null check allows 'null' maps to not be pushed to the chain, while 'undefined' gets the missing map warning
+        if (result.map !== null) {
+            const map = decodedSourcemap(result.map);
+            sourcemapChain.push(map || { missing: true, plugin: plugin.name });
+        }
+        return result.code;
+    });
+    const { compact, dir, file, sourcemap, sourcemapExcludeSources, sourcemapFile, sourcemapPathTransform, sourcemapIgnoreList } = options;
+    if (!compact && code[code.length - 1] !== '\n')
+        code += '\n';
+    if (sourcemap) {
+        timeStart('sourcemaps', 3);
+        let resultingFile;
+        if (file)
+            resultingFile = resolve$1(sourcemapFile || file);
+        else if (dir)
+            resultingFile = resolve$1(dir, fileName);
+        else
+            resultingFile = resolve$1(fileName);
+        const decodedMap = magicString.generateDecodedMap({});
+        map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, log);
+        for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
+            let sourcePath = map.sources[sourcesIndex];
+            const sourcemapPath = `${resultingFile}.map`;
+            const ignoreList = sourcemapIgnoreList(sourcePath, sourcemapPath);
+            if (typeof ignoreList !== 'boolean') {
+                error(logFailedValidation('sourcemapIgnoreList function must return a boolean.'));
+            }
+            if (ignoreList) {
+                if (map.x_google_ignoreList === undefined) {
+                    map.x_google_ignoreList = [];
+                }
+                if (!map.x_google_ignoreList.includes(sourcesIndex)) {
+                    map.x_google_ignoreList.push(sourcesIndex);
+                }
+            }
+            if (sourcemapPathTransform) {
+                sourcePath = sourcemapPathTransform(sourcePath, sourcemapPath);
+                if (typeof sourcePath !== 'string') {
+                    error(logFailedValidation(`sourcemapPathTransform function must return a string.`));
+                }
+            }
+            map.sources[sourcesIndex] = normalize(sourcePath);
+        }
+        timeEnd('sourcemaps', 3);
+    }
+    return {
+        code,
+        map
+    };
+}
+async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log) {
+    const nonHashedChunksWithPlaceholders = [];
+    const renderedChunksByPlaceholder = new Map();
+    const hashDependenciesByPlaceholder = new Map();
+    const initialHashesByPlaceholder = new Map();
+    const placeholders = new Set();
+    for (const { preliminaryFileName: { hashPlaceholder } } of renderedChunks) {
+        if (hashPlaceholder)
+            placeholders.add(hashPlaceholder);
+    }
+    await Promise.all(renderedChunks.map(async ({ chunk, preliminaryFileName: { fileName, hashPlaceholder }, preliminarySourcemapFileName, magicString, usedModules }) => {
+        const transformedChunk = {
+            chunk,
+            fileName,
+            sourcemapFileName: preliminarySourcemapFileName?.fileName ?? null,
+            ...(await transformChunk(magicString, fileName, usedModules, chunkGraph, outputOptions, pluginDriver, log))
+        };
+        const { code, map } = transformedChunk;
+        if (hashPlaceholder) {
+            // To create a reproducible content-only hash, all placeholders are
+            // replaced with the same value before hashing
+            const { containedPlaceholders, transformedCode } = replacePlaceholdersWithDefaultAndGetContainedPlaceholders(code, placeholders);
+            let contentToHash = transformedCode;
+            const hashAugmentation = pluginDriver.hookReduceValueSync('augmentChunkHash', '', [chunk.getRenderedChunkInfo()], (augmentation, pluginHash) => {
+                if (pluginHash) {
+                    augmentation += pluginHash;
+                }
+                return augmentation;
+            });
+            if (hashAugmentation) {
+                contentToHash += hashAugmentation;
+            }
+            renderedChunksByPlaceholder.set(hashPlaceholder, transformedChunk);
+            hashDependenciesByPlaceholder.set(hashPlaceholder, {
+                containedPlaceholders,
+                contentHash: getHash(contentToHash)
+            });
+        }
+        else {
+            nonHashedChunksWithPlaceholders.push(transformedChunk);
+        }
+        const sourcemapHashPlaceholder = preliminarySourcemapFileName?.hashPlaceholder;
+        if (map && sourcemapHashPlaceholder) {
+            initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getHash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
+        }
+    }));
+    return {
+        hashDependenciesByPlaceholder,
+        initialHashesByPlaceholder,
+        nonHashedChunksWithPlaceholders,
+        placeholders,
+        renderedChunksByPlaceholder
+    };
+}
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash) {
+    const hashesByPlaceholder = new Map(initialHashesByPlaceholder);
+    for (const placeholder of placeholders) {
+        const { fileName } = renderedChunksByPlaceholder.get(placeholder);
+        let contentToHash = '';
+        const hashDependencyPlaceholders = new Set([placeholder]);
+        for (const dependencyPlaceholder of hashDependencyPlaceholders) {
+            const { containedPlaceholders, contentHash } = hashDependenciesByPlaceholder.get(dependencyPlaceholder);
+            contentToHash += contentHash;
+            for (const containedPlaceholder of containedPlaceholders) {
+                // When looping over a map, setting an entry only causes a new iteration if the key is new
+                hashDependencyPlaceholders.add(containedPlaceholder);
+            }
+        }
+        let finalFileName;
+        let finalHash;
+        do {
+            // In case of a hash collision, create a hash of the hash
+            if (finalHash) {
+                contentToHash = finalHash;
+            }
+            finalHash = getHash(contentToHash).slice(0, placeholder.length);
+            finalFileName = replaceSinglePlaceholder(fileName, placeholder, finalHash);
+        } while (bundle[lowercaseBundleKeys].has(finalFileName.toLowerCase()));
+        bundle[finalFileName] = FILE_PLACEHOLDER;
+        hashesByPlaceholder.set(placeholder, finalHash);
+    }
+    return hashesByPlaceholder;
+}
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
+    for (const { chunk, code, fileName, sourcemapFileName, map } of renderedChunksByPlaceholder.values()) {
+        let updatedCode = replacePlaceholders(code, hashesByPlaceholder);
+        const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
+        let finalSourcemapFileName = null;
+        if (map) {
+            finalSourcemapFileName = sourcemapFileName
+                ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
+                : `${finalFileName}.map`;
+            map.file = replacePlaceholders(map.file, hashesByPlaceholder);
+            updatedCode += emitSourceMapAndGetComment(finalSourcemapFileName, map, pluginDriver, options);
+        }
+        bundle[finalFileName] = chunk.finalizeChunk(updatedCode, map, finalSourcemapFileName, hashesByPlaceholder);
+    }
+    for (const { chunk, code, fileName, sourcemapFileName, map } of nonHashedChunksWithPlaceholders) {
+        let updatedCode = hashesByPlaceholder.size > 0 ? replacePlaceholders(code, hashesByPlaceholder) : code;
+        let finalSourcemapFileName = null;
+        if (map) {
+            finalSourcemapFileName = sourcemapFileName
+                ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
+                : `${fileName}.map`;
+            updatedCode += emitSourceMapAndGetComment(finalSourcemapFileName, map, pluginDriver, options);
+        }
+        bundle[fileName] = chunk.finalizeChunk(updatedCode, map, finalSourcemapFileName, hashesByPlaceholder);
+    }
+}
+function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, sourcemapBaseUrl }) {
+    let url;
+    if (sourcemap === 'inline') {
+        url = map.toUrl();
+    }
+    else {
+        const sourcemapFileName = basename(fileName);
+        url = sourcemapBaseUrl
+            ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
+            : sourcemapFileName;
+        pluginDriver.emitFile({
+            fileName,
+            originalFileName: null,
+            source: map.toString(),
+            type: 'asset'
+        });
+    }
+    return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
+}
+
+class Bundle {
+    constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
+        this.outputOptions = outputOptions;
+        this.unsetOptions = unsetOptions;
+        this.inputOptions = inputOptions;
+        this.pluginDriver = pluginDriver;
+        this.graph = graph;
+        this.facadeChunkByModule = new Map();
+        this.includedNamespaces = new Set();
+    }
+    async generate(isWrite) {
+        timeStart('GENERATE', 1);
+        const outputBundleBase = Object.create(null);
+        const outputBundle = getOutputBundle(outputBundleBase);
+        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions);
+        try {
+            timeStart('initialize render', 2);
+            await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
+            timeEnd('initialize render', 2);
+            timeStart('generate chunks', 2);
+            const getHashPlaceholder = getHashPlaceholderGenerator();
+            const chunks = await this.generateChunks(outputBundle, getHashPlaceholder);
+            if (chunks.length > 1) {
+                validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onLog);
+            }
+            this.pluginDriver.setChunkInformation(this.facadeChunkByModule);
+            for (const chunk of chunks) {
+                chunk.generateExports();
+            }
+            timeEnd('generate chunks', 2);
+            await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onLog);
+        }
+        catch (error_) {
+            await this.pluginDriver.hookParallel('renderError', [error_]);
+            throw error_;
+        }
+        removeUnreferencedAssets(outputBundle);
+        timeStart('generate bundle', 2);
+        await this.pluginDriver.hookSeq('generateBundle', [
+            this.outputOptions,
+            outputBundle,
+            isWrite
+        ]);
+        this.finaliseAssets(outputBundle);
+        timeEnd('generate bundle', 2);
+        timeEnd('GENERATE', 1);
+        return outputBundleBase;
+    }
+    async addManualChunks(manualChunks) {
+        const manualChunkAliasByEntry = new Map();
+        const chunkEntries = await Promise.all(Object.entries(manualChunks).map(async ([alias, files]) => ({
+            alias,
+            entries: await this.graph.moduleLoader.addAdditionalModules(files, true)
+        })));
+        for (const { alias, entries } of chunkEntries) {
+            for (const entry of entries) {
+                addModuleToManualChunk(alias, entry, manualChunkAliasByEntry);
+            }
+        }
+        return manualChunkAliasByEntry;
+    }
+    assignManualChunks(getManualChunk) {
+        const manualChunkAliasesWithEntry = [];
+        const manualChunksApi = {
+            getModuleIds: () => this.graph.modulesById.keys(),
+            getModuleInfo: this.graph.getModuleInfo
+        };
+        for (const module of this.graph.modulesById.values()) {
+            if (module instanceof Module) {
+                const manualChunkAlias = getManualChunk(module.id, manualChunksApi);
+                if (typeof manualChunkAlias === 'string') {
+                    manualChunkAliasesWithEntry.push([manualChunkAlias, module]);
+                }
+            }
+        }
+        manualChunkAliasesWithEntry.sort(([aliasA], [aliasB]) => aliasA > aliasB ? 1 : aliasA < aliasB ? -1 : 0);
+        const manualChunkAliasByEntry = new Map();
+        for (const [alias, module] of manualChunkAliasesWithEntry) {
+            addModuleToManualChunk(alias, module, manualChunkAliasByEntry);
+        }
+        return manualChunkAliasByEntry;
+    }
+    finaliseAssets(bundle) {
+        if (this.outputOptions.validate) {
+            for (const file of Object.values(bundle)) {
+                if ('code' in file) {
+                    try {
+                        parseAst(file.code, { jsx: this.inputOptions.jsx !== false });
+                    }
+                    catch (error_) {
+                        this.inputOptions.onLog(LOGLEVEL_WARN, logChunkInvalid(file, error_));
+                    }
+                }
+            }
+        }
+        this.pluginDriver.finaliseAssets();
+    }
+    async generateChunks(bundle, getHashPlaceholder) {
+        const { experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
+        const manualChunkAliasByEntry = typeof manualChunks === 'object'
+            ? await this.addManualChunks(manualChunks)
+            : this.assignManualChunks(manualChunks);
+        const snippets = getGenerateCodeSnippets(this.outputOptions);
+        const includedModules = getIncludedModules(this.graph.modulesById);
+        const inputBase = commondir(getAbsoluteEntryModulePaths(includedModules, preserveModules));
+        const externalChunkByModule = getExternalChunkByModule(this.graph.modulesById, this.outputOptions, inputBase);
+        const chunks = [];
+        const chunkByModule = new Map();
+        for (const { alias, modules } of inlineDynamicImports
+            ? [{ alias: null, modules: includedModules }]
+            : preserveModules
+                ? includedModules.map(module => ({ alias: null, modules: [module] }))
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog)) {
+            sortByExecutionOrder(modules);
+            const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
+            chunks.push(chunk);
+        }
+        for (const chunk of chunks) {
+            chunk.link();
+        }
+        const facades = [];
+        for (const chunk of chunks) {
+            facades.push(...chunk.generateFacades());
+        }
+        return [...chunks, ...facades];
+    }
+}
+function validateOptionsForMultiChunkOutput(outputOptions, log) {
+    if (outputOptions.format === 'umd' || outputOptions.format === 'iife')
+        return error(logInvalidOption('output.format', URL_OUTPUT_FORMAT, 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
+    if (typeof outputOptions.file === 'string')
+        return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
+    if (outputOptions.sourcemapFile)
+        return error(logInvalidOption('output.sourcemapFile', URL_OUTPUT_SOURCEMAPFILE, '"output.sourcemapFile" is only supported for single-file builds'));
+    if (!outputOptions.amd.autoId && outputOptions.amd.id)
+        log(LOGLEVEL_WARN, logInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
+}
+function getIncludedModules(modulesById) {
+    const includedModules = [];
+    for (const module of modulesById.values()) {
+        if (module instanceof Module &&
+            (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0)) {
+            includedModules.push(module);
+        }
+    }
+    return includedModules;
+}
+function getAbsoluteEntryModulePaths(includedModules, preserveModules) {
+    const absoluteEntryModulePaths = [];
+    for (const module of includedModules) {
+        if ((module.info.isEntry || preserveModules) && isAbsolute$1(module.id)) {
+            absoluteEntryModulePaths.push(module.id);
+        }
+    }
+    return absoluteEntryModulePaths;
+}
+function getExternalChunkByModule(modulesById, outputOptions, inputBase) {
+    const externalChunkByModule = new Map();
+    for (const module of modulesById.values()) {
+        if (module instanceof ExternalModule) {
+            externalChunkByModule.set(module, new ExternalChunk(module, outputOptions, inputBase));
+        }
+    }
+    return externalChunkByModule;
+}
+function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
+    const existingAlias = manualChunkAliasByEntry.get(module);
+    if (typeof existingAlias === 'string' && existingAlias !== alias) {
+        return error(logCannotAssignModuleToChunk(module.id, alias, existingAlias));
+    }
+    manualChunkAliasByEntry.set(module, alias);
+}
+
+function flru (max) {
+	var num, curr, prev;
+	var limit = max;
+
+	function keep(key, value) {
+		if (++num > limit) {
+			prev = curr;
+			reset(1);
+			++num;
+		}
+		curr[key] = value;
+	}
+
+	function reset(isPartial) {
+		num = 0;
+		curr = Object.create(null);
+		isPartial || (prev=Object.create(null));
+	}
+
+	reset();
+
+	return {
+		clear: reset,
+		has: function (key) {
+			return curr[key] !== void 0 || prev[key] !== void 0;
+		},
+		get: function (key) {
+			var val = curr[key];
+			if (val !== void 0) return val;
+			if ((val=prev[key]) !== void 0) {
+				keep(key, val);
+				return val;
+			}
+		},
+		set: function (key, value) {
+			if (curr[key] !== void 0) {
+				curr[key] = value;
+			} else {
+				keep(key, value);
+			}
+		}
+	};
+}
+
+class GlobalScope extends Scope {
+    constructor() {
+        super();
+        this.parent = null;
+        this.variables.set('undefined', new UndefinedVariable());
+    }
+    findVariable(name) {
+        let variable = this.variables.get(name);
+        if (!variable) {
+            variable = new GlobalVariable(name);
+            this.variables.set(name, variable);
+        }
+        return variable;
+    }
+}
+
+function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
+    let skipped = null;
+    let replaceContext = null;
+    if (skip) {
+        skipped = new Set();
+        for (const skippedCall of skip) {
+            if (source === skippedCall.source && importer === skippedCall.importer) {
+                skipped.add(skippedCall.plugin);
+            }
+        }
+        replaceContext = (pluginContext, plugin) => ({
+            ...pluginContext,
+            resolve: (source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) => {
+                skipSelf ??= true;
+                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip);
+            }
+        });
+    }
+    return pluginDriver.hookFirstAndGetPlugin('resolveId', [source, importer, { attributes, custom: customOptions, isEntry }], replaceContext, skipped);
+}
+
+async function resolveId(source, importer, preserveSymlinks, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
+    const pluginResult = await resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes);
+    if (pluginResult != null) {
+        const [resolveIdResult, plugin] = pluginResult;
+        if (typeof resolveIdResult === 'object' && !resolveIdResult.resolvedBy) {
+            return {
+                ...resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        if (typeof resolveIdResult === 'string') {
+            return {
+                id: resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        return resolveIdResult;
+    }
+    // external modules (non-entry modules that start with neither '.' or '/')
+    // are skipped at this stage.
+    if (importer !== undefined && !isAbsolute$1(source) && source[0] !== '.')
+        return null;
+    // `resolve` processes paths from right to left, prepending them until an
+    // absolute path is created. Absolute importees therefore shortcircuit the
+    // resolve call and require no special handing on our part.
+    // See https://nodejs.org/api/path.html#path_path_resolve_paths
+    return addJsExtensionIfNecessary(importer ? resolve$1(dirname(importer), source) : resolve$1(source), preserveSymlinks);
+}
+async function addJsExtensionIfNecessary(file, preserveSymlinks) {
+    return ((await findFile(file, preserveSymlinks)) ??
+        (await findFile(file + '.mjs', preserveSymlinks)) ??
+        (await findFile(file + '.js', preserveSymlinks)));
+}
+async function findFile(file, preserveSymlinks) {
+    try {
+        const stats = await lstat(file);
+        if (!preserveSymlinks && stats.isSymbolicLink())
+            return await findFile(await realpath(file), preserveSymlinks);
+        if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
+            // check case
+            const name = basename(file);
+            const files = await readdir(dirname(file));
+            if (files.includes(name))
+                return file;
+        }
+    }
+    catch {
+        // suppress
+    }
+}
+
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
+
+function createPluginCache(cache) {
+    return {
+        delete(id) {
+            return delete cache[id];
+        },
+        get(id) {
+            const item = cache[id];
+            if (!item)
+                return;
+            item[0] = 0;
+            return item[1];
+        },
+        has(id) {
+            const item = cache[id];
+            if (!item)
+                return false;
+            item[0] = 0;
+            return true;
+        },
+        set(id, value) {
+            cache[id] = [0, value];
+        }
+    };
+}
+function getTrackedPluginCache(pluginCache, onUse) {
+    return {
+        delete(id) {
+            onUse();
+            return pluginCache.delete(id);
+        },
+        get(id) {
+            onUse();
+            return pluginCache.get(id);
+        },
+        has(id) {
+            onUse();
+            return pluginCache.has(id);
+        },
+        set(id, value) {
+            onUse();
+            return pluginCache.set(id, value);
+        }
+    };
+}
+const NO_CACHE = {
+    delete() {
+        return false;
+    },
+    get() {
+        return undefined;
+    },
+    has() {
+        return false;
+    },
+    set() { }
+};
+function uncacheablePluginError(pluginName) {
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
+        return error(logAnonymousPluginCache());
+    }
+    return error(logDuplicatePluginName(pluginName));
+}
+function getCacheForUncacheablePlugin(pluginName) {
+    return {
+        delete() {
+            return uncacheablePluginError(pluginName);
+        },
+        get() {
+            return uncacheablePluginError(pluginName);
+        },
+        has() {
+            return uncacheablePluginError(pluginName);
+        },
+        set() {
+            return uncacheablePluginError(pluginName);
+        }
+    };
+}
+
+async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}
+
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+    const { onwarn, onLog } = config;
+    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+    if (onLog) {
+        const minimalPriority = logLevelPriority[logLevel];
+        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+            if (level === LOGLEVEL_ERROR) {
+                return error(normalizeLog(handledLog));
+            }
+            if (logLevelPriority[level] >= minimalPriority) {
+                defaultOnLog(level, normalizeLog(handledLog));
+            }
+        });
+    }
+    return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn
+    ? (level, log) => {
+        if (level === LOGLEVEL_WARN) {
+            onwarn(addLogToString(log), warning => printLog(LOGLEVEL_WARN, normalizeLog(warning)));
+        }
+        else {
+            printLog(level, log);
+        }
+    }
+    : printLog;
+const addLogToString = (log) => {
+    Object.defineProperty(log, 'toString', {
+        value: () => log.message,
+        writable: true
+    });
+    return log;
+};
+const normalizeLog = (log) => typeof log === 'string'
+    ? { message: log }
+    : typeof log === 'function'
+        ? normalizeLog(log())
+        : log;
+const defaultPrintLog = (level, { message }) => {
+    switch (level) {
+        case LOGLEVEL_WARN: {
+            return console.warn(message);
+        }
+        case LOGLEVEL_DEBUG: {
+            return console.debug(message);
+        }
+        default: {
+            return console.info(message);
+        }
+    }
+};
+function warnUnknownOptions(passedOptions, validOptions, optionType, log, ignoredKeys = /$./) {
+    const validOptionSet = new Set(validOptions);
+    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
+    if (unknownOptions.length > 0) {
+        log(LOGLEVEL_WARN, logUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
+    }
+}
+const treeshakePresets = {
+    recommended: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: false
+    },
+    safest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: true,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: true
+    },
+    smallest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: EMPTY_ARRAY,
+        moduleSideEffects: () => false,
+        propertyReadSideEffects: false,
+        tryCatchDeoptimization: false,
+        unknownGlobalSideEffects: false
+    }
+};
+const jsxPresets = {
+    preserve: {
+        factory: null,
+        fragment: null,
+        importSource: null,
+        mode: 'preserve'
+    },
+    'preserve-react': {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'preserve'
+    },
+    react: {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'classic'
+    },
+    'react-jsx': {
+        factory: 'React.createElement',
+        importSource: 'react',
+        jsxImportSource: 'react/jsx-runtime',
+        mode: 'automatic'
+    }
+};
+const generatedCodePresets = {
+    es2015: {
+        arrowFunctions: true,
+        constBindings: true,
+        objectShorthand: true,
+        reservedNamesAsProps: true,
+        symbols: true
+    },
+    es5: {
+        arrowFunctions: false,
+        constBindings: false,
+        objectShorthand: false,
+        reservedNamesAsProps: true,
+        symbols: false
+    }
+};
+const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
+const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
+    if (typeof value === 'string') {
+        const preset = presets[value];
+        if (preset) {
+            return preset;
+        }
+        error(logInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
+    }
+    return objectifyOption(value);
+};
+const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
+    const presetName = value?.preset;
+    if (presetName) {
+        const preset = presets[presetName];
+        if (preset) {
+            return { ...preset, ...value };
+        }
+        else {
+            error(logInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${printQuotedStringList(Object.keys(presets))}`, presetName));
+        }
+    }
+    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
+};
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+async function transform(source, module, pluginDriver, log) {
+    const id = module.id;
+    const sourcemapChain = [];
+    let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
+    const originalCode = source.code;
+    let ast = source.ast;
+    const transformDependencies = [];
+    const emittedFiles = [];
+    let customTransformCache = false;
+    const useCustomTransformCache = () => (customTransformCache = true);
+    let pluginName = '';
+    let currentSource = source.code;
+    function transformReducer(previousCode, result, plugin) {
+        let code;
+        let map;
+        if (typeof result === 'string') {
+            code = result;
+        }
+        else if (result && typeof result === 'object') {
+            module.updateOptions(result);
+            if (result.code == null) {
+                if (result.map || result.ast) {
+                    log(LOGLEVEL_WARN, logNoTransformMapOrAstWithoutCode(plugin.name));
+                }
+                return previousCode;
+            }
+            ({ code, map, ast } = result);
+        }
+        else {
+            return previousCode;
+        }
+        // strict null check allows 'null' maps to not be pushed to the chain,
+        // while 'undefined' gets the missing map warning
+        if (map !== null) {
+            sourcemapChain.push(decodedSourcemap(typeof map === 'string' ? JSON.parse(map) : map) || {
+                missing: true,
+                plugin: plugin.name
+            });
+        }
+        currentSource = code;
+        return code;
+    }
+    const getLogHandler = (handler) => (log, pos) => {
+        log = normalizeLog(log);
+        if (pos)
+            augmentCodeLocation(log, pos, currentSource, id);
+        log.id = id;
+        log.hook = 'transform';
+        handler(log);
+    };
+    let code;
+    try {
+        code = await pluginDriver.hookReduceArg0('transform', [currentSource, id], transformReducer, (pluginContext, plugin) => {
+            pluginName = plugin.name;
+            return {
+                ...pluginContext,
+                addWatchFile(id) {
+                    transformDependencies.push(id);
+                    pluginContext.addWatchFile(id);
+                },
+                cache: customTransformCache
+                    ? pluginContext.cache
+                    : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
+                debug: getLogHandler(pluginContext.debug),
+                emitFile(emittedFile) {
+                    emittedFiles.push(emittedFile);
+                    return pluginDriver.emitFile(emittedFile);
+                },
+                error(error_, pos) {
+                    if (typeof error_ === 'string')
+                        error_ = { message: error_ };
+                    if (pos)
+                        augmentCodeLocation(error_, pos, currentSource, id);
+                    error_.id = id;
+                    error_.hook = 'transform';
+                    return pluginContext.error(error_);
+                },
+                getCombinedSourcemap() {
+                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log);
+                    if (!combinedMap) {
+                        const magicString = new MagicString(originalCode);
+                        return magicString.generateMap({ hires: true, includeContent: true, source: id });
+                    }
+                    if (originalSourcemap !== combinedMap) {
+                        originalSourcemap = combinedMap;
+                        sourcemapChain.length = 0;
+                    }
+                    return new SourceMap({
+                        ...combinedMap,
+                        file: null,
+                        sourcesContent: combinedMap.sourcesContent
+                    });
+                },
+                info: getLogHandler(pluginContext.info),
+                setAssetSource() {
+                    return this.error(logInvalidSetAssetSourceCall());
+                },
+                warn: getLogHandler(pluginContext.warn)
+            };
+        });
+    }
+    catch (error_) {
+        return error(logPluginError(error_, pluginName, { hook: 'transform', id }));
+    }
+    if (!customTransformCache && // files emitted by a transform hook need to be emitted again if the hook is skipped
+        emittedFiles.length > 0)
+        module.transformFiles = emittedFiles;
+    return {
+        ast,
+        code,
+        customTransformCache,
+        originalCode,
+        originalSourcemap,
+        sourcemapChain,
+        transformDependencies
+    };
+}
+
+const RESOLVE_DEPENDENCIES = 'resolveDependencies';
+class ModuleLoader {
+    constructor(graph, modulesById, options, pluginDriver) {
+        this.graph = graph;
+        this.modulesById = modulesById;
+        this.options = options;
+        this.pluginDriver = pluginDriver;
+        this.implicitEntryModules = new Set();
+        this.indexedEntryModules = [];
+        this.latestLoadModulesPromise = Promise.resolve();
+        this.moduleLoadPromises = new Map();
+        this.modulesWithLoadedDependencies = new Set();
+        this.nextChunkNamePriority = 0;
+        this.nextEntryModuleIndex = 0;
+        this.resolveId = async (source, importer, customOptions, isEntry, attributes, skip = null) => this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
+            ? false
+            : await resolveId(source, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, skip, customOptions, typeof isEntry === 'boolean' ? isEntry : !importer, attributes), importer, source), attributes);
+        this.hasModuleSideEffects = options.treeshake
+            ? options.treeshake.moduleSideEffects
+            : () => true;
+    }
+    async addAdditionalModules(unresolvedModules, isAddForManualChunks) {
+        const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null, isAddForManualChunks))));
+        await this.awaitLoadModulesPromise();
+        return result;
+    }
+    async addEntryModules(unresolvedEntryModules, isUserDefined) {
+        const firstEntryModuleIndex = this.nextEntryModuleIndex;
+        this.nextEntryModuleIndex += unresolvedEntryModules.length;
+        const firstChunkNamePriority = this.nextChunkNamePriority;
+        this.nextChunkNamePriority += unresolvedEntryModules.length;
+        const newEntryModules = await this.extendLoadModulesPromise(Promise.all(unresolvedEntryModules.map(({ id, importer }) => this.loadEntryModule(id, true, importer, null))).then(entryModules => {
+            for (const [index, entryModule] of entryModules.entries()) {
+                entryModule.isUserDefinedEntryPoint =
+                    entryModule.isUserDefinedEntryPoint || isUserDefined;
+                addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined, firstChunkNamePriority + index);
+                const existingIndexedModule = this.indexedEntryModules.find(indexedModule => indexedModule.module === entryModule);
+                if (existingIndexedModule) {
+                    existingIndexedModule.index = Math.min(existingIndexedModule.index, firstEntryModuleIndex + index);
+                }
+                else {
+                    this.indexedEntryModules.push({
+                        index: firstEntryModuleIndex + index,
+                        module: entryModule
+                    });
+                }
+            }
+            this.indexedEntryModules.sort(({ index: indexA }, { index: indexB }) => indexA > indexB ? 1 : -1);
+            return entryModules;
+        }));
+        await this.awaitLoadModulesPromise();
+        return {
+            entryModules: this.indexedEntryModules.map(({ module }) => module),
+            implicitEntryModules: [...this.implicitEntryModules],
+            newEntryModules
+        };
+    }
+    async emitChunk({ fileName, id, importer, name, implicitlyLoadedAfterOneOf, preserveSignature }) {
+        const unresolvedModule = {
+            fileName: fileName || null,
+            id,
+            importer,
+            name: name || null
+        };
+        const module = implicitlyLoadedAfterOneOf
+            ? await this.addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfterOneOf)
+            : (await this.addEntryModules([unresolvedModule], false)).newEntryModules[0];
+        if (preserveSignature != null) {
+            module.preserveSignature = preserveSignature;
+        }
+        return module;
+    }
+    async preloadModule(resolvedId) {
+        const module = await this.fetchModule(this.getResolvedIdWithDefaults(resolvedId, EMPTY_OBJECT), undefined, false, resolvedId.resolveDependencies ? RESOLVE_DEPENDENCIES : true);
+        return module.info;
+    }
+    addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfter) {
+        const chunkNamePriority = this.nextChunkNamePriority++;
+        return this.extendLoadModulesPromise(this.loadEntryModule(unresolvedModule.id, false, unresolvedModule.importer, null).then(async (entryModule) => {
+            addChunkNamesToModule(entryModule, unresolvedModule, false, chunkNamePriority);
+            if (!entryModule.info.isEntry) {
+                const implicitlyLoadedAfterModules = await Promise.all(implicitlyLoadedAfter.map(id => this.loadEntryModule(id, false, unresolvedModule.importer, entryModule.id)));
+                // We need to check again if this is still an entry module as these
+                // changes need to be performed atomically to avoid race conditions
+                // if the same module is re-emitted as an entry module.
+                // The inverse changes happen in "handleExistingModule"
+                if (!entryModule.info.isEntry) {
+                    this.implicitEntryModules.add(entryModule);
+                    for (const module of implicitlyLoadedAfterModules) {
+                        entryModule.implicitlyLoadedAfter.add(module);
+                    }
+                    for (const dependant of entryModule.implicitlyLoadedAfter) {
+                        dependant.implicitlyLoadedBefore.add(entryModule);
+                    }
+                }
+            }
+            return entryModule;
+        }));
+    }
+    async addModuleSource(id, importer, module) {
+        let source;
+        try {
+            source = await this.graph.fileOperationQueue.run(async () => {
+                const content = await this.pluginDriver.hookFirst('load', [id]);
+                if (content !== null)
+                    return content;
+                this.graph.watchFiles[id] = true;
+                return await readFile(id, 'utf8');
+            });
+        }
+        catch (error_) {
+            let message = `Could not load ${id}`;
+            if (importer)
+                message += ` (imported by ${relativeId(importer)})`;
+            message += `: ${error_.message}`;
+            error_.message = message;
+            throw error_;
+        }
+        const sourceDescription = typeof source === 'string'
+            ? { code: source }
+            : source != null && typeof source === 'object' && typeof source.code === 'string'
+                ? source
+                : error(logBadLoader(id));
+        const code = sourceDescription.code;
+        if (code.charCodeAt(0) === 0xfe_ff) {
+            sourceDescription.code = code.slice(1);
+        }
+        const cachedModule = this.graph.cachedModules.get(id);
+        if (cachedModule &&
+            !cachedModule.customTransformCache &&
+            cachedModule.originalCode === sourceDescription.code &&
+            !(await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
+                {
+                    ast: cachedModule.ast,
+                    code: cachedModule.code,
+                    id: cachedModule.id,
+                    meta: cachedModule.meta,
+                    moduleSideEffects: cachedModule.moduleSideEffects,
+                    resolvedSources: cachedModule.resolvedIds,
+                    syntheticNamedExports: cachedModule.syntheticNamedExports
+                }
+            ]))) {
+            if (cachedModule.transformFiles) {
+                for (const emittedFile of cachedModule.transformFiles)
+                    this.pluginDriver.emitFile(emittedFile);
+            }
+            await module.setSource(cachedModule);
+        }
+        else {
+            module.updateOptions(sourceDescription);
+            await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options.onLog));
+        }
+    }
+    async awaitLoadModulesPromise() {
+        let startingPromise;
+        do {
+            startingPromise = this.latestLoadModulesPromise;
+            await startingPromise;
+        } while (startingPromise !== this.latestLoadModulesPromise);
+    }
+    extendLoadModulesPromise(loadNewModulesPromise) {
+        this.latestLoadModulesPromise = Promise.all([
+            loadNewModulesPromise,
+            this.latestLoadModulesPromise
+        ]);
+        this.latestLoadModulesPromise.catch(() => {
+            /* Avoid unhandled Promise rejections */
+        });
+        return loadNewModulesPromise;
+    }
+    async fetchDynamicDependencies(module, resolveDynamicImportPromises) {
+        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([dynamicImport, resolvedId]) => {
+            if (resolvedId === null)
+                return null;
+            if (typeof resolvedId === 'string') {
+                dynamicImport.resolution = resolvedId;
+                return null;
+            }
+            return (dynamicImport.resolution = await this.fetchResolvedDependency(relativeId(resolvedId.id), module.id, resolvedId));
+        })));
+        for (const dependency of dependencies) {
+            if (dependency) {
+                module.dynamicDependencies.add(dependency);
+                dependency.dynamicImporters.push(module.id);
+            }
+        }
+    }
+    // If this is a preload, then this method always waits for the dependencies of
+    // the module to be resolved.
+    // Otherwise, if the module does not exist, it waits for the module and all
+    // its dependencies to be loaded.
+    // Otherwise, it returns immediately.
+    async fetchModule({ attributes, id, meta, moduleSideEffects, syntheticNamedExports }, importer, isEntry, isPreload) {
+        const existingModule = this.modulesById.get(id);
+        if (existingModule instanceof Module) {
+            if (importer && doAttributesDiffer(attributes, existingModule.info.attributes)) {
+                this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAttributes(existingModule.info.attributes, attributes, id, importer));
+            }
+            await this.handleExistingModule(existingModule, isEntry, isPreload);
+            return existingModule;
+        }
+        if (existingModule instanceof ExternalModule) {
+            return error(logExternalModulesCannotBeTransformedToModules(existingModule.id));
+        }
+        const module = new Module(this.graph, id, this.options, isEntry, moduleSideEffects, syntheticNamedExports, meta, attributes);
+        this.modulesById.set(id, module);
+        const loadPromise = this.addModuleSource(id, importer, module).then(() => [
+            this.getResolveStaticDependencyPromises(module),
+            this.getResolveDynamicImportPromises(module),
+            loadAndResolveDependenciesPromise
+        ]);
+        const loadAndResolveDependenciesPromise = waitForDependencyResolution(loadPromise).then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
+        loadAndResolveDependenciesPromise.catch(() => {
+            /* avoid unhandled promise rejections */
+        });
+        this.moduleLoadPromises.set(module, loadPromise);
+        const resolveDependencyPromises = await loadPromise;
+        if (!isPreload) {
+            await this.fetchModuleDependencies(module, ...resolveDependencyPromises);
+        }
+        else if (isPreload === RESOLVE_DEPENDENCIES) {
+            await loadAndResolveDependenciesPromise;
+        }
+        return module;
+    }
+    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises, loadAndResolveDependenciesPromise) {
+        if (this.modulesWithLoadedDependencies.has(module)) {
+            return;
+        }
+        this.modulesWithLoadedDependencies.add(module);
+        await Promise.all([
+            this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
+            this.fetchDynamicDependencies(module, resolveDynamicDependencyPromises)
+        ]);
+        module.linkImports();
+        // To handle errors when resolving dependencies or in moduleParsed
+        await loadAndResolveDependenciesPromise;
+    }
+    fetchResolvedDependency(source, importer, resolvedId) {
+        if (resolvedId.external) {
+            const { attributes, external, id, moduleSideEffects, meta } = resolvedId;
+            let externalModule = this.modulesById.get(id);
+            if (!externalModule) {
+                externalModule = new ExternalModule(this.options, id, moduleSideEffects, meta, external !== 'absolute' && isAbsolute$1(id), attributes);
+                this.modulesById.set(id, externalModule);
+            }
+            else if (!(externalModule instanceof ExternalModule)) {
+                return error(logInternalIdCannotBeExternal(source, importer));
+            }
+            else if (doAttributesDiffer(externalModule.info.attributes, attributes)) {
+                this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAttributes(externalModule.info.attributes, attributes, source, importer));
+            }
+            return Promise.resolve(externalModule);
+        }
+        return this.fetchModule(resolvedId, importer, false, false);
+    }
+    async fetchStaticDependencies(module, resolveStaticDependencyPromises) {
+        for (const dependency of await Promise.all(resolveStaticDependencyPromises.map(resolveStaticDependencyPromise => resolveStaticDependencyPromise.then(([source, resolvedId]) => this.fetchResolvedDependency(source, module.id, resolvedId))))) {
+            module.dependencies.add(dependency);
+            dependency.importers.push(module.id);
+        }
+        if (!this.options.treeshake || module.info.moduleSideEffects === 'no-treeshake') {
+            for (const dependency of module.dependencies) {
+                if (dependency instanceof Module) {
+                    dependency.importedFromNotTreeshaken = true;
+                }
+            }
+        }
+    }
+    getNormalizedResolvedIdWithoutDefaults(resolveIdResult, importer, source) {
+        const { makeAbsoluteExternalsRelative } = this.options;
+        if (resolveIdResult) {
+            if (typeof resolveIdResult === 'object') {
+                const external = resolveIdResult.external || this.options.external(resolveIdResult.id, importer, true);
+                return {
+                    ...resolveIdResult,
+                    external: external &&
+                        (external === 'relative' ||
+                            !isAbsolute$1(resolveIdResult.id) ||
+                            (external === true &&
+                                isNotAbsoluteExternal(resolveIdResult.id, source, makeAbsoluteExternalsRelative)) ||
+                            'absolute')
+                };
+            }
+            const external = this.options.external(resolveIdResult, importer, true);
+            return {
+                external: external &&
+                    (isNotAbsoluteExternal(resolveIdResult, source, makeAbsoluteExternalsRelative) ||
+                        'absolute'),
+                id: external && makeAbsoluteExternalsRelative
+                    ? normalizeRelativeExternalId(resolveIdResult, importer)
+                    : resolveIdResult
+            };
+        }
+        const id = makeAbsoluteExternalsRelative
+            ? normalizeRelativeExternalId(source, importer)
+            : source;
+        if (resolveIdResult !== false && !this.options.external(id, importer, true)) {
+            return null;
+        }
+        return {
+            external: isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) || 'absolute',
+            id
+        };
+    }
+    getResolveDynamicImportPromises(module) {
+        return module.dynamicImports.map(async (dynamicImport) => {
+            const resolvedId = await this.resolveDynamicImport(module, dynamicImport.argument, module.id, getAttributesFromImportExpression(dynamicImport.node));
+            if (resolvedId && typeof resolvedId === 'object') {
+                dynamicImport.id = resolvedId.id;
+            }
+            return [dynamicImport, resolvedId];
+        });
+    }
+    getResolveStaticDependencyPromises(module) {
+        return Array.from(module.sourcesWithAttributes, async ([source, attributes]) => [
+            source,
+            (module.resolvedIds[source] =
+                module.resolvedIds[source] ||
+                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, EMPTY_OBJECT, false, attributes), source, module.id, attributes))
+        ]);
+    }
+    getResolvedIdWithDefaults(resolvedId, attributes) {
+        if (!resolvedId) {
+            return null;
+        }
+        const external = resolvedId.external || false;
+        return {
+            attributes: resolvedId.attributes || attributes,
+            external,
+            id: resolvedId.id,
+            meta: resolvedId.meta || {},
+            moduleSideEffects: resolvedId.moduleSideEffects ?? this.hasModuleSideEffects(resolvedId.id, !!external),
+            resolvedBy: resolvedId.resolvedBy ?? 'rollup',
+            syntheticNamedExports: resolvedId.syntheticNamedExports ?? false
+        };
+    }
+    async handleExistingModule(module, isEntry, isPreload) {
+        const loadPromise = this.moduleLoadPromises.get(module);
+        if (isPreload) {
+            return isPreload === RESOLVE_DEPENDENCIES
+                ? waitForDependencyResolution(loadPromise)
+                : loadPromise;
+        }
+        if (isEntry) {
+            // This reverts the changes in addEntryWithImplicitDependants and needs to
+            // be performed atomically
+            module.info.isEntry = true;
+            this.implicitEntryModules.delete(module);
+            for (const dependant of module.implicitlyLoadedAfter) {
+                dependant.implicitlyLoadedBefore.delete(module);
+            }
+            module.implicitlyLoadedAfter.clear();
+        }
+        return this.fetchModuleDependencies(module, ...(await loadPromise));
+    }
+    handleInvalidResolvedId(resolvedId, source, importer, attributes) {
+        if (resolvedId === null) {
+            if (isRelative(source)) {
+                return error(logUnresolvedImport(source, importer));
+            }
+            this.options.onLog(LOGLEVEL_WARN, logUnresolvedImportTreatedAsExternal(source, importer));
+            return {
+                attributes,
+                external: true,
+                id: source,
+                meta: {},
+                moduleSideEffects: this.hasModuleSideEffects(source, true),
+                resolvedBy: 'rollup',
+                syntheticNamedExports: false
+            };
+        }
+        else if (resolvedId.external && resolvedId.syntheticNamedExports) {
+            this.options.onLog(LOGLEVEL_WARN, logExternalSyntheticExports(source, importer));
+        }
+        return resolvedId;
+    }
+    async loadEntryModule(unresolvedId, isEntry, importer, implicitlyLoadedBefore, isLoadForManualChunks = false) {
+        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT);
+        if (resolveIdResult == null) {
+            return error(implicitlyLoadedBefore === null
+                ? logUnresolvedEntry(unresolvedId)
+                : logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
+        }
+        const isExternalModules = typeof resolveIdResult === 'object' && resolveIdResult.external;
+        if (resolveIdResult === false || isExternalModules) {
+            return error(implicitlyLoadedBefore === null
+                ? isExternalModules && isLoadForManualChunks
+                    ? logExternalModulesCannotBeIncludedInManualChunks(unresolvedId)
+                    : logEntryCannotBeExternal(unresolvedId)
+                : logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
+        }
+        return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
+            ? resolveIdResult
+            : { id: resolveIdResult }, EMPTY_OBJECT), undefined, isEntry, false);
+    }
+    async resolveDynamicImport(module, specifier, importer, attributes) {
+        const resolution = await this.pluginDriver.hookFirst('resolveDynamicImport', [
+            specifier,
+            importer,
+            { attributes }
+        ]);
+        if (typeof specifier !== 'string') {
+            if (typeof resolution === 'string') {
+                return resolution;
+            }
+            if (!resolution) {
+                return null;
+            }
+            return this.getResolvedIdWithDefaults(resolution, attributes);
+        }
+        if (resolution == null) {
+            const existingResolution = module.resolvedIds[specifier];
+            if (existingResolution) {
+                if (doAttributesDiffer(existingResolution.attributes, attributes)) {
+                    this.options.onLog(LOGLEVEL_WARN, logInconsistentImportAttributes(existingResolution.attributes, attributes, specifier, importer));
+                }
+                return existingResolution;
+            }
+            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, EMPTY_OBJECT, false, attributes), specifier, module.id, attributes));
+        }
+        return this.handleInvalidResolvedId(this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier), attributes), specifier, importer, attributes);
+    }
+}
+function normalizeRelativeExternalId(source, importer) {
+    return isRelative(source)
+        ? importer
+            ? resolve$1(importer, '..', source)
+            : resolve$1(source)
+        : source;
+}
+function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
+    if (fileName !== null) {
+        module.chunkFileNames.add(fileName);
+    }
+    else if (name !== null) {
+        // Always keep chunkNames sorted by priority
+        let namePosition = 0;
+        while (module.chunkNames[namePosition]?.priority < priority)
+            namePosition++;
+        module.chunkNames.splice(namePosition, 0, { isUserDefined, name, priority });
+    }
+}
+function isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) {
+    return (makeAbsoluteExternalsRelative === true ||
+        (makeAbsoluteExternalsRelative === 'ifRelativeSource' && isRelative(source)) ||
+        !isAbsolute$1(id));
+}
+async function waitForDependencyResolution(loadPromise) {
+    const [resolveStaticDependencyPromises, resolveDynamicImportPromises] = await loadPromise;
+    return Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]);
+}
+
+function generateAssetFileName(name, names, source, originalFileName, originalFileNames, sourceHash, outputOptions, bundle, inputOptions) {
+    const emittedName = outputOptions.sanitizeFileName(name || 'asset');
+    return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
+        ? outputOptions.assetFileNames({
+            // Additionally, this should be non-enumerable in the next major
+            get name() {
+                warnDeprecation('Accessing the "name" property of emitted assets when generating the file name is deprecated. Use the "names" property instead.', URL_GENERATEBUNDLE, false, inputOptions);
+                return name;
+            },
+            names,
+            // Additionally, this should be non-enumerable in the next major
+            get originalFileName() {
+                warnDeprecation('Accessing the "originalFileName" property of emitted assets when generating the file name is deprecated. Use the "originalFileNames" property instead.', URL_GENERATEBUNDLE, false, inputOptions);
+                return originalFileName;
+            },
+            originalFileNames,
+            source,
+            type: 'asset'
+        })
+        : outputOptions.assetFileNames, 'output.assetFileNames', {
+        ext: () => extname(emittedName).slice(1),
+        extname: () => extname(emittedName),
+        hash: size => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
+        name: () => emittedName.slice(0, Math.max(0, emittedName.length - extname(emittedName).length))
+    }), bundle);
+}
+function reserveFileNameInBundle(fileName, { bundle }, log) {
+    if (bundle[lowercaseBundleKeys].has(fileName.toLowerCase())) {
+        log(LOGLEVEL_WARN, logFileNameConflict(fileName));
+    }
+    else {
+        bundle[fileName] = FILE_PLACEHOLDER;
+    }
+}
+const emittedFileTypes = new Set(['chunk', 'asset', 'prebuilt-chunk']);
+function hasValidType(emittedFile) {
+    return Boolean(emittedFile &&
+        emittedFileTypes.has(emittedFile.type));
+}
+function hasValidName(emittedFile) {
+    const validatedName = emittedFile.fileName || emittedFile.name;
+    return !validatedName || (typeof validatedName === 'string' && !isPathFragment(validatedName));
+}
+function getValidSource(source, emittedFile, fileReferenceId) {
+    if (!(typeof source === 'string' || source instanceof Uint8Array)) {
+        const assetName = emittedFile.fileName || emittedFile.name || fileReferenceId;
+        return error(logFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
+    }
+    return source;
+}
+function getAssetFileName(file, referenceId) {
+    if (typeof file.fileName !== 'string') {
+        return error(logAssetNotFinalisedForFileName(file.name || referenceId));
+    }
+    return file.fileName;
+}
+function getChunkFileName(file, facadeChunkByModule) {
+    if (file.fileName) {
+        return file.fileName;
+    }
+    if (facadeChunkByModule) {
+        return facadeChunkByModule.get(file.module).getFileName();
+    }
+    return error(logChunkNotGeneratedForFileName(file.fileName || file.name));
+}
+class FileEmitter {
+    constructor(graph, options, baseFileEmitter) {
+        this.graph = graph;
+        this.options = options;
+        this.facadeChunkByModule = null;
+        this.nextIdBase = 1;
+        this.output = null;
+        this.outputFileEmitters = [];
+        this.emitFile = (emittedFile) => {
+            if (!hasValidType(emittedFile)) {
+                return error(logFailedValidation(`Emitted files must be of type "asset", "chunk" or "prebuilt-chunk", received "${emittedFile && emittedFile.type}".`));
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return this.emitPrebuiltChunk(emittedFile);
+            }
+            if (!hasValidName(emittedFile)) {
+                return error(logFailedValidation(`The "fileName" or "name" properties of emitted chunks and assets must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
+            }
+            if (emittedFile.type === 'chunk') {
+                return this.emitChunk(emittedFile);
+            }
+            return this.emitAsset(emittedFile);
+        };
+        this.finaliseAssets = () => {
+            for (const [referenceId, emittedFile] of this.filesByReferenceId) {
+                if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
+                    return error(logNoAssetSourceSet(emittedFile.name || referenceId));
+            }
+        };
+        this.getFileName = (fileReferenceId) => {
+            const emittedFile = this.filesByReferenceId.get(fileReferenceId);
+            if (!emittedFile)
+                return error(logFileReferenceIdNotFoundForFilename(fileReferenceId));
+            if (emittedFile.type === 'chunk') {
+                return getChunkFileName(emittedFile, this.facadeChunkByModule);
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return emittedFile.fileName;
+            }
+            return getAssetFileName(emittedFile, fileReferenceId);
+        };
+        this.setAssetSource = (referenceId, requestedSource) => {
+            const consumedFile = this.filesByReferenceId.get(referenceId);
+            if (!consumedFile)
+                return error(logAssetReferenceIdNotFoundForSetSource(referenceId));
+            if (consumedFile.type !== 'asset') {
+                return error(logFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
+            }
+            if (consumedFile.source !== undefined) {
+                return error(logAssetSourceAlreadySet(consumedFile.name || referenceId));
+            }
+            const source = getValidSource(requestedSource, consumedFile, referenceId);
+            if (this.output) {
+                this.finalizeAdditionalAsset(consumedFile, source, this.output);
+            }
+            else {
+                consumedFile.source = source;
+                for (const emitter of this.outputFileEmitters) {
+                    emitter.finalizeAdditionalAsset(consumedFile, source, emitter.output);
+                }
+            }
+        };
+        this.setChunkInformation = (facadeChunkByModule) => {
+            this.facadeChunkByModule = facadeChunkByModule;
+        };
+        this.setOutputBundle = (bundle, outputOptions) => {
+            const getHash = hasherByType[outputOptions.hashCharacters];
+            const output = (this.output = {
+                bundle,
+                fileNamesBySourceHash: new Map(),
+                getHash,
+                outputOptions
+            });
+            for (const emittedFile of this.filesByReferenceId.values()) {
+                if (emittedFile.fileName) {
+                    reserveFileNameInBundle(emittedFile.fileName, output, this.options.onLog);
+                }
+            }
+            const consumedAssetsByHash = new Map();
+            for (const consumedFile of this.filesByReferenceId.values()) {
+                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                    if (consumedFile.fileName) {
+                        this.finalizeAdditionalAsset(consumedFile, consumedFile.source, output);
+                    }
+                    else {
+                        const sourceHash = getHash(consumedFile.source);
+                        getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
+                    }
+                }
+                else if (consumedFile.type === 'prebuilt-chunk') {
+                    this.output.bundle[consumedFile.fileName] = this.createPrebuiltChunk(consumedFile);
+                }
+            }
+            for (const [sourceHash, consumedFiles] of consumedAssetsByHash) {
+                this.finalizeAssetsWithSameSource(consumedFiles, sourceHash, output);
+            }
+        };
+        this.filesByReferenceId = baseFileEmitter
+            ? new Map(baseFileEmitter.filesByReferenceId)
+            : new Map();
+        baseFileEmitter?.addOutputFileEmitter(this);
+    }
+    addOutputFileEmitter(outputFileEmitter) {
+        this.outputFileEmitters.push(outputFileEmitter);
+    }
+    assignReferenceId(file, idBase) {
+        let referenceId = idBase;
+        do {
+            referenceId = getHash64(referenceId).slice(0, 8).replaceAll('-', '$');
+        } while (this.filesByReferenceId.has(referenceId) ||
+            this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
+        file.referenceId = referenceId;
+        this.filesByReferenceId.set(referenceId, file);
+        for (const { filesByReferenceId } of this.outputFileEmitters) {
+            filesByReferenceId.set(referenceId, file);
+        }
+        return referenceId;
+    }
+    createPrebuiltChunk(prebuiltChunk) {
+        return {
+            code: prebuiltChunk.code,
+            dynamicImports: [],
+            exports: prebuiltChunk.exports || [],
+            facadeModuleId: null,
+            fileName: prebuiltChunk.fileName,
+            implicitlyLoadedBefore: [],
+            importedBindings: {},
+            imports: [],
+            isDynamicEntry: false,
+            isEntry: false,
+            isImplicitEntry: false,
+            map: prebuiltChunk.map || null,
+            moduleIds: [],
+            modules: {},
+            name: prebuiltChunk.fileName,
+            preliminaryFileName: prebuiltChunk.fileName,
+            referencedFiles: [],
+            sourcemapFileName: prebuiltChunk.sourcemapFileName || null,
+            type: 'chunk'
+        };
+    }
+    emitAsset(emittedAsset) {
+        const source = emittedAsset.source === undefined
+            ? undefined
+            : getValidSource(emittedAsset.source, emittedAsset, null);
+        const originalFileName = emittedAsset.originalFileName || null;
+        if (typeof originalFileName === 'string') {
+            this.graph.watchFiles[originalFileName] = true;
+        }
+        const consumedAsset = {
+            fileName: emittedAsset.fileName,
+            name: emittedAsset.name,
+            needsCodeReference: !!emittedAsset.needsCodeReference,
+            originalFileName,
+            referenceId: '',
+            source,
+            type: 'asset'
+        };
+        const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || String(this.nextIdBase++));
+        if (this.output) {
+            this.emitAssetWithReferenceId(consumedAsset, this.output);
+        }
+        else {
+            for (const fileEmitter of this.outputFileEmitters) {
+                fileEmitter.emitAssetWithReferenceId(consumedAsset, fileEmitter.output);
+            }
+        }
+        return referenceId;
+    }
+    emitAssetWithReferenceId(consumedAsset, output) {
+        const { fileName, source } = consumedAsset;
+        if (fileName) {
+            reserveFileNameInBundle(fileName, output, this.options.onLog);
+        }
+        if (source !== undefined) {
+            this.finalizeAdditionalAsset(consumedAsset, source, output);
+        }
+    }
+    emitChunk(emittedChunk) {
+        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
+            return error(logInvalidRollupPhaseForChunkEmission());
+        }
+        if (typeof emittedChunk.id !== 'string') {
+            return error(logFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+        }
+        const consumedChunk = {
+            fileName: emittedChunk.fileName,
+            module: null,
+            name: emittedChunk.name || emittedChunk.id,
+            referenceId: '',
+            type: 'chunk'
+        };
+        this.graph.moduleLoader
+            .emitChunk(emittedChunk)
+            .then(module => (consumedChunk.module = module))
+            .catch(() => {
+            // Avoid unhandled Promise rejection as the error will be thrown later
+            // once module loading has finished
+        });
+        return this.assignReferenceId(consumedChunk, emittedChunk.id);
+    }
+    emitPrebuiltChunk(emitPrebuiltChunk) {
+        if (typeof emitPrebuiltChunk.code !== 'string') {
+            return error(logFailedValidation(`Emitted prebuilt chunks need to have a valid string code, received "${emitPrebuiltChunk.code}".`));
+        }
+        if (typeof emitPrebuiltChunk.fileName !== 'string' ||
+            isPathFragment(emitPrebuiltChunk.fileName)) {
+            return error(logFailedValidation(`The "fileName" property of emitted prebuilt chunks must be strings that are neither absolute nor relative paths, received "${emitPrebuiltChunk.fileName}".`));
+        }
+        const consumedPrebuiltChunk = {
+            code: emitPrebuiltChunk.code,
+            exports: emitPrebuiltChunk.exports,
+            fileName: emitPrebuiltChunk.fileName,
+            map: emitPrebuiltChunk.map,
+            referenceId: '',
+            type: 'prebuilt-chunk'
+        };
+        const referenceId = this.assignReferenceId(consumedPrebuiltChunk, consumedPrebuiltChunk.fileName);
+        if (this.output) {
+            this.output.bundle[consumedPrebuiltChunk.fileName] =
+                this.createPrebuiltChunk(consumedPrebuiltChunk);
+        }
+        return referenceId;
+    }
+    finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySourceHash, getHash, outputOptions }) {
+        let { fileName, name, needsCodeReference, originalFileName, referenceId } = consumedFile;
+        // Deduplicate assets if an explicit fileName is not provided
+        if (!fileName) {
+            const sourceHash = getHash(source);
+            fileName = fileNamesBySourceHash.get(sourceHash);
+            if (!fileName) {
+                fileName = generateAssetFileName(name, name ? [name] : [], source, originalFileName, originalFileName ? [originalFileName] : [], sourceHash, outputOptions, bundle, this.options);
+                fileNamesBySourceHash.set(sourceHash, fileName);
+            }
+        }
+        // We must not modify the original assets to avoid interaction between outputs
+        const assetWithFileName = { ...consumedFile, fileName, source };
+        this.filesByReferenceId.set(referenceId, assetWithFileName);
+        const existingAsset = bundle[fileName];
+        if (existingAsset?.type === 'asset') {
+            existingAsset.needsCodeReference &&= needsCodeReference;
+            if (name) {
+                existingAsset.names.push(name);
+            }
+            if (originalFileName) {
+                existingAsset.originalFileNames.push(originalFileName);
+            }
+        }
+        else {
+            const { options } = this;
+            bundle[fileName] = {
+                fileName,
+                get name() {
+                    // Additionally, this should be non-enumerable in the next major
+                    warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', URL_GENERATEBUNDLE, false, options);
+                    return name;
+                },
+                names: name ? [name] : [],
+                needsCodeReference,
+                get originalFileName() {
+                    // Additionally, this should be non-enumerable in the next major
+                    warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', URL_GENERATEBUNDLE, false, options);
+                    return originalFileName;
+                },
+                originalFileNames: originalFileName ? [originalFileName] : [],
+                source,
+                type: 'asset'
+            };
+        }
+    }
+    finalizeAssetsWithSameSource(consumedFiles, sourceHash, { bundle, fileNamesBySourceHash, outputOptions }) {
+        const { names, originalFileNames } = getNamesFromAssets(consumedFiles);
+        let fileName = '';
+        let usedConsumedFile;
+        let needsCodeReference = true;
+        for (const consumedFile of consumedFiles) {
+            needsCodeReference &&= consumedFile.needsCodeReference;
+            const assetFileName = generateAssetFileName(consumedFile.name, names, consumedFile.source, consumedFile.originalFileName, originalFileNames, sourceHash, outputOptions, bundle, this.options);
+            if (!fileName ||
+                assetFileName.length < fileName.length ||
+                (assetFileName.length === fileName.length && assetFileName < fileName)) {
+                fileName = assetFileName;
+                usedConsumedFile = consumedFile;
+            }
+        }
+        fileNamesBySourceHash.set(sourceHash, fileName);
+        for (const consumedFile of consumedFiles) {
+            // We must not modify the original assets to avoid interaction between outputs
+            const assetWithFileName = { ...consumedFile, fileName };
+            this.filesByReferenceId.set(consumedFile.referenceId, assetWithFileName);
+        }
+        const { options } = this;
+        bundle[fileName] = {
+            fileName,
+            get name() {
+                // Additionally, this should be non-enumerable in the next major
+                warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.name;
+            },
+            names,
+            needsCodeReference,
+            get originalFileName() {
+                // Additionally, this should be non-enumerable in the next major
+                warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.originalFileName;
+            },
+            originalFileNames,
+            source: usedConsumedFile.source,
+            type: 'asset'
+        };
+    }
+}
+function getNamesFromAssets(consumedFiles) {
+    const names = [];
+    const originalFileNames = [];
+    for (const { name, originalFileName } of consumedFiles) {
+        if (typeof name === 'string') {
+            names.push(name);
+        }
+        if (originalFileName) {
+            originalFileNames.push(originalFileName);
+        }
+    }
+    originalFileNames.sort();
+    // Sort by length first and then alphabetically so that the order is stable
+    // and the shortest names come first
+    names.sort((a, b) => a.length - b.length || (a > b ? 1 : a === b ? 0 : -1));
+    return { names, originalFileNames };
+}
+
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+    if (logLevelPriority[level] < logLevelPriority[logLevel]) {
+        return doNothing;
+    }
+    return (log, pos) => {
+        if (pos != null) {
+            logger(LOGLEVEL_WARN, logInvalidLogPosition(pluginName));
+        }
+        log = normalizeLog(log);
+        if (log.code && !log.pluginCode) {
+            log.pluginCode = log.code;
+        }
+        log.code = code;
+        log.plugin = pluginName;
+        logger(level, log);
+    };
+}
+
+function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, existingPluginNames) {
+    const { logLevel, onLog } = options;
+    let cacheable = true;
+    if (typeof plugin.cacheKey !== 'string') {
+        if (plugin.name.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+            plugin.name.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX) ||
+            existingPluginNames.has(plugin.name)) {
+            cacheable = false;
+        }
+        else {
+            existingPluginNames.add(plugin.name);
+        }
+    }
+    let cacheInstance;
+    if (!pluginCache) {
+        cacheInstance = NO_CACHE;
+    }
+    else if (cacheable) {
+        const cacheKey = plugin.cacheKey || plugin.name;
+        cacheInstance = createPluginCache(pluginCache[cacheKey] || (pluginCache[cacheKey] = Object.create(null)));
+    }
+    else {
+        cacheInstance = getCacheForUncacheablePlugin(plugin.name);
+    }
+    return {
+        addWatchFile(id) {
+            graph.watchFiles[id] = true;
+        },
+        cache: cacheInstance,
+        debug: getLogHandler(LOGLEVEL_DEBUG, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
+        emitFile: fileEmitter.emitFile.bind(fileEmitter),
+        error(error_) {
+            return error(logPluginError(normalizeLog(error_), plugin.name));
+        },
+        getFileName: fileEmitter.getFileName,
+        getModuleIds: () => graph.modulesById.keys(),
+        getModuleInfo: graph.getModuleInfo,
+        getWatchFiles: () => Object.keys(graph.watchFiles),
+        info: getLogHandler(LOGLEVEL_INFO, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
+        load(resolvedId) {
+            return graph.moduleLoader.preloadModule(resolvedId);
+        },
+        meta: {
+            rollupVersion: version,
+            watchMode: graph.watchMode
+        },
+        parse: parseAst,
+        resolve(source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) {
+            skipSelf ??= true;
+            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
+        },
+        setAssetSource: fileEmitter.setAssetSource,
+        warn: getLogHandler(LOGLEVEL_WARN, 'PLUGIN_WARNING', onLog, plugin.name, logLevel)
+    };
+}
+
+// This will make sure no input hook is omitted
+const inputHookNames = {
+    buildEnd: 1,
+    buildStart: 1,
+    closeBundle: 1,
+    closeWatcher: 1,
+    load: 1,
+    moduleParsed: 1,
+    onLog: 1,
+    options: 1,
+    resolveDynamicImport: 1,
+    resolveId: 1,
+    shouldTransformCachedModule: 1,
+    transform: 1,
+    watchChange: 1
+};
+const inputHooks = Object.keys(inputHookNames);
+class PluginDriver {
+    constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
+        this.graph = graph;
+        this.options = options;
+        this.pluginCache = pluginCache;
+        this.sortedPlugins = new Map();
+        this.unfulfilledActions = new Set();
+        this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
+        this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
+        this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
+        this.finaliseAssets = this.fileEmitter.finaliseAssets.bind(this.fileEmitter);
+        this.setChunkInformation = this.fileEmitter.setChunkInformation.bind(this.fileEmitter);
+        this.setOutputBundle = this.fileEmitter.setOutputBundle.bind(this.fileEmitter);
+        this.plugins = [...(basePluginDriver ? basePluginDriver.plugins : []), ...userPlugins];
+        const existingPluginNames = new Set();
+        this.pluginContexts = new Map(this.plugins.map(plugin => [
+            plugin,
+            getPluginContext(plugin, pluginCache, graph, options, this.fileEmitter, existingPluginNames)
+        ]));
+        if (basePluginDriver) {
+            for (const plugin of userPlugins) {
+                for (const hook of inputHooks) {
+                    if (hook in plugin) {
+                        options.onLog(LOGLEVEL_WARN, logInputHookInOutputPlugin(plugin.name, hook));
+                    }
+                }
+            }
+        }
+    }
+    createOutputPluginDriver(plugins) {
+        return new PluginDriver(this.graph, this.options, plugins, this.pluginCache, this);
+    }
+    getUnfulfilledHookActions() {
+        return this.unfulfilledActions;
+    }
+    // chains, first non-null result stops and returns
+    hookFirst(hookName, parameters, replaceContext, skipped) {
+        return this.hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped).then(result => result && result[0]);
+    }
+    // chains, first non-null result stops and returns result and last plugin
+    async hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (skipped?.has(plugin))
+                continue;
+            const result = await this.runHook(hookName, parameters, plugin, replaceContext);
+            if (result != null)
+                return [result, plugin];
+        }
+        return null;
+    }
+    // chains synchronously, first non-null result stops and returns
+    hookFirstSync(hookName, parameters, replaceContext) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+    // parallel, ignores returns
+    async hookParallel(hookName, parameters, replaceContext) {
+        const parallelPromises = [];
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (plugin[hookName].sequential) {
+                await Promise.all(parallelPromises);
+                parallelPromises.length = 0;
+                await this.runHook(hookName, parameters, plugin, replaceContext);
+            }
+            else {
+                parallelPromises.push(this.runHook(hookName, parameters, plugin, replaceContext));
+            }
+        }
+        await Promise.all(parallelPromises);
+    }
+    // chains, reduces returned value, handling the reduced value as the first hook argument
+    hookReduceArg0(hookName, [argument0, ...rest], reduce, replaceContext) {
+        let promise = Promise.resolve(argument0);
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(argument0 => this.runHook(hookName, [argument0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin)));
+        }
+        return promise;
+    }
+    // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
+    hookReduceArg0Sync(hookName, [argument0, ...rest], reduce, replaceContext) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const parameters = [argument0, ...rest];
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            argument0 = reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin);
+        }
+        return argument0;
+    }
+    // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
+    async hookReduceValue(hookName, initialValue, parameters, reducer) {
+        const results = [];
+        const parallelResults = [];
+        for (const plugin of this.getSortedPlugins(hookName, validateAddonPluginHandler)) {
+            if (plugin[hookName].sequential) {
+                results.push(...(await Promise.all(parallelResults)));
+                parallelResults.length = 0;
+                results.push(await this.runHook(hookName, parameters, plugin));
+            }
+            else {
+                parallelResults.push(this.runHook(hookName, parameters, plugin));
+            }
+        }
+        results.push(...(await Promise.all(parallelResults)));
+        return results.reduce(reducer, await initialValue);
+    }
+    // chains synchronously, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
+    hookReduceValueSync(hookName, initialValue, parameters, reduce, replaceContext) {
+        let accumulator = initialValue;
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            accumulator = reduce.call(this.pluginContexts.get(plugin), accumulator, result, plugin);
+        }
+        return accumulator;
+    }
+    // chains, ignores returns
+    hookSeq(hookName, parameters, replaceContext) {
+        let promise = Promise.resolve();
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(() => this.runHook(hookName, parameters, plugin, replaceContext));
+        }
+        return promise.then(noReturn);
+    }
+    getSortedPlugins(hookName, validateHandler) {
+        return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
+    }
+    // Implementation signature
+    runHook(hookName, parameters, plugin, replaceContext) {
+        // We always filter for plugins that support the hook before running it
+        const hook = plugin[hookName];
+        const handler = typeof hook === 'object' ? hook.handler : hook;
+        let context = this.pluginContexts.get(plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
+        }
+        let action = null;
+        return Promise.resolve()
+            .then(() => {
+            if (typeof handler !== 'function') {
+                return handler;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            const hookResult = handler.apply(context, parameters);
+            if (!hookResult?.then) {
+                // short circuit for non-thenables and non-Promises
+                return hookResult;
+            }
+            // Track pending hook actions to properly error out when
+            // unfulfilled promises cause rollup to abruptly and confusingly
+            // exit with a successful 0 return code but without producing any
+            // output, errors or warnings.
+            action = [plugin.name, hookName, parameters];
+            this.unfulfilledActions.add(action);
+            // Although it would be more elegant to just return hookResult here
+            // and put the .then() handler just above the .catch() handler below,
+            // doing so would subtly change the defacto async event dispatch order
+            // which at least one test and some plugins in the wild may depend on.
+            return Promise.resolve(hookResult).then(result => {
+                // action was fulfilled
+                this.unfulfilledActions.delete(action);
+                return result;
+            });
+        })
+            .catch(error_ => {
+            if (action !== null) {
+                // action considered to be fulfilled since error being handled
+                this.unfulfilledActions.delete(action);
+            }
+            return error(logPluginError(error_, plugin.name, { hook: hookName }));
+        });
+    }
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    runHookSync(hookName, parameters, plugin, replaceContext) {
+        const hook = plugin[hookName];
+        const handler = typeof hook === 'object' ? hook.handler : hook;
+        let context = this.pluginContexts.get(plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            return handler.apply(context, parameters);
+        }
+        catch (error_) {
+            return error(logPluginError(error_, plugin.name, { hook: hookName }));
+        }
+    }
+}
+function getSortedValidatedPlugins(hookName, plugins, validateHandler = validateFunctionPluginHandler) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                validateHandler(hook.handler, hookName, plugin);
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            else {
+                validateHandler(hook, hookName, plugin);
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}
+function validateFunctionPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'function') {
+        error(logInvalidFunctionPluginHook(hookName, plugin.name));
+    }
+}
+function validateAddonPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'string' && typeof handler !== 'function') {
+        return error(logInvalidAddonPluginHook(hookName, plugin.name));
+    }
+}
+function noReturn() { }
+
+class Queue {
+    constructor(maxParallel) {
+        this.maxParallel = maxParallel;
+        this.queue = [];
+        this.workerCount = 0;
+    }
+    run(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ reject, resolve, task });
+            this.work();
+        });
+    }
+    async work() {
+        if (this.workerCount >= this.maxParallel)
+            return;
+        this.workerCount++;
+        let entry;
+        while ((entry = this.queue.shift())) {
+            const { reject, resolve, task } = entry;
+            try {
+                const result = await task();
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        this.workerCount--;
+    }
+}
+
+function normalizeEntryModules(entryModules) {
+    if (Array.isArray(entryModules)) {
+        return entryModules.map(id => ({
+            fileName: null,
+            id,
+            implicitlyLoadedAfter: [],
+            importer: undefined,
+            name: null
+        }));
+    }
+    return Object.entries(entryModules).map(([name, id]) => ({
+        fileName: null,
+        id,
+        implicitlyLoadedAfter: [],
+        importer: undefined,
+        name
+    }));
+}
+class Graph {
+    constructor(options, watcher) {
+        this.options = options;
+        this.astLru = flru(5);
+        this.cachedModules = new Map();
+        this.deoptimizationTracker = new PathTracker();
+        this.entryModules = [];
+        this.modulesById = new Map();
+        this.needsTreeshakingPass = false;
+        this.phase = BuildPhase.LOAD_AND_PARSE;
+        this.scope = new GlobalScope();
+        this.watchFiles = Object.create(null);
+        this.watchMode = false;
+        this.externalModules = [];
+        this.implicitEntryModules = [];
+        this.modules = [];
+        this.getModuleInfo = (moduleId) => {
+            const foundModule = this.modulesById.get(moduleId);
+            if (!foundModule)
+                return null;
+            return foundModule.info;
+        };
+        if (options.cache !== false) {
+            if (options.cache?.modules) {
+                for (const module of options.cache.modules)
+                    this.cachedModules.set(module.id, module);
+            }
+            this.pluginCache = options.cache?.plugins || Object.create(null);
+            // increment access counter
+            for (const name in this.pluginCache) {
+                const cache = this.pluginCache[name];
+                for (const value of Object.values(cache))
+                    value[0]++;
+            }
+        }
+        if (watcher) {
+            this.watchMode = true;
+            const handleChange = (...parameters) => this.pluginDriver.hookParallel('watchChange', parameters);
+            const handleClose = () => this.pluginDriver.hookParallel('closeWatcher', []);
+            watcher.onCurrentRun('change', handleChange);
+            watcher.onCurrentRun('close', handleClose);
+        }
+        this.pluginDriver = new PluginDriver(this, options, options.plugins, this.pluginCache);
+        this.moduleLoader = new ModuleLoader(this, this.modulesById, this.options, this.pluginDriver);
+        this.fileOperationQueue = new Queue(options.maxParallelFileOps);
+        this.pureFunctions = getPureFunctions(options);
+    }
+    async build() {
+        timeStart('generate module graph', 2);
+        await this.generateModuleGraph();
+        timeEnd('generate module graph', 2);
+        timeStart('sort and bind modules', 2);
+        this.phase = BuildPhase.ANALYSE;
+        this.sortModules();
+        timeEnd('sort and bind modules', 2);
+        timeStart('mark included statements', 2);
+        this.includeStatements();
+        timeEnd('mark included statements', 2);
+        this.phase = BuildPhase.GENERATE;
+    }
+    getCache() {
+        // handle plugin cache eviction
+        for (const name in this.pluginCache) {
+            const cache = this.pluginCache[name];
+            let allDeleted = true;
+            for (const [key, value] of Object.entries(cache)) {
+                if (value[0] >= this.options.experimentalCacheExpiry)
+                    delete cache[key];
+                else
+                    allDeleted = false;
+            }
+            if (allDeleted)
+                delete this.pluginCache[name];
+        }
+        return {
+            modules: this.modules.map(module => module.toJSON()),
+            plugins: this.pluginCache
+        };
+    }
+    async generateModuleGraph() {
+        ({ entryModules: this.entryModules, implicitEntryModules: this.implicitEntryModules } =
+            await this.moduleLoader.addEntryModules(normalizeEntryModules(this.options.input), true));
+        if (this.entryModules.length === 0) {
+            throw new Error('You must supply options.input to rollup');
+        }
+        for (const module of this.modulesById.values()) {
+            module.cacheInfoGetters();
+            if (module instanceof Module) {
+                this.modules.push(module);
+            }
+            else {
+                this.externalModules.push(module);
+            }
+        }
+    }
+    includeStatements() {
+        const entryModules = [...this.entryModules, ...this.implicitEntryModules];
+        for (const module of entryModules) {
+            markModuleAndImpureDependenciesAsExecuted(module);
+        }
+        if (this.options.treeshake) {
+            let treeshakingPass = 1;
+            do {
+                timeStart(`treeshaking pass ${treeshakingPass}`, 3);
+                this.needsTreeshakingPass = false;
+                for (const module of this.modules) {
+                    if (module.isExecuted) {
+                        module.hasTreeShakingPassStarted = true;
+                        if (module.info.moduleSideEffects === 'no-treeshake') {
+                            module.includeAllInBundle();
+                        }
+                        else {
+                            module.include();
+                        }
+                    }
+                }
+                if (treeshakingPass === 1) {
+                    // We only include exports after the first pass to avoid issues with
+                    // the TDZ detection logic
+                    for (const module of entryModules) {
+                        if (module.preserveSignature !== false) {
+                            module.includeAllExports(false);
+                            this.needsTreeshakingPass = true;
+                        }
+                    }
+                }
+                timeEnd(`treeshaking pass ${treeshakingPass++}`, 3);
+            } while (this.needsTreeshakingPass);
+        }
+        else {
+            for (const module of this.modules)
+                module.includeAllInBundle();
+        }
+        for (const externalModule of this.externalModules)
+            externalModule.warnUnusedImports();
+        for (const module of this.implicitEntryModules) {
+            for (const dependant of module.implicitlyLoadedAfter) {
+                if (!(dependant.info.isEntry || dependant.isIncluded())) {
+                    error(logImplicitDependantIsNotIncluded(dependant));
+                }
+            }
+        }
+    }
+    sortModules() {
+        const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
+        for (const cyclePath of cyclePaths) {
+            this.options.onLog(LOGLEVEL_WARN, logCircularDependency(cyclePath));
+        }
+        this.modules = orderedModules;
+        for (const module of this.modules) {
+            module.bindReferences();
+        }
+        this.warnForMissingExports();
+    }
+    warnForMissingExports() {
+        for (const module of this.modules) {
+            for (const importDescription of module.importDescriptions.values()) {
+                if (importDescription.name !== '*' &&
+                    !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
+                    module.log(LOGLEVEL_WARN, logMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
+                }
+            }
+        }
+    }
+}
+
+function formatAction([pluginName, hookName, parameters]) {
+    const action = `(${pluginName}) ${hookName}`;
+    const s = JSON.stringify;
+    switch (hookName) {
+        case 'resolveId': {
+            return `${action} ${s(parameters[0])} ${s(parameters[1])}`;
+        }
+        case 'load': {
+            return `${action} ${s(parameters[0])}`;
+        }
+        case 'transform': {
+            return `${action} ${s(parameters[1])}`;
+        }
+        case 'shouldTransformCachedModule': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
+        case 'moduleParsed': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
+    }
+    return action;
+}
+let handleBeforeExit = null;
+const rejectByPluginDriver = new Map();
+async function catchUnfinishedHookActions(pluginDriver, callback) {
+    const emptyEventLoopPromise = new Promise((_, reject) => {
+        rejectByPluginDriver.set(pluginDriver, reject);
+        if (!handleBeforeExit) {
+            // We only ever create a single event listener to avoid max listener and
+            // other issues
+            handleBeforeExit = () => {
+                for (const [pluginDriver, reject] of rejectByPluginDriver) {
+                    const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
+                    reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
+                        [...unfulfilledActions].map(formatAction).join('\n')));
+                }
+            };
+            process$1.once('beforeExit', handleBeforeExit);
+        }
+    });
+    try {
+        return await Promise.race([callback(), emptyEventLoopPromise]);
+    }
+    finally {
+        rejectByPluginDriver.delete(pluginDriver);
+        if (rejectByPluginDriver.size === 0) {
+            process$1.off('beforeExit', handleBeforeExit);
+            handleBeforeExit = null;
+        }
+    }
+}
+
+async function initWasm() { }
+
+function getLogger(plugins, onLog, watchMode, logLevel) {
+    plugins = getSortedValidatedPlugins('onLog', plugins);
+    const minimalPriority = logLevelPriority[logLevel];
+    const logger = (level, log, skipped = EMPTY_SET) => {
+        augmentLogMessage(log);
+        const logPriority = logLevelPriority[level];
+        if (logPriority < minimalPriority) {
+            return;
+        }
+        for (const plugin of plugins) {
+            if (skipped.has(plugin))
+                continue;
+            const { onLog: pluginOnLog } = plugin;
+            const getLogHandler = (level) => {
+                if (logLevelPriority[level] < minimalPriority) {
+                    return doNothing;
+                }
+                return log => logger(level, normalizeLog(log), new Set(skipped).add(plugin));
+            };
+            const handler = 'handler' in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+            if (handler.call({
+                debug: getLogHandler(LOGLEVEL_DEBUG),
+                error: (log) => error(normalizeLog(log)),
+                info: getLogHandler(LOGLEVEL_INFO),
+                meta: { rollupVersion: version, watchMode },
+                warn: getLogHandler(LOGLEVEL_WARN)
+            }, level, log) === false) {
+                return;
+            }
+        }
+        onLog(level, log);
+    };
+    return logger;
+}
+
+function ensureArray(items) {
+    if (Array.isArray(items)) {
+        return items.filter(Boolean);
+    }
+    if (items) {
+        return [items];
+    }
+    return [];
+}
+
+async function normalizeInputOptions(config, watchMode) {
+    // These are options that may trigger special warnings or behaviour later
+    // if the user did not select an explicit value
+    const unsetOptions = new Set();
+    const context = config.context ?? 'undefined';
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || LOGLEVEL_INFO;
+    const onLog = getLogger(plugins, getOnLog(config, logLevel), watchMode, logLevel);
+    const strictDeprecations = config.strictDeprecations || false;
+    const maxParallelFileOps = getMaxParallelFileOps(config);
+    const options = {
+        cache: getCache(config),
+        context,
+        experimentalCacheExpiry: config.experimentalCacheExpiry ?? 10,
+        experimentalLogSideEffects: config.experimentalLogSideEffects || false,
+        external: getIdMatcher(config.external),
+        input: getInput(config),
+        jsx: getJsx(config),
+        logLevel,
+        makeAbsoluteExternalsRelative: config.makeAbsoluteExternalsRelative ?? 'ifRelativeSource',
+        maxParallelFileOps,
+        moduleContext: getModuleContext(config, context),
+        onLog,
+        perf: config.perf || false,
+        plugins,
+        preserveEntrySignatures: config.preserveEntrySignatures ?? 'exports-only',
+        preserveSymlinks: config.preserveSymlinks || false,
+        shimMissingExports: config.shimMissingExports || false,
+        strictDeprecations,
+        treeshake: getTreeshake(config)
+    };
+    warnUnknownOptions(config, [...Object.keys(options), 'onwarn', 'watch'], 'input options', onLog, /^(output)$/);
+    return { options, unsetOptions };
+}
+const getCache = (config) => config.cache === true // `true` is the default
+    ? undefined
+    : config.cache?.cache || config.cache;
+const getIdMatcher = (option) => {
+    if (option === true) {
+        return () => true;
+    }
+    if (typeof option === 'function') {
+        return (id, ...parameters) => (!id.startsWith('\0') && option(id, ...parameters)) || false;
+    }
+    if (option) {
+        const ids = new Set();
+        const matchers = [];
+        for (const value of ensureArray(option)) {
+            if (value instanceof RegExp) {
+                matchers.push(value);
+            }
+            else {
+                ids.add(value);
+            }
+        }
+        return (id, ..._arguments) => ids.has(id) || matchers.some(matcher => matcher.test(id));
+    }
+    return () => false;
+};
+const getInput = (config) => {
+    const configInput = config.input;
+    return configInput == null ? [] : typeof configInput === 'string' ? [configInput] : configInput;
+};
+const getJsx = (config) => {
+    const configJsx = config.jsx;
+    if (!configJsx)
+        return false;
+    const configWithPreset = getOptionWithPreset(configJsx, jsxPresets, 'jsx', URL_JSX, 'false, ');
+    const { factory, importSource, mode } = configWithPreset;
+    switch (mode) {
+        case 'automatic': {
+            return {
+                factory: factory || 'React.createElement',
+                importSource: importSource || 'react',
+                jsxImportSource: configWithPreset.jsxImportSource || 'react/jsx-runtime',
+                mode: 'automatic'
+            };
+        }
+        case 'preserve': {
+            if (importSource && !(factory || configWithPreset.fragment)) {
+                error(logInvalidOption('jsx', URL_JSX, 'when preserving JSX and specifying an importSource, you also need to specify a factory or fragment'));
+            }
+            return {
+                factory: factory || null,
+                fragment: configWithPreset.fragment || null,
+                importSource: importSource || null,
+                mode: 'preserve'
+            };
+        }
+        // case 'classic':
+        default: {
+            if (mode && mode !== 'classic') {
+                error(logInvalidOption('jsx.mode', URL_JSX, 'mode must be "automatic", "classic" or "preserve"', mode));
+            }
+            return {
+                factory: factory || 'React.createElement',
+                fragment: configWithPreset.fragment || 'React.Fragment',
+                importSource: importSource || null,
+                mode: 'classic'
+            };
+        }
+    }
+};
+const getMaxParallelFileOps = (config) => {
+    const maxParallelFileOps = config.maxParallelFileOps;
+    if (typeof maxParallelFileOps === 'number') {
+        if (maxParallelFileOps <= 0)
+            return Infinity;
+        return maxParallelFileOps;
+    }
+    return 20;
+};
+const getModuleContext = (config, context) => {
+    const configModuleContext = config.moduleContext;
+    if (typeof configModuleContext === 'function') {
+        return id => configModuleContext(id) ?? context;
+    }
+    if (configModuleContext) {
+        const contextByModuleId = Object.create(null);
+        for (const [key, moduleContext] of Object.entries(configModuleContext)) {
+            contextByModuleId[resolve$1(key)] = moduleContext;
+        }
+        return id => contextByModuleId[id] ?? context;
+    }
+    return () => context;
+};
+const getTreeshake = (config) => {
+    const configTreeshake = config.treeshake;
+    if (configTreeshake === false) {
+        return false;
+    }
+    const configWithPreset = getOptionWithPreset(config.treeshake, treeshakePresets, 'treeshake', URL_TREESHAKE, 'false, true, ');
+    return {
+        annotations: configWithPreset.annotations !== false,
+        correctVarValueBeforeDeclaration: configWithPreset.correctVarValueBeforeDeclaration === true,
+        manualPureFunctions: configWithPreset.manualPureFunctions ?? EMPTY_ARRAY,
+        moduleSideEffects: getHasModuleSideEffects(configWithPreset.moduleSideEffects),
+        propertyReadSideEffects: configWithPreset.propertyReadSideEffects === 'always'
+            ? 'always'
+            : configWithPreset.propertyReadSideEffects !== false,
+        tryCatchDeoptimization: configWithPreset.tryCatchDeoptimization !== false,
+        unknownGlobalSideEffects: configWithPreset.unknownGlobalSideEffects !== false
+    };
+};
+const getHasModuleSideEffects = (moduleSideEffectsOption) => {
+    if (typeof moduleSideEffectsOption === 'boolean') {
+        return () => moduleSideEffectsOption;
+    }
+    if (moduleSideEffectsOption === 'no-external') {
+        return (_id, external) => !external;
+    }
+    if (typeof moduleSideEffectsOption === 'function') {
+        return (id, external) => id.startsWith('\0') ? true : moduleSideEffectsOption(id, external) !== false;
+    }
+    if (Array.isArray(moduleSideEffectsOption)) {
+        const ids = new Set(moduleSideEffectsOption);
+        return id => ids.has(id);
+    }
+    if (moduleSideEffectsOption) {
+        error(logInvalidOption('treeshake.moduleSideEffects', URL_TREESHAKE_MODULESIDEEFFECTS, 'please use one of false, "no-external", a function or an array'));
+    }
+    return () => true;
+};
+
+// https://datatracker.ietf.org/doc/html/rfc2396
+// eslint-disable-next-line no-control-regex
+const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$%&*+,:;<=>?[\]^`{|}\u007F]/g;
+const DRIVE_LETTER_REGEX = /^[a-z]:/i;
+function sanitizeFileName(name) {
+    const match = DRIVE_LETTER_REGEX.exec(name);
+    const driveLetter = match ? match[0] : '';
+    // A `:` is only allowed as part of a windows drive letter (ex: C:\foo)
+    // Otherwise, avoid them because they can refer to NTFS alternate data streams.
+    return driveLetter + name.slice(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
+}
+
+async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
+    // These are options that may trigger special warnings or behaviour later
+    // if the user did not select an explicit value
+    const unsetOptions = new Set(unsetInputOptions);
+    const compact = config.compact || false;
+    const format = getFormat(config);
+    const inlineDynamicImports = getInlineDynamicImports(config, inputOptions);
+    const preserveModules = getPreserveModules(config, inlineDynamicImports, inputOptions);
+    const file = getFile(config, preserveModules, inputOptions);
+    const generatedCode = getGeneratedCode(config);
+    const externalImportAttributes = getExternalImportAttributes(config, inputOptions);
+    const outputOptions = {
+        amd: getAmd(config),
+        assetFileNames: config.assetFileNames ?? 'assets/[name]-[hash][extname]',
+        banner: getAddon(config, 'banner'),
+        chunkFileNames: config.chunkFileNames ?? '[name]-[hash].js',
+        compact,
+        dir: getDir(config, file),
+        dynamicImportInCjs: config.dynamicImportInCjs ?? true,
+        entryFileNames: getEntryFileNames(config, unsetOptions),
+        esModule: config.esModule ?? 'if-default-prop',
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
+        exports: getExports(config, unsetOptions),
+        extend: config.extend || false,
+        externalImportAssertions: externalImportAttributes,
+        externalImportAttributes,
+        externalLiveBindings: config.externalLiveBindings ?? true,
+        file,
+        footer: getAddon(config, 'footer'),
+        format,
+        freeze: config.freeze ?? true,
+        generatedCode,
+        globals: config.globals || {},
+        hashCharacters: config.hashCharacters ?? 'base64',
+        hoistTransitiveImports: config.hoistTransitiveImports ?? true,
+        importAttributesKey: config.importAttributesKey ?? 'assert',
+        indent: getIndent(config, compact),
+        inlineDynamicImports,
+        interop: getInterop(config),
+        intro: getAddon(config, 'intro'),
+        manualChunks: getManualChunks(config, inlineDynamicImports, preserveModules),
+        minifyInternalExports: getMinifyInternalExports(config, format, compact),
+        name: config.name,
+        noConflict: config.noConflict || false,
+        outro: getAddon(config, 'outro'),
+        paths: config.paths || {},
+        plugins: await normalizePluginOption(config.plugins),
+        preserveModules,
+        preserveModulesRoot: getPreserveModulesRoot(config),
+        reexportProtoFromExternal: config.reexportProtoFromExternal ?? true,
+        sanitizeFileName: typeof config.sanitizeFileName === 'function'
+            ? config.sanitizeFileName
+            : config.sanitizeFileName === false
+                ? id => id
+                : sanitizeFileName,
+        sourcemap: config.sourcemap || false,
+        sourcemapBaseUrl: getSourcemapBaseUrl(config),
+        sourcemapExcludeSources: config.sourcemapExcludeSources || false,
+        sourcemapFile: config.sourcemapFile,
+        sourcemapFileNames: getSourcemapFileNames(config, unsetOptions),
+        sourcemapIgnoreList: typeof config.sourcemapIgnoreList === 'function'
+            ? config.sourcemapIgnoreList
+            : config.sourcemapIgnoreList === false
+                ? () => false
+                : relativeSourcePath => relativeSourcePath.includes('node_modules'),
+        sourcemapPathTransform: config.sourcemapPathTransform,
+        strict: config.strict ?? true,
+        systemNullSetters: config.systemNullSetters ?? true,
+        validate: config.validate || false,
+        virtualDirname: config.virtualDirname || '_virtual'
+    };
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onLog);
+    return { options: outputOptions, unsetOptions };
+}
+const getFile = (config, preserveModules, inputOptions) => {
+    const { file } = config;
+    if (typeof file === 'string') {
+        if (preserveModules) {
+            return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
+        }
+        if (!Array.isArray(inputOptions.input))
+            return error(logInvalidOption('output.file', URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when providing named inputs'));
+    }
+    return file;
+};
+const getFormat = (config) => {
+    const configFormat = config.format;
+    switch (configFormat) {
+        case undefined:
+        case 'es':
+        case 'esm':
+        case 'module': {
+            return 'es';
+        }
+        case 'cjs':
+        case 'commonjs': {
+            return 'cjs';
+        }
+        case 'system':
+        case 'systemjs': {
+            return 'system';
+        }
+        case 'amd':
+        case 'iife':
+        case 'umd': {
+            return configFormat;
+        }
+        default: {
+            return error(logInvalidOption('output.format', URL_OUTPUT_FORMAT, `Valid values are "amd", "cjs", "system", "es", "iife" or "umd"`, configFormat));
+        }
+    }
+};
+const getInlineDynamicImports = (config, inputOptions) => {
+    const inlineDynamicImports = config.inlineDynamicImports || false;
+    const { input } = inputOptions;
+    if (inlineDynamicImports && (Array.isArray(input) ? input : Object.keys(input)).length > 1) {
+        return error(logInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
+    }
+    return inlineDynamicImports;
+};
+const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
+    const preserveModules = config.preserveModules || false;
+    if (preserveModules) {
+        if (inlineDynamicImports) {
+            return error(logInvalidOption('output.inlineDynamicImports', URL_OUTPUT_INLINEDYNAMICIMPORTS, `this option is not supported for "output.preserveModules"`));
+        }
+        if (inputOptions.preserveEntrySignatures === false) {
+            return error(logInvalidOption('preserveEntrySignatures', URL_PRESERVEENTRYSIGNATURES, 'setting this option to false is not supported for "output.preserveModules"'));
+        }
+    }
+    return preserveModules;
+};
+const getPreserveModulesRoot = (config) => {
+    const { preserveModulesRoot } = config;
+    if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
+        return undefined;
+    }
+    return resolve$1(preserveModulesRoot);
+};
+const getAmd = (config) => {
+    const mergedOption = {
+        autoId: false,
+        basePath: '',
+        define: 'define',
+        forceJsExtensionForImports: false,
+        ...config.amd
+    };
+    if ((mergedOption.autoId || mergedOption.basePath) && mergedOption.id) {
+        return error(logInvalidOption('output.amd.id', URL_OUTPUT_AMD_ID, 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
+    }
+    if (mergedOption.basePath && !mergedOption.autoId) {
+        return error(logInvalidOption('output.amd.basePath', URL_OUTPUT_AMD_BASEPATH, 'this option only works with "output.amd.autoId"'));
+    }
+    return mergedOption.autoId
+        ? {
+            autoId: true,
+            basePath: mergedOption.basePath,
+            define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports
+        }
+        : {
+            autoId: false,
+            define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports,
+            id: mergedOption.id
+        };
+};
+const getAddon = (config, name) => {
+    const configAddon = config[name];
+    if (typeof configAddon === 'function') {
+        return configAddon;
+    }
+    return () => configAddon || '';
+};
+const getDir = (config, file) => {
+    const { dir } = config;
+    if (typeof dir === 'string' && typeof file === 'string') {
+        return error(logInvalidOption('output.dir', URL_OUTPUT_DIR, 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
+    }
+    return dir;
+};
+const getEntryFileNames = (config, unsetOptions) => {
+    const configEntryFileNames = config.entryFileNames;
+    if (configEntryFileNames == null) {
+        unsetOptions.add('entryFileNames');
+    }
+    return configEntryFileNames ?? '[name].js';
+};
+function getExports(config, unsetOptions) {
+    const configExports = config.exports;
+    if (configExports == null) {
+        unsetOptions.add('exports');
+    }
+    else if (!['default', 'named', 'none', 'auto'].includes(configExports)) {
+        return error(logInvalidExportOptionValue(configExports));
+    }
+    return configExports || 'auto';
+}
+const getExternalImportAttributes = (config, inputOptions) => {
+    if (config.externalImportAssertions != undefined) {
+        warnDeprecation(`The "output.externalImportAssertions" option is deprecated. Use the "output.externalImportAttributes" option instead.`, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, true, inputOptions);
+    }
+    return config.externalImportAttributes ?? config.externalImportAssertions ?? true;
+};
+const getGeneratedCode = (config) => {
+    const configWithPreset = getOptionWithPreset(config.generatedCode, generatedCodePresets, 'output.generatedCode', URL_OUTPUT_GENERATEDCODE, '');
+    return {
+        arrowFunctions: configWithPreset.arrowFunctions === true,
+        constBindings: configWithPreset.constBindings === true,
+        objectShorthand: configWithPreset.objectShorthand === true,
+        reservedNamesAsProps: configWithPreset.reservedNamesAsProps !== false,
+        symbols: configWithPreset.symbols === true
+    };
+};
+const getIndent = (config, compact) => {
+    if (compact) {
+        return '';
+    }
+    const configIndent = config.indent;
+    return configIndent === false ? '' : (configIndent ?? true);
+};
+const ALLOWED_INTEROP_TYPES = new Set([
+    'compat',
+    'auto',
+    'esModule',
+    'default',
+    'defaultOnly'
+]);
+const getInterop = (config) => {
+    const configInterop = config.interop;
+    if (typeof configInterop === 'function') {
+        const interopPerId = Object.create(null);
+        let defaultInterop = null;
+        return id => id === null
+            ? defaultInterop || validateInterop((defaultInterop = configInterop(id)))
+            : id in interopPerId
+                ? interopPerId[id]
+                : validateInterop((interopPerId[id] = configInterop(id)));
+    }
+    return configInterop === undefined ? () => 'default' : () => validateInterop(configInterop);
+};
+const validateInterop = (interop) => {
+    if (!ALLOWED_INTEROP_TYPES.has(interop)) {
+        return error(logInvalidOption('output.interop', URL_OUTPUT_INTEROP, `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
+    }
+    return interop;
+};
+const getManualChunks = (config, inlineDynamicImports, preserveModules) => {
+    const configManualChunks = config.manualChunks;
+    if (configManualChunks) {
+        if (inlineDynamicImports) {
+            return error(logInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.inlineDynamicImports"'));
+        }
+        if (preserveModules) {
+            return error(logInvalidOption('output.manualChunks', URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.preserveModules"'));
+        }
+    }
+    return configManualChunks || {};
+};
+const getMinifyInternalExports = (config, format, compact) => config.minifyInternalExports ?? (compact || format === 'es' || format === 'system');
+const getSourcemapFileNames = (config, unsetOptions) => {
+    const configSourcemapFileNames = config.sourcemapFileNames;
+    if (configSourcemapFileNames == null) {
+        unsetOptions.add('sourcemapFileNames');
+    }
+    return configSourcemapFileNames;
+};
+const getSourcemapBaseUrl = (config) => {
+    const { sourcemapBaseUrl } = config;
+    if (sourcemapBaseUrl) {
+        if (isValidUrl(sourcemapBaseUrl)) {
+            return addTrailingSlashIfMissed(sourcemapBaseUrl);
+        }
+        return error(logInvalidOption('output.sourcemapBaseUrl', URL_OUTPUT_SOURCEMAPBASEURL, `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
+    }
+};
+
+function rollup(rawInputOptions) {
+    return rollupInternal(rawInputOptions, null);
+}
+async function rollupInternal(rawInputOptions, watcher) {
+    const { options: inputOptions, unsetOptions: unsetInputOptions } = await getInputOptions(rawInputOptions, watcher !== null);
+    initialiseTimers(inputOptions);
+    await initWasm();
+    const graph = new Graph(inputOptions, watcher);
+    // remove the cache object from the memory after graph creation (cache is not used anymore)
+    const useCache = rawInputOptions.cache !== false;
+    if (rawInputOptions.cache) {
+        inputOptions.cache = undefined;
+        rawInputOptions.cache = undefined;
+    }
+    timeStart('BUILD', 1);
+    await catchUnfinishedHookActions(graph.pluginDriver, async () => {
+        try {
+            timeStart('initialize', 2);
+            await graph.pluginDriver.hookParallel('buildStart', [inputOptions]);
+            timeEnd('initialize', 2);
+            await graph.build();
+        }
+        catch (error_) {
+            const watchFiles = Object.keys(graph.watchFiles);
+            if (watchFiles.length > 0) {
+                error_.watchFiles = watchFiles;
+            }
+            await graph.pluginDriver.hookParallel('buildEnd', [error_]);
+            await graph.pluginDriver.hookParallel('closeBundle', []);
+            throw error_;
+        }
+        await graph.pluginDriver.hookParallel('buildEnd', []);
+    });
+    timeEnd('BUILD', 1);
+    const result = {
+        cache: useCache ? graph.getCache() : undefined,
+        async close() {
+            if (result.closed)
+                return;
+            result.closed = true;
+            await graph.pluginDriver.hookParallel('closeBundle', []);
+        },
+        closed: false,
+        async generate(rawOutputOptions) {
+            if (result.closed)
+                return error(logAlreadyClosed());
+            return handleGenerateWrite(false, inputOptions, unsetInputOptions, rawOutputOptions, graph);
+        },
+        get watchFiles() {
+            return Object.keys(graph.watchFiles);
+        },
+        async write(rawOutputOptions) {
+            if (result.closed)
+                return error(logAlreadyClosed());
+            return handleGenerateWrite(true, inputOptions, unsetInputOptions, rawOutputOptions, graph);
+        }
+    };
+    if (inputOptions.perf)
+        result.getTimings = getTimings;
+    return result;
+}
+async function getInputOptions(initialInputOptions, watchMode) {
+    if (!initialInputOptions) {
+        throw new Error('You must supply an options object to rollup');
+    }
+    const processedInputOptions = await getProcessedInputOptions(initialInputOptions, watchMode);
+    const { options, unsetOptions } = await normalizeInputOptions(processedInputOptions, watchMode);
+    normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
+    return { options, unsetOptions };
+}
+async function getProcessedInputOptions(inputOptions, watchMode) {
+    const plugins = getSortedValidatedPlugins('options', await normalizePluginOption(inputOptions.plugins));
+    const logLevel = inputOptions.logLevel || LOGLEVEL_INFO;
+    const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), watchMode, logLevel);
+    for (const plugin of plugins) {
+        const { name, options } = plugin;
+        const handler = 'handler' in options ? options.handler : options;
+        const processedOptions = await handler.call({
+            debug: getLogHandler(LOGLEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
+            error: (error_) => error(logPluginError(normalizeLog(error_), name, { hook: 'onLog' })),
+            info: getLogHandler(LOGLEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
+            meta: { rollupVersion: version, watchMode },
+            warn: getLogHandler(LOGLEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel)
+        }, inputOptions);
+        if (processedOptions) {
+            inputOptions = processedOptions;
+        }
+    }
+    return inputOptions;
+}
+function normalizePlugins(plugins, anonymousPrefix) {
+    for (const [index, plugin] of plugins.entries()) {
+        if (!plugin.name) {
+            plugin.name = `${anonymousPrefix}${index + 1}`;
+        }
+    }
+}
+async function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutputOptions, graph) {
+    const { options: outputOptions, outputPluginDriver, unsetOptions } = await getOutputOptionsAndPluginDriver(rawOutputOptions, graph.pluginDriver, inputOptions, unsetInputOptions);
+    return catchUnfinishedHookActions(outputPluginDriver, async () => {
+        const bundle = new Bundle(outputOptions, unsetOptions, inputOptions, outputPluginDriver, graph);
+        const generated = await bundle.generate(isWrite);
+        if (isWrite) {
+            timeStart('WRITE', 1);
+            if (!outputOptions.dir && !outputOptions.file) {
+                return error(logMissingFileOrDirOption());
+            }
+            await Promise.all(Object.values(generated).map(chunk => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
+            await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);
+            timeEnd('WRITE', 1);
+        }
+        return createOutput(generated);
+    });
+}
+async function getOutputOptionsAndPluginDriver(rawOutputOptions, inputPluginDriver, inputOptions, unsetInputOptions) {
+    if (!rawOutputOptions) {
+        throw new Error('You must supply an options object');
+    }
+    const rawPlugins = await normalizePluginOption(rawOutputOptions.plugins);
+    normalizePlugins(rawPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX);
+    const outputPluginDriver = inputPluginDriver.createOutputPluginDriver(rawPlugins);
+    return {
+        ...(await getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver)),
+        outputPluginDriver
+    };
+}
+function getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver) {
+    return normalizeOutputOptions(outputPluginDriver.hookReduceArg0Sync('outputOptions', [rawOutputOptions], (outputOptions, result) => result || outputOptions, pluginContext => {
+        const emitError = () => pluginContext.error(logCannotEmitFromOptionsHook());
+        return {
+            ...pluginContext,
+            emitFile: emitError,
+            setAssetSource: emitError
+        };
+    }), inputOptions, unsetInputOptions);
+}
+function createOutput(outputBundle) {
+    return {
+        output: Object.values(outputBundle).filter(outputFile => Object.keys(outputFile).length > 0).sort((outputFileA, outputFileB) => getSortingFileType(outputFileA) - getSortingFileType(outputFileB))
+    };
+}
+var SortingFileType;
+(function (SortingFileType) {
+    SortingFileType[SortingFileType["ENTRY_CHUNK"] = 0] = "ENTRY_CHUNK";
+    SortingFileType[SortingFileType["SECONDARY_CHUNK"] = 1] = "SECONDARY_CHUNK";
+    SortingFileType[SortingFileType["ASSET"] = 2] = "ASSET";
+})(SortingFileType || (SortingFileType = {}));
+function getSortingFileType(file) {
+    if (file.type === 'asset') {
+        return SortingFileType.ASSET;
+    }
+    if (file.isEntry) {
+        return SortingFileType.ENTRY_CHUNK;
+    }
+    return SortingFileType.SECONDARY_CHUNK;
+}
+async function writeOutputFile(outputFile, outputOptions) {
+    const fileName = resolve$1(outputOptions.dir || dirname(outputOptions.file), outputFile.fileName);
+    // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
+    await mkdir(dirname(fileName), { recursive: true });
+    return writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
+}
+/**
+ * Auxiliary function for defining rollup configuration
+ * Mainly to facilitate IDE code prompts, after all, export default does not
+ * prompt, even if you add @type annotations, it is not accurate
+ * @param options
+ */
+function defineConfig(options) {
+    return options;
+}
+
+const {
+  env = {},
+  argv = [],
+  platform = "",
+} = typeof process === "undefined" ? {} : process;
+
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+
+const isCompatibleTerminal =
+  tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled &&
+  (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: String }),
+        {}
+      );
+
+createColors();
+
+// @see https://no-color.org
+// @see https://www.npmjs.com/package/chalk
+const { bold, cyan, dim, gray, green, red, underline, yellow } = createColors({
+    useColor: env$1.FORCE_COLOR !== '0' && !env$1.NO_COLOR
+});
+
+// log to stderr to keep `rollup main.js > bundle.js` from breaking
+const stderr = (...parameters) => process$1.stderr.write(`${parameters.join('')}\n`);
+function handleError(error, recover = false) {
+    const name = error.name || error.cause?.name;
+    const nameSection = name ? `${name}: ` : '';
+    const pluginSection = error.plugin ? `(plugin ${error.plugin}) ` : '';
+    const message = `${pluginSection}${nameSection}${error.message}`;
+    const outputLines = [bold(red(`[!] ${bold(message.toString())}`))];
+    if (error.url) {
+        outputLines.push(cyan(error.url));
+    }
+    if (error.loc) {
+        outputLines.push(`${relativeId((error.loc.file || error.id))} (${error.loc.line}:${error.loc.column})`);
+    }
+    else if (error.id) {
+        outputLines.push(relativeId(error.id));
+    }
+    if (error.frame) {
+        outputLines.push(dim(error.frame));
+    }
+    if (error.stack) {
+        outputLines.push(dim(error.stack?.replace(`${nameSection}${error.message}\n`, '')));
+    }
+    // ES2022: Error.prototype.cause is optional
+    if (error.cause) {
+        let cause = error.cause;
+        const causeErrorLines = [];
+        let indent = '';
+        while (cause) {
+            indent += '  ';
+            const message = cause.stack || cause;
+            causeErrorLines.push(...`[cause] ${message}`.split('\n').map(line => indent + line));
+            cause = cause.cause;
+        }
+        outputLines.push(dim(causeErrorLines.join('\n')));
+    }
+    outputLines.push('', '');
+    stderr(outputLines.join('\n'));
+    if (!recover)
+        process$1.exit(1);
+}
+
+const commandAliases = {
+    c: 'config',
+    d: 'dir',
+    e: 'external',
+    f: 'format',
+    g: 'globals',
+    h: 'help',
+    i: 'input',
+    m: 'sourcemap',
+    n: 'name',
+    o: 'file',
+    p: 'plugin',
+    v: 'version',
+    w: 'watch'
+};
+const EMPTY_COMMAND_OPTIONS = { external: [], globals: undefined };
+async function mergeOptions(config, watchMode, rawCommandOptions = EMPTY_COMMAND_OPTIONS, printLog) {
+    const command = getCommandOptions(rawCommandOptions);
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || LOGLEVEL_INFO;
+    const onLog = getOnLog(config, logLevel, printLog);
+    const log = getLogger(plugins, onLog, watchMode, logLevel);
+    const inputOptions = mergeInputOptions(config, command, plugins, log, onLog);
+    if (command.output) {
+        Object.assign(command, command.output);
+    }
+    const outputOptionsArray = ensureArray(config.output);
+    if (outputOptionsArray.length === 0)
+        outputOptionsArray.push({});
+    const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, log)));
+    warnUnknownOptions(command, [
+        ...Object.keys(inputOptions),
+        ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapIgnoreList' && option !== 'sourcemapPathTransform'),
+        ...Object.keys(commandAliases),
+        'bundleConfigAsCjs',
+        'config',
+        'configPlugin',
+        'environment',
+        'failAfterWarnings',
+        'filterLogs',
+        'forceExit',
+        'plugin',
+        'silent',
+        'stdin',
+        'waitForBundleInput'
+    ], 'CLI flags', log, /^_$|output$|config/);
+    inputOptions.output = outputOptions;
+    return inputOptions;
+}
+function getCommandOptions(rawCommandOptions) {
+    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
+        ? rawCommandOptions.external.split(',')
+        : [];
+    return {
+        ...rawCommandOptions,
+        external,
+        globals: typeof rawCommandOptions.globals === 'string'
+            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
+                const [id, variableName] = globalDefinition.split(':');
+                globals[id] = variableName;
+                if (!external.includes(id)) {
+                    external.push(id);
+                }
+                return globals;
+            }, Object.create(null))
+            : undefined
+    };
+}
+function mergeInputOptions(config, overrides, plugins, log, onLog) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const inputOptions = {
+        cache: config.cache,
+        context: getOption('context'),
+        experimentalCacheExpiry: getOption('experimentalCacheExpiry'),
+        experimentalLogSideEffects: getOption('experimentalLogSideEffects'),
+        external: getExternal(config, overrides),
+        input: getOption('input') || [],
+        jsx: getObjectOption(config, overrides, 'jsx', objectifyOptionWithPresets(jsxPresets, 'jsx', URL_JSX, 'false, ')),
+        logLevel: getOption('logLevel'),
+        makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
+        maxParallelFileOps: getOption('maxParallelFileOps'),
+        moduleContext: getOption('moduleContext'),
+        onLog,
+        onwarn: undefined,
+        perf: getOption('perf'),
+        plugins,
+        preserveEntrySignatures: getOption('preserveEntrySignatures'),
+        preserveSymlinks: getOption('preserveSymlinks'),
+        shimMissingExports: getOption('shimMissingExports'),
+        strictDeprecations: getOption('strictDeprecations'),
+        treeshake: getObjectOption(config, overrides, 'treeshake', objectifyOptionWithPresets(treeshakePresets, 'treeshake', URL_TREESHAKE, 'false, true, ')),
+        watch: getWatch(config, overrides)
+    };
+    warnUnknownOptions(config, Object.keys(inputOptions), 'input options', log, /^output$/);
+    return inputOptions;
+}
+const getExternal = (config, overrides) => {
+    const configExternal = config.external;
+    return typeof configExternal === 'function'
+        ? (source, importer, isResolved) => configExternal(source, importer, isResolved) || overrides.external.includes(source)
+        : [...ensureArray(configExternal), ...overrides.external];
+};
+const getObjectOption = (config, overrides, name, objectifyValue = objectifyOption) => {
+    const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
+    const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
+    if (commandOption !== undefined) {
+        return commandOption && { ...configOption, ...commandOption };
+    }
+    return configOption;
+};
+const getWatch = (config, overrides) => config.watch !== false && getObjectOption(config, overrides, 'watch');
+const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
+    if (!optionValue) {
+        return optionValue;
+    }
+    if (Array.isArray(optionValue)) {
+        return optionValue.reduce((result, value) => value && result && { ...result, ...objectifyValue(value) }, {});
+    }
+    return objectifyValue(optionValue);
+};
+async function mergeOutputOptions(config, overrides, log) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const outputOptions = {
+        amd: getObjectOption(config, overrides, 'amd'),
+        assetFileNames: getOption('assetFileNames'),
+        banner: getOption('banner'),
+        chunkFileNames: getOption('chunkFileNames'),
+        compact: getOption('compact'),
+        dir: getOption('dir'),
+        dynamicImportInCjs: getOption('dynamicImportInCjs'),
+        entryFileNames: getOption('entryFileNames'),
+        esModule: getOption('esModule'),
+        experimentalMinChunkSize: getOption('experimentalMinChunkSize'),
+        exports: getOption('exports'),
+        extend: getOption('extend'),
+        externalImportAssertions: getOption('externalImportAssertions'),
+        externalImportAttributes: getOption('externalImportAttributes'),
+        externalLiveBindings: getOption('externalLiveBindings'),
+        file: getOption('file'),
+        footer: getOption('footer'),
+        format: getOption('format'),
+        freeze: getOption('freeze'),
+        generatedCode: getObjectOption(config, overrides, 'generatedCode', objectifyOptionWithPresets(generatedCodePresets, 'output.generatedCode', URL_OUTPUT_GENERATEDCODE, '')),
+        globals: getOption('globals'),
+        hashCharacters: getOption('hashCharacters'),
+        hoistTransitiveImports: getOption('hoistTransitiveImports'),
+        importAttributesKey: getOption('importAttributesKey'),
+        indent: getOption('indent'),
+        inlineDynamicImports: getOption('inlineDynamicImports'),
+        interop: getOption('interop'),
+        intro: getOption('intro'),
+        manualChunks: getOption('manualChunks'),
+        minifyInternalExports: getOption('minifyInternalExports'),
+        name: getOption('name'),
+        noConflict: getOption('noConflict'),
+        outro: getOption('outro'),
+        paths: getOption('paths'),
+        plugins: await normalizePluginOption(config.plugins),
+        preserveModules: getOption('preserveModules'),
+        preserveModulesRoot: getOption('preserveModulesRoot'),
+        reexportProtoFromExternal: getOption('reexportProtoFromExternal'),
+        sanitizeFileName: getOption('sanitizeFileName'),
+        sourcemap: getOption('sourcemap'),
+        sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
+        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
+        sourcemapFile: getOption('sourcemapFile'),
+        sourcemapFileNames: getOption('sourcemapFileNames'),
+        sourcemapIgnoreList: getOption('sourcemapIgnoreList'),
+        sourcemapPathTransform: getOption('sourcemapPathTransform'),
+        strict: getOption('strict'),
+        systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate'),
+        virtualDirname: getOption('virtualDirname')
+    };
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', log);
+    return outputOptions;
+}
+
+class WatchEmitter {
+    constructor() {
+        this.currentHandlers = Object.create(null);
+        this.persistentHandlers = Object.create(null);
+    }
+    // Will be overwritten by Rollup
+    async close() { }
+    emit(event, ...parameters) {
+        return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
+    }
+    off(event, listener) {
+        const listeners = this.persistentHandlers[event];
+        if (listeners) {
+            // A hack stolen from "mitt": ">>> 0" does not change numbers >= 0, but -1
+            // (which would remove the last array element if used unchanged) is turned
+            // into max_int, which is outside the array and does not change anything.
+            listeners.splice(listeners.indexOf(listener) >>> 0, 1);
+        }
+        return this;
+    }
+    on(event, listener) {
+        this.getPersistentHandlers(event).push(listener);
+        return this;
+    }
+    onCurrentRun(event, listener) {
+        this.getCurrentHandlers(event).push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const selfRemovingListener = (...parameters) => {
+            this.off(event, selfRemovingListener);
+            return listener(...parameters);
+        };
+        this.on(event, selfRemovingListener);
+        return this;
+    }
+    removeAllListeners() {
+        this.removeListenersForCurrentRun();
+        this.persistentHandlers = Object.create(null);
+        return this;
+    }
+    removeListenersForCurrentRun() {
+        this.currentHandlers = Object.create(null);
+        return this;
+    }
+    getCurrentHandlers(event) {
+        return this.currentHandlers[event] || (this.currentHandlers[event] = []);
+    }
+    getPersistentHandlers(event) {
+        return this.persistentHandlers[event] || (this.persistentHandlers[event] = []);
+    }
+}
+
+let fsEvents;
+let fsEventsImportError;
+async function loadFsEvents() {
+    try {
+        ({ default: fsEvents } = await import('fsevents'));
+    }
+    catch (error) {
+        fsEventsImportError = error;
+    }
+}
+// A call to this function will be injected into the chokidar code
+function getFsEvents() {
+    if (fsEventsImportError)
+        throw fsEventsImportError;
+    return fsEvents;
+}
+
+const fseventsImporter = /*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  getFsEvents,
+  loadFsEvents
+}, Symbol.toStringTag, { value: 'Module' });
+
+function watch(configs) {
+    const emitter = new WatchEmitter();
+    watchInternal(configs, emitter).catch(error => {
+        handleError(error);
+    });
+    return emitter;
+}
+async function watchInternal(configs, emitter) {
+    const optionsList = await Promise.all(ensureArray(configs).map(config => mergeOptions(config, true)));
+    const watchOptionsList = optionsList.filter(config => config.watch !== false);
+    if (watchOptionsList.length === 0) {
+        return error(logInvalidOption('watch', URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
+    }
+    await loadFsEvents();
+    const { Watcher } = await import('./watch.js');
+    new Watcher(watchOptionsList, emitter);
+}
+
+export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, getDefaultExportFromCjs, rollup, rollupInternal, version, watch };
diff --git a/node_modules/rollup/dist/es/shared/parseAst.js b/node_modules/rollup/dist/es/shared/parseAst.js
new file mode 100644
index 0000000..cfd4bff
--- /dev/null
+++ b/node_modules/rollup/dist/es/shared/parseAst.js
@@ -0,0 +1,2071 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+import { parse, parseAsync } from '../../native.js';
+import { resolve, basename, extname, dirname } from 'node:path';
+
+// This file is generated by scripts/generate-node-types.js.
+// Do not edit this file directly.
+const ArrowFunctionExpression = 'ArrowFunctionExpression';
+const BlockStatement = 'BlockStatement';
+const CallExpression = 'CallExpression';
+const CatchClause = 'CatchClause';
+const ExportDefaultDeclaration = 'ExportDefaultDeclaration';
+const ExpressionStatement = 'ExpressionStatement';
+const Identifier = 'Identifier';
+const Literal = 'Literal';
+const PanicError = 'PanicError';
+const ParseError = 'ParseError';
+const Program = 'Program';
+const Property = 'Property';
+const ReturnStatement = 'ReturnStatement';
+const StaticBlock = 'StaticBlock';
+const TemplateLiteral = 'TemplateLiteral';
+const VariableDeclarator = 'VariableDeclarator';
+
+const BLANK = Object.freeze(Object.create(null));
+const EMPTY_OBJECT = Object.freeze({});
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_SET = Object.freeze(new (class extends Set {
+    add() {
+        throw new Error('Cannot add to empty set');
+    }
+})());
+
+// This file is generated by scripts/generate-string-constants.js.
+// Do not edit this file directly.
+const FIXED_STRINGS = [
+    'var',
+    'let',
+    'const',
+    'init',
+    'get',
+    'set',
+    'constructor',
+    'method',
+    '-',
+    '+',
+    '!',
+    '~',
+    'typeof',
+    'void',
+    'delete',
+    '++',
+    '--',
+    '==',
+    '!=',
+    '===',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '<<',
+    '>>',
+    '>>>',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '|',
+    '^',
+    '&',
+    '||',
+    '&&',
+    'in',
+    'instanceof',
+    '**',
+    '??',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '|=',
+    '^=',
+    '&=',
+    '**=',
+    '&&=',
+    '||=',
+    '??=',
+    'pure',
+    'noSideEffects',
+    'sourcemap',
+    'using',
+    'await using'
+];
+
+const ANNOTATION_KEY = '_rollupAnnotations';
+const INVALID_ANNOTATION_KEY = '_rollupRemoved';
+const convertAnnotations = (position, buffer) => {
+    if (position === 0)
+        return EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        list.push(convertAnnotation(buffer[position++], buffer));
+    }
+    return list;
+};
+const convertAnnotation = (position, buffer) => {
+    const start = buffer[position++];
+    const end = buffer[position++];
+    const type = FIXED_STRINGS[buffer[position]];
+    return { end, start, type };
+};
+
+/** @typedef {import('./types').Location} Location */
+
+/**
+ * @param {import('./types').Range} range
+ * @param {number} index
+ */
+function rangeContains(range, index) {
+	return range.start <= index && index < range.end;
+}
+
+/**
+ * @param {string} source
+ * @param {import('./types').Options} [options]
+ */
+function getLocator(source, options = {}) {
+	const { offsetLine = 0, offsetColumn = 0 } = options;
+
+	let start = 0;
+	const ranges = source.split('\n').map((line, i) => {
+		const end = start + line.length + 1;
+
+		/** @type {import('./types').Range} */
+		const range = { start, end, line: i };
+
+		start = end;
+		return range;
+	});
+
+	let i = 0;
+
+	/**
+	 * @param {string | number} search
+	 * @param {number} [index]
+	 * @returns {Location | undefined}
+	 */
+	function locator(search, index) {
+		if (typeof search === 'string') {
+			search = source.indexOf(search, index ?? 0);
+		}
+
+		if (search === -1) return undefined;
+
+		let range = ranges[i];
+
+		const d = search >= range.end ? 1 : -1;
+
+		while (range) {
+			if (rangeContains(range, search)) {
+				return {
+					line: offsetLine + range.line,
+					column: offsetColumn + search - range.start,
+					character: search
+				};
+			}
+
+			i += d;
+			range = ranges[i];
+		}
+	}
+
+	return locator;
+}
+
+/**
+ * @param {string} source
+ * @param {string | number} search
+ * @param {import('./types').Options} [options]
+ * @returns {Location | undefined}
+ */
+function locate(source, search, options) {
+	return getLocator(source, options)(search, options && options.startIndex);
+}
+
+function spaces(index) {
+    let result = '';
+    while (index--)
+        result += ' ';
+    return result;
+}
+function tabsToSpaces(value) {
+    return value.replace(/^\t+/, match => match.split('\t').join('  '));
+}
+const LINE_TRUNCATE_LENGTH = 120;
+const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
+const ELLIPSIS = '...';
+function getCodeFrame(source, line, column) {
+    let lines = source.split('\n');
+    // Needed if a plugin did not generate correct sourcemaps
+    if (line > lines.length)
+        return '';
+    const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length +
+        MIN_CHARACTERS_SHOWN_AFTER_LOCATION +
+        ELLIPSIS.length, LINE_TRUNCATE_LENGTH);
+    const frameStart = Math.max(0, line - 3);
+    let frameEnd = Math.min(line + 2, lines.length);
+    lines = lines.slice(frameStart, frameEnd);
+    while (!/\S/.test(lines[lines.length - 1])) {
+        lines.pop();
+        frameEnd -= 1;
+    }
+    const digits = String(frameEnd).length;
+    return lines
+        .map((sourceLine, index) => {
+        const isErrorLine = frameStart + index + 1 === line;
+        let lineNumber = String(index + frameStart + 1);
+        while (lineNumber.length < digits)
+            lineNumber = ` ${lineNumber}`;
+        let displayedLine = tabsToSpaces(sourceLine);
+        if (displayedLine.length > maxLineLength) {
+            displayedLine = `${displayedLine.slice(0, maxLineLength - ELLIPSIS.length)}${ELLIPSIS}`;
+        }
+        if (isErrorLine) {
+            const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + '^';
+            return `${lineNumber}: ${displayedLine}\n${indicator}`;
+        }
+        return `${lineNumber}: ${displayedLine}`;
+    })
+        .join('\n');
+}
+
+const LOGLEVEL_SILENT = 'silent';
+const LOGLEVEL_ERROR = 'error';
+const LOGLEVEL_WARN = 'warn';
+const LOGLEVEL_INFO = 'info';
+const LOGLEVEL_DEBUG = 'debug';
+const logLevelPriority = {
+    [LOGLEVEL_DEBUG]: 0,
+    [LOGLEVEL_INFO]: 1,
+    [LOGLEVEL_SILENT]: 3,
+    [LOGLEVEL_WARN]: 2
+};
+
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[/\\|])/;
+const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
+function isAbsolute(path) {
+    return ABSOLUTE_PATH_REGEX.test(path);
+}
+function isRelative(path) {
+    return RELATIVE_PATH_REGEX.test(path);
+}
+const BACKSLASH_REGEX = /\\/g;
+function normalize(path) {
+    return path.replace(BACKSLASH_REGEX, '/');
+}
+
+function printQuotedStringList(list, verbs) {
+    const isSingleItem = list.length <= 1;
+    const quotedList = list.map(item => `"${item}"`);
+    let output = isSingleItem
+        ? quotedList[0]
+        : `${quotedList.slice(0, -1).join(', ')} and ${quotedList.slice(-1)[0]}`;
+    if (verbs) {
+        output += ` ${isSingleItem ? verbs[0] : verbs[1]}`;
+    }
+    return output;
+}
+
+const ANY_SLASH_REGEX = /[/\\]/;
+function relative(from, to) {
+    const fromParts = from.split(ANY_SLASH_REGEX).filter(Boolean);
+    const toParts = to.split(ANY_SLASH_REGEX).filter(Boolean);
+    if (fromParts[0] === '.')
+        fromParts.shift();
+    if (toParts[0] === '.')
+        toParts.shift();
+    while (fromParts[0] && toParts[0] && fromParts[0] === toParts[0]) {
+        fromParts.shift();
+        toParts.shift();
+    }
+    while (toParts[0] === '..' && fromParts.length > 0) {
+        toParts.shift();
+        fromParts.pop();
+    }
+    while (fromParts.pop()) {
+        toParts.unshift('..');
+    }
+    return toParts.join('/');
+}
+
+function getAliasName(id) {
+    const base = basename(id);
+    return base.slice(0, Math.max(0, base.length - extname(id).length));
+}
+function relativeId(id) {
+    if (!isAbsolute(id))
+        return id;
+    return relative(resolve(), id);
+}
+function isPathFragment(name) {
+    // starting with "/", "./", "../", "C:/"
+    return (name[0] === '/' || (name[0] === '.' && (name[1] === '/' || name[1] === '.')) || isAbsolute(name));
+}
+const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
+function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
+    while (targetPath.startsWith('../')) {
+        targetPath = targetPath.slice(3);
+        importerId = '_/' + importerId;
+    }
+    let relativePath = normalize(relative(dirname(importerId), targetPath));
+    if (stripJsExtension && relativePath.endsWith('.js')) {
+        relativePath = relativePath.slice(0, -3);
+    }
+    if (ensureFileName) {
+        if (relativePath === '')
+            return '../' + basename(targetPath);
+        if (UPPER_DIR_REGEX.test(relativePath)) {
+            return [...relativePath.split('/'), '..', basename(targetPath)].join('/');
+        }
+    }
+    return relativePath ? (relativePath.startsWith('..') ? relativePath : './' + relativePath) : '.';
+}
+
+function isValidUrl(url) {
+    try {
+        new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function getRollupUrl(snippet) {
+    return `https://rollupjs.org/${snippet}`;
+}
+function addTrailingSlashIfMissed(url) {
+    if (!url.endsWith('/')) {
+        return url + '/';
+    }
+    return url;
+}
+
+// troubleshooting
+const URL_AVOIDING_EVAL = 'troubleshooting/#avoiding-eval';
+const URL_NAME_IS_NOT_EXPORTED = 'troubleshooting/#error-name-is-not-exported-by-module';
+const URL_THIS_IS_UNDEFINED = 'troubleshooting/#error-this-is-undefined';
+const URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY = 'troubleshooting/#warning-treating-module-as-external-dependency';
+const URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT = 'troubleshooting/#warning-sourcemap-is-likely-to-be-incorrect';
+// configuration-options
+const URL_JSX = 'configuration-options/#jsx';
+const URL_OUTPUT_AMD_ID = 'configuration-options/#output-amd-id';
+const URL_OUTPUT_AMD_BASEPATH = 'configuration-options/#output-amd-basepath';
+const URL_OUTPUT_DIR = 'configuration-options/#output-dir';
+const URL_OUTPUT_EXPORTS = 'configuration-options/#output-exports';
+const URL_OUTPUT_EXTEND = 'configuration-options/#output-extend';
+const URL_OUTPUT_EXTERNALIMPORTATTRIBUTES = 'configuration-options/#output-externalimportattributes';
+const URL_OUTPUT_FORMAT = 'configuration-options/#output-format';
+const URL_OUTPUT_GENERATEDCODE = 'configuration-options/#output-generatedcode';
+const URL_OUTPUT_GLOBALS = 'configuration-options/#output-globals';
+const URL_OUTPUT_INLINEDYNAMICIMPORTS = 'configuration-options/#output-inlinedynamicimports';
+const URL_OUTPUT_INTEROP = 'configuration-options/#output-interop';
+const URL_OUTPUT_MANUALCHUNKS = 'configuration-options/#output-manualchunks';
+const URL_OUTPUT_NAME = 'configuration-options/#output-name';
+const URL_OUTPUT_SOURCEMAPBASEURL = 'configuration-options/#output-sourcemapbaseurl';
+const URL_OUTPUT_SOURCEMAPFILE = 'configuration-options/#output-sourcemapfile';
+const URL_PRESERVEENTRYSIGNATURES = 'configuration-options/#preserveentrysignatures';
+const URL_TREESHAKE = 'configuration-options/#treeshake';
+const URL_TREESHAKE_PURE = 'configuration-options/#pure';
+const URL_TREESHAKE_NOSIDEEFFECTS = 'configuration-options/#no-side-effects';
+const URL_TREESHAKE_MODULESIDEEFFECTS = 'configuration-options/#treeshake-modulesideeffects';
+const URL_WATCH = 'configuration-options/#watch';
+const URL_GENERATEBUNDLE = 'plugin-development/#generatebundle';
+
+function error(base) {
+    throw base instanceof Error ? base : getRollupError(base);
+}
+function getRollupError(base) {
+    augmentLogMessage(base);
+    const errorInstance = Object.assign(new Error(base.message), base);
+    Object.defineProperty(errorInstance, 'name', {
+        value: 'RollupError',
+        writable: true
+    });
+    return errorInstance;
+}
+function augmentCodeLocation(properties, pos, source, id) {
+    if (typeof pos === 'object') {
+        const { line, column } = pos;
+        properties.loc = { column, file: id, line };
+    }
+    else {
+        properties.pos = pos;
+        const location = locate(source, pos, { offsetLine: 1 });
+        if (!location) {
+            return;
+        }
+        const { line, column } = location;
+        properties.loc = { column, file: id, line };
+    }
+    if (properties.frame === undefined) {
+        const { line, column } = properties.loc;
+        properties.frame = getCodeFrame(source, line, column);
+    }
+}
+const symbolAugmented = Symbol('augmented');
+function augmentLogMessage(log) {
+    // Make sure to only augment the log message once
+    if (!(log.plugin || log.loc) || log[symbolAugmented]) {
+        return;
+    }
+    log[symbolAugmented] = true;
+    let prefix = '';
+    if (log.plugin) {
+        prefix += `[plugin ${log.plugin}] `;
+    }
+    const id = log.id || log.loc?.file;
+    if (id) {
+        const position = log.loc ? ` (${log.loc.line}:${log.loc.column})` : '';
+        prefix += `${relativeId(id)}${position}: `;
+    }
+    const oldMessage = log.message;
+    log.message = prefix + log.message;
+    tweakStackMessage(log, oldMessage);
+}
+// Error codes should be sorted alphabetically while errors should be sorted by
+// error code below
+const ADDON_ERROR = 'ADDON_ERROR', ALREADY_CLOSED = 'ALREADY_CLOSED', AMBIGUOUS_EXTERNAL_NAMESPACES = 'AMBIGUOUS_EXTERNAL_NAMESPACES', ANONYMOUS_PLUGIN_CACHE = 'ANONYMOUS_PLUGIN_CACHE', ASSET_NOT_FINALISED = 'ASSET_NOT_FINALISED', ASSET_NOT_FOUND = 'ASSET_NOT_FOUND', ASSET_SOURCE_ALREADY_SET = 'ASSET_SOURCE_ALREADY_SET', ASSET_SOURCE_MISSING = 'ASSET_SOURCE_MISSING', BAD_LOADER = 'BAD_LOADER', CANNOT_CALL_NAMESPACE = 'CANNOT_CALL_NAMESPACE', CANNOT_EMIT_FROM_OPTIONS_HOOK = 'CANNOT_EMIT_FROM_OPTIONS_HOOK', CHUNK_NOT_GENERATED = 'CHUNK_NOT_GENERATED', CHUNK_INVALID = 'CHUNK_INVALID', CIRCULAR_DEPENDENCY = 'CIRCULAR_DEPENDENCY', CIRCULAR_REEXPORT = 'CIRCULAR_REEXPORT', CONST_REASSIGN = 'CONST_REASSIGN', CYCLIC_CROSS_CHUNK_REEXPORT = 'CYCLIC_CROSS_CHUNK_REEXPORT', DEPRECATED_FEATURE = 'DEPRECATED_FEATURE', DUPLICATE_ARGUMENT_NAME = 'DUPLICATE_ARGUMENT_NAME', DUPLICATE_EXPORT = 'DUPLICATE_EXPORT', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS = 'EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS', EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES = 'EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', FIRST_SIDE_EFFECT = 'FIRST_SIDE_EFFECT', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INCONSISTENT_IMPORT_ATTRIBUTES = 'INCONSISTENT_IMPORT_ATTRIBUTES', INVALID_ANNOTATION = 'INVALID_ANNOTATION', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_IMPORT_ATTRIBUTE = 'INVALID_IMPORT_ATTRIBUTE', INVALID_LOG_POSITION = 'INVALID_LOG_POSITION', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_JSX_EXPORT = 'MISSING_JSX_EXPORT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', OPTIMIZE_CHUNK_STATUS = 'OPTIMIZE_CHUNK_STATUS', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', REDECLARATION_ERROR = 'REDECLARATION_ERROR', RESERVED_NAMESPACE = 'RESERVED_NAMESPACE', SHIMMED_EXPORT = 'SHIMMED_EXPORT', SOURCEMAP_BROKEN = 'SOURCEMAP_BROKEN', SOURCEMAP_ERROR = 'SOURCEMAP_ERROR', SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT = 'SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT', THIS_IS_UNDEFINED = 'THIS_IS_UNDEFINED', UNEXPECTED_NAMED_IMPORT = 'UNEXPECTED_NAMED_IMPORT', UNKNOWN_OPTION = 'UNKNOWN_OPTION', UNRESOLVED_ENTRY = 'UNRESOLVED_ENTRY', UNRESOLVED_IMPORT = 'UNRESOLVED_IMPORT', UNUSED_EXTERNAL_IMPORT = 'UNUSED_EXTERNAL_IMPORT', VALIDATION_ERROR = 'VALIDATION_ERROR';
+function logAddonNotGenerated(message, hook, plugin) {
+    return {
+        code: ADDON_ERROR,
+        message: `Could not retrieve "${hook}". Check configuration of plugin "${plugin}".
+\tError Message: ${message}`
+    };
+}
+function logAlreadyClosed() {
+    return {
+        code: ALREADY_CLOSED,
+        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
+    };
+}
+function logAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
+    return {
+        binding,
+        code: AMBIGUOUS_EXTERNAL_NAMESPACES,
+        ids: sources,
+        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${binding}" from one of the external modules ${printQuotedStringList(sources.map(module => relativeId(module)))}, guessing "${relativeId(usedModule)}".`,
+        reexporter: reexportingModule
+    };
+}
+function logAnonymousPluginCache() {
+    return {
+        code: ANONYMOUS_PLUGIN_CACHE,
+        message: 'A plugin is trying to use the Rollup cache but is not declaring a plugin name or cacheKey.'
+    };
+}
+function logAssetNotFinalisedForFileName(name) {
+    return {
+        code: ASSET_NOT_FINALISED,
+        message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first. If you reference assets via import.meta.ROLLUP_FILE_URL_<referenceId>, you need to either have set their source after "renderStart" or need to provide an explicit "fileName" when emitting them.`
+    };
+}
+function logAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+    return {
+        code: ASSET_NOT_FOUND,
+        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
+    };
+}
+function logAssetSourceAlreadySet(name) {
+    return {
+        code: ASSET_SOURCE_ALREADY_SET,
+        message: `Unable to set the source for asset "${name}", source already set.`
+    };
+}
+function logNoAssetSourceSet(assetName) {
+    return {
+        code: ASSET_SOURCE_MISSING,
+        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+    };
+}
+function logBadLoader(id) {
+    return {
+        code: BAD_LOADER,
+        message: `Error loading "${relativeId(id)}": plugin load hook should return a string, a { code, map } object, or nothing/null.`
+    };
+}
+function logCannotCallNamespace(name) {
+    return {
+        code: CANNOT_CALL_NAMESPACE,
+        message: `Cannot call a namespace ("${name}").`
+    };
+}
+function logCannotEmitFromOptionsHook() {
+    return {
+        code: CANNOT_EMIT_FROM_OPTIONS_HOOK,
+        message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
+    };
+}
+function logChunkNotGeneratedForFileName(name) {
+    return {
+        code: CHUNK_NOT_GENERATED,
+        message: `Plugin error - Unable to get file name for emitted chunk "${name}". You can only get file names once chunks have been generated after the "renderStart" hook.`
+    };
+}
+function logChunkInvalid({ fileName, code }, { pos, message }) {
+    const errorProperties = {
+        code: CHUNK_INVALID,
+        message: `Chunk "${fileName}" is not valid JavaScript: ${message}.`
+    };
+    augmentCodeLocation(errorProperties, pos, code, fileName);
+    return errorProperties;
+}
+function logCircularDependency(cyclePath) {
+    return {
+        code: CIRCULAR_DEPENDENCY,
+        ids: cyclePath,
+        message: `Circular dependency: ${cyclePath.map(relativeId).join(' -> ')}`
+    };
+}
+function logCircularReexport(exportName, exporter) {
+    return {
+        code: CIRCULAR_REEXPORT,
+        exporter,
+        message: `"${exportName}" cannot be exported from "${relativeId(exporter)}" as it is a reexport that references itself.`
+    };
+}
+function logCyclicCrossChunkReexport(exportName, exporter, reexporter, importer, preserveModules) {
+    return {
+        code: CYCLIC_CROSS_CHUNK_REEXPORT,
+        exporter,
+        id: importer,
+        message: `Export "${exportName}" of module "${relativeId(exporter)}" was reexported through module "${relativeId(reexporter)}" while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in "${relativeId(importer)}" to point directly to the exporting module or ${preserveModules ? 'do not use "output.preserveModules"' : 'reconfigure "output.manualChunks"'} to ensure these modules end up in the same chunk.`,
+        reexporter
+    };
+}
+function logDeprecation(deprecation, urlSnippet, plugin) {
+    return {
+        code: DEPRECATED_FEATURE,
+        message: deprecation,
+        url: getRollupUrl(urlSnippet),
+        ...({})
+    };
+}
+function logConstVariableReassignError() {
+    return {
+        code: CONST_REASSIGN,
+        message: 'Cannot reassign a variable declared with `const`'
+    };
+}
+function logDuplicateArgumentNameError(name) {
+    return {
+        code: DUPLICATE_ARGUMENT_NAME,
+        message: `Duplicate argument name "${name}"`
+    };
+}
+function logDuplicateExportError(name) {
+    return { code: DUPLICATE_EXPORT, message: `Duplicate export "${name}"` };
+}
+function logDuplicatePluginName(plugin) {
+    return {
+        code: DUPLICATE_PLUGIN_NAME,
+        message: `The plugin name ${plugin} is being used twice in the same build. Plugin names must be distinct or provide a cacheKey (please post an issue to the plugin if you are a plugin user).`
+    };
+}
+function logEmptyChunk(chunkName) {
+    return {
+        code: EMPTY_BUNDLE,
+        message: `Generated an empty chunk: "${chunkName}".`,
+        names: [chunkName]
+    };
+}
+function logEval(id) {
+    return {
+        code: EVAL,
+        id,
+        message: `Use of eval in "${relativeId(id)}" is strongly discouraged as it poses security risks and may cause issues with minification.`,
+        url: getRollupUrl(URL_AVOIDING_EVAL)
+    };
+}
+function logExternalSyntheticExports(id, importer) {
+    return {
+        code: EXTERNAL_SYNTHETIC_EXPORTS,
+        exporter: id,
+        message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
+    };
+}
+function logFileNameConflict(fileName) {
+    return {
+        code: FILE_NAME_CONFLICT,
+        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
+    };
+}
+function logFileReferenceIdNotFoundForFilename(assetReferenceId) {
+    return {
+        code: FILE_NOT_FOUND,
+        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+    };
+}
+function logFirstSideEffect(source, id, { line, column }) {
+    return {
+        code: FIRST_SIDE_EFFECT,
+        message: `First side effect in ${relativeId(id)} is at (${line}:${column})\n${getCodeFrame(source, line, column)}`
+    };
+}
+function logIllegalIdentifierAsName(name) {
+    return {
+        code: ILLEGAL_IDENTIFIER_AS_NAME,
+        message: `Given name "${name}" is not a legal JS identifier. If you need this, you can try "output.extend: true".`,
+        url: getRollupUrl(URL_OUTPUT_EXTEND)
+    };
+}
+function logIllegalImportReassignment(name, importingId) {
+    return {
+        code: ILLEGAL_REASSIGNMENT,
+        message: `Illegal reassignment of import "${name}" in "${relativeId(importingId)}".`
+    };
+}
+function logInconsistentImportAttributes(existingAttributes, newAttributes, source, importer) {
+    return {
+        code: INCONSISTENT_IMPORT_ATTRIBUTES,
+        message: `Module "${relativeId(importer)}" tried to import "${relativeId(source)}" with ${formatAttributes(newAttributes)} attributes, but it was already imported elsewhere with ${formatAttributes(existingAttributes)} attributes. Please ensure that import attributes for the same module are always consistent.`
+    };
+}
+const formatAttributes = (attributes) => {
+    const entries = Object.entries(attributes);
+    if (entries.length === 0)
+        return 'no';
+    return entries.map(([key, value]) => `"${key}": "${value}"`).join(', ');
+};
+function logInvalidAnnotation(comment, id, type) {
+    return {
+        code: INVALID_ANNOTATION,
+        id,
+        message: `A comment\n\n"${comment}"\n\nin "${relativeId(id)}" contains an annotation that Rollup cannot interpret due to the position of the comment. The comment will be removed to avoid issues.`,
+        url: getRollupUrl(type === 'noSideEffects' ? URL_TREESHAKE_NOSIDEEFFECTS : URL_TREESHAKE_PURE)
+    };
+}
+function logInputHookInOutputPlugin(pluginName, hookName) {
+    return {
+        code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
+        message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
+    };
+}
+function logCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
+    return {
+        code: INVALID_CHUNK,
+        message: `Cannot assign "${relativeId(moduleId)}" to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
+    };
+}
+function tweakStackMessage(error, oldMessage) {
+    if (!error.stack) {
+        return error;
+    }
+    error.stack = error.stack.replace(oldMessage, error.message);
+    return error;
+}
+function logInvalidExportOptionValue(optionValue) {
+    return {
+        code: INVALID_EXPORT_OPTION,
+        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}".`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logIncompatibleExportOptionValue(optionValue, keys, entryModule) {
+    return {
+        code: INVALID_EXPORT_OPTION,
+        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${printQuotedStringList(keys)}`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logInternalIdCannotBeExternal(source, importer) {
+    return {
+        code: INVALID_EXTERNAL_ID,
+        message: `"${source}" is imported as an external by "${relativeId(importer)}", but is already an existing non-external module id.`
+    };
+}
+function logImportOptionsAreInvalid(importer) {
+    return {
+        code: INVALID_IMPORT_ATTRIBUTE,
+        message: `Rollup could not statically analyze the options argument of a dynamic import in "${relativeId(importer)}". Dynamic import options need to be an object with a nested attributes object.`
+    };
+}
+function logImportAttributeIsInvalid(importer) {
+    return {
+        code: INVALID_IMPORT_ATTRIBUTE,
+        message: `Rollup could not statically analyze an import attribute of a dynamic import in "${relativeId(importer)}". Import attributes need to have string keys and values. The attribute will be removed.`
+    };
+}
+function logInvalidLogPosition(plugin) {
+    return {
+        code: INVALID_LOG_POSITION,
+        message: `Plugin "${plugin}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
+    };
+}
+function logInvalidOption(option, urlSnippet, explanation, value) {
+    return {
+        code: INVALID_OPTION,
+        message: `Invalid value ${value === undefined ? '' : `${JSON.stringify(value)} `}for option "${option}" - ${explanation}.`,
+        url: getRollupUrl(urlSnippet)
+    };
+}
+function logInvalidAddonPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a string, a function hook or an object with a "handler" string or function.`,
+        plugin
+    };
+}
+function logInvalidFunctionPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a function hook or an object with a "handler" function.`,
+        plugin
+    };
+}
+function logInvalidRollupPhaseForChunkEmission() {
+    return {
+        code: INVALID_ROLLUP_PHASE,
+        message: `Cannot emit chunks after module loading has finished.`
+    };
+}
+function logInvalidSetAssetSourceCall() {
+    return {
+        code: INVALID_SETASSETSOURCE,
+        message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
+    };
+}
+function logInvalidFormatForTopLevelAwait(id, format) {
+    return {
+        code: INVALID_TLA_FORMAT,
+        id,
+        message: `Module format "${format}" does not support top-level await. Use the "es" or "system" output formats rather.`
+    };
+}
+function logMissingEntryExport(binding, exporter) {
+    return {
+        binding,
+        code: MISSING_EXPORT,
+        exporter,
+        message: `Exported variable "${binding}" is not defined in "${relativeId(exporter)}".`,
+        url: getRollupUrl(URL_NAME_IS_NOT_EXPORTED)
+    };
+}
+function logMissingExport(binding, importingModule, exporter) {
+    const isJson = extname(exporter) === '.json';
+    return {
+        binding,
+        code: MISSING_EXPORT,
+        exporter,
+        id: importingModule,
+        message: `"${binding}" is not exported by "${relativeId(exporter)}", imported by "${relativeId(importingModule)}".${isJson ? ' (Note that you need @rollup/plugin-json to import JSON files)' : ''}`,
+        url: getRollupUrl(URL_NAME_IS_NOT_EXPORTED)
+    };
+}
+function logMissingGlobalName(externalId, guess) {
+    return {
+        code: MISSING_GLOBAL_NAME,
+        id: externalId,
+        message: `No name was provided for external module "${externalId}" in "output.globals" – guessing "${guess}".`,
+        names: [guess],
+        url: getRollupUrl(URL_OUTPUT_GLOBALS)
+    };
+}
+function logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
+    };
+}
+function logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
+    };
+}
+function logImplicitDependantIsNotIncluded(module) {
+    const implicitDependencies = [...module.implicitlyLoadedBefore]
+        .map(dependency => relativeId(dependency.id))
+        .sort();
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before ${printQuotedStringList(implicitDependencies)} is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
+    };
+}
+function logMissingJsxExport(name, exporter, importer) {
+    return {
+        code: MISSING_JSX_EXPORT,
+        exporter,
+        id: importer,
+        message: `Export "${name}" is not defined in module "${relativeId(exporter)}" even though it is needed in "${relativeId(importer)}" to provide JSX syntax. Please check your "jsx" option.`,
+        names: [name],
+        url: getRollupUrl(URL_JSX)
+    };
+}
+function logMissingNameOptionForIifeExport() {
+    return {
+        code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
+        message: `If you do not supply "output.name", you may not be able to access the exports of an IIFE bundle.`,
+        url: getRollupUrl(URL_OUTPUT_NAME)
+    };
+}
+function logMissingNameOptionForUmdExport() {
+    return {
+        code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
+        message: 'You must supply "output.name" for UMD bundles that have exports so that the exports are accessible in environments without a module loader.',
+        url: getRollupUrl(URL_OUTPUT_NAME)
+    };
+}
+function logMissingNodeBuiltins(externalBuiltins) {
+    return {
+        code: MISSING_NODE_BUILTINS,
+        ids: externalBuiltins,
+        message: `Creating a browser bundle that depends on Node.js built-in modules (${printQuotedStringList(externalBuiltins)}). You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`
+    };
+}
+function logMissingFileOrDirOption() {
+    return {
+        code: MISSING_OPTION,
+        message: 'You must specify "output.file" or "output.dir" for the build.',
+        url: getRollupUrl(URL_OUTPUT_DIR)
+    };
+}
+function logMixedExport(facadeModuleId, name) {
+    return {
+        code: MIXED_EXPORTS,
+        id: facadeModuleId,
+        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}.default\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning.`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logModuleLevelDirective(directive, id) {
+    return {
+        code: MODULE_LEVEL_DIRECTIVE,
+        id,
+        message: `Module level directives cause errors when bundled, "${directive}" in "${relativeId(id)}" was ignored.`
+    };
+}
+function logNamespaceConflict(binding, reexportingModuleId, sources) {
+    return {
+        binding,
+        code: NAMESPACE_CONFLICT,
+        ids: sources,
+        message: `Conflicting namespaces: "${relativeId(reexportingModuleId)}" re-exports "${binding}" from one of the modules ${printQuotedStringList(sources.map(moduleId => relativeId(moduleId)))} (will be ignored).`,
+        reexporter: reexportingModuleId
+    };
+}
+function logNoTransformMapOrAstWithoutCode(pluginName) {
+    return {
+        code: NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
+        message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
+            'a "code". This will be ignored.'
+    };
+}
+function logOptimizeChunkStatus(chunks, smallChunks, pointInTime) {
+    return {
+        code: OPTIMIZE_CHUNK_STATUS,
+        message: `${pointInTime}, there are\n` +
+            `${chunks} chunks, of which\n` +
+            `${smallChunks} are below minChunkSize.`
+    };
+}
+function logParseError(message, pos) {
+    return { code: PARSE_ERROR, message, pos };
+}
+function logRedeclarationError(name) {
+    return {
+        code: REDECLARATION_ERROR,
+        message: `Identifier "${name}" has already been declared`
+    };
+}
+function logReservedNamespace(namespace) {
+    return {
+        code: RESERVED_NAMESPACE,
+        message: `You have overided reserved namespace "${namespace}"`
+    };
+}
+function logModuleParseError(error, moduleId) {
+    let message = error.message.replace(/ \(\d+:\d+\)$/, '');
+    if (moduleId.endsWith('.json')) {
+        message += ' (Note that you need @rollup/plugin-json to import JSON files)';
+    }
+    else if (!moduleId.endsWith('.js')) {
+        message += ' (Note that you need plugins to import files that are not JavaScript)';
+    }
+    return tweakStackMessage({
+        cause: error,
+        code: PARSE_ERROR,
+        id: moduleId,
+        message,
+        stack: error.stack
+    }, error.message);
+}
+function logPluginError(error, plugin, { hook, id } = {}) {
+    const code = error.code;
+    if (!error.pluginCode &&
+        code != null &&
+        (typeof code !== 'string' || !code.startsWith('PLUGIN_'))) {
+        error.pluginCode = code;
+    }
+    error.code = PLUGIN_ERROR;
+    error.plugin = plugin;
+    if (hook) {
+        error.hook = hook;
+    }
+    if (id) {
+        error.id = id;
+    }
+    return error;
+}
+function logShimmedExport(id, binding) {
+    return {
+        binding,
+        code: SHIMMED_EXPORT,
+        exporter: id,
+        message: `Missing export "${binding}" has been shimmed in module "${relativeId(id)}".`
+    };
+}
+function logSourcemapBroken(plugin) {
+    return {
+        code: SOURCEMAP_BROKEN,
+        message: `Sourcemap is likely to be incorrect: a plugin (${plugin}) was used to transform files, but didn't generate a sourcemap for the transformation. Consult the plugin documentation for help`,
+        plugin,
+        url: getRollupUrl(URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT)
+    };
+}
+function logConflictingSourcemapSources(filename) {
+    return {
+        code: SOURCEMAP_BROKEN,
+        message: `Multiple conflicting contents for sourcemap source ${filename}`
+    };
+}
+function logInvalidSourcemapForError(error, id, column, line, pos) {
+    return {
+        cause: error,
+        code: SOURCEMAP_ERROR,
+        id,
+        loc: {
+            column,
+            file: id,
+            line
+        },
+        message: `Error when using sourcemap for reporting an error: ${error.message}`,
+        pos
+    };
+}
+function logSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+    return {
+        code: SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
+        exporter: id,
+        message: `Module "${relativeId(id)}" that is marked with \`syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}\` needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
+            ? `an explicit export named "${syntheticNamedExportsOption}"`
+            : 'a default export'} that does not reexport an unresolved named export of the same module.`
+    };
+}
+function logThisIsUndefined() {
+    return {
+        code: THIS_IS_UNDEFINED,
+        message: `The 'this' keyword is equivalent to 'undefined' at the top level of an ES module, and has been rewritten`,
+        url: getRollupUrl(URL_THIS_IS_UNDEFINED)
+    };
+}
+function logUnexpectedNamedImport(id, imported, isReexport) {
+    const importType = isReexport ? 'reexport' : 'import';
+    return {
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `The named export "${imported}" was ${importType}ed from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
+        url: getRollupUrl(URL_OUTPUT_INTEROP)
+    };
+}
+function logUnexpectedNamespaceReexport(id) {
+    return {
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `There was a namespace "*" reexport from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
+        url: getRollupUrl(URL_OUTPUT_INTEROP)
+    };
+}
+function logUnknownOption(optionType, unknownOptions, validOptions) {
+    return {
+        code: UNKNOWN_OPTION,
+        message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.join(', ')}`
+    };
+}
+function logEntryCannotBeExternal(unresolvedId) {
+    return {
+        code: UNRESOLVED_ENTRY,
+        message: `Entry module "${relativeId(unresolvedId)}" cannot be external.`
+    };
+}
+function logExternalModulesCannotBeIncludedInManualChunks(source) {
+    return {
+        code: EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS,
+        message: `"${source}" cannot be included in manualChunks because it is resolved as an external module by the "external" option or plugins.`
+    };
+}
+function logExternalModulesCannotBeTransformedToModules(source) {
+    return {
+        code: EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES,
+        message: `${source} is resolved as a module now, but it was an external module before. Please check whether there are conflicts in your Rollup options "external" and "manualChunks", manualChunks cannot include external modules.`
+    };
+}
+function logUnresolvedEntry(unresolvedId) {
+    return {
+        code: UNRESOLVED_ENTRY,
+        message: `Could not resolve entry module "${relativeId(unresolvedId)}".`
+    };
+}
+function logUnresolvedImport(source, importer) {
+    return {
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `Could not resolve "${source}" from "${relativeId(importer)}"`
+    };
+}
+function logUnresolvedImportTreatedAsExternal(source, importer) {
+    return {
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `"${source}" is imported by "${relativeId(importer)}", but could not be resolved – treating it as an external dependency.`,
+        url: getRollupUrl(URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY)
+    };
+}
+function logUnusedExternalImports(externalId, names, importers) {
+    return {
+        code: UNUSED_EXTERNAL_IMPORT,
+        exporter: externalId,
+        ids: importers,
+        message: `${printQuotedStringList(names, [
+            'is',
+            'are'
+        ])} imported from external module "${externalId}" but never used in ${printQuotedStringList(importers.map(importer => relativeId(importer)))}.`,
+        names
+    };
+}
+function logFailedValidation(message) {
+    return {
+        code: VALIDATION_ERROR,
+        message
+    };
+}
+function warnDeprecation(deprecation, urlSnippet, activeDeprecation, options, plugin) {
+    warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, options.onLog, options.strictDeprecations);
+}
+function warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, log, strictDeprecations, plugin) {
+    if (activeDeprecation || strictDeprecations) {
+        const warning = logDeprecation(deprecation, urlSnippet);
+        if (strictDeprecations) {
+            return error(warning);
+        }
+        log(LOGLEVEL_WARN, warning);
+    }
+}
+
+// This file is generated by scripts/generate-buffer-to-ast.js.
+// Do not edit this file directly.
+function convertProgram(buffer) {
+    const node = convertNode(0, buffer);
+    switch (node.type) {
+        case PanicError: {
+            return error(getRollupError(logParseError(node.message)));
+        }
+        case ParseError: {
+            return error(getRollupError(logParseError(node.message, node.start)));
+        }
+        default: {
+            return node;
+        }
+    }
+}
+/* eslint-disable sort-keys */
+const nodeConverters = [
+    function panicError(position, buffer) {
+        return {
+            type: 'PanicError',
+            start: buffer[position],
+            end: buffer[position + 1],
+            message: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function parseError(position, buffer) {
+        return {
+            type: 'ParseError',
+            start: buffer[position],
+            end: buffer[position + 1],
+            message: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function arrayExpression(position, buffer) {
+        return {
+            type: 'ArrayExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            elements: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function arrayPattern(position, buffer) {
+        return {
+            type: 'ArrayPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            elements: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function arrowFunctionExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'ArrowFunctionExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            expression: (flags & 2) === 2,
+            generator: (flags & 4) === 4,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            params: convertNodeList(buffer[position + 4], buffer),
+            body: convertNode(buffer[position + 5], buffer),
+            id: null
+        };
+    },
+    function assignmentExpression(position, buffer) {
+        return {
+            type: 'AssignmentExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function assignmentPattern(position, buffer) {
+        return {
+            type: 'AssignmentPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            left: convertNode(buffer[position + 2], buffer),
+            right: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function awaitExpression(position, buffer) {
+        return {
+            type: 'AwaitExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function binaryExpression(position, buffer) {
+        return {
+            type: 'BinaryExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function blockStatement(position, buffer) {
+        return {
+            type: 'BlockStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function breakStatement(position, buffer) {
+        const labelPosition = buffer[position + 2];
+        return {
+            type: 'BreakStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: labelPosition === 0 ? null : convertNode(labelPosition, buffer)
+        };
+    },
+    function callExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'CallExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            optional: (flags & 1) === 1,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            callee: convertNode(buffer[position + 4], buffer),
+            arguments: convertNodeList(buffer[position + 5], buffer)
+        };
+    },
+    function catchClause(position, buffer) {
+        const parameterPosition = buffer[position + 2];
+        return {
+            type: 'CatchClause',
+            start: buffer[position],
+            end: buffer[position + 1],
+            param: parameterPosition === 0 ? null : convertNode(parameterPosition, buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function chainExpression(position, buffer) {
+        return {
+            type: 'ChainExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function classBody(position, buffer) {
+        return {
+            type: 'ClassBody',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function classDeclaration(position, buffer) {
+        const idPosition = buffer[position + 3];
+        const superClassPosition = buffer[position + 4];
+        return {
+            type: 'ClassDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            decorators: convertNodeList(buffer[position + 2], buffer),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            superClass: superClassPosition === 0 ? null : convertNode(superClassPosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function classExpression(position, buffer) {
+        const idPosition = buffer[position + 3];
+        const superClassPosition = buffer[position + 4];
+        return {
+            type: 'ClassExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            decorators: convertNodeList(buffer[position + 2], buffer),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            superClass: superClassPosition === 0 ? null : convertNode(superClassPosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function conditionalExpression(position, buffer) {
+        return {
+            type: 'ConditionalExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            consequent: convertNode(buffer[position + 3], buffer),
+            alternate: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function continueStatement(position, buffer) {
+        const labelPosition = buffer[position + 2];
+        return {
+            type: 'ContinueStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: labelPosition === 0 ? null : convertNode(labelPosition, buffer)
+        };
+    },
+    function debuggerStatement(position, buffer) {
+        return {
+            type: 'DebuggerStatement',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function decorator(position, buffer) {
+        return {
+            type: 'Decorator',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function directive(position, buffer) {
+        return {
+            type: 'ExpressionStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            directive: buffer.convertString(buffer[position + 2]),
+            expression: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function doWhileStatement(position, buffer) {
+        return {
+            type: 'DoWhileStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNode(buffer[position + 2], buffer),
+            test: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function emptyStatement(position, buffer) {
+        return {
+            type: 'EmptyStatement',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function exportAllDeclaration(position, buffer) {
+        const exportedPosition = buffer[position + 2];
+        return {
+            type: 'ExportAllDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            exported: exportedPosition === 0 ? null : convertNode(exportedPosition, buffer),
+            source: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function exportDefaultDeclaration(position, buffer) {
+        return {
+            type: 'ExportDefaultDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            declaration: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function exportNamedDeclaration(position, buffer) {
+        const sourcePosition = buffer[position + 3];
+        const declarationPosition = buffer[position + 5];
+        return {
+            type: 'ExportNamedDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            specifiers: convertNodeList(buffer[position + 2], buffer),
+            source: sourcePosition === 0 ? null : convertNode(sourcePosition, buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer),
+            declaration: declarationPosition === 0 ? null : convertNode(declarationPosition, buffer)
+        };
+    },
+    function exportSpecifier(position, buffer) {
+        const local = convertNode(buffer[position + 2], buffer);
+        const exportedPosition = buffer[position + 3];
+        return {
+            type: 'ExportSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local,
+            exported: exportedPosition === 0 ? { ...local } : convertNode(exportedPosition, buffer)
+        };
+    },
+    function expressionStatement(position, buffer) {
+        return {
+            type: 'ExpressionStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function forInStatement(position, buffer) {
+        return {
+            type: 'ForInStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            left: convertNode(buffer[position + 2], buffer),
+            right: convertNode(buffer[position + 3], buffer),
+            body: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function forOfStatement(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'ForOfStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            await: (flags & 1) === 1,
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function forStatement(position, buffer) {
+        const initPosition = buffer[position + 2];
+        const testPosition = buffer[position + 3];
+        const updatePosition = buffer[position + 4];
+        return {
+            type: 'ForStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            init: initPosition === 0 ? null : convertNode(initPosition, buffer),
+            test: testPosition === 0 ? null : convertNode(testPosition, buffer),
+            update: updatePosition === 0 ? null : convertNode(updatePosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function functionDeclaration(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        const idPosition = buffer[position + 4];
+        return {
+            type: 'FunctionDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            generator: (flags & 2) === 2,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            params: convertNodeList(buffer[position + 5], buffer),
+            body: convertNode(buffer[position + 6], buffer),
+            expression: false
+        };
+    },
+    function functionExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        const idPosition = buffer[position + 4];
+        return {
+            type: 'FunctionExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            generator: (flags & 2) === 2,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            params: convertNodeList(buffer[position + 5], buffer),
+            body: convertNode(buffer[position + 6], buffer),
+            expression: false
+        };
+    },
+    function identifier(position, buffer) {
+        return {
+            type: 'Identifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function ifStatement(position, buffer) {
+        const alternatePosition = buffer[position + 4];
+        return {
+            type: 'IfStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            consequent: convertNode(buffer[position + 3], buffer),
+            alternate: alternatePosition === 0 ? null : convertNode(alternatePosition, buffer)
+        };
+    },
+    function importAttribute(position, buffer) {
+        return {
+            type: 'ImportAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            key: convertNode(buffer[position + 2], buffer),
+            value: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function importDeclaration(position, buffer) {
+        return {
+            type: 'ImportDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            specifiers: convertNodeList(buffer[position + 2], buffer),
+            source: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function importDefaultSpecifier(position, buffer) {
+        return {
+            type: 'ImportDefaultSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function importExpression(position, buffer) {
+        const optionsPosition = buffer[position + 3];
+        return {
+            type: 'ImportExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            source: convertNode(buffer[position + 2], buffer),
+            options: optionsPosition === 0 ? null : convertNode(optionsPosition, buffer)
+        };
+    },
+    function importNamespaceSpecifier(position, buffer) {
+        return {
+            type: 'ImportNamespaceSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function importSpecifier(position, buffer) {
+        const importedPosition = buffer[position + 2];
+        const local = convertNode(buffer[position + 3], buffer);
+        return {
+            type: 'ImportSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            imported: importedPosition === 0 ? { ...local } : convertNode(importedPosition, buffer),
+            local
+        };
+    },
+    function jsxAttribute(position, buffer) {
+        const valuePosition = buffer[position + 3];
+        return {
+            type: 'JSXAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: convertNode(buffer[position + 2], buffer),
+            value: valuePosition === 0 ? null : convertNode(valuePosition, buffer)
+        };
+    },
+    function jsxClosingElement(position, buffer) {
+        return {
+            type: 'JSXClosingElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxClosingFragment(position, buffer) {
+        return {
+            type: 'JSXClosingFragment',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function jsxElement(position, buffer) {
+        const closingElementPosition = buffer[position + 4];
+        return {
+            type: 'JSXElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            openingElement: convertNode(buffer[position + 2], buffer),
+            children: convertNodeList(buffer[position + 3], buffer),
+            closingElement: closingElementPosition === 0 ? null : convertNode(closingElementPosition, buffer)
+        };
+    },
+    function jsxEmptyExpression(position, buffer) {
+        return {
+            type: 'JSXEmptyExpression',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function jsxExpressionContainer(position, buffer) {
+        return {
+            type: 'JSXExpressionContainer',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxFragment(position, buffer) {
+        return {
+            type: 'JSXFragment',
+            start: buffer[position],
+            end: buffer[position + 1],
+            openingFragment: convertNode(buffer[position + 2], buffer),
+            children: convertNodeList(buffer[position + 3], buffer),
+            closingFragment: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function jsxIdentifier(position, buffer) {
+        return {
+            type: 'JSXIdentifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function jsxMemberExpression(position, buffer) {
+        return {
+            type: 'JSXMemberExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            object: convertNode(buffer[position + 2], buffer),
+            property: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function jsxNamespacedName(position, buffer) {
+        return {
+            type: 'JSXNamespacedName',
+            start: buffer[position],
+            end: buffer[position + 1],
+            namespace: convertNode(buffer[position + 2], buffer),
+            name: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function jsxOpeningElement(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'JSXOpeningElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            selfClosing: (flags & 1) === 1,
+            name: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function jsxOpeningFragment(position, buffer) {
+        return {
+            type: 'JSXOpeningFragment',
+            start: buffer[position],
+            end: buffer[position + 1],
+            attributes: [],
+            selfClosing: false
+        };
+    },
+    function jsxSpreadAttribute(position, buffer) {
+        return {
+            type: 'JSXSpreadAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxSpreadChild(position, buffer) {
+        return {
+            type: 'JSXSpreadChild',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxText(position, buffer) {
+        return {
+            type: 'JSXText',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value: buffer.convertString(buffer[position + 2]),
+            raw: buffer.convertString(buffer[position + 3])
+        };
+    },
+    function labeledStatement(position, buffer) {
+        return {
+            type: 'LabeledStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: convertNode(buffer[position + 2], buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function literalBigInt(position, buffer) {
+        const bigint = buffer.convertString(buffer[position + 2]);
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            bigint,
+            raw: buffer.convertString(buffer[position + 3]),
+            value: BigInt(bigint)
+        };
+    },
+    function literalBoolean(position, buffer) {
+        const flags = buffer[position + 2];
+        const value = (flags & 1) === 1;
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value,
+            raw: value ? 'true' : 'false'
+        };
+    },
+    function literalNull(position, buffer) {
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: 'null',
+            value: null
+        };
+    },
+    function literalNumber(position, buffer) {
+        const rawPosition = buffer[position + 2];
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: rawPosition === 0 ? undefined : buffer.convertString(rawPosition),
+            value: new DataView(buffer.buffer).getFloat64((position + 3) << 2, true)
+        };
+    },
+    function literalRegExp(position, buffer) {
+        const flags = buffer.convertString(buffer[position + 2]);
+        const pattern = buffer.convertString(buffer[position + 3]);
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: `/${pattern}/${flags}`,
+            regex: { flags, pattern },
+            value: new RegExp(pattern, flags)
+        };
+    },
+    function literalString(position, buffer) {
+        const rawPosition = buffer[position + 3];
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value: buffer.convertString(buffer[position + 2]),
+            raw: rawPosition === 0 ? undefined : buffer.convertString(rawPosition)
+        };
+    },
+    function logicalExpression(position, buffer) {
+        return {
+            type: 'LogicalExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function memberExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'MemberExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            computed: (flags & 1) === 1,
+            optional: (flags & 2) === 2,
+            object: convertNode(buffer[position + 3], buffer),
+            property: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function metaProperty(position, buffer) {
+        return {
+            type: 'MetaProperty',
+            start: buffer[position],
+            end: buffer[position + 1],
+            meta: convertNode(buffer[position + 2], buffer),
+            property: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function methodDefinition(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'MethodDefinition',
+            start: buffer[position],
+            end: buffer[position + 1],
+            static: (flags & 1) === 1,
+            computed: (flags & 2) === 2,
+            decorators: convertNodeList(buffer[position + 3], buffer),
+            key: convertNode(buffer[position + 4], buffer),
+            value: convertNode(buffer[position + 5], buffer),
+            kind: FIXED_STRINGS[buffer[position + 6]]
+        };
+    },
+    function newExpression(position, buffer) {
+        const annotations = convertAnnotations(buffer[position + 2], buffer);
+        return {
+            type: 'NewExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            callee: convertNode(buffer[position + 3], buffer),
+            arguments: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function objectExpression(position, buffer) {
+        return {
+            type: 'ObjectExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            properties: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function objectPattern(position, buffer) {
+        return {
+            type: 'ObjectPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            properties: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function privateIdentifier(position, buffer) {
+        return {
+            type: 'PrivateIdentifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function program(position, buffer) {
+        const invalidAnnotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'Program',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer),
+            ...(invalidAnnotations.length > 0 ? { [INVALID_ANNOTATION_KEY]: invalidAnnotations } : {}),
+            sourceType: 'module'
+        };
+    },
+    function property(position, buffer) {
+        const flags = buffer[position + 2];
+        const keyPosition = buffer[position + 3];
+        const value = convertNode(buffer[position + 4], buffer);
+        return {
+            type: 'Property',
+            start: buffer[position],
+            end: buffer[position + 1],
+            method: (flags & 1) === 1,
+            shorthand: (flags & 2) === 2,
+            computed: (flags & 4) === 4,
+            key: keyPosition === 0 ? { ...value } : convertNode(keyPosition, buffer),
+            value,
+            kind: FIXED_STRINGS[buffer[position + 5]]
+        };
+    },
+    function propertyDefinition(position, buffer) {
+        const flags = buffer[position + 2];
+        const valuePosition = buffer[position + 5];
+        return {
+            type: 'PropertyDefinition',
+            start: buffer[position],
+            end: buffer[position + 1],
+            static: (flags & 1) === 1,
+            computed: (flags & 2) === 2,
+            decorators: convertNodeList(buffer[position + 3], buffer),
+            key: convertNode(buffer[position + 4], buffer),
+            value: valuePosition === 0 ? null : convertNode(valuePosition, buffer)
+        };
+    },
+    function restElement(position, buffer) {
+        return {
+            type: 'RestElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function returnStatement(position, buffer) {
+        const argumentPosition = buffer[position + 2];
+        return {
+            type: 'ReturnStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: argumentPosition === 0 ? null : convertNode(argumentPosition, buffer)
+        };
+    },
+    function sequenceExpression(position, buffer) {
+        return {
+            type: 'SequenceExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expressions: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function spreadElement(position, buffer) {
+        return {
+            type: 'SpreadElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function staticBlock(position, buffer) {
+        return {
+            type: 'StaticBlock',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function superElement(position, buffer) {
+        return {
+            type: 'Super',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function switchCase(position, buffer) {
+        const testPosition = buffer[position + 2];
+        return {
+            type: 'SwitchCase',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: testPosition === 0 ? null : convertNode(testPosition, buffer),
+            consequent: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function switchStatement(position, buffer) {
+        return {
+            type: 'SwitchStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            discriminant: convertNode(buffer[position + 2], buffer),
+            cases: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function taggedTemplateExpression(position, buffer) {
+        return {
+            type: 'TaggedTemplateExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            tag: convertNode(buffer[position + 2], buffer),
+            quasi: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function templateElement(position, buffer) {
+        const flags = buffer[position + 2];
+        const cookedPosition = buffer[position + 3];
+        const cooked = cookedPosition === 0 ? undefined : buffer.convertString(cookedPosition);
+        const raw = buffer.convertString(buffer[position + 4]);
+        return {
+            type: 'TemplateElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            tail: (flags & 1) === 1,
+            value: { cooked, raw }
+        };
+    },
+    function templateLiteral(position, buffer) {
+        return {
+            type: 'TemplateLiteral',
+            start: buffer[position],
+            end: buffer[position + 1],
+            quasis: convertNodeList(buffer[position + 2], buffer),
+            expressions: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function thisExpression(position, buffer) {
+        return {
+            type: 'ThisExpression',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function throwStatement(position, buffer) {
+        return {
+            type: 'ThrowStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function tryStatement(position, buffer) {
+        const handlerPosition = buffer[position + 3];
+        const finalizerPosition = buffer[position + 4];
+        return {
+            type: 'TryStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            block: convertNode(buffer[position + 2], buffer),
+            handler: handlerPosition === 0 ? null : convertNode(handlerPosition, buffer),
+            finalizer: finalizerPosition === 0 ? null : convertNode(finalizerPosition, buffer)
+        };
+    },
+    function unaryExpression(position, buffer) {
+        return {
+            type: 'UnaryExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            argument: convertNode(buffer[position + 3], buffer),
+            prefix: true
+        };
+    },
+    function updateExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'UpdateExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            prefix: (flags & 1) === 1,
+            operator: FIXED_STRINGS[buffer[position + 3]],
+            argument: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function variableDeclaration(position, buffer) {
+        return {
+            type: 'VariableDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            kind: FIXED_STRINGS[buffer[position + 2]],
+            declarations: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function variableDeclarator(position, buffer) {
+        const initPosition = buffer[position + 3];
+        return {
+            type: 'VariableDeclarator',
+            start: buffer[position],
+            end: buffer[position + 1],
+            id: convertNode(buffer[position + 2], buffer),
+            init: initPosition === 0 ? null : convertNode(initPosition, buffer)
+        };
+    },
+    function whileStatement(position, buffer) {
+        return {
+            type: 'WhileStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function yieldExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const argumentPosition = buffer[position + 3];
+        return {
+            type: 'YieldExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            delegate: (flags & 1) === 1,
+            argument: argumentPosition === 0 ? null : convertNode(argumentPosition, buffer)
+        };
+    }
+];
+function convertNode(position, buffer) {
+    const nodeType = buffer[position];
+    const converter = nodeConverters[nodeType];
+    /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
+    if (!converter) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    return converter(position + 1, buffer);
+}
+function convertNodeList(position, buffer) {
+    if (position === 0)
+        return EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(nodePosition, buffer) : null);
+    }
+    return list;
+}
+
+function getAstBuffer(astBuffer) {
+    const array = new Uint32Array(astBuffer.buffer);
+    let convertString;
+    if (typeof Buffer !== 'undefined' && astBuffer instanceof Buffer) {
+        convertString = (position) => {
+            const length = array[position++];
+            const bytePosition = position << 2;
+            return astBuffer.toString('utf8', bytePosition, bytePosition + length);
+        };
+    }
+    else {
+        const textDecoder = new TextDecoder();
+        convertString = (position) => {
+            const length = array[position++];
+            const bytePosition = position << 2;
+            return textDecoder.decode(astBuffer.subarray(bytePosition, bytePosition + length));
+        };
+    }
+    return Object.assign(array, { convertString });
+}
+
+const parseAst = (input, { allowReturnOutsideFunction = false, jsx = false } = {}) => convertProgram(getAstBuffer(parse(input, allowReturnOutsideFunction, jsx)));
+const parseAstAsync = async (input, { allowReturnOutsideFunction = false, jsx = false, signal } = {}) => convertProgram(getAstBuffer(await parseAsync(input, allowReturnOutsideFunction, jsx, signal)));
+
+export { ANNOTATION_KEY, ArrowFunctionExpression, BLANK, BlockStatement, CallExpression, CatchClause, EMPTY_ARRAY, EMPTY_OBJECT, EMPTY_SET, ExportDefaultDeclaration, ExpressionStatement, FIXED_STRINGS, INVALID_ANNOTATION_KEY, Identifier, LOGLEVEL_DEBUG, LOGLEVEL_ERROR, LOGLEVEL_INFO, LOGLEVEL_WARN, Literal, Program, Property, ReturnStatement, StaticBlock, TemplateLiteral, URL_GENERATEBUNDLE, URL_JSX, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_AMD_ID, URL_OUTPUT_DIR, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, URL_OUTPUT_FORMAT, URL_OUTPUT_GENERATEDCODE, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_OUTPUT_INTEROP, URL_OUTPUT_MANUALCHUNKS, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_SOURCEMAPFILE, URL_PRESERVEENTRYSIGNATURES, URL_TREESHAKE, URL_TREESHAKE_MODULESIDEEFFECTS, URL_WATCH, VariableDeclarator, addTrailingSlashIfMissed, augmentCodeLocation, augmentLogMessage, convertAnnotations, convertNode, error, getAliasName, getAstBuffer, getImportPath, getRollupError, isAbsolute, isPathFragment, isRelative, isValidUrl, locate, logAddonNotGenerated, logAlreadyClosed, logAmbiguousExternalNamespaces, logAnonymousPluginCache, logAssetNotFinalisedForFileName, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logBadLoader, logCannotAssignModuleToChunk, logCannotCallNamespace, logCannotEmitFromOptionsHook, logChunkInvalid, logChunkNotGeneratedForFileName, logCircularDependency, logCircularReexport, logConflictingSourcemapSources, logConstVariableReassignError, logCyclicCrossChunkReexport, logDuplicateArgumentNameError, logDuplicateExportError, logDuplicatePluginName, logEmptyChunk, logEntryCannotBeExternal, logEval, logExternalModulesCannotBeIncludedInManualChunks, logExternalModulesCannotBeTransformedToModules, logExternalSyntheticExports, logFailedValidation, logFileNameConflict, logFileReferenceIdNotFoundForFilename, logFirstSideEffect, logIllegalIdentifierAsName, logIllegalImportReassignment, logImplicitDependantCannotBeExternal, logImplicitDependantIsNotIncluded, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logIncompatibleExportOptionValue, logInconsistentImportAttributes, logInputHookInOutputPlugin, logInternalIdCannotBeExternal, logInvalidAddonPluginHook, logInvalidAnnotation, logInvalidExportOptionValue, logInvalidFormatForTopLevelAwait, logInvalidFunctionPluginHook, logInvalidLogPosition, logInvalidOption, logInvalidRollupPhaseForChunkEmission, logInvalidSetAssetSourceCall, logInvalidSourcemapForError, logLevelPriority, logMissingEntryExport, logMissingExport, logMissingFileOrDirOption, logMissingGlobalName, logMissingJsxExport, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, logMissingNodeBuiltins, logMixedExport, logModuleLevelDirective, logModuleParseError, logNamespaceConflict, logNoAssetSourceSet, logNoTransformMapOrAstWithoutCode, logOptimizeChunkStatus, logParseError, logPluginError, logRedeclarationError, logReservedNamespace, logShimmedExport, logSourcemapBroken, logSyntheticNamedExportsNeedNamespaceExport, logThisIsUndefined, logUnexpectedNamedImport, logUnexpectedNamespaceReexport, logUnknownOption, logUnresolvedEntry, logUnresolvedImplicitDependant, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logUnusedExternalImports, normalize, parseAst, parseAstAsync, printQuotedStringList, relative, relativeId, warnDeprecation };
diff --git a/node_modules/rollup/dist/es/shared/watch.js b/node_modules/rollup/dist/es/shared/watch.js
new file mode 100644
index 0000000..349dae1
--- /dev/null
+++ b/node_modules/rollup/dist/es/shared/watch.js
@@ -0,0 +1,9296 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+import { getAugmentedNamespace, fseventsImporter, getDefaultExportFromCjs, createFilter, rollupInternal } from './node-entry.js';
+import path from 'node:path';
+import process$1 from 'node:process';
+import require$$0$1 from 'path';
+import require$$0$2 from 'fs';
+import require$$2 from 'util';
+import require$$1 from 'stream';
+import require$$2$1 from 'os';
+import require$$0$3 from 'events';
+import { platform } from 'node:os';
+import './parseAst.js';
+import '../../native.js';
+import 'node:perf_hooks';
+import 'node:fs/promises';
+import 'tty';
+
+var chokidar$1 = {};
+
+var utils$2 = {};
+
+var constants$3;
+var hasRequiredConstants$3;
+
+function requireConstants$3 () {
+	if (hasRequiredConstants$3) return constants$3;
+	hasRequiredConstants$3 = 1;
+
+	const path = require$$0$1;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants$3 = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants$3;
+}
+
+var hasRequiredUtils$2;
+
+function requireUtils$2 () {
+	if (hasRequiredUtils$2) return utils$2;
+	hasRequiredUtils$2 = 1;
+	(function (exports) {
+
+		const path = require$$0$1;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants$3();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils$2));
+	return utils$2;
+}
+
+var scan_1$1;
+var hasRequiredScan$1;
+
+function requireScan$1 () {
+	if (hasRequiredScan$1) return scan_1$1;
+	hasRequiredScan$1 = 1;
+
+	const utils = /*@__PURE__*/ requireUtils$2();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants$3();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1$1 = scan;
+	return scan_1$1;
+}
+
+var parse_1$2;
+var hasRequiredParse$2;
+
+function requireParse$2 () {
+	if (hasRequiredParse$2) return parse_1$2;
+	hasRequiredParse$2 = 1;
+
+	const constants = /*@__PURE__*/ requireConstants$3();
+	const utils = /*@__PURE__*/ requireUtils$2();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1$2 = parse;
+	return parse_1$2;
+}
+
+var picomatch_1$1;
+var hasRequiredPicomatch$3;
+
+function requirePicomatch$3 () {
+	if (hasRequiredPicomatch$3) return picomatch_1$1;
+	hasRequiredPicomatch$3 = 1;
+
+	const path = require$$0$1;
+	const scan = /*@__PURE__*/ requireScan$1();
+	const parse = /*@__PURE__*/ requireParse$2();
+	const utils = /*@__PURE__*/ requireUtils$2();
+	const constants = /*@__PURE__*/ requireConstants$3();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1$1 = picomatch;
+	return picomatch_1$1;
+}
+
+var picomatch$1;
+var hasRequiredPicomatch$2;
+
+function requirePicomatch$2 () {
+	if (hasRequiredPicomatch$2) return picomatch$1;
+	hasRequiredPicomatch$2 = 1;
+
+	picomatch$1 = /*@__PURE__*/ requirePicomatch$3();
+	return picomatch$1;
+}
+
+var readdirp_1;
+var hasRequiredReaddirp;
+
+function requireReaddirp () {
+	if (hasRequiredReaddirp) return readdirp_1;
+	hasRequiredReaddirp = 1;
+
+	const fs = require$$0$2;
+	const { Readable } = require$$1;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const picomatch = /*@__PURE__*/ requirePicomatch$2();
+
+	const readdir = promisify(fs.readdir);
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const realpath = promisify(fs.realpath);
+
+	/**
+	 * @typedef {Object} EntryInfo
+	 * @property {String} path
+	 * @property {String} fullPath
+	 * @property {fs.Stats=} stats
+	 * @property {fs.Dirent=} dirent
+	 * @property {String} basename
+	 */
+
+	const BANG = '!';
+	const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+	const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+	const FILE_TYPE = 'files';
+	const DIR_TYPE = 'directories';
+	const FILE_DIR_TYPE = 'files_directories';
+	const EVERYTHING_TYPE = 'all';
+	const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+
+	const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+	const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+	const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
+
+	const normalizeFilter = filter => {
+	  if (filter === undefined) return;
+	  if (typeof filter === 'function') return filter;
+
+	  if (typeof filter === 'string') {
+	    const glob = picomatch(filter.trim());
+	    return entry => glob(entry.basename);
+	  }
+
+	  if (Array.isArray(filter)) {
+	    const positive = [];
+	    const negative = [];
+	    for (const item of filter) {
+	      const trimmed = item.trim();
+	      if (trimmed.charAt(0) === BANG) {
+	        negative.push(picomatch(trimmed.slice(1)));
+	      } else {
+	        positive.push(picomatch(trimmed));
+	      }
+	    }
+
+	    if (negative.length > 0) {
+	      if (positive.length > 0) {
+	        return entry =>
+	          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
+	      }
+	      return entry => !negative.some(f => f(entry.basename));
+	    }
+	    return entry => positive.some(f => f(entry.basename));
+	  }
+	};
+
+	class ReaddirpStream extends Readable {
+	  static get defaultOptions() {
+	    return {
+	      root: '.',
+	      /* eslint-disable no-unused-vars */
+	      fileFilter: (path) => true,
+	      directoryFilter: (path) => true,
+	      /* eslint-enable no-unused-vars */
+	      type: FILE_TYPE,
+	      lstat: false,
+	      depth: 2147483648,
+	      alwaysStat: false
+	    };
+	  }
+
+	  constructor(options = {}) {
+	    super({
+	      objectMode: true,
+	      autoDestroy: true,
+	      highWaterMark: options.highWaterMark || 4096
+	    });
+	    const opts = { ...ReaddirpStream.defaultOptions, ...options };
+	    const { root, type } = opts;
+
+	    this._fileFilter = normalizeFilter(opts.fileFilter);
+	    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+
+	    const statMethod = opts.lstat ? lstat : stat;
+	    // Use bigint stats if it's windows and stat() supports options (node 10+).
+	    if (wantBigintFsStats) {
+	      this._stat = path => statMethod(path, { bigint: true });
+	    } else {
+	      this._stat = statMethod;
+	    }
+
+	    this._maxDepth = opts.depth;
+	    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+	    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+	    this._wantsEverything = type === EVERYTHING_TYPE;
+	    this._root = sysPath.resolve(root);
+	    this._isDirent = ('Dirent' in fs) && !opts.alwaysStat;
+	    this._statsProp = this._isDirent ? 'dirent' : 'stats';
+	    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+
+	    // Launch stream with one parent, the root dir.
+	    this.parents = [this._exploreDir(root, 1)];
+	    this.reading = false;
+	    this.parent = undefined;
+	  }
+
+	  async _read(batch) {
+	    if (this.reading) return;
+	    this.reading = true;
+
+	    try {
+	      while (!this.destroyed && batch > 0) {
+	        const { path, depth, files = [] } = this.parent || {};
+
+	        if (files.length > 0) {
+	          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
+	          for (const entry of await Promise.all(slice)) {
+	            if (this.destroyed) return;
+
+	            const entryType = await this._getEntryType(entry);
+	            if (entryType === 'directory' && this._directoryFilter(entry)) {
+	              if (depth <= this._maxDepth) {
+	                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+	              }
+
+	              if (this._wantsDir) {
+	                this.push(entry);
+	                batch--;
+	              }
+	            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+	              if (this._wantsFile) {
+	                this.push(entry);
+	                batch--;
+	              }
+	            }
+	          }
+	        } else {
+	          const parent = this.parents.pop();
+	          if (!parent) {
+	            this.push(null);
+	            break;
+	          }
+	          this.parent = await parent;
+	          if (this.destroyed) return;
+	        }
+	      }
+	    } catch (error) {
+	      this.destroy(error);
+	    } finally {
+	      this.reading = false;
+	    }
+	  }
+
+	  async _exploreDir(path, depth) {
+	    let files;
+	    try {
+	      files = await readdir(path, this._rdOptions);
+	    } catch (error) {
+	      this._onError(error);
+	    }
+	    return { files, depth, path };
+	  }
+
+	  async _formatEntry(dirent, path) {
+	    let entry;
+	    try {
+	      const basename = this._isDirent ? dirent.name : dirent;
+	      const fullPath = sysPath.resolve(sysPath.join(path, basename));
+	      entry = { path: sysPath.relative(this._root, fullPath), fullPath, basename };
+	      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+	    } catch (err) {
+	      this._onError(err);
+	    }
+	    return entry;
+	  }
+
+	  _onError(err) {
+	    if (isNormalFlowError(err) && !this.destroyed) {
+	      this.emit('warn', err);
+	    } else {
+	      this.destroy(err);
+	    }
+	  }
+
+	  async _getEntryType(entry) {
+	    // entry may be undefined, because a warning or an error were emitted
+	    // and the statsProp is undefined
+	    const stats = entry && entry[this._statsProp];
+	    if (!stats) {
+	      return;
+	    }
+	    if (stats.isFile()) {
+	      return 'file';
+	    }
+	    if (stats.isDirectory()) {
+	      return 'directory';
+	    }
+	    if (stats && stats.isSymbolicLink()) {
+	      const full = entry.fullPath;
+	      try {
+	        const entryRealPath = await realpath(full);
+	        const entryRealPathStats = await lstat(entryRealPath);
+	        if (entryRealPathStats.isFile()) {
+	          return 'file';
+	        }
+	        if (entryRealPathStats.isDirectory()) {
+	          const len = entryRealPath.length;
+	          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath.sep) {
+	            const recursiveError = new Error(
+	              `Circular symlink detected: "${full}" points to "${entryRealPath}"`
+	            );
+	            recursiveError.code = RECURSIVE_ERROR_CODE;
+	            return this._onError(recursiveError);
+	          }
+	          return 'directory';
+	        }
+	      } catch (error) {
+	        this._onError(error);
+	      }
+	    }
+	  }
+
+	  _includeAsFile(entry) {
+	    const stats = entry && entry[this._statsProp];
+
+	    return stats && this._wantsEverything && !stats.isDirectory();
+	  }
+	}
+
+	/**
+	 * @typedef {Object} ReaddirpArguments
+	 * @property {Function=} fileFilter
+	 * @property {Function=} directoryFilter
+	 * @property {String=} type
+	 * @property {Number=} depth
+	 * @property {String=} root
+	 * @property {Boolean=} lstat
+	 * @property {Boolean=} bigint
+	 */
+
+	/**
+	 * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+	 * @param {String} root Root directory
+	 * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+	 */
+	const readdirp = (root, options = {}) => {
+	  let type = options.entryType || options.type;
+	  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
+	  if (type) options.type = type;
+	  if (!root) {
+	    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+	  } else if (typeof root !== 'string') {
+	    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+	  } else if (type && !ALL_TYPES.includes(type)) {
+	    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+	  }
+
+	  options.root = root;
+	  return new ReaddirpStream(options);
+	};
+
+	const readdirpPromise = (root, options = {}) => {
+	  return new Promise((resolve, reject) => {
+	    const files = [];
+	    readdirp(root, options)
+	      .on('data', entry => files.push(entry))
+	      .on('end', () => resolve(files))
+	      .on('error', error => reject(error));
+	  });
+	};
+
+	readdirp.promise = readdirpPromise;
+	readdirp.ReaddirpStream = ReaddirpStream;
+	readdirp.default = readdirp;
+
+	readdirp_1 = readdirp;
+	return readdirp_1;
+}
+
+var anymatch = {exports: {}};
+
+var utils$1 = {};
+
+var constants$2;
+var hasRequiredConstants$2;
+
+function requireConstants$2 () {
+	if (hasRequiredConstants$2) return constants$2;
+	hasRequiredConstants$2 = 1;
+
+	const path = require$$0$1;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants$2 = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants$2;
+}
+
+var hasRequiredUtils$1;
+
+function requireUtils$1 () {
+	if (hasRequiredUtils$1) return utils$1;
+	hasRequiredUtils$1 = 1;
+	(function (exports) {
+
+		const path = require$$0$1;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants$2();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils$1));
+	return utils$1;
+}
+
+var scan_1;
+var hasRequiredScan;
+
+function requireScan () {
+	if (hasRequiredScan) return scan_1;
+	hasRequiredScan = 1;
+
+	const utils = /*@__PURE__*/ requireUtils$1();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants$2();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1 = scan;
+	return scan_1;
+}
+
+var parse_1$1;
+var hasRequiredParse$1;
+
+function requireParse$1 () {
+	if (hasRequiredParse$1) return parse_1$1;
+	hasRequiredParse$1 = 1;
+
+	const constants = /*@__PURE__*/ requireConstants$2();
+	const utils = /*@__PURE__*/ requireUtils$1();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1$1 = parse;
+	return parse_1$1;
+}
+
+var picomatch_1;
+var hasRequiredPicomatch$1;
+
+function requirePicomatch$1 () {
+	if (hasRequiredPicomatch$1) return picomatch_1;
+	hasRequiredPicomatch$1 = 1;
+
+	const path = require$$0$1;
+	const scan = /*@__PURE__*/ requireScan();
+	const parse = /*@__PURE__*/ requireParse$1();
+	const utils = /*@__PURE__*/ requireUtils$1();
+	const constants = /*@__PURE__*/ requireConstants$2();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1 = picomatch;
+	return picomatch_1;
+}
+
+var picomatch;
+var hasRequiredPicomatch;
+
+function requirePicomatch () {
+	if (hasRequiredPicomatch) return picomatch;
+	hasRequiredPicomatch = 1;
+
+	picomatch = /*@__PURE__*/ requirePicomatch$1();
+	return picomatch;
+}
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var normalizePath;
+var hasRequiredNormalizePath;
+
+function requireNormalizePath () {
+	if (hasRequiredNormalizePath) return normalizePath;
+	hasRequiredNormalizePath = 1;
+	normalizePath = function(path, stripTrailing) {
+	  if (typeof path !== 'string') {
+	    throw new TypeError('expected path to be a string');
+	  }
+
+	  if (path === '\\' || path === '/') return '/';
+
+	  var len = path.length;
+	  if (len <= 1) return path;
+
+	  // ensure that win32 namespaces has two leading slashes, so that the path is
+	  // handled properly by the win32 version of path.parse() after being normalized
+	  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+	  var prefix = '';
+	  if (len > 4 && path[3] === '\\') {
+	    var ch = path[2];
+	    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+	      path = path.slice(2);
+	      prefix = '//';
+	    }
+	  }
+
+	  var segs = path.split(/[/\\]+/);
+	  if (stripTrailing !== false && segs[segs.length - 1] === '') {
+	    segs.pop();
+	  }
+	  return prefix + segs.join('/');
+	};
+	return normalizePath;
+}
+
+var anymatch_1 = anymatch.exports;
+
+var hasRequiredAnymatch;
+
+function requireAnymatch () {
+	if (hasRequiredAnymatch) return anymatch.exports;
+	hasRequiredAnymatch = 1;
+
+	Object.defineProperty(anymatch_1, "__esModule", { value: true });
+
+	const picomatch = /*@__PURE__*/ requirePicomatch();
+	const normalizePath = /*@__PURE__*/ requireNormalizePath();
+
+	/**
+	 * @typedef {(testString: string) => boolean} AnymatchFn
+	 * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+	 * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+	 */
+	const BANG = '!';
+	const DEFAULT_OPTIONS = {returnIndex: false};
+	const arrify = (item) => Array.isArray(item) ? item : [item];
+
+	/**
+	 * @param {AnymatchPattern} matcher
+	 * @param {object} options
+	 * @returns {AnymatchFn}
+	 */
+	const createPattern = (matcher, options) => {
+	  if (typeof matcher === 'function') {
+	    return matcher;
+	  }
+	  if (typeof matcher === 'string') {
+	    const glob = picomatch(matcher, options);
+	    return (string) => matcher === string || glob(string);
+	  }
+	  if (matcher instanceof RegExp) {
+	    return (string) => matcher.test(string);
+	  }
+	  return (string) => false;
+	};
+
+	/**
+	 * @param {Array<Function>} patterns
+	 * @param {Array<Function>} negPatterns
+	 * @param {String|Array} args
+	 * @param {Boolean} returnIndex
+	 * @returns {boolean|number}
+	 */
+	const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+	  const isList = Array.isArray(args);
+	  const _path = isList ? args[0] : args;
+	  if (!isList && typeof _path !== 'string') {
+	    throw new TypeError('anymatch: second argument must be a string: got ' +
+	      Object.prototype.toString.call(_path))
+	  }
+	  const path = normalizePath(_path, false);
+
+	  for (let index = 0; index < negPatterns.length; index++) {
+	    const nglob = negPatterns[index];
+	    if (nglob(path)) {
+	      return returnIndex ? -1 : false;
+	    }
+	  }
+
+	  const applied = isList && [path].concat(args.slice(1));
+	  for (let index = 0; index < patterns.length; index++) {
+	    const pattern = patterns[index];
+	    if (isList ? pattern(...applied) : pattern(path)) {
+	      return returnIndex ? index : true;
+	    }
+	  }
+
+	  return returnIndex ? -1 : false;
+	};
+
+	/**
+	 * @param {AnymatchMatcher} matchers
+	 * @param {Array|string} testString
+	 * @param {object} options
+	 * @returns {boolean|number|Function}
+	 */
+	const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
+	  if (matchers == null) {
+	    throw new TypeError('anymatch: specify first argument');
+	  }
+	  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
+	  const returnIndex = opts.returnIndex || false;
+
+	  // Early cache for matchers.
+	  const mtchers = arrify(matchers);
+	  const negatedGlobs = mtchers
+	    .filter(item => typeof item === 'string' && item.charAt(0) === BANG)
+	    .map(item => item.slice(1))
+	    .map(item => picomatch(item, opts));
+	  const patterns = mtchers
+	    .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG))
+	    .map(matcher => createPattern(matcher, opts));
+
+	  if (testString == null) {
+	    return (testString, ri = false) => {
+	      const returnIndex = typeof ri === 'boolean' ? ri : false;
+	      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+	    }
+	  }
+
+	  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+	};
+
+	anymatch$1.default = anymatch$1;
+	anymatch.exports = anymatch$1;
+	return anymatch.exports;
+}
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob;
+var hasRequiredIsExtglob;
+
+function requireIsExtglob () {
+	if (hasRequiredIsExtglob) return isExtglob;
+	hasRequiredIsExtglob = 1;
+	isExtglob = function isExtglob(str) {
+	  if (typeof str !== 'string' || str === '') {
+	    return false;
+	  }
+
+	  var match;
+	  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+	    if (match[2]) return true;
+	    str = str.slice(match.index + match[0].length);
+	  }
+
+	  return false;
+	};
+	return isExtglob;
+}
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isGlob;
+var hasRequiredIsGlob;
+
+function requireIsGlob () {
+	if (hasRequiredIsGlob) return isGlob;
+	hasRequiredIsGlob = 1;
+	var isExtglob = /*@__PURE__*/ requireIsExtglob();
+	var chars = { '{': '}', '(': ')', '[': ']'};
+	var strictCheck = function(str) {
+	  if (str[0] === '!') {
+	    return true;
+	  }
+	  var index = 0;
+	  var pipeIndex = -2;
+	  var closeSquareIndex = -2;
+	  var closeCurlyIndex = -2;
+	  var closeParenIndex = -2;
+	  var backSlashIndex = -2;
+	  while (index < str.length) {
+	    if (str[index] === '*') {
+	      return true;
+	    }
+
+	    if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) {
+	      return true;
+	    }
+
+	    if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') {
+	      if (closeSquareIndex < index) {
+	        closeSquareIndex = str.indexOf(']', index);
+	      }
+	      if (closeSquareIndex > index) {
+	        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+	          return true;
+	        }
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') {
+	      closeCurlyIndex = str.indexOf('}', index);
+	      if (closeCurlyIndex > index) {
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') {
+	      closeParenIndex = str.indexOf(')', index);
+	      if (closeParenIndex > index) {
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+	      if (pipeIndex < index) {
+	        pipeIndex = str.indexOf('|', index);
+	      }
+	      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+	        closeParenIndex = str.indexOf(')', pipeIndex);
+	        if (closeParenIndex > pipeIndex) {
+	          backSlashIndex = str.indexOf('\\', pipeIndex);
+	          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+	            return true;
+	          }
+	        }
+	      }
+	    }
+
+	    if (str[index] === '\\') {
+	      var open = str[index + 1];
+	      index += 2;
+	      var close = chars[open];
+
+	      if (close) {
+	        var n = str.indexOf(close, index);
+	        if (n !== -1) {
+	          index = n + 1;
+	        }
+	      }
+
+	      if (str[index] === '!') {
+	        return true;
+	      }
+	    } else {
+	      index++;
+	    }
+	  }
+	  return false;
+	};
+
+	var relaxedCheck = function(str) {
+	  if (str[0] === '!') {
+	    return true;
+	  }
+	  var index = 0;
+	  while (index < str.length) {
+	    if (/[*?{}()[\]]/.test(str[index])) {
+	      return true;
+	    }
+
+	    if (str[index] === '\\') {
+	      var open = str[index + 1];
+	      index += 2;
+	      var close = chars[open];
+
+	      if (close) {
+	        var n = str.indexOf(close, index);
+	        if (n !== -1) {
+	          index = n + 1;
+	        }
+	      }
+
+	      if (str[index] === '!') {
+	        return true;
+	      }
+	    } else {
+	      index++;
+	    }
+	  }
+	  return false;
+	};
+
+	isGlob = function isGlob(str, options) {
+	  if (typeof str !== 'string' || str === '') {
+	    return false;
+	  }
+
+	  if (isExtglob(str)) {
+	    return true;
+	  }
+
+	  var check = strictCheck;
+
+	  // optionally relax check
+	  if (options && options.strict === false) {
+	    check = relaxedCheck;
+	  }
+
+	  return check(str);
+	};
+	return isGlob;
+}
+
+var globParent;
+var hasRequiredGlobParent;
+
+function requireGlobParent () {
+	if (hasRequiredGlobParent) return globParent;
+	hasRequiredGlobParent = 1;
+
+	var isGlob = /*@__PURE__*/ requireIsGlob();
+	var pathPosixDirname = require$$0$1.posix.dirname;
+	var isWin32 = require$$2$1.platform() === 'win32';
+
+	var slash = '/';
+	var backslash = /\\/g;
+	var enclosure = /[\{\[].*[\}\]]$/;
+	var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+	var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+	/**
+	 * @param {string} str
+	 * @param {Object} opts
+	 * @param {boolean} [opts.flipBackslashes=true]
+	 * @returns {string}
+	 */
+	globParent = function globParent(str, opts) {
+	  var options = Object.assign({ flipBackslashes: true }, opts);
+
+	  // flip windows path separators
+	  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+	    str = str.replace(backslash, slash);
+	  }
+
+	  // special case for strings ending in enclosure containing path separator
+	  if (enclosure.test(str)) {
+	    str += slash;
+	  }
+
+	  // preserves full path in case of trailing path separator
+	  str += 'a';
+
+	  // remove path parts that are globby
+	  do {
+	    str = pathPosixDirname(str);
+	  } while (isGlob(str) || globby.test(str));
+
+	  // remove escape chars and return result
+	  return str.replace(escaped, '$1');
+	};
+	return globParent;
+}
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+
+		exports.isInteger = num => {
+		  if (typeof num === 'number') {
+		    return Number.isInteger(num);
+		  }
+		  if (typeof num === 'string' && num.trim() !== '') {
+		    return Number.isInteger(Number(num));
+		  }
+		  return false;
+		};
+
+		/**
+		 * Find a node of the given type
+		 */
+
+		exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+		/**
+		 * Find a node of the given type
+		 */
+
+		exports.exceedsLimit = (min, max, step = 1, limit) => {
+		  if (limit === false) return false;
+		  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+		  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+		};
+
+		/**
+		 * Escape the given node with '\\' before node.value
+		 */
+
+		exports.escapeNode = (block, n = 0, type) => {
+		  const node = block.nodes[n];
+		  if (!node) return;
+
+		  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+		    if (node.escaped !== true) {
+		      node.value = '\\' + node.value;
+		      node.escaped = true;
+		    }
+		  }
+		};
+
+		/**
+		 * Returns true if the given brace node should be enclosed in literal braces
+		 */
+
+		exports.encloseBrace = node => {
+		  if (node.type !== 'brace') return false;
+		  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+		    node.invalid = true;
+		    return true;
+		  }
+		  return false;
+		};
+
+		/**
+		 * Returns true if a brace node is invalid.
+		 */
+
+		exports.isInvalidBrace = block => {
+		  if (block.type !== 'brace') return false;
+		  if (block.invalid === true || block.dollar) return true;
+		  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+		    block.invalid = true;
+		    return true;
+		  }
+		  if (block.open !== true || block.close !== true) {
+		    block.invalid = true;
+		    return true;
+		  }
+		  return false;
+		};
+
+		/**
+		 * Returns true if a node is an open or close node
+		 */
+
+		exports.isOpenOrClose = node => {
+		  if (node.type === 'open' || node.type === 'close') {
+		    return true;
+		  }
+		  return node.open === true || node.close === true;
+		};
+
+		/**
+		 * Reduce an array of text nodes.
+		 */
+
+		exports.reduce = nodes => nodes.reduce((acc, node) => {
+		  if (node.type === 'text') acc.push(node.value);
+		  if (node.type === 'range') node.type = 'text';
+		  return acc;
+		}, []);
+
+		/**
+		 * Flatten an array
+		 */
+
+		exports.flatten = (...args) => {
+		  const result = [];
+
+		  const flat = arr => {
+		    for (let i = 0; i < arr.length; i++) {
+		      const ele = arr[i];
+
+		      if (Array.isArray(ele)) {
+		        flat(ele);
+		        continue;
+		      }
+
+		      if (ele !== undefined) {
+		        result.push(ele);
+		      }
+		    }
+		    return result;
+		  };
+
+		  flat(args);
+		  return result;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var stringify;
+var hasRequiredStringify;
+
+function requireStringify () {
+	if (hasRequiredStringify) return stringify;
+	hasRequiredStringify = 1;
+
+	const utils = /*@__PURE__*/ requireUtils();
+
+	stringify = (ast, options = {}) => {
+	  const stringify = (node, parent = {}) => {
+	    const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+	    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+	    let output = '';
+
+	    if (node.value) {
+	      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+	        return '\\' + node.value;
+	      }
+	      return node.value;
+	    }
+
+	    if (node.value) {
+	      return node.value;
+	    }
+
+	    if (node.nodes) {
+	      for (const child of node.nodes) {
+	        output += stringify(child);
+	      }
+	    }
+	    return output;
+	  };
+
+	  return stringify(ast);
+	};
+	return stringify;
+}
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isNumber;
+var hasRequiredIsNumber;
+
+function requireIsNumber () {
+	if (hasRequiredIsNumber) return isNumber;
+	hasRequiredIsNumber = 1;
+
+	isNumber = function(num) {
+	  if (typeof num === 'number') {
+	    return num - num === 0;
+	  }
+	  if (typeof num === 'string' && num.trim() !== '') {
+	    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+	  }
+	  return false;
+	};
+	return isNumber;
+}
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var toRegexRange_1;
+var hasRequiredToRegexRange;
+
+function requireToRegexRange () {
+	if (hasRequiredToRegexRange) return toRegexRange_1;
+	hasRequiredToRegexRange = 1;
+
+	const isNumber = /*@__PURE__*/ requireIsNumber();
+
+	const toRegexRange = (min, max, options) => {
+	  if (isNumber(min) === false) {
+	    throw new TypeError('toRegexRange: expected the first argument to be a number');
+	  }
+
+	  if (max === void 0 || min === max) {
+	    return String(min);
+	  }
+
+	  if (isNumber(max) === false) {
+	    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+	  }
+
+	  let opts = { relaxZeros: true, ...options };
+	  if (typeof opts.strictZeros === 'boolean') {
+	    opts.relaxZeros = opts.strictZeros === false;
+	  }
+
+	  let relax = String(opts.relaxZeros);
+	  let shorthand = String(opts.shorthand);
+	  let capture = String(opts.capture);
+	  let wrap = String(opts.wrap);
+	  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+	  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+	    return toRegexRange.cache[cacheKey].result;
+	  }
+
+	  let a = Math.min(min, max);
+	  let b = Math.max(min, max);
+
+	  if (Math.abs(a - b) === 1) {
+	    let result = min + '|' + max;
+	    if (opts.capture) {
+	      return `(${result})`;
+	    }
+	    if (opts.wrap === false) {
+	      return result;
+	    }
+	    return `(?:${result})`;
+	  }
+
+	  let isPadded = hasPadding(min) || hasPadding(max);
+	  let state = { min, max, a, b };
+	  let positives = [];
+	  let negatives = [];
+
+	  if (isPadded) {
+	    state.isPadded = isPadded;
+	    state.maxLen = String(state.max).length;
+	  }
+
+	  if (a < 0) {
+	    let newMin = b < 0 ? Math.abs(b) : 1;
+	    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+	    a = state.a = 0;
+	  }
+
+	  if (b >= 0) {
+	    positives = splitToPatterns(a, b, state, opts);
+	  }
+
+	  state.negatives = negatives;
+	  state.positives = positives;
+	  state.result = collatePatterns(negatives, positives);
+
+	  if (opts.capture === true) {
+	    state.result = `(${state.result})`;
+	  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+	    state.result = `(?:${state.result})`;
+	  }
+
+	  toRegexRange.cache[cacheKey] = state;
+	  return state.result;
+	};
+
+	function collatePatterns(neg, pos, options) {
+	  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
+	  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
+	  let intersected = filterPatterns(neg, pos, '-?', true) || [];
+	  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+	  return subpatterns.join('|');
+	}
+
+	function splitToRanges(min, max) {
+	  let nines = 1;
+	  let zeros = 1;
+
+	  let stop = countNines(min, nines);
+	  let stops = new Set([max]);
+
+	  while (min <= stop && stop <= max) {
+	    stops.add(stop);
+	    nines += 1;
+	    stop = countNines(min, nines);
+	  }
+
+	  stop = countZeros(max + 1, zeros) - 1;
+
+	  while (min < stop && stop <= max) {
+	    stops.add(stop);
+	    zeros += 1;
+	    stop = countZeros(max + 1, zeros) - 1;
+	  }
+
+	  stops = [...stops];
+	  stops.sort(compare);
+	  return stops;
+	}
+
+	/**
+	 * Convert a range to a regex pattern
+	 * @param {Number} `start`
+	 * @param {Number} `stop`
+	 * @return {String}
+	 */
+
+	function rangeToPattern(start, stop, options) {
+	  if (start === stop) {
+	    return { pattern: start, count: [], digits: 0 };
+	  }
+
+	  let zipped = zip(start, stop);
+	  let digits = zipped.length;
+	  let pattern = '';
+	  let count = 0;
+
+	  for (let i = 0; i < digits; i++) {
+	    let [startDigit, stopDigit] = zipped[i];
+
+	    if (startDigit === stopDigit) {
+	      pattern += startDigit;
+
+	    } else if (startDigit !== '0' || stopDigit !== '9') {
+	      pattern += toCharacterClass(startDigit, stopDigit);
+
+	    } else {
+	      count++;
+	    }
+	  }
+
+	  if (count) {
+	    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+	  }
+
+	  return { pattern, count: [count], digits };
+	}
+
+	function splitToPatterns(min, max, tok, options) {
+	  let ranges = splitToRanges(min, max);
+	  let tokens = [];
+	  let start = min;
+	  let prev;
+
+	  for (let i = 0; i < ranges.length; i++) {
+	    let max = ranges[i];
+	    let obj = rangeToPattern(String(start), String(max), options);
+	    let zeros = '';
+
+	    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+	      if (prev.count.length > 1) {
+	        prev.count.pop();
+	      }
+
+	      prev.count.push(obj.count[0]);
+	      prev.string = prev.pattern + toQuantifier(prev.count);
+	      start = max + 1;
+	      continue;
+	    }
+
+	    if (tok.isPadded) {
+	      zeros = padZeros(max, tok, options);
+	    }
+
+	    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+	    tokens.push(obj);
+	    start = max + 1;
+	    prev = obj;
+	  }
+
+	  return tokens;
+	}
+
+	function filterPatterns(arr, comparison, prefix, intersection, options) {
+	  let result = [];
+
+	  for (let ele of arr) {
+	    let { string } = ele;
+
+	    // only push if _both_ are negative...
+	    if (!intersection && !contains(comparison, 'string', string)) {
+	      result.push(prefix + string);
+	    }
+
+	    // or _both_ are positive
+	    if (intersection && contains(comparison, 'string', string)) {
+	      result.push(prefix + string);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Zip strings
+	 */
+
+	function zip(a, b) {
+	  let arr = [];
+	  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+	  return arr;
+	}
+
+	function compare(a, b) {
+	  return a > b ? 1 : b > a ? -1 : 0;
+	}
+
+	function contains(arr, key, val) {
+	  return arr.some(ele => ele[key] === val);
+	}
+
+	function countNines(min, len) {
+	  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+	}
+
+	function countZeros(integer, zeros) {
+	  return integer - (integer % Math.pow(10, zeros));
+	}
+
+	function toQuantifier(digits) {
+	  let [start = 0, stop = ''] = digits;
+	  if (stop || start > 1) {
+	    return `{${start + (stop ? ',' + stop : '')}}`;
+	  }
+	  return '';
+	}
+
+	function toCharacterClass(a, b, options) {
+	  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+	}
+
+	function hasPadding(str) {
+	  return /^-?(0+)\d/.test(str);
+	}
+
+	function padZeros(value, tok, options) {
+	  if (!tok.isPadded) {
+	    return value;
+	  }
+
+	  let diff = Math.abs(tok.maxLen - String(value).length);
+	  let relax = options.relaxZeros !== false;
+
+	  switch (diff) {
+	    case 0:
+	      return '';
+	    case 1:
+	      return relax ? '0?' : '0';
+	    case 2:
+	      return relax ? '0{0,2}' : '00';
+	    default: {
+	      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+	    }
+	  }
+	}
+
+	/**
+	 * Cache
+	 */
+
+	toRegexRange.cache = {};
+	toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+	/**
+	 * Expose `toRegexRange`
+	 */
+
+	toRegexRange_1 = toRegexRange;
+	return toRegexRange_1;
+}
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var fillRange;
+var hasRequiredFillRange;
+
+function requireFillRange () {
+	if (hasRequiredFillRange) return fillRange;
+	hasRequiredFillRange = 1;
+
+	const util = require$$2;
+	const toRegexRange = /*@__PURE__*/ requireToRegexRange();
+
+	const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+	const transform = toNumber => {
+	  return value => toNumber === true ? Number(value) : String(value);
+	};
+
+	const isValidValue = value => {
+	  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+	};
+
+	const isNumber = num => Number.isInteger(+num);
+
+	const zeros = input => {
+	  let value = `${input}`;
+	  let index = -1;
+	  if (value[0] === '-') value = value.slice(1);
+	  if (value === '0') return false;
+	  while (value[++index] === '0');
+	  return index > 0;
+	};
+
+	const stringify = (start, end, options) => {
+	  if (typeof start === 'string' || typeof end === 'string') {
+	    return true;
+	  }
+	  return options.stringify === true;
+	};
+
+	const pad = (input, maxLength, toNumber) => {
+	  if (maxLength > 0) {
+	    let dash = input[0] === '-' ? '-' : '';
+	    if (dash) input = input.slice(1);
+	    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+	  }
+	  if (toNumber === false) {
+	    return String(input);
+	  }
+	  return input;
+	};
+
+	const toMaxLen = (input, maxLength) => {
+	  let negative = input[0] === '-' ? '-' : '';
+	  if (negative) {
+	    input = input.slice(1);
+	    maxLength--;
+	  }
+	  while (input.length < maxLength) input = '0' + input;
+	  return negative ? ('-' + input) : input;
+	};
+
+	const toSequence = (parts, options, maxLen) => {
+	  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+	  let prefix = options.capture ? '' : '?:';
+	  let positives = '';
+	  let negatives = '';
+	  let result;
+
+	  if (parts.positives.length) {
+	    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
+	  }
+
+	  if (parts.negatives.length) {
+	    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
+	  }
+
+	  if (positives && negatives) {
+	    result = `${positives}|${negatives}`;
+	  } else {
+	    result = positives || negatives;
+	  }
+
+	  if (options.wrap) {
+	    return `(${prefix}${result})`;
+	  }
+
+	  return result;
+	};
+
+	const toRange = (a, b, isNumbers, options) => {
+	  if (isNumbers) {
+	    return toRegexRange(a, b, { wrap: false, ...options });
+	  }
+
+	  let start = String.fromCharCode(a);
+	  if (a === b) return start;
+
+	  let stop = String.fromCharCode(b);
+	  return `[${start}-${stop}]`;
+	};
+
+	const toRegex = (start, end, options) => {
+	  if (Array.isArray(start)) {
+	    let wrap = options.wrap === true;
+	    let prefix = options.capture ? '' : '?:';
+	    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+	  }
+	  return toRegexRange(start, end, options);
+	};
+
+	const rangeError = (...args) => {
+	  return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+	};
+
+	const invalidRange = (start, end, options) => {
+	  if (options.strictRanges === true) throw rangeError([start, end]);
+	  return [];
+	};
+
+	const invalidStep = (step, options) => {
+	  if (options.strictRanges === true) {
+	    throw new TypeError(`Expected step "${step}" to be a number`);
+	  }
+	  return [];
+	};
+
+	const fillNumbers = (start, end, step = 1, options = {}) => {
+	  let a = Number(start);
+	  let b = Number(end);
+
+	  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+	    if (options.strictRanges === true) throw rangeError([start, end]);
+	    return [];
+	  }
+
+	  // fix negative zero
+	  if (a === 0) a = 0;
+	  if (b === 0) b = 0;
+
+	  let descending = a > b;
+	  let startString = String(start);
+	  let endString = String(end);
+	  let stepString = String(step);
+	  step = Math.max(Math.abs(step), 1);
+
+	  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+	  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+	  let toNumber = padded === false && stringify(start, end, options) === false;
+	  let format = options.transform || transform(toNumber);
+
+	  if (options.toRegex && step === 1) {
+	    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+	  }
+
+	  let parts = { negatives: [], positives: [] };
+	  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+	  let range = [];
+	  let index = 0;
+
+	  while (descending ? a >= b : a <= b) {
+	    if (options.toRegex === true && step > 1) {
+	      push(a);
+	    } else {
+	      range.push(pad(format(a, index), maxLen, toNumber));
+	    }
+	    a = descending ? a - step : a + step;
+	    index++;
+	  }
+
+	  if (options.toRegex === true) {
+	    return step > 1
+	      ? toSequence(parts, options, maxLen)
+	      : toRegex(range, null, { wrap: false, ...options });
+	  }
+
+	  return range;
+	};
+
+	const fillLetters = (start, end, step = 1, options = {}) => {
+	  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+	    return invalidRange(start, end, options);
+	  }
+
+	  let format = options.transform || (val => String.fromCharCode(val));
+	  let a = `${start}`.charCodeAt(0);
+	  let b = `${end}`.charCodeAt(0);
+
+	  let descending = a > b;
+	  let min = Math.min(a, b);
+	  let max = Math.max(a, b);
+
+	  if (options.toRegex && step === 1) {
+	    return toRange(min, max, false, options);
+	  }
+
+	  let range = [];
+	  let index = 0;
+
+	  while (descending ? a >= b : a <= b) {
+	    range.push(format(a, index));
+	    a = descending ? a - step : a + step;
+	    index++;
+	  }
+
+	  if (options.toRegex === true) {
+	    return toRegex(range, null, { wrap: false, options });
+	  }
+
+	  return range;
+	};
+
+	const fill = (start, end, step, options = {}) => {
+	  if (end == null && isValidValue(start)) {
+	    return [start];
+	  }
+
+	  if (!isValidValue(start) || !isValidValue(end)) {
+	    return invalidRange(start, end, options);
+	  }
+
+	  if (typeof step === 'function') {
+	    return fill(start, end, 1, { transform: step });
+	  }
+
+	  if (isObject(step)) {
+	    return fill(start, end, 0, step);
+	  }
+
+	  let opts = { ...options };
+	  if (opts.capture === true) opts.wrap = true;
+	  step = step || opts.step || 1;
+
+	  if (!isNumber(step)) {
+	    if (step != null && !isObject(step)) return invalidStep(step, opts);
+	    return fill(start, end, 1, step);
+	  }
+
+	  if (isNumber(start) && isNumber(end)) {
+	    return fillNumbers(start, end, step, opts);
+	  }
+
+	  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+	};
+
+	fillRange = fill;
+	return fillRange;
+}
+
+var compile_1;
+var hasRequiredCompile;
+
+function requireCompile () {
+	if (hasRequiredCompile) return compile_1;
+	hasRequiredCompile = 1;
+
+	const fill = /*@__PURE__*/ requireFillRange();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	const compile = (ast, options = {}) => {
+	  const walk = (node, parent = {}) => {
+	    const invalidBlock = utils.isInvalidBrace(parent);
+	    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+	    const invalid = invalidBlock === true || invalidNode === true;
+	    const prefix = options.escapeInvalid === true ? '\\' : '';
+	    let output = '';
+
+	    if (node.isOpen === true) {
+	      return prefix + node.value;
+	    }
+
+	    if (node.isClose === true) {
+	      console.log('node.isClose', prefix, node.value);
+	      return prefix + node.value;
+	    }
+
+	    if (node.type === 'open') {
+	      return invalid ? prefix + node.value : '(';
+	    }
+
+	    if (node.type === 'close') {
+	      return invalid ? prefix + node.value : ')';
+	    }
+
+	    if (node.type === 'comma') {
+	      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';
+	    }
+
+	    if (node.value) {
+	      return node.value;
+	    }
+
+	    if (node.nodes && node.ranges > 0) {
+	      const args = utils.reduce(node.nodes);
+	      const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
+
+	      if (range.length !== 0) {
+	        return args.length > 1 && range.length > 1 ? `(${range})` : range;
+	      }
+	    }
+
+	    if (node.nodes) {
+	      for (const child of node.nodes) {
+	        output += walk(child, node);
+	      }
+	    }
+
+	    return output;
+	  };
+
+	  return walk(ast);
+	};
+
+	compile_1 = compile;
+	return compile_1;
+}
+
+var expand_1;
+var hasRequiredExpand;
+
+function requireExpand () {
+	if (hasRequiredExpand) return expand_1;
+	hasRequiredExpand = 1;
+
+	const fill = /*@__PURE__*/ requireFillRange();
+	const stringify = /*@__PURE__*/ requireStringify();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	const append = (queue = '', stash = '', enclose = false) => {
+	  const result = [];
+
+	  queue = [].concat(queue);
+	  stash = [].concat(stash);
+
+	  if (!stash.length) return queue;
+	  if (!queue.length) {
+	    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+	  }
+
+	  for (const item of queue) {
+	    if (Array.isArray(item)) {
+	      for (const value of item) {
+	        result.push(append(value, stash, enclose));
+	      }
+	    } else {
+	      for (let ele of stash) {
+	        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+	        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+	      }
+	    }
+	  }
+	  return utils.flatten(result);
+	};
+
+	const expand = (ast, options = {}) => {
+	  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
+
+	  const walk = (node, parent = {}) => {
+	    node.queue = [];
+
+	    let p = parent;
+	    let q = parent.queue;
+
+	    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+	      p = p.parent;
+	      q = p.queue;
+	    }
+
+	    if (node.invalid || node.dollar) {
+	      q.push(append(q.pop(), stringify(node, options)));
+	      return;
+	    }
+
+	    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+	      q.push(append(q.pop(), ['{}']));
+	      return;
+	    }
+
+	    if (node.nodes && node.ranges > 0) {
+	      const args = utils.reduce(node.nodes);
+
+	      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+	        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+	      }
+
+	      let range = fill(...args, options);
+	      if (range.length === 0) {
+	        range = stringify(node, options);
+	      }
+
+	      q.push(append(q.pop(), range));
+	      node.nodes = [];
+	      return;
+	    }
+
+	    const enclose = utils.encloseBrace(node);
+	    let queue = node.queue;
+	    let block = node;
+
+	    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+	      block = block.parent;
+	      queue = block.queue;
+	    }
+
+	    for (let i = 0; i < node.nodes.length; i++) {
+	      const child = node.nodes[i];
+
+	      if (child.type === 'comma' && node.type === 'brace') {
+	        if (i === 1) queue.push('');
+	        queue.push('');
+	        continue;
+	      }
+
+	      if (child.type === 'close') {
+	        q.push(append(q.pop(), queue, enclose));
+	        continue;
+	      }
+
+	      if (child.value && child.type !== 'open') {
+	        queue.push(append(queue.pop(), child.value));
+	        continue;
+	      }
+
+	      if (child.nodes) {
+	        walk(child, node);
+	      }
+	    }
+
+	    return queue;
+	  };
+
+	  return utils.flatten(walk(ast));
+	};
+
+	expand_1 = expand;
+	return expand_1;
+}
+
+var constants$1;
+var hasRequiredConstants$1;
+
+function requireConstants$1 () {
+	if (hasRequiredConstants$1) return constants$1;
+	hasRequiredConstants$1 = 1;
+
+	constants$1 = {
+	  MAX_LENGTH: 10000,
+
+	  // Digits
+	  CHAR_0: '0', /* 0 */
+	  CHAR_9: '9', /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 'A', /* A */
+	  CHAR_LOWERCASE_A: 'a', /* a */
+	  CHAR_UPPERCASE_Z: 'Z', /* Z */
+	  CHAR_LOWERCASE_Z: 'z', /* z */
+
+	  CHAR_LEFT_PARENTHESES: '(', /* ( */
+	  CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+	  CHAR_ASTERISK: '*', /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: '&', /* & */
+	  CHAR_AT: '@', /* @ */
+	  CHAR_BACKSLASH: '\\', /* \ */
+	  CHAR_BACKTICK: '`', /* ` */
+	  CHAR_CARRIAGE_RETURN: '\r', /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+	  CHAR_COLON: ':', /* : */
+	  CHAR_COMMA: ',', /* , */
+	  CHAR_DOLLAR: '$', /* . */
+	  CHAR_DOT: '.', /* . */
+	  CHAR_DOUBLE_QUOTE: '"', /* " */
+	  CHAR_EQUAL: '=', /* = */
+	  CHAR_EXCLAMATION_MARK: '!', /* ! */
+	  CHAR_FORM_FEED: '\f', /* \f */
+	  CHAR_FORWARD_SLASH: '/', /* / */
+	  CHAR_HASH: '#', /* # */
+	  CHAR_HYPHEN_MINUS: '-', /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+	  CHAR_LEFT_CURLY_BRACE: '{', /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+	  CHAR_LINE_FEED: '\n', /* \n */
+	  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+	  CHAR_PERCENT: '%', /* % */
+	  CHAR_PLUS: '+', /* + */
+	  CHAR_QUESTION_MARK: '?', /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+	  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+	  CHAR_SEMICOLON: ';', /* ; */
+	  CHAR_SINGLE_QUOTE: '\'', /* ' */
+	  CHAR_SPACE: ' ', /*   */
+	  CHAR_TAB: '\t', /* \t */
+	  CHAR_UNDERSCORE: '_', /* _ */
+	  CHAR_VERTICAL_LINE: '|', /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+	};
+	return constants$1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const stringify = /*@__PURE__*/ requireStringify();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  CHAR_BACKSLASH, /* \ */
+	  CHAR_BACKTICK, /* ` */
+	  CHAR_COMMA, /* , */
+	  CHAR_DOT, /* . */
+	  CHAR_LEFT_PARENTHESES, /* ( */
+	  CHAR_RIGHT_PARENTHESES, /* ) */
+	  CHAR_LEFT_CURLY_BRACE, /* { */
+	  CHAR_RIGHT_CURLY_BRACE, /* } */
+	  CHAR_LEFT_SQUARE_BRACKET, /* [ */
+	  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+	  CHAR_DOUBLE_QUOTE, /* " */
+	  CHAR_SINGLE_QUOTE, /* ' */
+	  CHAR_NO_BREAK_SPACE,
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE
+	} = /*@__PURE__*/ requireConstants$1();
+
+	/**
+	 * parse
+	 */
+
+	const parse = (input, options = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  const opts = options || {};
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  if (input.length > max) {
+	    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+	  }
+
+	  const ast = { type: 'root', input, nodes: [] };
+	  const stack = [ast];
+	  let block = ast;
+	  let prev = ast;
+	  let brackets = 0;
+	  const length = input.length;
+	  let index = 0;
+	  let depth = 0;
+	  let value;
+
+	  /**
+	   * Helpers
+	   */
+
+	  const advance = () => input[index++];
+	  const push = node => {
+	    if (node.type === 'text' && prev.type === 'dot') {
+	      prev.type = 'text';
+	    }
+
+	    if (prev && prev.type === 'text' && node.type === 'text') {
+	      prev.value += node.value;
+	      return;
+	    }
+
+	    block.nodes.push(node);
+	    node.parent = block;
+	    node.prev = prev;
+	    prev = node;
+	    return node;
+	  };
+
+	  push({ type: 'bos' });
+
+	  while (index < length) {
+	    block = stack[stack.length - 1];
+	    value = advance();
+
+	    /**
+	     * Invalid chars
+	     */
+
+	    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped chars
+	     */
+
+	    if (value === CHAR_BACKSLASH) {
+	      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+	      continue;
+	    }
+
+	    /**
+	     * Right square bracket (literal): ']'
+	     */
+
+	    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+	      push({ type: 'text', value: '\\' + value });
+	      continue;
+	    }
+
+	    /**
+	     * Left square bracket: '['
+	     */
+
+	    if (value === CHAR_LEFT_SQUARE_BRACKET) {
+	      brackets++;
+
+	      let next;
+
+	      while (index < length && (next = advance())) {
+	        value += next;
+
+	        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+	          brackets++;
+	          continue;
+	        }
+
+	        if (next === CHAR_BACKSLASH) {
+	          value += advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          brackets--;
+
+	          if (brackets === 0) {
+	            break;
+	          }
+	        }
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === CHAR_LEFT_PARENTHESES) {
+	      block = push({ type: 'paren', nodes: [] });
+	      stack.push(block);
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    if (value === CHAR_RIGHT_PARENTHESES) {
+	      if (block.type !== 'paren') {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	      block = stack.pop();
+	      push({ type: 'text', value });
+	      block = stack[stack.length - 1];
+	      continue;
+	    }
+
+	    /**
+	     * Quotes: '|"|`
+	     */
+
+	    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+	      const open = value;
+	      let next;
+
+	      if (options.keepQuotes !== true) {
+	        value = '';
+	      }
+
+	      while (index < length && (next = advance())) {
+	        if (next === CHAR_BACKSLASH) {
+	          value += next + advance();
+	          continue;
+	        }
+
+	        if (next === open) {
+	          if (options.keepQuotes === true) value += next;
+	          break;
+	        }
+
+	        value += next;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Left curly brace: '{'
+	     */
+
+	    if (value === CHAR_LEFT_CURLY_BRACE) {
+	      depth++;
+
+	      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+	      const brace = {
+	        type: 'brace',
+	        open: true,
+	        close: false,
+	        dollar,
+	        depth,
+	        commas: 0,
+	        ranges: 0,
+	        nodes: []
+	      };
+
+	      block = push(brace);
+	      stack.push(block);
+	      push({ type: 'open', value });
+	      continue;
+	    }
+
+	    /**
+	     * Right curly brace: '}'
+	     */
+
+	    if (value === CHAR_RIGHT_CURLY_BRACE) {
+	      if (block.type !== 'brace') {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      const type = 'close';
+	      block = stack.pop();
+	      block.close = true;
+
+	      push({ type, value });
+	      depth--;
+
+	      block = stack[stack.length - 1];
+	      continue;
+	    }
+
+	    /**
+	     * Comma: ','
+	     */
+
+	    if (value === CHAR_COMMA && depth > 0) {
+	      if (block.ranges > 0) {
+	        block.ranges = 0;
+	        const open = block.nodes.shift();
+	        block.nodes = [open, { type: 'text', value: stringify(block) }];
+	      }
+
+	      push({ type: 'comma', value });
+	      block.commas++;
+	      continue;
+	    }
+
+	    /**
+	     * Dot: '.'
+	     */
+
+	    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+	      const siblings = block.nodes;
+
+	      if (depth === 0 || siblings.length === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      if (prev.type === 'dot') {
+	        block.range = [];
+	        prev.value += value;
+	        prev.type = 'range';
+
+	        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+	          block.invalid = true;
+	          block.ranges = 0;
+	          prev.type = 'text';
+	          continue;
+	        }
+
+	        block.ranges++;
+	        block.args = [];
+	        continue;
+	      }
+
+	      if (prev.type === 'range') {
+	        siblings.pop();
+
+	        const before = siblings[siblings.length - 1];
+	        before.value += prev.value + value;
+	        prev = before;
+	        block.ranges--;
+	        continue;
+	      }
+
+	      push({ type: 'dot', value });
+	      continue;
+	    }
+
+	    /**
+	     * Text
+	     */
+
+	    push({ type: 'text', value });
+	  }
+
+	  // Mark imbalanced braces and brackets as invalid
+	  do {
+	    block = stack.pop();
+
+	    if (block.type !== 'root') {
+	      block.nodes.forEach(node => {
+	        if (!node.nodes) {
+	          if (node.type === 'open') node.isOpen = true;
+	          if (node.type === 'close') node.isClose = true;
+	          if (!node.nodes) node.type = 'text';
+	          node.invalid = true;
+	        }
+	      });
+
+	      // get the location of the block on parent.nodes (block's siblings)
+	      const parent = stack[stack.length - 1];
+	      const index = parent.nodes.indexOf(block);
+	      // replace the (invalid) block with it's nodes
+	      parent.nodes.splice(index, 1, ...block.nodes);
+	    }
+	  } while (stack.length > 0);
+
+	  push({ type: 'eos' });
+	  return ast;
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+var braces_1;
+var hasRequiredBraces;
+
+function requireBraces () {
+	if (hasRequiredBraces) return braces_1;
+	hasRequiredBraces = 1;
+
+	const stringify = /*@__PURE__*/ requireStringify();
+	const compile = /*@__PURE__*/ requireCompile();
+	const expand = /*@__PURE__*/ requireExpand();
+	const parse = /*@__PURE__*/ requireParse();
+
+	/**
+	 * Expand the given pattern or create a regex-compatible string.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+	 * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {String}
+	 * @api public
+	 */
+
+	const braces = (input, options = {}) => {
+	  let output = [];
+
+	  if (Array.isArray(input)) {
+	    for (const pattern of input) {
+	      const result = braces.create(pattern, options);
+	      if (Array.isArray(result)) {
+	        output.push(...result);
+	      } else {
+	        output.push(result);
+	      }
+	    }
+	  } else {
+	    output = [].concat(braces.create(input, options));
+	  }
+
+	  if (options && options.expand === true && options.nodupes === true) {
+	    output = [...new Set(output)];
+	  }
+	  return output;
+	};
+
+	/**
+	 * Parse the given `str` with the given `options`.
+	 *
+	 * ```js
+	 * // braces.parse(pattern, [, options]);
+	 * const ast = braces.parse('a/{b,c}/d');
+	 * console.log(ast);
+	 * ```
+	 * @param {String} pattern Brace pattern to parse
+	 * @param {Object} options
+	 * @return {Object} Returns an AST
+	 * @api public
+	 */
+
+	braces.parse = (input, options = {}) => parse(input, options);
+
+	/**
+	 * Creates a braces string from an AST, or an AST node.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * let ast = braces.parse('foo/{a,b}/bar');
+	 * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+	 * ```
+	 * @param {String} `input` Brace pattern or AST.
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.stringify = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    return stringify(braces.parse(input, options), options);
+	  }
+	  return stringify(input, options);
+	};
+
+	/**
+	 * Compiles a brace pattern into a regex-compatible, optimized string.
+	 * This method is called by the main [braces](#braces) function by default.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.compile('a/{b,c}/d'));
+	 * //=> ['a/(b|c)/d']
+	 * ```
+	 * @param {String} `input` Brace pattern or AST.
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.compile = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    input = braces.parse(input, options);
+	  }
+	  return compile(input, options);
+	};
+
+	/**
+	 * Expands a brace pattern into an array. This method is called by the
+	 * main [braces](#braces) function when `options.expand` is true. Before
+	 * using this method it's recommended that you read the [performance notes](#performance))
+	 * and advantages of using [.compile](#compile) instead.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.expand('a/{b,c}/d'));
+	 * //=> ['a/b/d', 'a/c/d'];
+	 * ```
+	 * @param {String} `pattern` Brace pattern
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.expand = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    input = braces.parse(input, options);
+	  }
+
+	  let result = expand(input, options);
+
+	  // filter out empty strings if specified
+	  if (options.noempty === true) {
+	    result = result.filter(Boolean);
+	  }
+
+	  // filter out duplicates if specified
+	  if (options.nodupes === true) {
+	    result = [...new Set(result)];
+	  }
+
+	  return result;
+	};
+
+	/**
+	 * Processes a brace pattern and returns either an expanded array
+	 * (if `options.expand` is true), a highly optimized regex-compatible string.
+	 * This method is called by the main [braces](#braces) function.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+	 * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+	 * ```
+	 * @param {String} `pattern` Brace pattern
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.create = (input, options = {}) => {
+	  if (input === '' || input.length < 3) {
+	    return [input];
+	  }
+
+	  return options.expand !== true
+	    ? braces.compile(input, options)
+	    : braces.expand(input, options);
+	};
+
+	/**
+	 * Expose "braces"
+	 */
+
+	braces_1 = braces;
+	return braces_1;
+}
+
+const require$$0 = [
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+];
+
+var binaryExtensions;
+var hasRequiredBinaryExtensions;
+
+function requireBinaryExtensions () {
+	if (hasRequiredBinaryExtensions) return binaryExtensions;
+	hasRequiredBinaryExtensions = 1;
+	binaryExtensions = require$$0;
+	return binaryExtensions;
+}
+
+var isBinaryPath;
+var hasRequiredIsBinaryPath;
+
+function requireIsBinaryPath () {
+	if (hasRequiredIsBinaryPath) return isBinaryPath;
+	hasRequiredIsBinaryPath = 1;
+	const path = require$$0$1;
+	const binaryExtensions = /*@__PURE__*/ requireBinaryExtensions();
+
+	const extensions = new Set(binaryExtensions);
+
+	isBinaryPath = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
+	return isBinaryPath;
+}
+
+var constants = {};
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	(function (exports) {
+
+		const {sep} = require$$0$1;
+		const {platform} = process;
+		const os = require$$2$1;
+
+		exports.EV_ALL = 'all';
+		exports.EV_READY = 'ready';
+		exports.EV_ADD = 'add';
+		exports.EV_CHANGE = 'change';
+		exports.EV_ADD_DIR = 'addDir';
+		exports.EV_UNLINK = 'unlink';
+		exports.EV_UNLINK_DIR = 'unlinkDir';
+		exports.EV_RAW = 'raw';
+		exports.EV_ERROR = 'error';
+
+		exports.STR_DATA = 'data';
+		exports.STR_END = 'end';
+		exports.STR_CLOSE = 'close';
+
+		exports.FSEVENT_CREATED = 'created';
+		exports.FSEVENT_MODIFIED = 'modified';
+		exports.FSEVENT_DELETED = 'deleted';
+		exports.FSEVENT_MOVED = 'moved';
+		exports.FSEVENT_CLONED = 'cloned';
+		exports.FSEVENT_UNKNOWN = 'unknown';
+		exports.FSEVENT_FLAG_MUST_SCAN_SUBDIRS = 1;
+		exports.FSEVENT_TYPE_FILE = 'file';
+		exports.FSEVENT_TYPE_DIRECTORY = 'directory';
+		exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+
+		exports.KEY_LISTENERS = 'listeners';
+		exports.KEY_ERR = 'errHandlers';
+		exports.KEY_RAW = 'rawEmitters';
+		exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+
+		exports.DOT_SLASH = `.${sep}`;
+
+		exports.BACK_SLASH_RE = /\\/g;
+		exports.DOUBLE_SLASH_RE = /\/\//;
+		exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+		exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+		exports.REPLACER_RE = /^\.[/\\]/;
+
+		exports.SLASH = '/';
+		exports.SLASH_SLASH = '//';
+		exports.BRACE_START = '{';
+		exports.BANG = '!';
+		exports.ONE_DOT = '.';
+		exports.TWO_DOTS = '..';
+		exports.STAR = '*';
+		exports.GLOBSTAR = '**';
+		exports.ROOT_GLOBSTAR = '/**/*';
+		exports.SLASH_GLOBSTAR = '/**';
+		exports.DIR_SUFFIX = 'Dir';
+		exports.ANYMATCH_OPTS = {dot: true};
+		exports.STRING_TYPE = 'string';
+		exports.FUNCTION_TYPE = 'function';
+		exports.EMPTY_STR = '';
+		exports.EMPTY_FN = () => {};
+		exports.IDENTITY_FN = val => val;
+
+		exports.isWindows = platform === 'win32';
+		exports.isMacos = platform === 'darwin';
+		exports.isLinux = platform === 'linux';
+		exports.isIBMi = os.type() === 'OS400'; 
+	} (constants));
+	return constants;
+}
+
+var nodefsHandler;
+var hasRequiredNodefsHandler;
+
+function requireNodefsHandler () {
+	if (hasRequiredNodefsHandler) return nodefsHandler;
+	hasRequiredNodefsHandler = 1;
+
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const isBinaryPath = /*@__PURE__*/ requireIsBinaryPath();
+	const {
+	  isWindows,
+	  isLinux,
+	  EMPTY_FN,
+	  EMPTY_STR,
+	  KEY_LISTENERS,
+	  KEY_ERR,
+	  KEY_RAW,
+	  HANDLER_KEYS,
+	  EV_CHANGE,
+	  EV_ADD,
+	  EV_ADD_DIR,
+	  EV_ERROR,
+	  STR_DATA,
+	  STR_END,
+	  BRACE_START,
+	  STAR
+	} = /*@__PURE__*/ requireConstants();
+
+	const THROTTLE_MODE_WATCH = 'watch';
+
+	const open = promisify(fs.open);
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const close = promisify(fs.close);
+	const fsrealpath = promisify(fs.realpath);
+
+	const statMethods = { lstat, stat };
+
+	// TODO: emit errors properly. Example: EMFILE on Macos.
+	const foreach = (val, fn) => {
+	  if (val instanceof Set) {
+	    val.forEach(fn);
+	  } else {
+	    fn(val);
+	  }
+	};
+
+	const addAndConvert = (main, prop, item) => {
+	  let container = main[prop];
+	  if (!(container instanceof Set)) {
+	    main[prop] = container = new Set([container]);
+	  }
+	  container.add(item);
+	};
+
+	const clearItem = cont => key => {
+	  const set = cont[key];
+	  if (set instanceof Set) {
+	    set.clear();
+	  } else {
+	    delete cont[key];
+	  }
+	};
+
+	const delFromSet = (main, prop, item) => {
+	  const container = main[prop];
+	  if (container instanceof Set) {
+	    container.delete(item);
+	  } else if (container === item) {
+	    delete main[prop];
+	  }
+	};
+
+	const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+
+	/**
+	 * @typedef {String} Path
+	 */
+
+	// fs_watch helpers
+
+	// object to hold per-process fs_watch instances
+	// (may be shared across chokidar FSWatcher instances)
+
+	/**
+	 * @typedef {Object} FsWatchContainer
+	 * @property {Set} listeners
+	 * @property {Set} errHandlers
+	 * @property {Set} rawEmitters
+	 * @property {fs.FSWatcher=} watcher
+	 * @property {Boolean=} watcherUnusable
+	 */
+
+	/**
+	 * @type {Map<String,FsWatchContainer>}
+	 */
+	const FsWatchInstances = new Map();
+
+	/**
+	 * Instantiates the fs_watch interface
+	 * @param {String} path to be watched
+	 * @param {Object} options to be passed to fs_watch
+	 * @param {Function} listener main event handler
+	 * @param {Function} errHandler emits info about errors
+	 * @param {Function} emitRaw emits raw event data
+	 * @returns {fs.FSWatcher} new fsevents instance
+	 */
+	function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+	  const handleEvent = (rawEvent, evPath) => {
+	    listener(path);
+	    emitRaw(rawEvent, evPath, {watchedPath: path});
+
+	    // emit based on events occurring for files from a directory's watcher in
+	    // case the file's watcher misses it (and rely on throttling to de-dupe)
+	    if (evPath && path !== evPath) {
+	      fsWatchBroadcast(
+	        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
+	      );
+	    }
+	  };
+	  try {
+	    return fs.watch(path, options, handleEvent);
+	  } catch (error) {
+	    errHandler(error);
+	  }
+	}
+
+	/**
+	 * Helper for passing fs_watch event data to a collection of listeners
+	 * @param {Path} fullPath absolute path bound to fs_watch instance
+	 * @param {String} type listener type
+	 * @param {*=} val1 arguments to be passed to listeners
+	 * @param {*=} val2
+	 * @param {*=} val3
+	 */
+	const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+	  const cont = FsWatchInstances.get(fullPath);
+	  if (!cont) return;
+	  foreach(cont[type], (listener) => {
+	    listener(val1, val2, val3);
+	  });
+	};
+
+	/**
+	 * Instantiates the fs_watch interface or binds listeners
+	 * to an existing one covering the same file system entry
+	 * @param {String} path
+	 * @param {String} fullPath absolute path
+	 * @param {Object} options to be passed to fs_watch
+	 * @param {Object} handlers container for event listener functions
+	 */
+	const setFsWatchListener = (path, fullPath, options, handlers) => {
+	  const {listener, errHandler, rawEmitter} = handlers;
+	  let cont = FsWatchInstances.get(fullPath);
+
+	  /** @type {fs.FSWatcher=} */
+	  let watcher;
+	  if (!options.persistent) {
+	    watcher = createFsWatchInstance(
+	      path, options, listener, errHandler, rawEmitter
+	    );
+	    return watcher.close.bind(watcher);
+	  }
+	  if (cont) {
+	    addAndConvert(cont, KEY_LISTENERS, listener);
+	    addAndConvert(cont, KEY_ERR, errHandler);
+	    addAndConvert(cont, KEY_RAW, rawEmitter);
+	  } else {
+	    watcher = createFsWatchInstance(
+	      path,
+	      options,
+	      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+	      errHandler, // no need to use broadcast here
+	      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+	    );
+	    if (!watcher) return;
+	    watcher.on(EV_ERROR, async (error) => {
+	      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+	      cont.watcherUnusable = true; // documented since Node 10.4.1
+	      // Workaround for https://github.com/joyent/node/issues/4337
+	      if (isWindows && error.code === 'EPERM') {
+	        try {
+	          const fd = await open(path, 'r');
+	          await close(fd);
+	          broadcastErr(error);
+	        } catch (err) {}
+	      } else {
+	        broadcastErr(error);
+	      }
+	    });
+	    cont = {
+	      listeners: listener,
+	      errHandlers: errHandler,
+	      rawEmitters: rawEmitter,
+	      watcher
+	    };
+	    FsWatchInstances.set(fullPath, cont);
+	  }
+	  // const index = cont.listeners.indexOf(listener);
+
+	  // removes this instance's listeners and closes the underlying fs_watch
+	  // instance if there are no more listeners left
+	  return () => {
+	    delFromSet(cont, KEY_LISTENERS, listener);
+	    delFromSet(cont, KEY_ERR, errHandler);
+	    delFromSet(cont, KEY_RAW, rawEmitter);
+	    if (isEmptySet(cont.listeners)) {
+	      // Check to protect against issue gh-730.
+	      // if (cont.watcherUnusable) {
+	      cont.watcher.close();
+	      // }
+	      FsWatchInstances.delete(fullPath);
+	      HANDLER_KEYS.forEach(clearItem(cont));
+	      cont.watcher = undefined;
+	      Object.freeze(cont);
+	    }
+	  };
+	};
+
+	// fs_watchFile helpers
+
+	// object to hold per-process fs_watchFile instances
+	// (may be shared across chokidar FSWatcher instances)
+	const FsWatchFileInstances = new Map();
+
+	/**
+	 * Instantiates the fs_watchFile interface or binds listeners
+	 * to an existing one covering the same file system entry
+	 * @param {String} path to be watched
+	 * @param {String} fullPath absolute path
+	 * @param {Object} options options to be passed to fs_watchFile
+	 * @param {Object} handlers container for event listener functions
+	 * @returns {Function} closer
+	 */
+	const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	  const {listener, rawEmitter} = handlers;
+	  let cont = FsWatchFileInstances.get(fullPath);
+
+	  const copts = cont && cont.options;
+	  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+	    fs.unwatchFile(fullPath);
+	    cont = undefined;
+	  }
+
+	  /* eslint-enable no-unused-vars, prefer-destructuring */
+
+	  if (cont) {
+	    addAndConvert(cont, KEY_LISTENERS, listener);
+	    addAndConvert(cont, KEY_RAW, rawEmitter);
+	  } else {
+	    // TODO
+	    // listeners.add(listener);
+	    // rawEmitters.add(rawEmitter);
+	    cont = {
+	      listeners: listener,
+	      rawEmitters: rawEmitter,
+	      options,
+	      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
+	        foreach(cont.rawEmitters, (rawEmitter) => {
+	          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
+	        });
+	        const currmtime = curr.mtimeMs;
+	        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+	          foreach(cont.listeners, (listener) => listener(path, curr));
+	        }
+	      })
+	    };
+	    FsWatchFileInstances.set(fullPath, cont);
+	  }
+	  // const index = cont.listeners.indexOf(listener);
+
+	  // Removes this instance's listeners and closes the underlying fs_watchFile
+	  // instance if there are no more listeners left.
+	  return () => {
+	    delFromSet(cont, KEY_LISTENERS, listener);
+	    delFromSet(cont, KEY_RAW, rawEmitter);
+	    if (isEmptySet(cont.listeners)) {
+	      FsWatchFileInstances.delete(fullPath);
+	      fs.unwatchFile(fullPath);
+	      cont.options = cont.watcher = undefined;
+	      Object.freeze(cont);
+	    }
+	  };
+	};
+
+	/**
+	 * @mixin
+	 */
+	class NodeFsHandler {
+
+	/**
+	 * @param {import("../index").FSWatcher} fsW
+	 */
+	constructor(fsW) {
+	  this.fsw = fsW;
+	  this._boundHandleError = (error) => fsW._handleError(error);
+	}
+
+	/**
+	 * Watch file for changes with fs_watchFile or fs_watch.
+	 * @param {String} path to file or dir
+	 * @param {Function} listener on fs change
+	 * @returns {Function} closer for the watcher instance
+	 */
+	_watchWithNodeFs(path, listener) {
+	  const opts = this.fsw.options;
+	  const directory = sysPath.dirname(path);
+	  const basename = sysPath.basename(path);
+	  const parent = this.fsw._getWatchedDir(directory);
+	  parent.add(basename);
+	  const absolutePath = sysPath.resolve(path);
+	  const options = {persistent: opts.persistent};
+	  if (!listener) listener = EMPTY_FN;
+
+	  let closer;
+	  if (opts.usePolling) {
+	    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+	      opts.binaryInterval : opts.interval;
+	    closer = setFsWatchFileListener(path, absolutePath, options, {
+	      listener,
+	      rawEmitter: this.fsw._emitRaw
+	    });
+	  } else {
+	    closer = setFsWatchListener(path, absolutePath, options, {
+	      listener,
+	      errHandler: this._boundHandleError,
+	      rawEmitter: this.fsw._emitRaw
+	    });
+	  }
+	  return closer;
+	}
+
+	/**
+	 * Watch a file and emit add event if warranted.
+	 * @param {Path} file Path
+	 * @param {fs.Stats} stats result of fs_stat
+	 * @param {Boolean} initialAdd was the file added at watch instantiation?
+	 * @returns {Function} closer for the watcher instance
+	 */
+	_handleFile(file, stats, initialAdd) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const dirname = sysPath.dirname(file);
+	  const basename = sysPath.basename(file);
+	  const parent = this.fsw._getWatchedDir(dirname);
+	  // stats is always present
+	  let prevStats = stats;
+
+	  // if the file is already being watched, do nothing
+	  if (parent.has(basename)) return;
+
+	  const listener = async (path, newStats) => {
+	    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+	    if (!newStats || newStats.mtimeMs === 0) {
+	      try {
+	        const newStats = await stat(file);
+	        if (this.fsw.closed) return;
+	        // Check that change event was not fired because of changed only accessTime.
+	        const at = newStats.atimeMs;
+	        const mt = newStats.mtimeMs;
+	        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+	          this.fsw._emit(EV_CHANGE, file, newStats);
+	        }
+	        if (isLinux && prevStats.ino !== newStats.ino) {
+	          this.fsw._closeFile(path);
+	          prevStats = newStats;
+	          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+	        } else {
+	          prevStats = newStats;
+	        }
+	      } catch (error) {
+	        // Fix issues where mtime is null but file is still present
+	        this.fsw._remove(dirname, basename);
+	      }
+	      // add is about to be emitted if file not already tracked in parent
+	    } else if (parent.has(basename)) {
+	      // Check that change event was not fired because of changed only accessTime.
+	      const at = newStats.atimeMs;
+	      const mt = newStats.mtimeMs;
+	      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+	        this.fsw._emit(EV_CHANGE, file, newStats);
+	      }
+	      prevStats = newStats;
+	    }
+	  };
+	  // kick off the watcher
+	  const closer = this._watchWithNodeFs(file, listener);
+
+	  // emit an add event if we're supposed to
+	  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+	    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
+	    this.fsw._emit(EV_ADD, file, stats);
+	  }
+
+	  return closer;
+	}
+
+	/**
+	 * Handle symlinks encountered while reading a dir.
+	 * @param {Object} entry returned by readdirp
+	 * @param {String} directory path of dir being read
+	 * @param {String} path of this item
+	 * @param {String} item basename of this item
+	 * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+	 */
+	async _handleSymlink(entry, directory, path, item) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const full = entry.fullPath;
+	  const dir = this.fsw._getWatchedDir(directory);
+
+	  if (!this.fsw.options.followSymlinks) {
+	    // watch symlink directly (don't follow) and detect changes
+	    this.fsw._incrReadyCount();
+
+	    let linkPath;
+	    try {
+	      linkPath = await fsrealpath(path);
+	    } catch (e) {
+	      this.fsw._emitReady();
+	      return true;
+	    }
+
+	    if (this.fsw.closed) return;
+	    if (dir.has(item)) {
+	      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+	        this.fsw._symlinkPaths.set(full, linkPath);
+	        this.fsw._emit(EV_CHANGE, path, entry.stats);
+	      }
+	    } else {
+	      dir.add(item);
+	      this.fsw._symlinkPaths.set(full, linkPath);
+	      this.fsw._emit(EV_ADD, path, entry.stats);
+	    }
+	    this.fsw._emitReady();
+	    return true;
+	  }
+
+	  // don't follow the same symlink more than once
+	  if (this.fsw._symlinkPaths.has(full)) {
+	    return true;
+	  }
+
+	  this.fsw._symlinkPaths.set(full, true);
+	}
+
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+	  // Normalize the directory name on Windows
+	  directory = sysPath.join(directory, EMPTY_STR);
+
+	  if (!wh.hasGlob) {
+	    throttler = this.fsw._throttle('readdir', directory, 1000);
+	    if (!throttler) return;
+	  }
+
+	  const previous = this.fsw._getWatchedDir(wh.path);
+	  const current = new Set();
+
+	  let stream = this.fsw._readdirp(directory, {
+	    fileFilter: entry => wh.filterPath(entry),
+	    directoryFilter: entry => wh.filterDir(entry),
+	    depth: 0
+	  }).on(STR_DATA, async (entry) => {
+	    if (this.fsw.closed) {
+	      stream = undefined;
+	      return;
+	    }
+	    const item = entry.path;
+	    let path = sysPath.join(directory, item);
+	    current.add(item);
+
+	    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+	      return;
+	    }
+
+	    if (this.fsw.closed) {
+	      stream = undefined;
+	      return;
+	    }
+	    // Files that present in current directory snapshot
+	    // but absent in previous are added to watch list and
+	    // emit `add` event.
+	    if (item === target || !target && !previous.has(item)) {
+	      this.fsw._incrReadyCount();
+
+	      // ensure relativeness of path is preserved in case of watcher reuse
+	      path = sysPath.join(dir, sysPath.relative(dir, path));
+
+	      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+	    }
+	  }).on(EV_ERROR, this._boundHandleError);
+
+	  return new Promise(resolve =>
+	    stream.once(STR_END, () => {
+	      if (this.fsw.closed) {
+	        stream = undefined;
+	        return;
+	      }
+	      const wasThrottled = throttler ? throttler.clear() : false;
+
+	      resolve();
+
+	      // Files that absent in current directory snapshot
+	      // but present in previous emit `remove` event
+	      // and are removed from @watched[directory].
+	      previous.getChildren().filter((item) => {
+	        return item !== directory &&
+	          !current.has(item) &&
+	          // in case of intersecting globs;
+	          // a path may have been filtered out of this readdir, but
+	          // shouldn't be removed because it matches a different glob
+	          (!wh.hasGlob || wh.filterPath({
+	            fullPath: sysPath.resolve(directory, item)
+	          }));
+	      }).forEach((item) => {
+	        this.fsw._remove(directory, item);
+	      });
+
+	      stream = undefined;
+
+	      // one more time for any missed in case changes came in extremely quickly
+	      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+	    })
+	  );
+	}
+
+	/**
+	 * Read directory to add / remove files from `@watched` list and re-read it on change.
+	 * @param {String} dir fs path
+	 * @param {fs.Stats} stats
+	 * @param {Boolean} initialAdd
+	 * @param {Number} depth relative to user-supplied path
+	 * @param {String} target child path targeted for watch
+	 * @param {Object} wh Common watch helpers for this path
+	 * @param {String} realpath
+	 * @returns {Promise<Function>} closer for the watcher instance.
+	 */
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+	  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+	  const tracked = parentDir.has(sysPath.basename(dir));
+	  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+	    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
+	  }
+
+	  // ensure dir is tracked (harmless if redundant)
+	  parentDir.add(sysPath.basename(dir));
+	  this.fsw._getWatchedDir(dir);
+	  let throttler;
+	  let closer;
+
+	  const oDepth = this.fsw.options.depth;
+	  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+	    if (!target) {
+	      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+	      if (this.fsw.closed) return;
+	    }
+
+	    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+	      // if current directory is removed, do nothing
+	      if (stats && stats.mtimeMs === 0) return;
+
+	      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+	    });
+	  }
+	  return closer;
+	}
+
+	/**
+	 * Handle added file, directory, or glob pattern.
+	 * Delegates call to _handleFile / _handleDir after checks.
+	 * @param {String} path to file or ir
+	 * @param {Boolean} initialAdd was the file added at watch instantiation?
+	 * @param {Object} priorWh depth relative to user-supplied path
+	 * @param {Number} depth Child path actually targeted for watch
+	 * @param {String=} target Child path actually targeted for watch
+	 * @returns {Promise}
+	 */
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+	  const ready = this.fsw._emitReady;
+	  if (this.fsw._isIgnored(path) || this.fsw.closed) {
+	    ready();
+	    return false;
+	  }
+
+	  const wh = this.fsw._getWatchHelpers(path, depth);
+	  if (!wh.hasGlob && priorWh) {
+	    wh.hasGlob = priorWh.hasGlob;
+	    wh.globFilter = priorWh.globFilter;
+	    wh.filterPath = entry => priorWh.filterPath(entry);
+	    wh.filterDir = entry => priorWh.filterDir(entry);
+	  }
+
+	  // evaluate what is at the path we're being asked to watch
+	  try {
+	    const stats = await statMethods[wh.statMethod](wh.watchPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+	      ready();
+	      return false;
+	    }
+
+	    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START);
+	    let closer;
+	    if (stats.isDirectory()) {
+	      const absPath = sysPath.resolve(path);
+	      const targetPath = follow ? await fsrealpath(path) : path;
+	      if (this.fsw.closed) return;
+	      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+	      if (this.fsw.closed) return;
+	      // preserve this symlink's target path
+	      if (absPath !== targetPath && targetPath !== undefined) {
+	        this.fsw._symlinkPaths.set(absPath, targetPath);
+	      }
+	    } else if (stats.isSymbolicLink()) {
+	      const targetPath = follow ? await fsrealpath(path) : path;
+	      if (this.fsw.closed) return;
+	      const parent = sysPath.dirname(wh.watchPath);
+	      this.fsw._getWatchedDir(parent).add(wh.watchPath);
+	      this.fsw._emit(EV_ADD, wh.watchPath, stats);
+	      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+	      if (this.fsw.closed) return;
+
+	      // preserve this symlink's target path
+	      if (targetPath !== undefined) {
+	        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+	      }
+	    } else {
+	      closer = this._handleFile(wh.watchPath, stats, initialAdd);
+	    }
+	    ready();
+
+	    this.fsw._addPathCloser(path, closer);
+	    return false;
+
+	  } catch (error) {
+	    if (this.fsw._handleError(error)) {
+	      ready();
+	      return path;
+	    }
+	  }
+	}
+
+	}
+
+	nodefsHandler = NodeFsHandler;
+	return nodefsHandler;
+}
+
+var fseventsHandler = {exports: {}};
+
+const require$$3 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
+
+var hasRequiredFseventsHandler;
+
+function requireFseventsHandler () {
+	if (hasRequiredFseventsHandler) return fseventsHandler.exports;
+	hasRequiredFseventsHandler = 1;
+
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+
+	let fsevents;
+	try {
+	  fsevents = require$$3.getFsEvents();
+	} catch (error) {
+	  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+	}
+
+	if (fsevents) {
+	  // TODO: real check
+	  const mtch = process.version.match(/v(\d+)\.(\d+)/);
+	  if (mtch && mtch[1] && mtch[2]) {
+	    const maj = Number.parseInt(mtch[1], 10);
+	    const min = Number.parseInt(mtch[2], 10);
+	    if (maj === 8 && min < 16) {
+	      fsevents = undefined;
+	    }
+	  }
+	}
+
+	const {
+	  EV_ADD,
+	  EV_CHANGE,
+	  EV_ADD_DIR,
+	  EV_UNLINK,
+	  EV_ERROR,
+	  STR_DATA,
+	  STR_END,
+	  FSEVENT_CREATED,
+	  FSEVENT_MODIFIED,
+	  FSEVENT_DELETED,
+	  FSEVENT_MOVED,
+	  // FSEVENT_CLONED,
+	  FSEVENT_UNKNOWN,
+	  FSEVENT_FLAG_MUST_SCAN_SUBDIRS,
+	  FSEVENT_TYPE_FILE,
+	  FSEVENT_TYPE_DIRECTORY,
+	  FSEVENT_TYPE_SYMLINK,
+
+	  ROOT_GLOBSTAR,
+	  DIR_SUFFIX,
+	  DOT_SLASH,
+	  FUNCTION_TYPE,
+	  EMPTY_FN,
+	  IDENTITY_FN
+	} = /*@__PURE__*/ requireConstants();
+
+	const Depth = (value) => isNaN(value) ? {} : {depth: value};
+
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const realpath = promisify(fs.realpath);
+
+	const statMethods = { stat, lstat };
+
+	/**
+	 * @typedef {String} Path
+	 */
+
+	/**
+	 * @typedef {Object} FsEventsWatchContainer
+	 * @property {Set<Function>} listeners
+	 * @property {Function} rawEmitter
+	 * @property {{stop: Function}} watcher
+	 */
+
+	// fsevents instance helper functions
+	/**
+	 * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+	 * @type {Map<Path,FsEventsWatchContainer>}
+	 */
+	const FSEventsWatchers = new Map();
+
+	// Threshold of duplicate path prefixes at which to start
+	// consolidating going forward
+	const consolidateThreshhold = 10;
+
+	const wrongEventFlags = new Set([
+	  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
+	]);
+
+	/**
+	 * Instantiates the fsevents interface
+	 * @param {Path} path path to be watched
+	 * @param {Function} callback called when fsevents is bound and ready
+	 * @returns {{stop: Function}} new fsevents instance
+	 */
+	const createFSEventsInstance = (path, callback) => {
+	  const stop = fsevents.watch(path, callback);
+	  return {stop};
+	};
+
+	/**
+	 * Instantiates the fsevents interface or binds listeners to an existing one covering
+	 * the same file tree.
+	 * @param {Path} path           - to be watched
+	 * @param {Path} realPath       - real path for symlinks
+	 * @param {Function} listener   - called when fsevents emits events
+	 * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+	 * @returns {Function} closer
+	 */
+	function setFSEventsListener(path, realPath, listener, rawEmitter) {
+	  let watchPath = sysPath.extname(realPath) ? sysPath.dirname(realPath) : realPath;
+
+	  const parentPath = sysPath.dirname(watchPath);
+	  let cont = FSEventsWatchers.get(watchPath);
+
+	  // If we've accumulated a substantial number of paths that
+	  // could have been consolidated by watching one directory
+	  // above the current one, create a watcher on the parent
+	  // path instead, so that we do consolidate going forward.
+	  if (couldConsolidate(parentPath)) {
+	    watchPath = parentPath;
+	  }
+
+	  const resolvedPath = sysPath.resolve(path);
+	  const hasSymlink = resolvedPath !== realPath;
+
+	  const filteredListener = (fullPath, flags, info) => {
+	    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+	    if (
+	      fullPath === resolvedPath ||
+	      !fullPath.indexOf(resolvedPath + sysPath.sep)
+	    ) listener(fullPath, flags, info);
+	  };
+
+	  // check if there is already a watcher on a parent path
+	  // modifies `watchPath` to the parent path when it finds a match
+	  let watchedParent = false;
+	  for (const watchedPath of FSEventsWatchers.keys()) {
+	    if (realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep) === 0) {
+	      watchPath = watchedPath;
+	      cont = FSEventsWatchers.get(watchPath);
+	      watchedParent = true;
+	      break;
+	    }
+	  }
+
+	  if (cont || watchedParent) {
+	    cont.listeners.add(filteredListener);
+	  } else {
+	    cont = {
+	      listeners: new Set([filteredListener]),
+	      rawEmitter,
+	      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+	        if (!cont.listeners.size) return;
+	        if (flags & FSEVENT_FLAG_MUST_SCAN_SUBDIRS) return;
+	        const info = fsevents.getInfo(fullPath, flags);
+	        cont.listeners.forEach(list => {
+	          list(fullPath, flags, info);
+	        });
+
+	        cont.rawEmitter(info.event, fullPath, info);
+	      })
+	    };
+	    FSEventsWatchers.set(watchPath, cont);
+	  }
+
+	  // removes this instance's listeners and closes the underlying fsevents
+	  // instance if there are no more listeners left
+	  return () => {
+	    const lst = cont.listeners;
+
+	    lst.delete(filteredListener);
+	    if (!lst.size) {
+	      FSEventsWatchers.delete(watchPath);
+	      if (cont.watcher) return cont.watcher.stop().then(() => {
+	        cont.rawEmitter = cont.watcher = undefined;
+	        Object.freeze(cont);
+	      });
+	    }
+	  };
+	}
+
+	// Decide whether or not we should start a new higher-level
+	// parent watcher
+	const couldConsolidate = (path) => {
+	  let count = 0;
+	  for (const watchPath of FSEventsWatchers.keys()) {
+	    if (watchPath.indexOf(path) === 0) {
+	      count++;
+	      if (count >= consolidateThreshhold) {
+	        return true;
+	      }
+	    }
+	  }
+
+	  return false;
+	};
+
+	// returns boolean indicating whether fsevents can be used
+	const canUse = () => fsevents && FSEventsWatchers.size < 128;
+
+	// determines subdirectory traversal levels from root to path
+	const calcDepth = (path, root) => {
+	  let i = 0;
+	  while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
+	  return i;
+	};
+
+	// returns boolean indicating whether the fsevents' event info has the same type
+	// as the one returned by fs.stat
+	const sameTypes = (info, stats) => (
+	  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+	  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+	  info.type === FSEVENT_TYPE_FILE && stats.isFile()
+	);
+
+	/**
+	 * @mixin
+	 */
+	class FsEventsHandler {
+
+	/**
+	 * @param {import('../index').FSWatcher} fsw
+	 */
+	constructor(fsw) {
+	  this.fsw = fsw;
+	}
+	checkIgnored(path, stats) {
+	  const ipaths = this.fsw._ignoredPaths;
+	  if (this.fsw._isIgnored(path, stats)) {
+	    ipaths.add(path);
+	    if (stats && stats.isDirectory()) {
+	      ipaths.add(path + ROOT_GLOBSTAR);
+	    }
+	    return true;
+	  }
+
+	  ipaths.delete(path);
+	  ipaths.delete(path + ROOT_GLOBSTAR);
+	}
+
+	addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  const event = watchedDir.has(item) ? EV_CHANGE : EV_ADD;
+	  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	}
+
+	async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  try {
+	    const stats = await stat(path);
+	    if (this.fsw.closed) return;
+	    if (sameTypes(info, stats)) {
+	      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    } else {
+	      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    }
+	  } catch (error) {
+	    if (error.code === 'EACCES') {
+	      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    } else {
+	      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    }
+	  }
+	}
+
+	handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  if (this.fsw.closed || this.checkIgnored(path)) return;
+
+	  if (event === EV_UNLINK) {
+	    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+	    // suppress unlink events on never before seen files
+	    if (isDirectory || watchedDir.has(item)) {
+	      this.fsw._remove(parent, item, isDirectory);
+	    }
+	  } else {
+	    if (event === EV_ADD) {
+	      // track new directories
+	      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+
+	      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+	        // push symlinks back to the top of the stack to get handled
+	        const curDepth = opts.depth === undefined ?
+	          undefined : calcDepth(fullPath, realPath) + 1;
+	        return this._addToFsEvents(path, false, true, curDepth);
+	      }
+
+	      // track new paths
+	      // (other than symlinks being followed, which will be tracked soon)
+	      this.fsw._getWatchedDir(parent).add(item);
+	    }
+	    /**
+	     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+	     */
+	    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+	    this.fsw._emit(eventName, path);
+	    if (eventName === EV_ADD_DIR) this._addToFsEvents(path, false, true);
+	  }
+	}
+
+	/**
+	 * Handle symlinks encountered during directory scan
+	 * @param {String} watchPath  - file/dir path to be watched with fsevents
+	 * @param {String} realPath   - real path (in case of symlinks)
+	 * @param {Function} transform  - path transformer
+	 * @param {Function} globFilter - path filter in case a glob pattern was provided
+	 * @returns {Function} closer for the watcher instance
+	*/
+	_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+	  if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+	  const opts = this.fsw.options;
+	  const watchCallback = async (fullPath, flags, info) => {
+	    if (this.fsw.closed) return;
+	    if (
+	      opts.depth !== undefined &&
+	      calcDepth(fullPath, realPath) > opts.depth
+	    ) return;
+	    const path = transform(sysPath.join(
+	      watchPath, sysPath.relative(watchPath, fullPath)
+	    ));
+	    if (globFilter && !globFilter(path)) return;
+	    // ensure directories are tracked
+	    const parent = sysPath.dirname(path);
+	    const item = sysPath.basename(path);
+	    const watchedDir = this.fsw._getWatchedDir(
+	      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+	    );
+
+	    // correct for wrong events emitted
+	    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
+	      if (typeof opts.ignored === FUNCTION_TYPE) {
+	        let stats;
+	        try {
+	          stats = await stat(path);
+	        } catch (error) {}
+	        if (this.fsw.closed) return;
+	        if (this.checkIgnored(path, stats)) return;
+	        if (sameTypes(info, stats)) {
+	          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	        } else {
+	          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	        }
+	      } else {
+	        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      }
+	    } else {
+	      switch (info.event) {
+	      case FSEVENT_CREATED:
+	      case FSEVENT_MODIFIED:
+	        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      case FSEVENT_DELETED:
+	      case FSEVENT_MOVED:
+	        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      }
+	    }
+	  };
+
+	  const closer = setFSEventsListener(
+	    watchPath,
+	    realPath,
+	    watchCallback,
+	    this.fsw._emitRaw
+	  );
+
+	  this.fsw._emitReady();
+	  return closer;
+	}
+
+	/**
+	 * Handle symlinks encountered during directory scan
+	 * @param {String} linkPath path to symlink
+	 * @param {String} fullPath absolute path to the symlink
+	 * @param {Function} transform pre-existing path transformer
+	 * @param {Number} curDepth level of subdirectories traversed to where symlink is
+	 * @returns {Promise<void>}
+	 */
+	async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+	  // don't follow the same symlink more than once
+	  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+
+	  this.fsw._symlinkPaths.set(fullPath, true);
+	  this.fsw._incrReadyCount();
+
+	  try {
+	    const linkTarget = await realpath(linkPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(linkTarget)) {
+	      return this.fsw._emitReady();
+	    }
+
+	    this.fsw._incrReadyCount();
+
+	    // add the linkTarget for watching with a wrapper for transform
+	    // that causes emitted paths to incorporate the link's path
+	    this._addToFsEvents(linkTarget || linkPath, (path) => {
+	      let aliasedPath = linkPath;
+	      if (linkTarget && linkTarget !== DOT_SLASH) {
+	        aliasedPath = path.replace(linkTarget, linkPath);
+	      } else if (path !== DOT_SLASH) {
+	        aliasedPath = sysPath.join(linkPath, path);
+	      }
+	      return transform(aliasedPath);
+	    }, false, curDepth);
+	  } catch(error) {
+	    if (this.fsw._handleError(error)) {
+	      return this.fsw._emitReady();
+	    }
+	  }
+	}
+
+	/**
+	 *
+	 * @param {Path} newPath
+	 * @param {fs.Stats} stats
+	 */
+	emitAdd(newPath, stats, processPath, opts, forceAdd) {
+	  const pp = processPath(newPath);
+	  const isDir = stats.isDirectory();
+	  const dirObj = this.fsw._getWatchedDir(sysPath.dirname(pp));
+	  const base = sysPath.basename(pp);
+
+	  // ensure empty dirs get tracked
+	  if (isDir) this.fsw._getWatchedDir(pp);
+	  if (dirObj.has(base)) return;
+	  dirObj.add(base);
+
+	  if (!opts.ignoreInitial || forceAdd === true) {
+	    this.fsw._emit(isDir ? EV_ADD_DIR : EV_ADD, pp, stats);
+	  }
+	}
+
+	initWatch(realPath, path, wh, processPath) {
+	  if (this.fsw.closed) return;
+	  const closer = this._watchWithFsEvents(
+	    wh.watchPath,
+	    sysPath.resolve(realPath || wh.watchPath),
+	    processPath,
+	    wh.globFilter
+	  );
+	  this.fsw._addPathCloser(path, closer);
+	}
+
+	/**
+	 * Handle added path with fsevents
+	 * @param {String} path file/dir path or glob pattern
+	 * @param {Function|Boolean=} transform converts working path to what the user expects
+	 * @param {Boolean=} forceAdd ensure add is emitted
+	 * @param {Number=} priorDepth Level of subdirectories already traversed.
+	 * @returns {Promise<void>}
+	 */
+	async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const opts = this.fsw.options;
+	  const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
+
+	  const wh = this.fsw._getWatchHelpers(path);
+
+	  // evaluate what is at the path we're being asked to watch
+	  try {
+	    const stats = await statMethods[wh.statMethod](wh.watchPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+	      throw null;
+	    }
+	    if (stats.isDirectory()) {
+	      // emit addDir unless this is a glob parent
+	      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+
+	      // don't recurse further if it would exceed depth setting
+	      if (priorDepth && priorDepth > opts.depth) return;
+
+	      // scan the contents of the dir
+	      this.fsw._readdirp(wh.watchPath, {
+	        fileFilter: entry => wh.filterPath(entry),
+	        directoryFilter: entry => wh.filterDir(entry),
+	        ...Depth(opts.depth - (priorDepth || 0))
+	      }).on(STR_DATA, (entry) => {
+	        // need to check filterPath on dirs b/c filterDir is less restrictive
+	        if (this.fsw.closed) {
+	          return;
+	        }
+	        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+
+	        const joinedPath = sysPath.join(wh.watchPath, entry.path);
+	        const {fullPath} = entry;
+
+	        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+	          // preserve the current depth here since it can't be derived from
+	          // real paths past the symlink
+	          const curDepth = opts.depth === undefined ?
+	            undefined : calcDepth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;
+
+	          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+	        } else {
+	          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+	        }
+	      }).on(EV_ERROR, EMPTY_FN).on(STR_END, () => {
+	        this.fsw._emitReady();
+	      });
+	    } else {
+	      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+	      this.fsw._emitReady();
+	    }
+	  } catch (error) {
+	    if (!error || this.fsw._handleError(error)) {
+	      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
+	      this.fsw._emitReady();
+	      this.fsw._emitReady();
+	    }
+	  }
+
+	  if (opts.persistent && forceAdd !== true) {
+	    if (typeof transform === FUNCTION_TYPE) {
+	      // realpath has already been resolved
+	      this.initWatch(undefined, path, wh, processPath);
+	    } else {
+	      let realPath;
+	      try {
+	        realPath = await realpath(wh.watchPath);
+	      } catch (e) {}
+	      this.initWatch(realPath, path, wh, processPath);
+	    }
+	  }
+	}
+
+	}
+
+	fseventsHandler.exports = FsEventsHandler;
+	fseventsHandler.exports.canUse = canUse;
+	return fseventsHandler.exports;
+}
+
+var hasRequiredChokidar;
+
+function requireChokidar () {
+	if (hasRequiredChokidar) return chokidar$1;
+	hasRequiredChokidar = 1;
+
+	const { EventEmitter } = require$$0$3;
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const readdirp = /*@__PURE__*/ requireReaddirp();
+	const anymatch = /*@__PURE__*/ requireAnymatch().default;
+	const globParent = /*@__PURE__*/ requireGlobParent();
+	const isGlob = /*@__PURE__*/ requireIsGlob();
+	const braces = /*@__PURE__*/ requireBraces();
+	const normalizePath = /*@__PURE__*/ requireNormalizePath();
+
+	const NodeFsHandler = /*@__PURE__*/ requireNodefsHandler();
+	const FsEventsHandler = /*@__PURE__*/ requireFseventsHandler();
+	const {
+	  EV_ALL,
+	  EV_READY,
+	  EV_ADD,
+	  EV_CHANGE,
+	  EV_UNLINK,
+	  EV_ADD_DIR,
+	  EV_UNLINK_DIR,
+	  EV_RAW,
+	  EV_ERROR,
+
+	  STR_CLOSE,
+	  STR_END,
+
+	  BACK_SLASH_RE,
+	  DOUBLE_SLASH_RE,
+	  SLASH_OR_BACK_SLASH_RE,
+	  DOT_RE,
+	  REPLACER_RE,
+
+	  SLASH,
+	  SLASH_SLASH,
+	  BRACE_START,
+	  BANG,
+	  ONE_DOT,
+	  TWO_DOTS,
+	  GLOBSTAR,
+	  SLASH_GLOBSTAR,
+	  ANYMATCH_OPTS,
+	  STRING_TYPE,
+	  FUNCTION_TYPE,
+	  EMPTY_STR,
+	  EMPTY_FN,
+
+	  isWindows,
+	  isMacos,
+	  isIBMi
+	} = /*@__PURE__*/ requireConstants();
+
+	const stat = promisify(fs.stat);
+	const readdir = promisify(fs.readdir);
+
+	/**
+	 * @typedef {String} Path
+	 * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+	 * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+	 */
+
+	/**
+	 *
+	 * @typedef {Object} WatchHelpers
+	 * @property {Boolean} followSymlinks
+	 * @property {'stat'|'lstat'} statMethod
+	 * @property {Path} path
+	 * @property {Path} watchPath
+	 * @property {Function} entryPath
+	 * @property {Boolean} hasGlob
+	 * @property {Object} globFilter
+	 * @property {Function} filterPath
+	 * @property {Function} filterDir
+	 */
+
+	const arrify = (value = []) => Array.isArray(value) ? value : [value];
+	const flatten = (list, result = []) => {
+	  list.forEach(item => {
+	    if (Array.isArray(item)) {
+	      flatten(item, result);
+	    } else {
+	      result.push(item);
+	    }
+	  });
+	  return result;
+	};
+
+	const unifyPaths = (paths_) => {
+	  /**
+	   * @type {Array<String>}
+	   */
+	  const paths = flatten(arrify(paths_));
+	  if (!paths.every(p => typeof p === STRING_TYPE)) {
+	    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	  }
+	  return paths.map(normalizePathToUnix);
+	};
+
+	// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+	//     because "//StoragePC/DrivePool/Movies" is a valid network path
+	const toUnix = (string) => {
+	  let str = string.replace(BACK_SLASH_RE, SLASH);
+	  let prepend = false;
+	  if (str.startsWith(SLASH_SLASH)) {
+	    prepend = true;
+	  }
+	  while (str.match(DOUBLE_SLASH_RE)) {
+	    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	  }
+	  if (prepend) {
+	    str = SLASH + str;
+	  }
+	  return str;
+	};
+
+	// Our version of upath.normalize
+	// TODO: this is not equal to path-normalize module - investigate why
+	const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+
+	const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+	  if (typeof path !== STRING_TYPE) return path;
+	  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+	};
+
+	const getAbsolutePath = (path, cwd) => {
+	  if (sysPath.isAbsolute(path)) {
+	    return path;
+	  }
+	  if (path.startsWith(BANG)) {
+	    return BANG + sysPath.join(cwd, path.slice(1));
+	  }
+	  return sysPath.join(cwd, path);
+	};
+
+	const undef = (opts, key) => opts[key] === undefined;
+
+	/**
+	 * Directory entry.
+	 * @property {Path} path
+	 * @property {Set<Path>} items
+	 */
+	class DirEntry {
+	  /**
+	   * @param {Path} dir
+	   * @param {Function} removeWatcher
+	   */
+	  constructor(dir, removeWatcher) {
+	    this.path = dir;
+	    this._removeWatcher = removeWatcher;
+	    /** @type {Set<Path>} */
+	    this.items = new Set();
+	  }
+
+	  add(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	  }
+
+	  async remove(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    items.delete(item);
+	    if (items.size > 0) return;
+
+	    const dir = this.path;
+	    try {
+	      await readdir(dir);
+	    } catch (err) {
+	      if (this._removeWatcher) {
+	        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+	      }
+	    }
+	  }
+
+	  has(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    return items.has(item);
+	  }
+
+	  /**
+	   * @returns {Array<String>}
+	   */
+	  getChildren() {
+	    const {items} = this;
+	    if (!items) return;
+	    return [...items.values()];
+	  }
+
+	  dispose() {
+	    this.items.clear();
+	    delete this.path;
+	    delete this._removeWatcher;
+	    delete this.items;
+	    Object.freeze(this);
+	  }
+	}
+
+	const STAT_METHOD_F = 'stat';
+	const STAT_METHOD_L = 'lstat';
+	class WatchHelper {
+	  constructor(path, watchPath, follow, fsw) {
+	    this.fsw = fsw;
+	    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+	    this.watchPath = watchPath;
+	    this.fullWatchPath = sysPath.resolve(watchPath);
+	    this.hasGlob = watchPath !== path;
+	    /** @type {object|boolean} */
+	    if (path === EMPTY_STR) this.hasGlob = false;
+	    this.globSymlink = this.hasGlob && follow ? undefined : false;
+	    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
+	    this.dirParts = this.getDirParts(path);
+	    this.dirParts.forEach((parts) => {
+	      if (parts.length > 1) parts.pop();
+	    });
+	    this.followSymlinks = follow;
+	    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	  }
+
+	  checkGlobSymlink(entry) {
+	    // only need to resolve once
+	    // first entry should always have entry.parentDir === EMPTY_STR
+	    if (this.globSymlink === undefined) {
+	      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
+	        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+	    }
+
+	    if (this.globSymlink) {
+	      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+	    }
+
+	    return entry.fullPath;
+	  }
+
+	  entryPath(entry) {
+	    return sysPath.join(this.watchPath,
+	      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+	    );
+	  }
+
+	  filterPath(entry) {
+	    const {stats} = entry;
+	    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+	    const resolvedPath = this.entryPath(entry);
+	    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
+	      this.globFilter(resolvedPath) : true;
+	    return matchesGlob &&
+	      this.fsw._isntIgnored(resolvedPath, stats) &&
+	      this.fsw._hasReadPermissions(stats);
+	  }
+
+	  getDirParts(path) {
+	    if (!this.hasGlob) return [];
+	    const parts = [];
+	    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+	    expandedPath.forEach((path) => {
+	      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+	    });
+	    return parts;
+	  }
+
+	  filterDir(entry) {
+	    if (this.hasGlob) {
+	      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+	      let globstar = false;
+	      this.unmatchedGlob = !this.dirParts.some((parts) => {
+	        return parts.every((part, i) => {
+	          if (part === GLOBSTAR) globstar = true;
+	          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+	        });
+	      });
+	    }
+	    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	  }
+	}
+
+	/**
+	 * Watches files & directories for changes. Emitted events:
+	 * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+	 *
+	 *     new FSWatcher()
+	 *       .add(directories)
+	 *       .on('add', path => log('File', path, 'was added'))
+	 */
+	class FSWatcher extends EventEmitter {
+	// Not indenting methods for history sake; for now.
+	constructor(_opts) {
+	  super();
+
+	  const opts = {};
+	  if (_opts) Object.assign(opts, _opts); // for frozen objects
+
+	  /** @type {Map<String, DirEntry>} */
+	  this._watched = new Map();
+	  /** @type {Map<String, Array>} */
+	  this._closers = new Map();
+	  /** @type {Set<String>} */
+	  this._ignoredPaths = new Set();
+
+	  /** @type {Map<ThrottleType, Map>} */
+	  this._throttled = new Map();
+
+	  /** @type {Map<Path, String|Boolean>} */
+	  this._symlinkPaths = new Map();
+
+	  this._streams = new Set();
+	  this.closed = false;
+
+	  // Set up default options.
+	  if (undef(opts, 'persistent')) opts.persistent = true;
+	  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
+	  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
+	  if (undef(opts, 'interval')) opts.interval = 100;
+	  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
+	  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
+	  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+
+	  // Enable fsevents on OS X when polling isn't explicitly enabled.
+	  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+
+	  // If we can't use fsevents, ensure the options reflect it's disabled.
+	  const canUseFsEvents = FsEventsHandler.canUse();
+	  if (!canUseFsEvents) opts.useFsEvents = false;
+
+	  // Use polling on Mac if not using fsevents.
+	  // Other platforms use non-polling fs_watch.
+	  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
+	    opts.usePolling = isMacos;
+	  }
+
+	  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+	  if(isIBMi) {
+	    opts.usePolling = true;
+	  }
+
+	  // Global override (useful for end-developers that need to force polling for all
+	  // instances of chokidar, regardless of usage/dependency depth)
+	  const envPoll = process.env.CHOKIDAR_USEPOLLING;
+	  if (envPoll !== undefined) {
+	    const envLower = envPoll.toLowerCase();
+
+	    if (envLower === 'false' || envLower === '0') {
+	      opts.usePolling = false;
+	    } else if (envLower === 'true' || envLower === '1') {
+	      opts.usePolling = true;
+	    } else {
+	      opts.usePolling = !!envLower;
+	    }
+	  }
+	  const envInterval = process.env.CHOKIDAR_INTERVAL;
+	  if (envInterval) {
+	    opts.interval = Number.parseInt(envInterval, 10);
+	  }
+
+	  // Editor atomic write normalization enabled by default with fs.watch
+	  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+	  if (opts.atomic) this._pendingUnlinks = new Map();
+
+	  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+
+	  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
+	  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+	  const awf = opts.awaitWriteFinish;
+	  if (awf) {
+	    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
+	    if (!awf.pollInterval) awf.pollInterval = 100;
+	    this._pendingWrites = new Map();
+	  }
+	  if (opts.ignored) opts.ignored = arrify(opts.ignored);
+
+	  let readyCalls = 0;
+	  this._emitReady = () => {
+	    readyCalls++;
+	    if (readyCalls >= this._readyCount) {
+	      this._emitReady = EMPTY_FN;
+	      this._readyEmitted = true;
+	      // use process.nextTick to allow time for listener to be bound
+	      process.nextTick(() => this.emit(EV_READY));
+	    }
+	  };
+	  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+	  this._readyEmitted = false;
+	  this.options = opts;
+
+	  // Initialize with proper watcher.
+	  if (opts.useFsEvents) {
+	    this._fsEventsHandler = new FsEventsHandler(this);
+	  } else {
+	    this._nodeFsHandler = new NodeFsHandler(this);
+	  }
+
+	  // You’re frozen when your heart’s not open.
+	  Object.freeze(opts);
+	}
+
+	// Public methods
+
+	/**
+	 * Adds paths to be watched on an existing FSWatcher instance
+	 * @param {Path|Array<Path>} paths_
+	 * @param {String=} _origAdd private; for handling non-existent paths to be watched
+	 * @param {Boolean=} _internal private; indicates a non-user add
+	 * @returns {FSWatcher} for chaining
+	 */
+	add(paths_, _origAdd, _internal) {
+	  const {cwd, disableGlobbing} = this.options;
+	  this.closed = false;
+	  let paths = unifyPaths(paths_);
+	  if (cwd) {
+	    paths = paths.map((path) => {
+	      const absPath = getAbsolutePath(path, cwd);
+
+	      // Check `path` instead of `absPath` because the cwd portion can't be a glob
+	      if (disableGlobbing || !isGlob(path)) {
+	        return absPath;
+	      }
+	      return normalizePath(absPath);
+	    });
+	  }
+
+	  // set aside negated glob strings
+	  paths = paths.filter((path) => {
+	    if (path.startsWith(BANG)) {
+	      this._ignoredPaths.add(path.slice(1));
+	      return false;
+	    }
+
+	    // if a path is being added that was previously ignored, stop ignoring it
+	    this._ignoredPaths.delete(path);
+	    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+
+	    // reset the cached userIgnored anymatch fn
+	    // to make ignoredPaths changes effective
+	    this._userIgnored = undefined;
+
+	    return true;
+	  });
+
+	  if (this.options.useFsEvents && this._fsEventsHandler) {
+	    if (!this._readyCount) this._readyCount = paths.length;
+	    if (this.options.persistent) this._readyCount += paths.length;
+	    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+	  } else {
+	    if (!this._readyCount) this._readyCount = 0;
+	    this._readyCount += paths.length;
+	    Promise.all(
+	      paths.map(async path => {
+	        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+	        if (res) this._emitReady();
+	        return res;
+	      })
+	    ).then(results => {
+	      if (this.closed) return;
+	      results.filter(item => item).forEach(item => {
+	        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+	      });
+	    });
+	  }
+
+	  return this;
+	}
+
+	/**
+	 * Close watchers or start ignoring events from specified paths.
+	 * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+	 * @returns {FSWatcher} for chaining
+	*/
+	unwatch(paths_) {
+	  if (this.closed) return this;
+	  const paths = unifyPaths(paths_);
+	  const {cwd} = this.options;
+
+	  paths.forEach((path) => {
+	    // convert to absolute path unless relative path already matches
+	    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+	      if (cwd) path = sysPath.join(cwd, path);
+	      path = sysPath.resolve(path);
+	    }
+
+	    this._closePath(path);
+
+	    this._ignoredPaths.add(path);
+	    if (this._watched.has(path)) {
+	      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+	    }
+
+	    // reset the cached userIgnored anymatch fn
+	    // to make ignoredPaths changes effective
+	    this._userIgnored = undefined;
+	  });
+
+	  return this;
+	}
+
+	/**
+	 * Close watchers and remove all listeners from watched paths.
+	 * @returns {Promise<void>}.
+	*/
+	close() {
+	  if (this.closed) return this._closePromise;
+	  this.closed = true;
+
+	  // Memory management.
+	  this.removeAllListeners();
+	  const closers = [];
+	  this._closers.forEach(closerList => closerList.forEach(closer => {
+	    const promise = closer();
+	    if (promise instanceof Promise) closers.push(promise);
+	  }));
+	  this._streams.forEach(stream => stream.destroy());
+	  this._userIgnored = undefined;
+	  this._readyCount = 0;
+	  this._readyEmitted = false;
+	  this._watched.forEach(dirent => dirent.dispose());
+	  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
+	    this[`_${key}`].clear();
+	  });
+
+	  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+	  return this._closePromise;
+	}
+
+	/**
+	 * Expose list of watched paths
+	 * @returns {Object} for chaining
+	*/
+	getWatched() {
+	  const watchList = {};
+	  this._watched.forEach((entry, dir) => {
+	    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+	    watchList[key || ONE_DOT] = entry.getChildren().sort();
+	  });
+	  return watchList;
+	}
+
+	emitWithAll(event, args) {
+	  this.emit(...args);
+	  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+	}
+
+	// Common helpers
+	// --------------
+
+	/**
+	 * Normalize and emit events.
+	 * Calling _emit DOES NOT MEAN emit() would be called!
+	 * @param {EventName} event Type of event
+	 * @param {Path} path File or directory path
+	 * @param {*=} val1 arguments to be passed with event
+	 * @param {*=} val2
+	 * @param {*=} val3
+	 * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	 */
+	async _emit(event, path, val1, val2, val3) {
+	  if (this.closed) return;
+
+	  const opts = this.options;
+	  if (isWindows) path = sysPath.normalize(path);
+	  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+	  /** @type Array<any> */
+	  const args = [event, path];
+	  if (val3 !== undefined) args.push(val1, val2, val3);
+	  else if (val2 !== undefined) args.push(val1, val2);
+	  else if (val1 !== undefined) args.push(val1);
+
+	  const awf = opts.awaitWriteFinish;
+	  let pw;
+	  if (awf && (pw = this._pendingWrites.get(path))) {
+	    pw.lastChange = new Date();
+	    return this;
+	  }
+
+	  if (opts.atomic) {
+	    if (event === EV_UNLINK) {
+	      this._pendingUnlinks.set(path, args);
+	      setTimeout(() => {
+	        this._pendingUnlinks.forEach((entry, path) => {
+	          this.emit(...entry);
+	          this.emit(EV_ALL, ...entry);
+	          this._pendingUnlinks.delete(path);
+	        });
+	      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+	      return this;
+	    }
+	    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+	      event = args[0] = EV_CHANGE;
+	      this._pendingUnlinks.delete(path);
+	    }
+	  }
+
+	  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+	    const awfEmit = (err, stats) => {
+	      if (err) {
+	        event = args[0] = EV_ERROR;
+	        args[1] = err;
+	        this.emitWithAll(event, args);
+	      } else if (stats) {
+	        // if stats doesn't exist the file must have been deleted
+	        if (args.length > 2) {
+	          args[2] = stats;
+	        } else {
+	          args.push(stats);
+	        }
+	        this.emitWithAll(event, args);
+	      }
+	    };
+
+	    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+	    return this;
+	  }
+
+	  if (event === EV_CHANGE) {
+	    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+	    if (isThrottled) return this;
+	  }
+
+	  if (opts.alwaysStat && val1 === undefined &&
+	    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
+	  ) {
+	    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+	    let stats;
+	    try {
+	      stats = await stat(fullPath);
+	    } catch (err) {}
+	    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+	    if (!stats || this.closed) return;
+	    args.push(stats);
+	  }
+	  this.emitWithAll(event, args);
+
+	  return this;
+	}
+
+	/**
+	 * Common handler for errors
+	 * @param {Error} error
+	 * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	 */
+	_handleError(error) {
+	  const code = error && error.code;
+	  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
+	    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
+	  ) {
+	    this.emit(EV_ERROR, error);
+	  }
+	  return error || this.closed;
+	}
+
+	/**
+	 * Helper utility for throttling
+	 * @param {ThrottleType} actionType type being throttled
+	 * @param {Path} path being acted upon
+	 * @param {Number} timeout duration of time to suppress duplicate actions
+	 * @returns {Object|false} tracking object or false if action should be suppressed
+	 */
+	_throttle(actionType, path, timeout) {
+	  if (!this._throttled.has(actionType)) {
+	    this._throttled.set(actionType, new Map());
+	  }
+
+	  /** @type {Map<Path, Object>} */
+	  const action = this._throttled.get(actionType);
+	  /** @type {Object} */
+	  const actionPath = action.get(path);
+
+	  if (actionPath) {
+	    actionPath.count++;
+	    return false;
+	  }
+
+	  let timeoutObject;
+	  const clear = () => {
+	    const item = action.get(path);
+	    const count = item ? item.count : 0;
+	    action.delete(path);
+	    clearTimeout(timeoutObject);
+	    if (item) clearTimeout(item.timeoutObject);
+	    return count;
+	  };
+	  timeoutObject = setTimeout(clear, timeout);
+	  const thr = {timeoutObject, clear, count: 0};
+	  action.set(path, thr);
+	  return thr;
+	}
+
+	_incrReadyCount() {
+	  return this._readyCount++;
+	}
+
+	/**
+	 * Awaits write operation to finish.
+	 * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	 * @param {Path} path being acted upon
+	 * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	 * @param {EventName} event
+	 * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+	 */
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+	  let timeoutHandler;
+
+	  let fullPath = path;
+	  if (this.options.cwd && !sysPath.isAbsolute(path)) {
+	    fullPath = sysPath.join(this.options.cwd, path);
+	  }
+
+	  const now = new Date();
+
+	  const awaitWriteFinish = (prevStat) => {
+	    fs.stat(fullPath, (err, curStat) => {
+	      if (err || !this._pendingWrites.has(path)) {
+	        if (err && err.code !== 'ENOENT') awfEmit(err);
+	        return;
+	      }
+
+	      const now = Number(new Date());
+
+	      if (prevStat && curStat.size !== prevStat.size) {
+	        this._pendingWrites.get(path).lastChange = now;
+	      }
+	      const pw = this._pendingWrites.get(path);
+	      const df = now - pw.lastChange;
+
+	      if (df >= threshold) {
+	        this._pendingWrites.delete(path);
+	        awfEmit(undefined, curStat);
+	      } else {
+	        timeoutHandler = setTimeout(
+	          awaitWriteFinish,
+	          this.options.awaitWriteFinish.pollInterval,
+	          curStat
+	        );
+	      }
+	    });
+	  };
+
+	  if (!this._pendingWrites.has(path)) {
+	    this._pendingWrites.set(path, {
+	      lastChange: now,
+	      cancelWait: () => {
+	        this._pendingWrites.delete(path);
+	        clearTimeout(timeoutHandler);
+	        return event;
+	      }
+	    });
+	    timeoutHandler = setTimeout(
+	      awaitWriteFinish,
+	      this.options.awaitWriteFinish.pollInterval
+	    );
+	  }
+	}
+
+	_getGlobIgnored() {
+	  return [...this._ignoredPaths.values()];
+	}
+
+	/**
+	 * Determines whether user has asked to ignore this path.
+	 * @param {Path} path filepath or dir
+	 * @param {fs.Stats=} stats result of fs.stat
+	 * @returns {Boolean}
+	 */
+	_isIgnored(path, stats) {
+	  if (this.options.atomic && DOT_RE.test(path)) return true;
+	  if (!this._userIgnored) {
+	    const {cwd} = this.options;
+	    const ign = this.options.ignored;
+
+	    const ignored = ign && ign.map(normalizeIgnored(cwd));
+	    const paths = arrify(ignored)
+	      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+	      .map((path) => path + SLASH_GLOBSTAR);
+	    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+	    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+	  }
+
+	  return this._userIgnored([path, stats]);
+	}
+
+	_isntIgnored(path, stat) {
+	  return !this._isIgnored(path, stat);
+	}
+
+	/**
+	 * Provides a set of common helpers and properties relating to symlink and glob handling.
+	 * @param {Path} path file, directory, or glob pattern being watched
+	 * @param {Number=} depth at any depth > 0, this isn't a glob
+	 * @returns {WatchHelper} object containing helpers for this path
+	 */
+	_getWatchHelpers(path, depth) {
+	  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+	  const follow = this.options.followSymlinks;
+
+	  return new WatchHelper(path, watchPath, follow, this);
+	}
+
+	// Directory helpers
+	// -----------------
+
+	/**
+	 * Provides directory tracking objects
+	 * @param {String} directory path of the directory
+	 * @returns {DirEntry} the directory's tracking object
+	 */
+	_getWatchedDir(directory) {
+	  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+	  const dir = sysPath.resolve(directory);
+	  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+	  return this._watched.get(dir);
+	}
+
+	// File helpers
+	// ------------
+
+	/**
+	 * Check for read permissions.
+	 * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+	 * @param {fs.Stats} stats - object, result of fs_stat
+	 * @returns {Boolean} indicates whether the file can be read
+	*/
+	_hasReadPermissions(stats) {
+	  if (this.options.ignorePermissionErrors) return true;
+
+	  // stats.mode may be bigint
+	  const md = stats && Number.parseInt(stats.mode, 10);
+	  const st = md & 0o777;
+	  const it = Number.parseInt(st.toString(8)[0], 10);
+	  return Boolean(4 & it);
+	}
+
+	/**
+	 * Handles emitting unlink events for
+	 * files and directories, and via recursion, for
+	 * files and directories within directories that are unlinked
+	 * @param {String} directory within which the following item is located
+	 * @param {String} item      base path of item/directory
+	 * @returns {void}
+	*/
+	_remove(directory, item, isDirectory) {
+	  // if what is being deleted is a directory, get that directory's paths
+	  // for recursive deleting and cleaning of watched object
+	  // if it is not a directory, nestedDirectoryChildren will be empty array
+	  const path = sysPath.join(directory, item);
+	  const fullPath = sysPath.resolve(path);
+	  isDirectory = isDirectory != null
+	    ? isDirectory
+	    : this._watched.has(path) || this._watched.has(fullPath);
+
+	  // prevent duplicate handling in case of arriving here nearly simultaneously
+	  // via multiple paths (such as _handleFile and _handleDir)
+	  if (!this._throttle('remove', path, 100)) return;
+
+	  // if the only watched file is removed, watch for its return
+	  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+	    this.add(directory, item, true);
+	  }
+
+	  // This will create a new entry in the watched object in either case
+	  // so we got to do the directory check beforehand
+	  const wp = this._getWatchedDir(path);
+	  const nestedDirectoryChildren = wp.getChildren();
+
+	  // Recursively remove children directories / files.
+	  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+
+	  // Check if item was on the watched list and remove it
+	  const parent = this._getWatchedDir(directory);
+	  const wasTracked = parent.has(item);
+	  parent.remove(item);
+
+	  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+	  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+	  // but never removed from the map in case the path was deleted.
+	  // This leads to an incorrect state if the path was recreated:
+	  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+	  if (this._symlinkPaths.has(fullPath)) {
+	    this._symlinkPaths.delete(fullPath);
+	  }
+
+	  // If we wait for this file to be fully written, cancel the wait.
+	  let relPath = path;
+	  if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+	  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+	    const event = this._pendingWrites.get(relPath).cancelWait();
+	    if (event === EV_ADD) return;
+	  }
+
+	  // The Entry will either be a directory that just got removed
+	  // or a bogus entry to a file, in either case we have to remove it
+	  this._watched.delete(path);
+	  this._watched.delete(fullPath);
+	  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+	  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+
+	  // Avoid conflicts if we later create another file with the same name
+	  if (!this.options.useFsEvents) {
+	    this._closePath(path);
+	  }
+	}
+
+	/**
+	 * Closes all watchers for a path
+	 * @param {Path} path
+	 */
+	_closePath(path) {
+	  this._closeFile(path);
+	  const dir = sysPath.dirname(path);
+	  this._getWatchedDir(dir).remove(sysPath.basename(path));
+	}
+
+	/**
+	 * Closes only file-specific watchers
+	 * @param {Path} path
+	 */
+	_closeFile(path) {
+	  const closers = this._closers.get(path);
+	  if (!closers) return;
+	  closers.forEach(closer => closer());
+	  this._closers.delete(path);
+	}
+
+	/**
+	 *
+	 * @param {Path} path
+	 * @param {Function} closer
+	 */
+	_addPathCloser(path, closer) {
+	  if (!closer) return;
+	  let list = this._closers.get(path);
+	  if (!list) {
+	    list = [];
+	    this._closers.set(path, list);
+	  }
+	  list.push(closer);
+	}
+
+	_readdirp(root, opts) {
+	  if (this.closed) return;
+	  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
+	  let stream = readdirp(root, options);
+	  this._streams.add(stream);
+	  stream.once(STR_CLOSE, () => {
+	    stream = undefined;
+	  });
+	  stream.once(STR_END, () => {
+	    if (stream) {
+	      this._streams.delete(stream);
+	      stream = undefined;
+	    }
+	  });
+	  return stream;
+	}
+
+	}
+
+	// Export FSWatcher class
+	chokidar$1.FSWatcher = FSWatcher;
+
+	/**
+	 * Instantiates watcher with paths to be tracked.
+	 * @param {String|Array<String>} paths file/directory paths and/or globs
+	 * @param {Object=} options chokidar opts
+	 * @returns an instance of FSWatcher for chaining.
+	 */
+	const watch = (paths, options) => {
+	  const watcher = new FSWatcher(options);
+	  watcher.add(paths);
+	  return watcher;
+	};
+
+	chokidar$1.watch = watch;
+	return chokidar$1;
+}
+
+var chokidarExports = /*@__PURE__*/ requireChokidar();
+const chokidar = /*@__PURE__*/getDefaultExportFromCjs(chokidarExports);
+
+class FileWatcher {
+    constructor(task, chokidarOptions) {
+        this.transformWatchers = new Map();
+        this.chokidarOptions = chokidarOptions;
+        this.task = task;
+        this.watcher = this.createWatcher(null);
+    }
+    close() {
+        this.watcher.close();
+        for (const watcher of this.transformWatchers.values()) {
+            watcher.close();
+        }
+    }
+    unwatch(id) {
+        this.watcher.unwatch(id);
+        const transformWatcher = this.transformWatchers.get(id);
+        if (transformWatcher) {
+            this.transformWatchers.delete(id);
+            transformWatcher.close();
+        }
+    }
+    watch(id, isTransformDependency) {
+        if (isTransformDependency) {
+            const watcher = this.transformWatchers.get(id) ?? this.createWatcher(id);
+            watcher.add(id);
+            this.transformWatchers.set(id, watcher);
+        }
+        else {
+            this.watcher.add(id);
+        }
+    }
+    createWatcher(transformWatcherId) {
+        const task = this.task;
+        const isLinux = platform() === 'linux';
+        const isTransformDependency = transformWatcherId !== null;
+        const handleChange = (id, event) => {
+            const changedId = transformWatcherId || id;
+            if (isLinux) {
+                // unwatching and watching fixes an issue with chokidar where on certain systems,
+                // a file that was unlinked and immediately recreated would create a change event
+                // but then no longer any further events
+                watcher.unwatch(changedId);
+                watcher.add(changedId);
+            }
+            task.invalidate(changedId, { event, isTransformDependency });
+        };
+        const watcher = chokidar
+            .watch([], this.chokidarOptions)
+            .on('add', id => handleChange(id, 'create'))
+            .on('change', id => handleChange(id, 'update'))
+            .on('unlink', id => handleChange(id, 'delete'));
+        return watcher;
+    }
+}
+
+const eventsRewrites = {
+    create: {
+        create: 'buggy',
+        delete: null, //delete file from map
+        update: 'create'
+    },
+    delete: {
+        create: 'update',
+        delete: 'buggy',
+        update: 'buggy'
+    },
+    update: {
+        create: 'buggy',
+        delete: 'delete',
+        update: 'update'
+    }
+};
+class Watcher {
+    constructor(optionsList, emitter) {
+        this.buildDelay = 0;
+        this.buildTimeout = null;
+        this.closed = false;
+        this.invalidatedIds = new Map();
+        this.rerun = false;
+        this.running = true;
+        this.emitter = emitter;
+        emitter.close = this.close.bind(this);
+        this.tasks = optionsList.map(options => new Task(this, options));
+        for (const { watch } of optionsList) {
+            if (watch && typeof watch.buildDelay === 'number') {
+                this.buildDelay = Math.max(this.buildDelay, watch.buildDelay);
+            }
+        }
+        process$1.nextTick(() => this.run());
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        for (const task of this.tasks) {
+            task.close();
+        }
+        await this.emitter.emit('close');
+        this.emitter.removeAllListeners();
+    }
+    invalidate(file) {
+        if (file) {
+            const previousEvent = this.invalidatedIds.get(file.id);
+            const event = previousEvent ? eventsRewrites[previousEvent][file.event] : file.event;
+            if (event === 'buggy') {
+                //TODO: throws or warn? Currently just ignore, uses new event
+                this.invalidatedIds.set(file.id, file.event);
+            }
+            else if (event === null) {
+                this.invalidatedIds.delete(file.id);
+            }
+            else {
+                this.invalidatedIds.set(file.id, event);
+            }
+        }
+        if (this.running) {
+            this.rerun = true;
+            return;
+        }
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        this.buildTimeout = setTimeout(async () => {
+            this.buildTimeout = null;
+            try {
+                await Promise.all([...this.invalidatedIds].map(([id, event]) => this.emitter.emit('change', id, { event })));
+                this.invalidatedIds.clear();
+                await this.emitter.emit('restart');
+                this.emitter.removeListenersForCurrentRun();
+                this.run();
+            }
+            catch (error) {
+                this.invalidatedIds.clear();
+                await this.emitter.emit('event', {
+                    code: 'ERROR',
+                    error,
+                    result: null
+                });
+                await this.emitter.emit('event', {
+                    code: 'END'
+                });
+            }
+        }, this.buildDelay);
+    }
+    async run() {
+        this.running = true;
+        await this.emitter.emit('event', {
+            code: 'START'
+        });
+        for (const task of this.tasks) {
+            await task.run();
+        }
+        this.running = false;
+        await this.emitter.emit('event', {
+            code: 'END'
+        });
+        if (this.rerun) {
+            this.rerun = false;
+            this.invalidate();
+        }
+    }
+}
+class Task {
+    constructor(watcher, options) {
+        this.cache = { modules: [] };
+        this.watchFiles = [];
+        this.closed = false;
+        this.invalidated = true;
+        this.watched = new Set();
+        this.watcher = watcher;
+        this.options = options;
+        this.skipWrite = Boolean(options.watch && options.watch.skipWrite);
+        this.outputs = this.options.output;
+        this.outputFiles = this.outputs.map(output => {
+            if (output.file || output.dir)
+                return path.resolve(output.file || output.dir);
+            return undefined;
+        });
+        const watchOptions = this.options.watch || {};
+        this.filter = createFilter(watchOptions.include, watchOptions.exclude);
+        this.fileWatcher = new FileWatcher(this, {
+            ...watchOptions.chokidar,
+            disableGlobbing: true,
+            ignoreInitial: true
+        });
+    }
+    close() {
+        this.closed = true;
+        this.fileWatcher.close();
+    }
+    invalidate(id, details) {
+        this.invalidated = true;
+        if (details.isTransformDependency) {
+            for (const module of this.cache.modules) {
+                if (!module.transformDependencies.includes(id))
+                    continue;
+                // effective invalidation
+                module.originalCode = null;
+            }
+        }
+        this.watcher.invalidate({ event: details.event, id });
+    }
+    async run() {
+        if (!this.invalidated)
+            return;
+        this.invalidated = false;
+        const options = {
+            ...this.options,
+            cache: this.cache
+        };
+        const start = Date.now();
+        await this.watcher.emitter.emit('event', {
+            code: 'BUNDLE_START',
+            input: this.options.input,
+            output: this.outputFiles
+        });
+        let result = null;
+        try {
+            result = await rollupInternal(options, this.watcher.emitter);
+            if (this.closed) {
+                return;
+            }
+            this.updateWatchedFiles(result);
+            if (!this.skipWrite) {
+                await Promise.all(this.outputs.map(output => result.write(output)));
+                if (this.closed) {
+                    return;
+                }
+                this.updateWatchedFiles(result);
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'BUNDLE_END',
+                duration: Date.now() - start,
+                input: this.options.input,
+                output: this.outputFiles,
+                result
+            });
+        }
+        catch (error) {
+            if (!this.closed) {
+                if (Array.isArray(error.watchFiles)) {
+                    for (const id of error.watchFiles) {
+                        this.watchFile(id);
+                    }
+                }
+                if (error.id) {
+                    this.cache.modules = this.cache.modules.filter(module => module.id !== error.id);
+                }
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'ERROR',
+                error,
+                result
+            });
+        }
+    }
+    updateWatchedFiles(result) {
+        const previouslyWatched = this.watched;
+        this.watched = new Set();
+        this.watchFiles = result.watchFiles;
+        this.cache = result.cache;
+        for (const id of this.watchFiles) {
+            this.watchFile(id);
+        }
+        for (const module of this.cache.modules) {
+            for (const depId of module.transformDependencies) {
+                this.watchFile(depId, true);
+            }
+        }
+        for (const id of previouslyWatched) {
+            if (!this.watched.has(id)) {
+                this.fileWatcher.unwatch(id);
+            }
+        }
+    }
+    watchFile(id, isTransformDependency = false) {
+        if (!this.filter(id))
+            return;
+        this.watched.add(id);
+        if (this.outputFiles.includes(id)) {
+            throw new Error('Cannot import the generated bundle');
+        }
+        // this is necessary to ensure that any 'renamed' files
+        // continue to be watched following an error
+        this.fileWatcher.watch(id, isTransformDependency);
+    }
+}
+
+export { Task, Watcher };
diff --git a/node_modules/rollup/dist/getLogFilter.d.ts b/node_modules/rollup/dist/getLogFilter.d.ts
new file mode 100644
index 0000000..cc75d62
--- /dev/null
+++ b/node_modules/rollup/dist/getLogFilter.d.ts
@@ -0,0 +1,5 @@
+import type { RollupLog } from './rollup';
+
+export type GetLogFilter = typeof getLogFilter;
+
+export function getLogFilter(filters: string[]): (log: RollupLog) => boolean;
diff --git a/node_modules/rollup/dist/getLogFilter.js b/node_modules/rollup/dist/getLogFilter.js
new file mode 100644
index 0000000..8a459ff
--- /dev/null
+++ b/node_modules/rollup/dist/getLogFilter.js
@@ -0,0 +1,69 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const getLogFilter = filters => {
+    if (filters.length === 0)
+        return () => true;
+    const normalizedFilters = filters.map(filter => filter.split('&').map(subFilter => {
+        const inverted = subFilter.startsWith('!');
+        if (inverted)
+            subFilter = subFilter.slice(1);
+        const [key, ...value] = subFilter.split(':');
+        return { inverted, key: key.split('.'), parts: value.join(':').split('*') };
+    }));
+    return (log) => {
+        nextIntersectedFilter: for (const intersectedFilters of normalizedFilters) {
+            for (const { inverted, key, parts } of intersectedFilters) {
+                const isFilterSatisfied = testFilter(log, key, parts);
+                if (inverted ? isFilterSatisfied : !isFilterSatisfied) {
+                    continue nextIntersectedFilter;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+};
+const testFilter = (log, key, parts) => {
+    let rawValue = log;
+    for (let index = 0; index < key.length; index++) {
+        if (!rawValue) {
+            return false;
+        }
+        const part = key[index];
+        if (!(part in rawValue)) {
+            return false;
+        }
+        rawValue = rawValue[part];
+    }
+    let value = typeof rawValue === 'object' ? JSON.stringify(rawValue) : String(rawValue);
+    if (parts.length === 1) {
+        return value === parts[0];
+    }
+    if (!value.startsWith(parts[0])) {
+        return false;
+    }
+    const lastPartIndex = parts.length - 1;
+    for (let index = 1; index < lastPartIndex; index++) {
+        const part = parts[index];
+        const position = value.indexOf(part);
+        if (position === -1) {
+            return false;
+        }
+        value = value.slice(position + part.length);
+    }
+    return value.endsWith(parts[lastPartIndex]);
+};
+
+exports.getLogFilter = getLogFilter;
+//# sourceMappingURL=getLogFilter.js.map
diff --git a/node_modules/rollup/dist/loadConfigFile.d.ts b/node_modules/rollup/dist/loadConfigFile.d.ts
new file mode 100644
index 0000000..4306b09
--- /dev/null
+++ b/node_modules/rollup/dist/loadConfigFile.d.ts
@@ -0,0 +1,20 @@
+import type { LogHandler, MergedRollupOptions, RollupLog } from './rollup';
+
+export interface BatchWarnings {
+	add: (warning: RollupLog) => void;
+	readonly count: number;
+	flush: () => void;
+	log: LogHandler;
+	readonly warningOccurred: boolean;
+}
+
+export type LoadConfigFile = typeof loadConfigFile;
+
+export function loadConfigFile(
+	fileName: string,
+	commandOptions: any,
+	watchMode?: boolean
+): Promise<{
+	options: MergedRollupOptions[];
+	warnings: BatchWarnings;
+}>;
diff --git a/node_modules/rollup/dist/loadConfigFile.js b/node_modules/rollup/dist/loadConfigFile.js
new file mode 100644
index 0000000..1015a64
--- /dev/null
+++ b/node_modules/rollup/dist/loadConfigFile.js
@@ -0,0 +1,30 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('node:fs/promises');
+require('node:path');
+require('node:process');
+require('node:url');
+require('./shared/rollup.js');
+require('./shared/parseAst.js');
+const loadConfigFile_js = require('./shared/loadConfigFile.js');
+require('tty');
+require('path');
+require('./native.js');
+require('node:perf_hooks');
+require('./getLogFilter.js');
+
+
+
+exports.loadConfigFile = loadConfigFile_js.loadConfigFile;
+//# sourceMappingURL=loadConfigFile.js.map
diff --git a/node_modules/rollup/dist/native.js b/node_modules/rollup/dist/native.js
new file mode 100644
index 0000000..e0d54b8
--- /dev/null
+++ b/node_modules/rollup/dist/native.js
@@ -0,0 +1,105 @@
+const { existsSync } = require('node:fs');
+const path = require('node:path');
+const { platform, arch, report } = require('node:process');
+
+const isMusl = () => !report.getReport().header.glibcVersionRuntime;
+
+const bindingsByPlatformAndArch = {
+	android: {
+		arm: { base: 'android-arm-eabi' },
+		arm64: { base: 'android-arm64' }
+	},
+	darwin: {
+		arm64: { base: 'darwin-arm64' },
+		x64: { base: 'darwin-x64' }
+	},
+	linux: {
+		arm: { base: 'linux-arm-gnueabihf', musl: 'linux-arm-musleabihf' },
+		arm64: { base: 'linux-arm64-gnu', musl: 'linux-arm64-musl' },
+		ppc64: { base: 'linux-powerpc64le-gnu', musl: null },
+		riscv64: { base: 'linux-riscv64-gnu', musl: null },
+		s390x: { base: 'linux-s390x-gnu', musl: null },
+		x64: { base: 'linux-x64-gnu', musl: 'linux-x64-musl' }
+	},
+	win32: {
+		arm64: { base: 'win32-arm64-msvc' },
+		ia32: { base: 'win32-ia32-msvc' },
+		x64: { base: 'win32-x64-msvc' }
+	}
+};
+
+const msvcLinkFilenameByArch = {
+	arm64: 'vc_redist.arm64.exe',
+	ia32: 'vc_redist.x86.exe',
+	x64: 'vc_redist.x64.exe'
+};
+
+const packageBase = getPackageBase();
+const localName = `./rollup.${packageBase}.node`;
+const requireWithFriendlyError = id => {
+	try {
+		return require(id);
+	} catch (error) {
+		if (
+			platform === 'win32' &&
+			error instanceof Error &&
+			error.code === 'ERR_DLOPEN_FAILED' &&
+			error.message.includes('The specified module could not be found')
+		) {
+			const msvcDownloadLink = `https://aka.ms/vs/17/release/${msvcLinkFilenameByArch[arch]}`;
+			throw new Error(
+				`Failed to load module ${id}. ` +
+					'Required DLL was not found. ' +
+					'This error usually happens when Microsoft Visual C++ Redistributable is not installed. ' +
+					`You can download it from ${msvcDownloadLink}`,
+				{ cause: error }
+			);
+		}
+
+		throw new Error(
+			`Cannot find module ${id}. ` +
+				`npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+				'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+			{ cause: error }
+		);
+	}
+};
+
+const { parse, parseAsync, xxhashBase64Url, xxhashBase36, xxhashBase16 } = requireWithFriendlyError(
+	existsSync(path.join(__dirname, localName)) ? localName : `@rollup/rollup-${packageBase}`
+);
+
+function getPackageBase() {
+	const imported = bindingsByPlatformAndArch[platform]?.[arch];
+	if (!imported) {
+		throwUnsupportedError(false);
+	}
+	if ('musl' in imported && isMusl()) {
+		return imported.musl || throwUnsupportedError(true);
+	}
+	return imported.base;
+}
+
+function throwUnsupportedError(isMusl) {
+	throw new Error(
+		`Your current platform "${platform}${isMusl ? ' (musl)' : ''}" and architecture "${arch}" combination is not yet supported by the native Rollup build. Please use the WASM build "@rollup/wasm-node" instead.
+
+The following platform-architecture combinations are supported:
+${Object.entries(bindingsByPlatformAndArch)
+	.flatMap(([platformName, architectures]) =>
+		Object.entries(architectures).flatMap(([architectureName, { musl }]) => {
+			const name = `${platformName}-${architectureName}`;
+			return musl ? [name, `${name} (musl)`] : [name];
+		})
+	)
+	.join('\n')}
+
+If this is important to you, please consider supporting Rollup to make a native build for your platform and architecture available.`
+	);
+}
+
+module.exports.parse = parse;
+module.exports.parseAsync = parseAsync;
+module.exports.xxhashBase64Url = xxhashBase64Url;
+module.exports.xxhashBase36 = xxhashBase36;
+module.exports.xxhashBase16 = xxhashBase16;
diff --git a/node_modules/rollup/dist/parseAst.d.ts b/node_modules/rollup/dist/parseAst.d.ts
new file mode 100644
index 0000000..4d64dac
--- /dev/null
+++ b/node_modules/rollup/dist/parseAst.d.ts
@@ -0,0 +1,4 @@
+import type { ParseAst, ParseAstAsync } from './rollup';
+
+export const parseAst: ParseAst;
+export const parseAstAsync: ParseAstAsync;
diff --git a/node_modules/rollup/dist/parseAst.js b/node_modules/rollup/dist/parseAst.js
new file mode 100644
index 0000000..004878b
--- /dev/null
+++ b/node_modules/rollup/dist/parseAst.js
@@ -0,0 +1,22 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('./native.js');
+const parseAst_js = require('./shared/parseAst.js');
+require('node:path');
+
+
+
+exports.parseAst = parseAst_js.parseAst;
+exports.parseAstAsync = parseAst_js.parseAstAsync;
+//# sourceMappingURL=parseAst.js.map
diff --git a/node_modules/rollup/dist/rollup.d.ts b/node_modules/rollup/dist/rollup.d.ts
new file mode 100644
index 0000000..8dfbd7e
--- /dev/null
+++ b/node_modules/rollup/dist/rollup.d.ts
@@ -0,0 +1,1053 @@
+import type * as estree from 'estree';
+
+declare module 'estree' {
+	export interface Decorator extends estree.BaseNode {
+		type: 'Decorator';
+		expression: estree.Expression;
+	}
+	interface PropertyDefinition {
+		decorators: estree.Decorator[];
+	}
+	interface MethodDefinition {
+		decorators: estree.Decorator[];
+	}
+	interface BaseClass {
+		decorators: estree.Decorator[];
+	}
+}
+
+export const VERSION: string;
+
+// utils
+type NullValue = null | undefined | void;
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+export interface RollupError extends RollupLog {
+	name?: string;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+export interface RollupLog {
+	binding?: string;
+	cause?: unknown;
+	code?: string;
+	exporter?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	ids?: string[];
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	meta?: any;
+	names?: string[];
+	plugin?: string;
+	pluginCode?: unknown;
+	pos?: number;
+	reexporter?: string;
+	stack?: string;
+	url?: string;
+}
+
+export type LogLevel = 'warn' | 'info' | 'debug';
+export type LogLevelOption = LogLevel | 'silent';
+
+export type SourceMapSegment =
+	| [number]
+	| [number, number, number, number]
+	| [number, number, number, number, number];
+
+export interface ExistingDecodedSourceMap {
+	file?: string;
+	readonly mappings: SourceMapSegment[][];
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	x_google_ignoreList?: number[];
+}
+
+export interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	x_google_ignoreList?: number[];
+}
+
+export type DecodedSourceMapOrMissing =
+	| {
+			missing: true;
+			plugin: string;
+	  }
+	| (ExistingDecodedSourceMap & { missing?: false });
+
+export interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	toString(): string;
+	toUrl(): string;
+}
+
+export type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
+
+interface ModuleOptions {
+	attributes: Record<string, string>;
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+export interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+	ast?: ProgramNode;
+	code: string;
+	map?: SourceMapInput;
+}
+
+export interface TransformModuleJSON {
+	ast?: ProgramNode;
+	code: string;
+	// note if plugins use new this.cache to opt-out auto transform cache
+	customTransformCache: boolean;
+	originalCode: string;
+	originalSourcemap: ExistingDecodedSourceMap | null;
+	sourcemapChain: DecodedSourceMapOrMissing[];
+	transformDependencies: string[];
+}
+
+export interface ModuleJSON extends TransformModuleJSON, ModuleOptions {
+	ast: ProgramNode;
+	dependencies: string[];
+	id: string;
+	resolvedIds: ResolvedIdMap;
+	transformFiles: EmittedFile[] | undefined;
+}
+
+export interface PluginCache {
+	delete(id: string): boolean;
+	get<T = any>(id: string): T;
+	has(id: string): boolean;
+	set<T = any>(id: string, value: T): void;
+}
+
+export type LoggingFunction = (log: RollupLog | string | (() => RollupLog | string)) => void;
+
+export interface MinimalPluginContext {
+	debug: LoggingFunction;
+	error: (error: RollupError | string) => never;
+	info: LoggingFunction;
+	meta: PluginContextMeta;
+	warn: LoggingFunction;
+}
+
+export interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	needsCodeReference?: boolean;
+	originalFileName?: string | null;
+	source?: string | Uint8Array;
+	type: 'asset';
+}
+
+export interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	implicitlyLoadedAfterOneOf?: string[];
+	importer?: string;
+	name?: string;
+	preserveSignature?: PreserveEntrySignaturesOption;
+	type: 'chunk';
+}
+
+export interface EmittedPrebuiltChunk {
+	code: string;
+	exports?: string[];
+	fileName: string;
+	map?: SourceMap;
+	sourcemapFileName?: string;
+	type: 'prebuilt-chunk';
+}
+
+export type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk;
+
+export type EmitFile = (emittedFile: EmittedFile) => string;
+
+interface ModuleInfo extends ModuleOptions {
+	ast: ProgramNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	exportedBindings: Record<string, string[]> | null;
+	exports: string[] | null;
+	hasDefaultExport: boolean | null;
+	id: string;
+	implicitlyLoadedAfterOneOf: readonly string[];
+	implicitlyLoadedBefore: readonly string[];
+	importedIdResolutions: readonly ResolvedId[];
+	importedIds: readonly string[];
+	importers: readonly string[];
+	isEntry: boolean;
+	isExternal: boolean;
+	isIncluded: boolean | null;
+}
+
+export type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+
+export type CustomPluginOptions = Record<string, any>;
+
+type LoggingFunctionWithPosition = (
+	log: RollupLog | string | (() => RollupLog | string),
+	pos?: number | { column: number; line: number }
+) => void;
+
+export type ParseAst = (
+	input: string,
+	options?: { allowReturnOutsideFunction?: boolean; jsx?: boolean }
+) => ProgramNode;
+
+// declare AbortSignal here for environments without DOM lib or @types/node
+declare global {
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+	interface AbortSignal {}
+}
+
+export type ParseAstAsync = (
+	input: string,
+	options?: { allowReturnOutsideFunction?: boolean; jsx?: boolean; signal?: AbortSignal }
+) => Promise<ProgramNode>;
+
+export interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	debug: LoggingFunction;
+	emitFile: EmitFile;
+	error: (error: RollupError | string) => never;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+	getWatchFiles: () => string[];
+	info: LoggingFunction;
+	load: (
+		options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
+	) => Promise<ModuleInfo>;
+	parse: ParseAst;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: {
+			attributes?: Record<string, string>;
+			custom?: CustomPluginOptions;
+			isEntry?: boolean;
+			skipSelf?: boolean;
+		}
+	) => Promise<ResolvedId | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
+	warn: LoggingFunction;
+}
+
+export interface PluginContextMeta {
+	rollupVersion: string;
+	watchMode: boolean;
+}
+
+export interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
+	resolvedBy: string;
+}
+
+export type ResolvedIdMap = Record<string, ResolvedId>;
+
+interface PartialResolvedId extends Partial<PartialNull<ModuleOptions>> {
+	external?: boolean | 'absolute' | 'relative';
+	id: string;
+	resolvedBy?: string;
+}
+
+export type ResolveIdResult = string | NullValue | false | PartialResolvedId;
+
+export type ResolveIdResultWithoutNullValue = string | false | PartialResolvedId;
+
+export type ResolveIdHook = (
+	this: PluginContext,
+	source: string,
+	importer: string | undefined,
+	options: { attributes: Record<string, string>; custom?: CustomPluginOptions; isEntry: boolean }
+) => ResolveIdResult;
+
+export type ShouldTransformCachedModuleHook = (
+	this: PluginContext,
+	options: {
+		ast: ProgramNode;
+		code: string;
+		id: string;
+		meta: CustomPluginOptions;
+		moduleSideEffects: boolean | 'no-treeshake';
+		resolvedSources: ResolvedIdMap;
+		syntheticNamedExports: boolean | string;
+	}
+) => boolean | NullValue;
+
+export type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+export type HasModuleSideEffects = (id: string, external: boolean) => boolean;
+
+export type LoadResult = SourceDescription | string | NullValue;
+
+export type LoadHook = (this: PluginContext, id: string) => LoadResult;
+
+export interface TransformPluginContext extends PluginContext {
+	debug: LoggingFunctionWithPosition;
+	error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	getCombinedSourcemap: () => SourceMap;
+	info: LoggingFunctionWithPosition;
+	warn: LoggingFunctionWithPosition;
+}
+
+export type TransformResult = string | NullValue | Partial<SourceDescription>;
+
+export type TransformHook = (
+	this: TransformPluginContext,
+	code: string,
+	id: string
+) => TransformResult;
+
+export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void;
+
+export type RenderChunkHook = (
+	this: PluginContext,
+	code: string,
+	chunk: RenderedChunk,
+	options: NormalizedOutputOptions,
+	meta: { chunks: Record<string, RenderedChunk> }
+) => { code: string; map?: SourceMapInput } | string | NullValue;
+
+export type ResolveDynamicImportHook = (
+	this: PluginContext,
+	specifier: string | AstNode,
+	importer: string,
+	options: { attributes: Record<string, string> }
+) => ResolveIdResult;
+
+export type ResolveImportMetaHook = (
+	this: PluginContext,
+	property: string | null,
+	options: { chunkId: string; format: InternalModuleFormat; moduleId: string }
+) => string | NullValue;
+
+export type ResolveFileUrlHook = (
+	this: PluginContext,
+	options: {
+		chunkId: string;
+		fileName: string;
+		format: InternalModuleFormat;
+		moduleId: string;
+		referenceId: string;
+		relativePath: string;
+	}
+) => string | NullValue;
+
+export type AddonHookFunction = (
+	this: PluginContext,
+	chunk: RenderedChunk
+) => string | Promise<string>;
+export type AddonHook = string | AddonHookFunction;
+
+export type ChangeEvent = 'create' | 'update' | 'delete';
+export type WatchChangeHook = (
+	this: PluginContext,
+	id: string,
+	change: { event: ChangeEvent }
+) => void;
+
+/**
+ * use this type for plugin annotation
+ * @example
+ * ```ts
+ * interface Options {
+ * ...
+ * }
+ * const myPlugin: PluginImpl<Options> = (options = {}) => { ... }
+ * ```
+ */
+export type PluginImpl<O extends object = object, A = any> = (options?: O) => Plugin<A>;
+
+export type OutputBundle = Record<string, OutputAsset | OutputChunk>;
+
+export interface FunctionPluginHooks {
+	augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void;
+	buildEnd: (this: PluginContext, error?: Error) => void;
+	buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;
+	closeBundle: (this: PluginContext) => void;
+	closeWatcher: (this: PluginContext) => void;
+	generateBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		bundle: OutputBundle,
+		isWrite: boolean
+	) => void;
+	load: LoadHook;
+	moduleParsed: ModuleParsedHook;
+	onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue;
+	options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue;
+	outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue;
+	renderChunk: RenderChunkHook;
+	renderDynamicImport: (
+		this: PluginContext,
+		options: {
+			customResolution: string | null;
+			format: InternalModuleFormat;
+			moduleId: string;
+			targetModuleId: string | null;
+		}
+	) => { left: string; right: string } | NullValue;
+	renderError: (this: PluginContext, error?: Error) => void;
+	renderStart: (
+		this: PluginContext,
+		outputOptions: NormalizedOutputOptions,
+		inputOptions: NormalizedInputOptions
+	) => void;
+	resolveDynamicImport: ResolveDynamicImportHook;
+	resolveFileUrl: ResolveFileUrlHook;
+	resolveId: ResolveIdHook;
+	resolveImportMeta: ResolveImportMetaHook;
+	shouldTransformCachedModule: ShouldTransformCachedModuleHook;
+	transform: TransformHook;
+	watchChange: WatchChangeHook;
+	writeBundle: (
+		this: PluginContext,
+		options: NormalizedOutputOptions,
+		bundle: OutputBundle
+	) => void;
+}
+
+export type OutputPluginHooks =
+	| 'augmentChunkHash'
+	| 'generateBundle'
+	| 'outputOptions'
+	| 'renderChunk'
+	| 'renderDynamicImport'
+	| 'renderError'
+	| 'renderStart'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta'
+	| 'writeBundle';
+
+export type InputPluginHooks = Exclude<keyof FunctionPluginHooks, OutputPluginHooks>;
+
+export type SyncPluginHooks =
+	| 'augmentChunkHash'
+	| 'onLog'
+	| 'outputOptions'
+	| 'renderDynamicImport'
+	| 'resolveFileUrl'
+	| 'resolveImportMeta';
+
+export type AsyncPluginHooks = Exclude<keyof FunctionPluginHooks, SyncPluginHooks>;
+
+export type FirstPluginHooks =
+	| 'load'
+	| 'renderDynamicImport'
+	| 'resolveDynamicImport'
+	| 'resolveFileUrl'
+	| 'resolveId'
+	| 'resolveImportMeta'
+	| 'shouldTransformCachedModule';
+
+export type SequentialPluginHooks =
+	| 'augmentChunkHash'
+	| 'generateBundle'
+	| 'onLog'
+	| 'options'
+	| 'outputOptions'
+	| 'renderChunk'
+	| 'transform';
+
+export type ParallelPluginHooks = Exclude<
+	keyof FunctionPluginHooks | AddonHooks,
+	FirstPluginHooks | SequentialPluginHooks
+>;
+
+export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro';
+
+type MakeAsync<Function_> = Function_ extends (
+	this: infer This,
+	...parameters: infer Arguments
+) => infer Return
+	? (this: This, ...parameters: Arguments) => Return | Promise<Return>
+	: never;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+type ObjectHook<T, O = {}> = T | ({ handler: T; order?: 'pre' | 'post' | null } & O);
+
+export type PluginHooks = {
+	[K in keyof FunctionPluginHooks]: ObjectHook<
+		K extends AsyncPluginHooks ? MakeAsync<FunctionPluginHooks[K]> : FunctionPluginHooks[K],
+		// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+		K extends ParallelPluginHooks ? { sequential?: boolean } : {}
+	>;
+};
+
+export interface OutputPlugin
+	extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>,
+		Partial<{ [K in AddonHooks]: ObjectHook<AddonHook> }> {
+	cacheKey?: string;
+	name: string;
+	version?: string;
+}
+
+export interface Plugin<A = any> extends OutputPlugin, Partial<PluginHooks> {
+	// for inter-plugin communication
+	api?: A;
+}
+
+export type JsxPreset = 'react' | 'react-jsx' | 'preserve' | 'preserve-react';
+
+export type NormalizedJsxOptions =
+	| NormalizedJsxPreserveOptions
+	| NormalizedJsxClassicOptions
+	| NormalizedJsxAutomaticOptions;
+
+interface NormalizedJsxPreserveOptions {
+	factory: string | null;
+	fragment: string | null;
+	importSource: string | null;
+	mode: 'preserve';
+}
+
+interface NormalizedJsxClassicOptions {
+	factory: string;
+	fragment: string;
+	importSource: string | null;
+	mode: 'classic';
+}
+
+interface NormalizedJsxAutomaticOptions {
+	factory: string;
+	importSource: string | null;
+	jsxImportSource: string;
+	mode: 'automatic';
+}
+
+export type JsxOptions = Partial<NormalizedJsxOptions> & {
+	preset?: JsxPreset;
+};
+
+export type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';
+
+export interface NormalizedTreeshakingOptions {
+	annotations: boolean;
+	correctVarValueBeforeDeclaration: boolean;
+	manualPureFunctions: readonly string[];
+	moduleSideEffects: HasModuleSideEffects;
+	propertyReadSideEffects: boolean | 'always';
+	tryCatchDeoptimization: boolean;
+	unknownGlobalSideEffects: boolean;
+}
+
+export interface TreeshakingOptions
+	extends Partial<Omit<NormalizedTreeshakingOptions, 'moduleSideEffects'>> {
+	moduleSideEffects?: ModuleSideEffectsOption;
+	preset?: TreeshakingPreset;
+}
+
+interface ManualChunkMeta {
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+}
+
+export type GetManualChunk = (id: string, meta: ManualChunkMeta) => string | NullValue;
+
+export type ExternalOption =
+	| (string | RegExp)[]
+	| string
+	| RegExp
+	| ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue);
+
+export type GlobalsOption = Record<string, string> | ((name: string) => string);
+
+export type InputOption = string | string[] | Record<string, string>;
+
+export type ManualChunksOption = Record<string, string[]> | GetManualChunk;
+
+export type LogHandlerWithDefault = (
+	level: LogLevel,
+	log: RollupLog,
+	defaultHandler: LogOrStringHandler
+) => void;
+
+export type LogOrStringHandler = (level: LogLevel | 'error', log: RollupLog | string) => void;
+
+export type LogHandler = (level: LogLevel, log: RollupLog) => void;
+
+export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects;
+
+export type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+export type SourcemapPathTransformOption = (
+	relativeSourcePath: string,
+	sourcemapPath: string
+) => string;
+
+export type SourcemapIgnoreListOption = (
+	relativeSourcePath: string,
+	sourcemapPath: string
+) => boolean;
+
+export type InputPluginOption = MaybePromise<Plugin | NullValue | false | InputPluginOption[]>;
+
+export interface InputOptions {
+	cache?: boolean | RollupCache;
+	context?: string;
+	experimentalCacheExpiry?: number;
+	experimentalLogSideEffects?: boolean;
+	external?: ExternalOption;
+	input?: InputOption;
+	jsx?: false | JsxPreset | JsxOptions;
+	logLevel?: LogLevelOption;
+	makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource';
+	maxParallelFileOps?: number;
+	moduleContext?: ((id: string) => string | NullValue) | Record<string, string>;
+	onLog?: LogHandlerWithDefault;
+	onwarn?: WarningHandlerWithDefault;
+	perf?: boolean;
+	plugins?: InputPluginOption;
+	preserveEntrySignatures?: PreserveEntrySignaturesOption;
+	preserveSymlinks?: boolean;
+	shimMissingExports?: boolean;
+	strictDeprecations?: boolean;
+	treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;
+	watch?: WatcherOptions | false;
+}
+
+export interface InputOptionsWithPlugins extends InputOptions {
+	plugins: Plugin[];
+}
+
+export interface NormalizedInputOptions {
+	cache: false | undefined | RollupCache;
+	context: string;
+	experimentalCacheExpiry: number;
+	experimentalLogSideEffects: boolean;
+	external: IsExternal;
+	input: string[] | Record<string, string>;
+	jsx: false | NormalizedJsxOptions;
+	logLevel: LogLevelOption;
+	makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource';
+	maxParallelFileOps: number;
+	moduleContext: (id: string) => string;
+	onLog: LogHandler;
+	perf: boolean;
+	plugins: Plugin[];
+	preserveEntrySignatures: PreserveEntrySignaturesOption;
+	preserveSymlinks: boolean;
+	shimMissingExports: boolean;
+	strictDeprecations: boolean;
+	treeshake: false | NormalizedTreeshakingOptions;
+}
+
+export type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd';
+export type ImportAttributesKey = 'with' | 'assert';
+
+export type ModuleFormat = InternalModuleFormat | 'commonjs' | 'esm' | 'module' | 'systemjs';
+
+type GeneratedCodePreset = 'es5' | 'es2015';
+
+interface NormalizedGeneratedCodeOptions {
+	arrowFunctions: boolean;
+	constBindings: boolean;
+	objectShorthand: boolean;
+	reservedNamesAsProps: boolean;
+	symbols: boolean;
+}
+
+interface GeneratedCodeOptions extends Partial<NormalizedGeneratedCodeOptions> {
+	preset?: GeneratedCodePreset;
+}
+
+export type OptionsPaths = Record<string, string> | ((id: string) => string);
+
+export type InteropType = 'compat' | 'auto' | 'esModule' | 'default' | 'defaultOnly';
+
+export type GetInterop = (id: string | null) => InteropType;
+
+export type AmdOptions = (
+	| {
+			autoId?: false;
+			id: string;
+	  }
+	| {
+			autoId: true;
+			basePath?: string;
+			id?: undefined;
+	  }
+	| {
+			autoId?: false;
+			id?: undefined;
+	  }
+) & {
+	define?: string;
+	forceJsExtensionForImports?: boolean;
+};
+
+export type NormalizedAmdOptions = (
+	| {
+			autoId: false;
+			id?: string;
+	  }
+	| {
+			autoId: true;
+			basePath: string;
+	  }
+) & {
+	define: string;
+	forceJsExtensionForImports: boolean;
+};
+
+type AddonFunction = (chunk: RenderedChunk) => string | Promise<string>;
+
+type OutputPluginOption = MaybePromise<OutputPlugin | NullValue | false | OutputPluginOption[]>;
+
+type HashCharacters = 'base64' | 'base36' | 'hex';
+
+export interface OutputOptions {
+	amd?: AmdOptions;
+	assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner?: string | AddonFunction;
+	chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact?: boolean;
+	// only required for bundle.write
+	dir?: string;
+	dynamicImportInCjs?: boolean;
+	entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule?: boolean | 'if-default-prop';
+	experimentalMinChunkSize?: number;
+	exports?: 'default' | 'named' | 'none' | 'auto';
+	extend?: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions?: boolean;
+	externalImportAttributes?: boolean;
+	externalLiveBindings?: boolean;
+	// only required for bundle.write
+	file?: string;
+	footer?: string | AddonFunction;
+	format?: ModuleFormat;
+	freeze?: boolean;
+	generatedCode?: GeneratedCodePreset | GeneratedCodeOptions;
+	globals?: GlobalsOption;
+	hashCharacters?: HashCharacters;
+	hoistTransitiveImports?: boolean;
+	importAttributesKey?: ImportAttributesKey;
+	indent?: string | boolean;
+	inlineDynamicImports?: boolean;
+	interop?: InteropType | GetInterop;
+	intro?: string | AddonFunction;
+	manualChunks?: ManualChunksOption;
+	minifyInternalExports?: boolean;
+	name?: string;
+	noConflict?: boolean;
+	outro?: string | AddonFunction;
+	paths?: OptionsPaths;
+	plugins?: OutputPluginOption;
+	preserveModules?: boolean;
+	preserveModulesRoot?: string;
+	reexportProtoFromExternal?: boolean;
+	sanitizeFileName?: boolean | ((fileName: string) => string);
+	sourcemap?: boolean | 'inline' | 'hidden';
+	sourcemapBaseUrl?: string;
+	sourcemapExcludeSources?: boolean;
+	sourcemapFile?: string;
+	sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);
+	sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption;
+	sourcemapPathTransform?: SourcemapPathTransformOption;
+	strict?: boolean;
+	systemNullSetters?: boolean;
+	validate?: boolean;
+	virtualDirname?: string;
+}
+
+export interface NormalizedOutputOptions {
+	amd: NormalizedAmdOptions;
+	assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string);
+	banner: AddonFunction;
+	chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	compact: boolean;
+	dir: string | undefined;
+	dynamicImportInCjs: boolean;
+	entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string);
+	esModule: boolean | 'if-default-prop';
+	experimentalMinChunkSize: number;
+	exports: 'default' | 'named' | 'none' | 'auto';
+	extend: boolean;
+	/** @deprecated Use "externalImportAttributes" instead. */
+	externalImportAssertions: boolean;
+	externalImportAttributes: boolean;
+	externalLiveBindings: boolean;
+	file: string | undefined;
+	footer: AddonFunction;
+	format: InternalModuleFormat;
+	freeze: boolean;
+	generatedCode: NormalizedGeneratedCodeOptions;
+	globals: GlobalsOption;
+	hashCharacters: HashCharacters;
+	hoistTransitiveImports: boolean;
+	importAttributesKey: ImportAttributesKey;
+	indent: true | string;
+	inlineDynamicImports: boolean;
+	interop: GetInterop;
+	intro: AddonFunction;
+	manualChunks: ManualChunksOption;
+	minifyInternalExports: boolean;
+	name: string | undefined;
+	noConflict: boolean;
+	outro: AddonFunction;
+	paths: OptionsPaths;
+	plugins: OutputPlugin[];
+	preserveModules: boolean;
+	preserveModulesRoot: string | undefined;
+	reexportProtoFromExternal: boolean;
+	sanitizeFileName: (fileName: string) => string;
+	sourcemap: boolean | 'inline' | 'hidden';
+	sourcemapBaseUrl: string | undefined;
+	sourcemapExcludeSources: boolean;
+	sourcemapFile: string | undefined;
+	sourcemapFileNames: string | ((chunkInfo: PreRenderedChunk) => string) | undefined;
+	sourcemapIgnoreList: SourcemapIgnoreListOption;
+	sourcemapPathTransform: SourcemapPathTransformOption | undefined;
+	strict: boolean;
+	systemNullSetters: boolean;
+	validate: boolean;
+	virtualDirname: string;
+}
+
+export type WarningHandlerWithDefault = (
+	warning: RollupLog,
+	defaultHandler: LoggingFunction
+) => void;
+
+export type SerializedTimings = Record<string, [number, number, number]>;
+
+export interface PreRenderedAsset {
+	/** @deprecated Use "names" instead. */
+	name: string | undefined;
+	names: string[];
+	/** @deprecated Use "originalFileNames" instead. */
+	originalFileName: string | null;
+	originalFileNames: string[];
+	source: string | Uint8Array;
+	type: 'asset';
+}
+
+export interface OutputAsset extends PreRenderedAsset {
+	fileName: string;
+	needsCodeReference: boolean;
+}
+
+export interface RenderedModule {
+	readonly code: string | null;
+	originalLength: number;
+	removedExports: string[];
+	renderedExports: string[];
+	renderedLength: number;
+}
+
+export interface PreRenderedChunk {
+	exports: string[];
+	facadeModuleId: string | null;
+	isDynamicEntry: boolean;
+	isEntry: boolean;
+	isImplicitEntry: boolean;
+	moduleIds: string[];
+	name: string;
+	type: 'chunk';
+}
+
+export interface RenderedChunk extends PreRenderedChunk {
+	dynamicImports: string[];
+	fileName: string;
+	implicitlyLoadedBefore: string[];
+	importedBindings: Record<string, string[]>;
+	imports: string[];
+	modules: Record<string, RenderedModule>;
+	referencedFiles: string[];
+}
+
+export interface OutputChunk extends RenderedChunk {
+	code: string;
+	map: SourceMap | null;
+	sourcemapFileName: string | null;
+	preliminaryFileName: string;
+}
+
+export type SerializablePluginCache = Record<string, [number, any]>;
+
+export interface RollupCache {
+	modules: ModuleJSON[];
+	plugins?: Record<string, SerializablePluginCache>;
+}
+
+export interface RollupOutput {
+	output: [OutputChunk, ...(OutputChunk | OutputAsset)[]];
+}
+
+export interface RollupBuild {
+	cache: RollupCache | undefined;
+	close: () => Promise<void>;
+	closed: boolean;
+	generate: (outputOptions: OutputOptions) => Promise<RollupOutput>;
+	getTimings?: () => SerializedTimings;
+	watchFiles: string[];
+	write: (options: OutputOptions) => Promise<RollupOutput>;
+}
+
+export interface RollupOptions extends InputOptions {
+	// This is included for compatibility with config files but ignored by rollup.rollup
+	output?: OutputOptions | OutputOptions[];
+}
+
+export interface MergedRollupOptions extends InputOptionsWithPlugins {
+	output: OutputOptions[];
+}
+
+export function rollup(options: RollupOptions): Promise<RollupBuild>;
+
+export interface ChokidarOptions {
+	alwaysStat?: boolean;
+	atomic?: boolean | number;
+	awaitWriteFinish?:
+		| {
+				pollInterval?: number;
+				stabilityThreshold?: number;
+		  }
+		| boolean;
+	binaryInterval?: number;
+	cwd?: string;
+	depth?: number;
+	disableGlobbing?: boolean;
+	followSymlinks?: boolean;
+	ignoreInitial?: boolean;
+	ignorePermissionErrors?: boolean;
+	ignored?: any;
+	interval?: number;
+	persistent?: boolean;
+	useFsEvents?: boolean;
+	usePolling?: boolean;
+}
+
+export type RollupWatchHooks = 'onError' | 'onStart' | 'onBundleStart' | 'onBundleEnd' | 'onEnd';
+
+export interface WatcherOptions {
+	buildDelay?: number;
+	chokidar?: ChokidarOptions;
+	clearScreen?: boolean;
+	exclude?: string | RegExp | (string | RegExp)[];
+	include?: string | RegExp | (string | RegExp)[];
+	skipWrite?: boolean;
+}
+
+export interface RollupWatchOptions extends InputOptions {
+	output?: OutputOptions | OutputOptions[];
+	watch?: WatcherOptions | false;
+}
+
+export type AwaitedEventListener<
+	T extends Record<string, (...parameters: any) => any>,
+	K extends keyof T
+> = (...parameters: Parameters<T[K]>) => void | Promise<void>;
+
+export interface AwaitingEventEmitter<T extends Record<string, (...parameters: any) => any>> {
+	close(): Promise<void>;
+	emit<K extends keyof T>(event: K, ...parameters: Parameters<T[K]>): Promise<unknown>;
+	/**
+	 * Removes an event listener.
+	 */
+	off<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
+	/**
+	 * Registers an event listener that will be awaited before Rollup continues.
+	 * All listeners will be awaited in parallel while rejections are tracked via
+	 * Promise.all.
+	 */
+	on<K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>): this;
+	/**
+	 * Registers an event listener that will be awaited before Rollup continues.
+	 * All listeners will be awaited in parallel while rejections are tracked via
+	 * Promise.all.
+	 * Listeners are removed automatically when removeListenersForCurrentRun is
+	 * called, which happens automatically after each run.
+	 */
+	onCurrentRun<K extends keyof T>(
+		event: K,
+		listener: (...parameters: Parameters<T[K]>) => Promise<ReturnType<T[K]>>
+	): this;
+	removeAllListeners(): this;
+	removeListenersForCurrentRun(): this;
+}
+
+export type RollupWatcherEvent =
+	| { code: 'START' }
+	| { code: 'BUNDLE_START'; input?: InputOption; output: readonly string[] }
+	| {
+			code: 'BUNDLE_END';
+			duration: number;
+			input?: InputOption;
+			output: readonly string[];
+			result: RollupBuild;
+	  }
+	| { code: 'END' }
+	| { code: 'ERROR'; error: RollupError; result: RollupBuild | null };
+
+export type RollupWatcher = AwaitingEventEmitter<{
+	change: (id: string, change: { event: ChangeEvent }) => void;
+	close: () => void;
+	event: (event: RollupWatcherEvent) => void;
+	restart: () => void;
+}>;
+
+export function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher;
+
+interface AstNodeLocation {
+	end: number;
+	start: number;
+}
+
+type OmittedEstreeKeys =
+	| 'loc'
+	| 'range'
+	| 'leadingComments'
+	| 'trailingComments'
+	| 'innerComments'
+	| 'comments';
+type RollupAstNode<T> = Omit<T, OmittedEstreeKeys> & AstNodeLocation;
+
+type ProgramNode = RollupAstNode<estree.Program>;
+export type AstNode = RollupAstNode<estree.Node>;
+
+export function defineConfig(options: RollupOptions): RollupOptions;
+export function defineConfig(options: RollupOptions[]): RollupOptions[];
+export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction;
+
+export type RollupOptionsFunction = (
+	commandLineArguments: Record<string, any>
+) => MaybePromise<RollupOptions | RollupOptions[]>;
diff --git a/node_modules/rollup/dist/rollup.js b/node_modules/rollup/dist/rollup.js
new file mode 100644
index 0000000..e414e17
--- /dev/null
+++ b/node_modules/rollup/dist/rollup.js
@@ -0,0 +1,100 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const rollup = require('./shared/rollup.js');
+const parseAst_js = require('./shared/parseAst.js');
+const fseventsImporter = require('./shared/fsevents-importer.js');
+require('node:process');
+require('tty');
+require('node:path');
+require('path');
+require('./native.js');
+require('node:perf_hooks');
+require('node:fs/promises');
+
+class WatchEmitter {
+    constructor() {
+        this.currentHandlers = Object.create(null);
+        this.persistentHandlers = Object.create(null);
+    }
+    // Will be overwritten by Rollup
+    async close() { }
+    emit(event, ...parameters) {
+        return Promise.all([...this.getCurrentHandlers(event), ...this.getPersistentHandlers(event)].map(handler => handler(...parameters)));
+    }
+    off(event, listener) {
+        const listeners = this.persistentHandlers[event];
+        if (listeners) {
+            // A hack stolen from "mitt": ">>> 0" does not change numbers >= 0, but -1
+            // (which would remove the last array element if used unchanged) is turned
+            // into max_int, which is outside the array and does not change anything.
+            listeners.splice(listeners.indexOf(listener) >>> 0, 1);
+        }
+        return this;
+    }
+    on(event, listener) {
+        this.getPersistentHandlers(event).push(listener);
+        return this;
+    }
+    onCurrentRun(event, listener) {
+        this.getCurrentHandlers(event).push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const selfRemovingListener = (...parameters) => {
+            this.off(event, selfRemovingListener);
+            return listener(...parameters);
+        };
+        this.on(event, selfRemovingListener);
+        return this;
+    }
+    removeAllListeners() {
+        this.removeListenersForCurrentRun();
+        this.persistentHandlers = Object.create(null);
+        return this;
+    }
+    removeListenersForCurrentRun() {
+        this.currentHandlers = Object.create(null);
+        return this;
+    }
+    getCurrentHandlers(event) {
+        return this.currentHandlers[event] || (this.currentHandlers[event] = []);
+    }
+    getPersistentHandlers(event) {
+        return this.persistentHandlers[event] || (this.persistentHandlers[event] = []);
+    }
+}
+
+function watch(configs) {
+    const emitter = new WatchEmitter();
+    watchInternal(configs, emitter).catch(error => {
+        rollup.handleError(error);
+    });
+    return emitter;
+}
+async function watchInternal(configs, emitter) {
+    const optionsList = await Promise.all(rollup.ensureArray(configs).map(config => rollup.mergeOptions(config, true)));
+    const watchOptionsList = optionsList.filter(config => config.watch !== false);
+    if (watchOptionsList.length === 0) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('watch', parseAst_js.URL_WATCH, 'there must be at least one config where "watch" is not set to "false"'));
+    }
+    await fseventsImporter.loadFsEvents();
+    const { Watcher } = await Promise.resolve().then(() => require('./shared/watch.js'));
+    new Watcher(watchOptionsList, emitter);
+}
+
+exports.VERSION = rollup.version;
+exports.defineConfig = rollup.defineConfig;
+exports.rollup = rollup.rollup;
+exports.watch = watch;
+//# sourceMappingURL=rollup.js.map
diff --git a/node_modules/rollup/dist/shared/fsevents-importer.js b/node_modules/rollup/dist/shared/fsevents-importer.js
new file mode 100644
index 0000000..461222f
--- /dev/null
+++ b/node_modules/rollup/dist/shared/fsevents-importer.js
@@ -0,0 +1,37 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+let fsEvents;
+let fsEventsImportError;
+async function loadFsEvents() {
+    try {
+        ({ default: fsEvents } = await import('fsevents'));
+    }
+    catch (error) {
+        fsEventsImportError = error;
+    }
+}
+// A call to this function will be injected into the chokidar code
+function getFsEvents() {
+    if (fsEventsImportError)
+        throw fsEventsImportError;
+    return fsEvents;
+}
+
+const fseventsImporter = /*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getFsEvents,
+    loadFsEvents
+}, Symbol.toStringTag, { value: 'Module' });
+
+exports.fseventsImporter = fseventsImporter;
+exports.loadFsEvents = loadFsEvents;
+//# sourceMappingURL=fsevents-importer.js.map
diff --git a/node_modules/rollup/dist/shared/index.js b/node_modules/rollup/dist/shared/index.js
new file mode 100644
index 0000000..3885b8e
--- /dev/null
+++ b/node_modules/rollup/dist/shared/index.js
@@ -0,0 +1,9003 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const rollup = require('./rollup.js');
+const require$$0$1 = require('path');
+const require$$0$2 = require('fs');
+const require$$2 = require('util');
+const require$$1 = require('stream');
+const require$$2$1 = require('os');
+const fseventsImporter = require('./fsevents-importer.js');
+const require$$0$3 = require('events');
+
+var chokidar$1 = {};
+
+var utils$2 = {};
+
+var constants$3;
+var hasRequiredConstants$3;
+
+function requireConstants$3 () {
+	if (hasRequiredConstants$3) return constants$3;
+	hasRequiredConstants$3 = 1;
+
+	const path = require$$0$1;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants$3 = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants$3;
+}
+
+var hasRequiredUtils$2;
+
+function requireUtils$2 () {
+	if (hasRequiredUtils$2) return utils$2;
+	hasRequiredUtils$2 = 1;
+	(function (exports) {
+
+		const path = require$$0$1;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants$3();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils$2));
+	return utils$2;
+}
+
+var scan_1$1;
+var hasRequiredScan$1;
+
+function requireScan$1 () {
+	if (hasRequiredScan$1) return scan_1$1;
+	hasRequiredScan$1 = 1;
+
+	const utils = /*@__PURE__*/ requireUtils$2();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants$3();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1$1 = scan;
+	return scan_1$1;
+}
+
+var parse_1$2;
+var hasRequiredParse$2;
+
+function requireParse$2 () {
+	if (hasRequiredParse$2) return parse_1$2;
+	hasRequiredParse$2 = 1;
+
+	const constants = /*@__PURE__*/ requireConstants$3();
+	const utils = /*@__PURE__*/ requireUtils$2();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1$2 = parse;
+	return parse_1$2;
+}
+
+var picomatch_1$1;
+var hasRequiredPicomatch$3;
+
+function requirePicomatch$3 () {
+	if (hasRequiredPicomatch$3) return picomatch_1$1;
+	hasRequiredPicomatch$3 = 1;
+
+	const path = require$$0$1;
+	const scan = /*@__PURE__*/ requireScan$1();
+	const parse = /*@__PURE__*/ requireParse$2();
+	const utils = /*@__PURE__*/ requireUtils$2();
+	const constants = /*@__PURE__*/ requireConstants$3();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1$1 = picomatch;
+	return picomatch_1$1;
+}
+
+var picomatch$1;
+var hasRequiredPicomatch$2;
+
+function requirePicomatch$2 () {
+	if (hasRequiredPicomatch$2) return picomatch$1;
+	hasRequiredPicomatch$2 = 1;
+
+	picomatch$1 = /*@__PURE__*/ requirePicomatch$3();
+	return picomatch$1;
+}
+
+var readdirp_1;
+var hasRequiredReaddirp;
+
+function requireReaddirp () {
+	if (hasRequiredReaddirp) return readdirp_1;
+	hasRequiredReaddirp = 1;
+
+	const fs = require$$0$2;
+	const { Readable } = require$$1;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const picomatch = /*@__PURE__*/ requirePicomatch$2();
+
+	const readdir = promisify(fs.readdir);
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const realpath = promisify(fs.realpath);
+
+	/**
+	 * @typedef {Object} EntryInfo
+	 * @property {String} path
+	 * @property {String} fullPath
+	 * @property {fs.Stats=} stats
+	 * @property {fs.Dirent=} dirent
+	 * @property {String} basename
+	 */
+
+	const BANG = '!';
+	const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+	const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+	const FILE_TYPE = 'files';
+	const DIR_TYPE = 'directories';
+	const FILE_DIR_TYPE = 'files_directories';
+	const EVERYTHING_TYPE = 'all';
+	const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+
+	const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+	const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+	const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
+
+	const normalizeFilter = filter => {
+	  if (filter === undefined) return;
+	  if (typeof filter === 'function') return filter;
+
+	  if (typeof filter === 'string') {
+	    const glob = picomatch(filter.trim());
+	    return entry => glob(entry.basename);
+	  }
+
+	  if (Array.isArray(filter)) {
+	    const positive = [];
+	    const negative = [];
+	    for (const item of filter) {
+	      const trimmed = item.trim();
+	      if (trimmed.charAt(0) === BANG) {
+	        negative.push(picomatch(trimmed.slice(1)));
+	      } else {
+	        positive.push(picomatch(trimmed));
+	      }
+	    }
+
+	    if (negative.length > 0) {
+	      if (positive.length > 0) {
+	        return entry =>
+	          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
+	      }
+	      return entry => !negative.some(f => f(entry.basename));
+	    }
+	    return entry => positive.some(f => f(entry.basename));
+	  }
+	};
+
+	class ReaddirpStream extends Readable {
+	  static get defaultOptions() {
+	    return {
+	      root: '.',
+	      /* eslint-disable no-unused-vars */
+	      fileFilter: (path) => true,
+	      directoryFilter: (path) => true,
+	      /* eslint-enable no-unused-vars */
+	      type: FILE_TYPE,
+	      lstat: false,
+	      depth: 2147483648,
+	      alwaysStat: false
+	    };
+	  }
+
+	  constructor(options = {}) {
+	    super({
+	      objectMode: true,
+	      autoDestroy: true,
+	      highWaterMark: options.highWaterMark || 4096
+	    });
+	    const opts = { ...ReaddirpStream.defaultOptions, ...options };
+	    const { root, type } = opts;
+
+	    this._fileFilter = normalizeFilter(opts.fileFilter);
+	    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+
+	    const statMethod = opts.lstat ? lstat : stat;
+	    // Use bigint stats if it's windows and stat() supports options (node 10+).
+	    if (wantBigintFsStats) {
+	      this._stat = path => statMethod(path, { bigint: true });
+	    } else {
+	      this._stat = statMethod;
+	    }
+
+	    this._maxDepth = opts.depth;
+	    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+	    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+	    this._wantsEverything = type === EVERYTHING_TYPE;
+	    this._root = sysPath.resolve(root);
+	    this._isDirent = ('Dirent' in fs) && !opts.alwaysStat;
+	    this._statsProp = this._isDirent ? 'dirent' : 'stats';
+	    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+
+	    // Launch stream with one parent, the root dir.
+	    this.parents = [this._exploreDir(root, 1)];
+	    this.reading = false;
+	    this.parent = undefined;
+	  }
+
+	  async _read(batch) {
+	    if (this.reading) return;
+	    this.reading = true;
+
+	    try {
+	      while (!this.destroyed && batch > 0) {
+	        const { path, depth, files = [] } = this.parent || {};
+
+	        if (files.length > 0) {
+	          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
+	          for (const entry of await Promise.all(slice)) {
+	            if (this.destroyed) return;
+
+	            const entryType = await this._getEntryType(entry);
+	            if (entryType === 'directory' && this._directoryFilter(entry)) {
+	              if (depth <= this._maxDepth) {
+	                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+	              }
+
+	              if (this._wantsDir) {
+	                this.push(entry);
+	                batch--;
+	              }
+	            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+	              if (this._wantsFile) {
+	                this.push(entry);
+	                batch--;
+	              }
+	            }
+	          }
+	        } else {
+	          const parent = this.parents.pop();
+	          if (!parent) {
+	            this.push(null);
+	            break;
+	          }
+	          this.parent = await parent;
+	          if (this.destroyed) return;
+	        }
+	      }
+	    } catch (error) {
+	      this.destroy(error);
+	    } finally {
+	      this.reading = false;
+	    }
+	  }
+
+	  async _exploreDir(path, depth) {
+	    let files;
+	    try {
+	      files = await readdir(path, this._rdOptions);
+	    } catch (error) {
+	      this._onError(error);
+	    }
+	    return { files, depth, path };
+	  }
+
+	  async _formatEntry(dirent, path) {
+	    let entry;
+	    try {
+	      const basename = this._isDirent ? dirent.name : dirent;
+	      const fullPath = sysPath.resolve(sysPath.join(path, basename));
+	      entry = { path: sysPath.relative(this._root, fullPath), fullPath, basename };
+	      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+	    } catch (err) {
+	      this._onError(err);
+	    }
+	    return entry;
+	  }
+
+	  _onError(err) {
+	    if (isNormalFlowError(err) && !this.destroyed) {
+	      this.emit('warn', err);
+	    } else {
+	      this.destroy(err);
+	    }
+	  }
+
+	  async _getEntryType(entry) {
+	    // entry may be undefined, because a warning or an error were emitted
+	    // and the statsProp is undefined
+	    const stats = entry && entry[this._statsProp];
+	    if (!stats) {
+	      return;
+	    }
+	    if (stats.isFile()) {
+	      return 'file';
+	    }
+	    if (stats.isDirectory()) {
+	      return 'directory';
+	    }
+	    if (stats && stats.isSymbolicLink()) {
+	      const full = entry.fullPath;
+	      try {
+	        const entryRealPath = await realpath(full);
+	        const entryRealPathStats = await lstat(entryRealPath);
+	        if (entryRealPathStats.isFile()) {
+	          return 'file';
+	        }
+	        if (entryRealPathStats.isDirectory()) {
+	          const len = entryRealPath.length;
+	          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath.sep) {
+	            const recursiveError = new Error(
+	              `Circular symlink detected: "${full}" points to "${entryRealPath}"`
+	            );
+	            recursiveError.code = RECURSIVE_ERROR_CODE;
+	            return this._onError(recursiveError);
+	          }
+	          return 'directory';
+	        }
+	      } catch (error) {
+	        this._onError(error);
+	      }
+	    }
+	  }
+
+	  _includeAsFile(entry) {
+	    const stats = entry && entry[this._statsProp];
+
+	    return stats && this._wantsEverything && !stats.isDirectory();
+	  }
+	}
+
+	/**
+	 * @typedef {Object} ReaddirpArguments
+	 * @property {Function=} fileFilter
+	 * @property {Function=} directoryFilter
+	 * @property {String=} type
+	 * @property {Number=} depth
+	 * @property {String=} root
+	 * @property {Boolean=} lstat
+	 * @property {Boolean=} bigint
+	 */
+
+	/**
+	 * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+	 * @param {String} root Root directory
+	 * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+	 */
+	const readdirp = (root, options = {}) => {
+	  let type = options.entryType || options.type;
+	  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
+	  if (type) options.type = type;
+	  if (!root) {
+	    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+	  } else if (typeof root !== 'string') {
+	    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+	  } else if (type && !ALL_TYPES.includes(type)) {
+	    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+	  }
+
+	  options.root = root;
+	  return new ReaddirpStream(options);
+	};
+
+	const readdirpPromise = (root, options = {}) => {
+	  return new Promise((resolve, reject) => {
+	    const files = [];
+	    readdirp(root, options)
+	      .on('data', entry => files.push(entry))
+	      .on('end', () => resolve(files))
+	      .on('error', error => reject(error));
+	  });
+	};
+
+	readdirp.promise = readdirpPromise;
+	readdirp.ReaddirpStream = ReaddirpStream;
+	readdirp.default = readdirp;
+
+	readdirp_1 = readdirp;
+	return readdirp_1;
+}
+
+var anymatch = {exports: {}};
+
+var utils$1 = {};
+
+var constants$2;
+var hasRequiredConstants$2;
+
+function requireConstants$2 () {
+	if (hasRequiredConstants$2) return constants$2;
+	hasRequiredConstants$2 = 1;
+
+	const path = require$$0$1;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants$2 = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants$2;
+}
+
+var hasRequiredUtils$1;
+
+function requireUtils$1 () {
+	if (hasRequiredUtils$1) return utils$1;
+	hasRequiredUtils$1 = 1;
+	(function (exports) {
+
+		const path = require$$0$1;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants$2();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils$1));
+	return utils$1;
+}
+
+var scan_1;
+var hasRequiredScan;
+
+function requireScan () {
+	if (hasRequiredScan) return scan_1;
+	hasRequiredScan = 1;
+
+	const utils = /*@__PURE__*/ requireUtils$1();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants$2();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1 = scan;
+	return scan_1;
+}
+
+var parse_1$1;
+var hasRequiredParse$1;
+
+function requireParse$1 () {
+	if (hasRequiredParse$1) return parse_1$1;
+	hasRequiredParse$1 = 1;
+
+	const constants = /*@__PURE__*/ requireConstants$2();
+	const utils = /*@__PURE__*/ requireUtils$1();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1$1 = parse;
+	return parse_1$1;
+}
+
+var picomatch_1;
+var hasRequiredPicomatch$1;
+
+function requirePicomatch$1 () {
+	if (hasRequiredPicomatch$1) return picomatch_1;
+	hasRequiredPicomatch$1 = 1;
+
+	const path = require$$0$1;
+	const scan = /*@__PURE__*/ requireScan();
+	const parse = /*@__PURE__*/ requireParse$1();
+	const utils = /*@__PURE__*/ requireUtils$1();
+	const constants = /*@__PURE__*/ requireConstants$2();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1 = picomatch;
+	return picomatch_1;
+}
+
+var picomatch;
+var hasRequiredPicomatch;
+
+function requirePicomatch () {
+	if (hasRequiredPicomatch) return picomatch;
+	hasRequiredPicomatch = 1;
+
+	picomatch = /*@__PURE__*/ requirePicomatch$1();
+	return picomatch;
+}
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var normalizePath;
+var hasRequiredNormalizePath;
+
+function requireNormalizePath () {
+	if (hasRequiredNormalizePath) return normalizePath;
+	hasRequiredNormalizePath = 1;
+	normalizePath = function(path, stripTrailing) {
+	  if (typeof path !== 'string') {
+	    throw new TypeError('expected path to be a string');
+	  }
+
+	  if (path === '\\' || path === '/') return '/';
+
+	  var len = path.length;
+	  if (len <= 1) return path;
+
+	  // ensure that win32 namespaces has two leading slashes, so that the path is
+	  // handled properly by the win32 version of path.parse() after being normalized
+	  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+	  var prefix = '';
+	  if (len > 4 && path[3] === '\\') {
+	    var ch = path[2];
+	    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+	      path = path.slice(2);
+	      prefix = '//';
+	    }
+	  }
+
+	  var segs = path.split(/[/\\]+/);
+	  if (stripTrailing !== false && segs[segs.length - 1] === '') {
+	    segs.pop();
+	  }
+	  return prefix + segs.join('/');
+	};
+	return normalizePath;
+}
+
+var anymatch_1 = anymatch.exports;
+
+var hasRequiredAnymatch;
+
+function requireAnymatch () {
+	if (hasRequiredAnymatch) return anymatch.exports;
+	hasRequiredAnymatch = 1;
+
+	Object.defineProperty(anymatch_1, "__esModule", { value: true });
+
+	const picomatch = /*@__PURE__*/ requirePicomatch();
+	const normalizePath = /*@__PURE__*/ requireNormalizePath();
+
+	/**
+	 * @typedef {(testString: string) => boolean} AnymatchFn
+	 * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+	 * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+	 */
+	const BANG = '!';
+	const DEFAULT_OPTIONS = {returnIndex: false};
+	const arrify = (item) => Array.isArray(item) ? item : [item];
+
+	/**
+	 * @param {AnymatchPattern} matcher
+	 * @param {object} options
+	 * @returns {AnymatchFn}
+	 */
+	const createPattern = (matcher, options) => {
+	  if (typeof matcher === 'function') {
+	    return matcher;
+	  }
+	  if (typeof matcher === 'string') {
+	    const glob = picomatch(matcher, options);
+	    return (string) => matcher === string || glob(string);
+	  }
+	  if (matcher instanceof RegExp) {
+	    return (string) => matcher.test(string);
+	  }
+	  return (string) => false;
+	};
+
+	/**
+	 * @param {Array<Function>} patterns
+	 * @param {Array<Function>} negPatterns
+	 * @param {String|Array} args
+	 * @param {Boolean} returnIndex
+	 * @returns {boolean|number}
+	 */
+	const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+	  const isList = Array.isArray(args);
+	  const _path = isList ? args[0] : args;
+	  if (!isList && typeof _path !== 'string') {
+	    throw new TypeError('anymatch: second argument must be a string: got ' +
+	      Object.prototype.toString.call(_path))
+	  }
+	  const path = normalizePath(_path, false);
+
+	  for (let index = 0; index < negPatterns.length; index++) {
+	    const nglob = negPatterns[index];
+	    if (nglob(path)) {
+	      return returnIndex ? -1 : false;
+	    }
+	  }
+
+	  const applied = isList && [path].concat(args.slice(1));
+	  for (let index = 0; index < patterns.length; index++) {
+	    const pattern = patterns[index];
+	    if (isList ? pattern(...applied) : pattern(path)) {
+	      return returnIndex ? index : true;
+	    }
+	  }
+
+	  return returnIndex ? -1 : false;
+	};
+
+	/**
+	 * @param {AnymatchMatcher} matchers
+	 * @param {Array|string} testString
+	 * @param {object} options
+	 * @returns {boolean|number|Function}
+	 */
+	const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
+	  if (matchers == null) {
+	    throw new TypeError('anymatch: specify first argument');
+	  }
+	  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
+	  const returnIndex = opts.returnIndex || false;
+
+	  // Early cache for matchers.
+	  const mtchers = arrify(matchers);
+	  const negatedGlobs = mtchers
+	    .filter(item => typeof item === 'string' && item.charAt(0) === BANG)
+	    .map(item => item.slice(1))
+	    .map(item => picomatch(item, opts));
+	  const patterns = mtchers
+	    .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG))
+	    .map(matcher => createPattern(matcher, opts));
+
+	  if (testString == null) {
+	    return (testString, ri = false) => {
+	      const returnIndex = typeof ri === 'boolean' ? ri : false;
+	      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+	    }
+	  }
+
+	  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+	};
+
+	anymatch$1.default = anymatch$1;
+	anymatch.exports = anymatch$1;
+	return anymatch.exports;
+}
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob;
+var hasRequiredIsExtglob;
+
+function requireIsExtglob () {
+	if (hasRequiredIsExtglob) return isExtglob;
+	hasRequiredIsExtglob = 1;
+	isExtglob = function isExtglob(str) {
+	  if (typeof str !== 'string' || str === '') {
+	    return false;
+	  }
+
+	  var match;
+	  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+	    if (match[2]) return true;
+	    str = str.slice(match.index + match[0].length);
+	  }
+
+	  return false;
+	};
+	return isExtglob;
+}
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isGlob;
+var hasRequiredIsGlob;
+
+function requireIsGlob () {
+	if (hasRequiredIsGlob) return isGlob;
+	hasRequiredIsGlob = 1;
+	var isExtglob = /*@__PURE__*/ requireIsExtglob();
+	var chars = { '{': '}', '(': ')', '[': ']'};
+	var strictCheck = function(str) {
+	  if (str[0] === '!') {
+	    return true;
+	  }
+	  var index = 0;
+	  var pipeIndex = -2;
+	  var closeSquareIndex = -2;
+	  var closeCurlyIndex = -2;
+	  var closeParenIndex = -2;
+	  var backSlashIndex = -2;
+	  while (index < str.length) {
+	    if (str[index] === '*') {
+	      return true;
+	    }
+
+	    if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) {
+	      return true;
+	    }
+
+	    if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') {
+	      if (closeSquareIndex < index) {
+	        closeSquareIndex = str.indexOf(']', index);
+	      }
+	      if (closeSquareIndex > index) {
+	        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+	          return true;
+	        }
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') {
+	      closeCurlyIndex = str.indexOf('}', index);
+	      if (closeCurlyIndex > index) {
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') {
+	      closeParenIndex = str.indexOf(')', index);
+	      if (closeParenIndex > index) {
+	        backSlashIndex = str.indexOf('\\', index);
+	        if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+	          return true;
+	        }
+	      }
+	    }
+
+	    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+	      if (pipeIndex < index) {
+	        pipeIndex = str.indexOf('|', index);
+	      }
+	      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+	        closeParenIndex = str.indexOf(')', pipeIndex);
+	        if (closeParenIndex > pipeIndex) {
+	          backSlashIndex = str.indexOf('\\', pipeIndex);
+	          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+	            return true;
+	          }
+	        }
+	      }
+	    }
+
+	    if (str[index] === '\\') {
+	      var open = str[index + 1];
+	      index += 2;
+	      var close = chars[open];
+
+	      if (close) {
+	        var n = str.indexOf(close, index);
+	        if (n !== -1) {
+	          index = n + 1;
+	        }
+	      }
+
+	      if (str[index] === '!') {
+	        return true;
+	      }
+	    } else {
+	      index++;
+	    }
+	  }
+	  return false;
+	};
+
+	var relaxedCheck = function(str) {
+	  if (str[0] === '!') {
+	    return true;
+	  }
+	  var index = 0;
+	  while (index < str.length) {
+	    if (/[*?{}()[\]]/.test(str[index])) {
+	      return true;
+	    }
+
+	    if (str[index] === '\\') {
+	      var open = str[index + 1];
+	      index += 2;
+	      var close = chars[open];
+
+	      if (close) {
+	        var n = str.indexOf(close, index);
+	        if (n !== -1) {
+	          index = n + 1;
+	        }
+	      }
+
+	      if (str[index] === '!') {
+	        return true;
+	      }
+	    } else {
+	      index++;
+	    }
+	  }
+	  return false;
+	};
+
+	isGlob = function isGlob(str, options) {
+	  if (typeof str !== 'string' || str === '') {
+	    return false;
+	  }
+
+	  if (isExtglob(str)) {
+	    return true;
+	  }
+
+	  var check = strictCheck;
+
+	  // optionally relax check
+	  if (options && options.strict === false) {
+	    check = relaxedCheck;
+	  }
+
+	  return check(str);
+	};
+	return isGlob;
+}
+
+var globParent;
+var hasRequiredGlobParent;
+
+function requireGlobParent () {
+	if (hasRequiredGlobParent) return globParent;
+	hasRequiredGlobParent = 1;
+
+	var isGlob = /*@__PURE__*/ requireIsGlob();
+	var pathPosixDirname = require$$0$1.posix.dirname;
+	var isWin32 = require$$2$1.platform() === 'win32';
+
+	var slash = '/';
+	var backslash = /\\/g;
+	var enclosure = /[\{\[].*[\}\]]$/;
+	var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+	var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+	/**
+	 * @param {string} str
+	 * @param {Object} opts
+	 * @param {boolean} [opts.flipBackslashes=true]
+	 * @returns {string}
+	 */
+	globParent = function globParent(str, opts) {
+	  var options = Object.assign({ flipBackslashes: true }, opts);
+
+	  // flip windows path separators
+	  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+	    str = str.replace(backslash, slash);
+	  }
+
+	  // special case for strings ending in enclosure containing path separator
+	  if (enclosure.test(str)) {
+	    str += slash;
+	  }
+
+	  // preserves full path in case of trailing path separator
+	  str += 'a';
+
+	  // remove path parts that are globby
+	  do {
+	    str = pathPosixDirname(str);
+	  } while (isGlob(str) || globby.test(str));
+
+	  // remove escape chars and return result
+	  return str.replace(escaped, '$1');
+	};
+	return globParent;
+}
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+
+		exports.isInteger = num => {
+		  if (typeof num === 'number') {
+		    return Number.isInteger(num);
+		  }
+		  if (typeof num === 'string' && num.trim() !== '') {
+		    return Number.isInteger(Number(num));
+		  }
+		  return false;
+		};
+
+		/**
+		 * Find a node of the given type
+		 */
+
+		exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+		/**
+		 * Find a node of the given type
+		 */
+
+		exports.exceedsLimit = (min, max, step = 1, limit) => {
+		  if (limit === false) return false;
+		  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+		  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+		};
+
+		/**
+		 * Escape the given node with '\\' before node.value
+		 */
+
+		exports.escapeNode = (block, n = 0, type) => {
+		  const node = block.nodes[n];
+		  if (!node) return;
+
+		  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+		    if (node.escaped !== true) {
+		      node.value = '\\' + node.value;
+		      node.escaped = true;
+		    }
+		  }
+		};
+
+		/**
+		 * Returns true if the given brace node should be enclosed in literal braces
+		 */
+
+		exports.encloseBrace = node => {
+		  if (node.type !== 'brace') return false;
+		  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+		    node.invalid = true;
+		    return true;
+		  }
+		  return false;
+		};
+
+		/**
+		 * Returns true if a brace node is invalid.
+		 */
+
+		exports.isInvalidBrace = block => {
+		  if (block.type !== 'brace') return false;
+		  if (block.invalid === true || block.dollar) return true;
+		  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+		    block.invalid = true;
+		    return true;
+		  }
+		  if (block.open !== true || block.close !== true) {
+		    block.invalid = true;
+		    return true;
+		  }
+		  return false;
+		};
+
+		/**
+		 * Returns true if a node is an open or close node
+		 */
+
+		exports.isOpenOrClose = node => {
+		  if (node.type === 'open' || node.type === 'close') {
+		    return true;
+		  }
+		  return node.open === true || node.close === true;
+		};
+
+		/**
+		 * Reduce an array of text nodes.
+		 */
+
+		exports.reduce = nodes => nodes.reduce((acc, node) => {
+		  if (node.type === 'text') acc.push(node.value);
+		  if (node.type === 'range') node.type = 'text';
+		  return acc;
+		}, []);
+
+		/**
+		 * Flatten an array
+		 */
+
+		exports.flatten = (...args) => {
+		  const result = [];
+
+		  const flat = arr => {
+		    for (let i = 0; i < arr.length; i++) {
+		      const ele = arr[i];
+
+		      if (Array.isArray(ele)) {
+		        flat(ele);
+		        continue;
+		      }
+
+		      if (ele !== undefined) {
+		        result.push(ele);
+		      }
+		    }
+		    return result;
+		  };
+
+		  flat(args);
+		  return result;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var stringify;
+var hasRequiredStringify;
+
+function requireStringify () {
+	if (hasRequiredStringify) return stringify;
+	hasRequiredStringify = 1;
+
+	const utils = /*@__PURE__*/ requireUtils();
+
+	stringify = (ast, options = {}) => {
+	  const stringify = (node, parent = {}) => {
+	    const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+	    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+	    let output = '';
+
+	    if (node.value) {
+	      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+	        return '\\' + node.value;
+	      }
+	      return node.value;
+	    }
+
+	    if (node.value) {
+	      return node.value;
+	    }
+
+	    if (node.nodes) {
+	      for (const child of node.nodes) {
+	        output += stringify(child);
+	      }
+	    }
+	    return output;
+	  };
+
+	  return stringify(ast);
+	};
+	return stringify;
+}
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isNumber;
+var hasRequiredIsNumber;
+
+function requireIsNumber () {
+	if (hasRequiredIsNumber) return isNumber;
+	hasRequiredIsNumber = 1;
+
+	isNumber = function(num) {
+	  if (typeof num === 'number') {
+	    return num - num === 0;
+	  }
+	  if (typeof num === 'string' && num.trim() !== '') {
+	    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+	  }
+	  return false;
+	};
+	return isNumber;
+}
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var toRegexRange_1;
+var hasRequiredToRegexRange;
+
+function requireToRegexRange () {
+	if (hasRequiredToRegexRange) return toRegexRange_1;
+	hasRequiredToRegexRange = 1;
+
+	const isNumber = /*@__PURE__*/ requireIsNumber();
+
+	const toRegexRange = (min, max, options) => {
+	  if (isNumber(min) === false) {
+	    throw new TypeError('toRegexRange: expected the first argument to be a number');
+	  }
+
+	  if (max === void 0 || min === max) {
+	    return String(min);
+	  }
+
+	  if (isNumber(max) === false) {
+	    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+	  }
+
+	  let opts = { relaxZeros: true, ...options };
+	  if (typeof opts.strictZeros === 'boolean') {
+	    opts.relaxZeros = opts.strictZeros === false;
+	  }
+
+	  let relax = String(opts.relaxZeros);
+	  let shorthand = String(opts.shorthand);
+	  let capture = String(opts.capture);
+	  let wrap = String(opts.wrap);
+	  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+	  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
+	    return toRegexRange.cache[cacheKey].result;
+	  }
+
+	  let a = Math.min(min, max);
+	  let b = Math.max(min, max);
+
+	  if (Math.abs(a - b) === 1) {
+	    let result = min + '|' + max;
+	    if (opts.capture) {
+	      return `(${result})`;
+	    }
+	    if (opts.wrap === false) {
+	      return result;
+	    }
+	    return `(?:${result})`;
+	  }
+
+	  let isPadded = hasPadding(min) || hasPadding(max);
+	  let state = { min, max, a, b };
+	  let positives = [];
+	  let negatives = [];
+
+	  if (isPadded) {
+	    state.isPadded = isPadded;
+	    state.maxLen = String(state.max).length;
+	  }
+
+	  if (a < 0) {
+	    let newMin = b < 0 ? Math.abs(b) : 1;
+	    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+	    a = state.a = 0;
+	  }
+
+	  if (b >= 0) {
+	    positives = splitToPatterns(a, b, state, opts);
+	  }
+
+	  state.negatives = negatives;
+	  state.positives = positives;
+	  state.result = collatePatterns(negatives, positives);
+
+	  if (opts.capture === true) {
+	    state.result = `(${state.result})`;
+	  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+	    state.result = `(?:${state.result})`;
+	  }
+
+	  toRegexRange.cache[cacheKey] = state;
+	  return state.result;
+	};
+
+	function collatePatterns(neg, pos, options) {
+	  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
+	  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
+	  let intersected = filterPatterns(neg, pos, '-?', true) || [];
+	  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+	  return subpatterns.join('|');
+	}
+
+	function splitToRanges(min, max) {
+	  let nines = 1;
+	  let zeros = 1;
+
+	  let stop = countNines(min, nines);
+	  let stops = new Set([max]);
+
+	  while (min <= stop && stop <= max) {
+	    stops.add(stop);
+	    nines += 1;
+	    stop = countNines(min, nines);
+	  }
+
+	  stop = countZeros(max + 1, zeros) - 1;
+
+	  while (min < stop && stop <= max) {
+	    stops.add(stop);
+	    zeros += 1;
+	    stop = countZeros(max + 1, zeros) - 1;
+	  }
+
+	  stops = [...stops];
+	  stops.sort(compare);
+	  return stops;
+	}
+
+	/**
+	 * Convert a range to a regex pattern
+	 * @param {Number} `start`
+	 * @param {Number} `stop`
+	 * @return {String}
+	 */
+
+	function rangeToPattern(start, stop, options) {
+	  if (start === stop) {
+	    return { pattern: start, count: [], digits: 0 };
+	  }
+
+	  let zipped = zip(start, stop);
+	  let digits = zipped.length;
+	  let pattern = '';
+	  let count = 0;
+
+	  for (let i = 0; i < digits; i++) {
+	    let [startDigit, stopDigit] = zipped[i];
+
+	    if (startDigit === stopDigit) {
+	      pattern += startDigit;
+
+	    } else if (startDigit !== '0' || stopDigit !== '9') {
+	      pattern += toCharacterClass(startDigit, stopDigit);
+
+	    } else {
+	      count++;
+	    }
+	  }
+
+	  if (count) {
+	    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+	  }
+
+	  return { pattern, count: [count], digits };
+	}
+
+	function splitToPatterns(min, max, tok, options) {
+	  let ranges = splitToRanges(min, max);
+	  let tokens = [];
+	  let start = min;
+	  let prev;
+
+	  for (let i = 0; i < ranges.length; i++) {
+	    let max = ranges[i];
+	    let obj = rangeToPattern(String(start), String(max), options);
+	    let zeros = '';
+
+	    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+	      if (prev.count.length > 1) {
+	        prev.count.pop();
+	      }
+
+	      prev.count.push(obj.count[0]);
+	      prev.string = prev.pattern + toQuantifier(prev.count);
+	      start = max + 1;
+	      continue;
+	    }
+
+	    if (tok.isPadded) {
+	      zeros = padZeros(max, tok, options);
+	    }
+
+	    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+	    tokens.push(obj);
+	    start = max + 1;
+	    prev = obj;
+	  }
+
+	  return tokens;
+	}
+
+	function filterPatterns(arr, comparison, prefix, intersection, options) {
+	  let result = [];
+
+	  for (let ele of arr) {
+	    let { string } = ele;
+
+	    // only push if _both_ are negative...
+	    if (!intersection && !contains(comparison, 'string', string)) {
+	      result.push(prefix + string);
+	    }
+
+	    // or _both_ are positive
+	    if (intersection && contains(comparison, 'string', string)) {
+	      result.push(prefix + string);
+	    }
+	  }
+	  return result;
+	}
+
+	/**
+	 * Zip strings
+	 */
+
+	function zip(a, b) {
+	  let arr = [];
+	  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+	  return arr;
+	}
+
+	function compare(a, b) {
+	  return a > b ? 1 : b > a ? -1 : 0;
+	}
+
+	function contains(arr, key, val) {
+	  return arr.some(ele => ele[key] === val);
+	}
+
+	function countNines(min, len) {
+	  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+	}
+
+	function countZeros(integer, zeros) {
+	  return integer - (integer % Math.pow(10, zeros));
+	}
+
+	function toQuantifier(digits) {
+	  let [start = 0, stop = ''] = digits;
+	  if (stop || start > 1) {
+	    return `{${start + (stop ? ',' + stop : '')}}`;
+	  }
+	  return '';
+	}
+
+	function toCharacterClass(a, b, options) {
+	  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+	}
+
+	function hasPadding(str) {
+	  return /^-?(0+)\d/.test(str);
+	}
+
+	function padZeros(value, tok, options) {
+	  if (!tok.isPadded) {
+	    return value;
+	  }
+
+	  let diff = Math.abs(tok.maxLen - String(value).length);
+	  let relax = options.relaxZeros !== false;
+
+	  switch (diff) {
+	    case 0:
+	      return '';
+	    case 1:
+	      return relax ? '0?' : '0';
+	    case 2:
+	      return relax ? '0{0,2}' : '00';
+	    default: {
+	      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+	    }
+	  }
+	}
+
+	/**
+	 * Cache
+	 */
+
+	toRegexRange.cache = {};
+	toRegexRange.clearCache = () => (toRegexRange.cache = {});
+
+	/**
+	 * Expose `toRegexRange`
+	 */
+
+	toRegexRange_1 = toRegexRange;
+	return toRegexRange_1;
+}
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var fillRange;
+var hasRequiredFillRange;
+
+function requireFillRange () {
+	if (hasRequiredFillRange) return fillRange;
+	hasRequiredFillRange = 1;
+
+	const util = require$$2;
+	const toRegexRange = /*@__PURE__*/ requireToRegexRange();
+
+	const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+	const transform = toNumber => {
+	  return value => toNumber === true ? Number(value) : String(value);
+	};
+
+	const isValidValue = value => {
+	  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+	};
+
+	const isNumber = num => Number.isInteger(+num);
+
+	const zeros = input => {
+	  let value = `${input}`;
+	  let index = -1;
+	  if (value[0] === '-') value = value.slice(1);
+	  if (value === '0') return false;
+	  while (value[++index] === '0');
+	  return index > 0;
+	};
+
+	const stringify = (start, end, options) => {
+	  if (typeof start === 'string' || typeof end === 'string') {
+	    return true;
+	  }
+	  return options.stringify === true;
+	};
+
+	const pad = (input, maxLength, toNumber) => {
+	  if (maxLength > 0) {
+	    let dash = input[0] === '-' ? '-' : '';
+	    if (dash) input = input.slice(1);
+	    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+	  }
+	  if (toNumber === false) {
+	    return String(input);
+	  }
+	  return input;
+	};
+
+	const toMaxLen = (input, maxLength) => {
+	  let negative = input[0] === '-' ? '-' : '';
+	  if (negative) {
+	    input = input.slice(1);
+	    maxLength--;
+	  }
+	  while (input.length < maxLength) input = '0' + input;
+	  return negative ? ('-' + input) : input;
+	};
+
+	const toSequence = (parts, options, maxLen) => {
+	  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+	  let prefix = options.capture ? '' : '?:';
+	  let positives = '';
+	  let negatives = '';
+	  let result;
+
+	  if (parts.positives.length) {
+	    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
+	  }
+
+	  if (parts.negatives.length) {
+	    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
+	  }
+
+	  if (positives && negatives) {
+	    result = `${positives}|${negatives}`;
+	  } else {
+	    result = positives || negatives;
+	  }
+
+	  if (options.wrap) {
+	    return `(${prefix}${result})`;
+	  }
+
+	  return result;
+	};
+
+	const toRange = (a, b, isNumbers, options) => {
+	  if (isNumbers) {
+	    return toRegexRange(a, b, { wrap: false, ...options });
+	  }
+
+	  let start = String.fromCharCode(a);
+	  if (a === b) return start;
+
+	  let stop = String.fromCharCode(b);
+	  return `[${start}-${stop}]`;
+	};
+
+	const toRegex = (start, end, options) => {
+	  if (Array.isArray(start)) {
+	    let wrap = options.wrap === true;
+	    let prefix = options.capture ? '' : '?:';
+	    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+	  }
+	  return toRegexRange(start, end, options);
+	};
+
+	const rangeError = (...args) => {
+	  return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+	};
+
+	const invalidRange = (start, end, options) => {
+	  if (options.strictRanges === true) throw rangeError([start, end]);
+	  return [];
+	};
+
+	const invalidStep = (step, options) => {
+	  if (options.strictRanges === true) {
+	    throw new TypeError(`Expected step "${step}" to be a number`);
+	  }
+	  return [];
+	};
+
+	const fillNumbers = (start, end, step = 1, options = {}) => {
+	  let a = Number(start);
+	  let b = Number(end);
+
+	  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+	    if (options.strictRanges === true) throw rangeError([start, end]);
+	    return [];
+	  }
+
+	  // fix negative zero
+	  if (a === 0) a = 0;
+	  if (b === 0) b = 0;
+
+	  let descending = a > b;
+	  let startString = String(start);
+	  let endString = String(end);
+	  let stepString = String(step);
+	  step = Math.max(Math.abs(step), 1);
+
+	  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+	  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+	  let toNumber = padded === false && stringify(start, end, options) === false;
+	  let format = options.transform || transform(toNumber);
+
+	  if (options.toRegex && step === 1) {
+	    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+	  }
+
+	  let parts = { negatives: [], positives: [] };
+	  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+	  let range = [];
+	  let index = 0;
+
+	  while (descending ? a >= b : a <= b) {
+	    if (options.toRegex === true && step > 1) {
+	      push(a);
+	    } else {
+	      range.push(pad(format(a, index), maxLen, toNumber));
+	    }
+	    a = descending ? a - step : a + step;
+	    index++;
+	  }
+
+	  if (options.toRegex === true) {
+	    return step > 1
+	      ? toSequence(parts, options, maxLen)
+	      : toRegex(range, null, { wrap: false, ...options });
+	  }
+
+	  return range;
+	};
+
+	const fillLetters = (start, end, step = 1, options = {}) => {
+	  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+	    return invalidRange(start, end, options);
+	  }
+
+	  let format = options.transform || (val => String.fromCharCode(val));
+	  let a = `${start}`.charCodeAt(0);
+	  let b = `${end}`.charCodeAt(0);
+
+	  let descending = a > b;
+	  let min = Math.min(a, b);
+	  let max = Math.max(a, b);
+
+	  if (options.toRegex && step === 1) {
+	    return toRange(min, max, false, options);
+	  }
+
+	  let range = [];
+	  let index = 0;
+
+	  while (descending ? a >= b : a <= b) {
+	    range.push(format(a, index));
+	    a = descending ? a - step : a + step;
+	    index++;
+	  }
+
+	  if (options.toRegex === true) {
+	    return toRegex(range, null, { wrap: false, options });
+	  }
+
+	  return range;
+	};
+
+	const fill = (start, end, step, options = {}) => {
+	  if (end == null && isValidValue(start)) {
+	    return [start];
+	  }
+
+	  if (!isValidValue(start) || !isValidValue(end)) {
+	    return invalidRange(start, end, options);
+	  }
+
+	  if (typeof step === 'function') {
+	    return fill(start, end, 1, { transform: step });
+	  }
+
+	  if (isObject(step)) {
+	    return fill(start, end, 0, step);
+	  }
+
+	  let opts = { ...options };
+	  if (opts.capture === true) opts.wrap = true;
+	  step = step || opts.step || 1;
+
+	  if (!isNumber(step)) {
+	    if (step != null && !isObject(step)) return invalidStep(step, opts);
+	    return fill(start, end, 1, step);
+	  }
+
+	  if (isNumber(start) && isNumber(end)) {
+	    return fillNumbers(start, end, step, opts);
+	  }
+
+	  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+	};
+
+	fillRange = fill;
+	return fillRange;
+}
+
+var compile_1;
+var hasRequiredCompile;
+
+function requireCompile () {
+	if (hasRequiredCompile) return compile_1;
+	hasRequiredCompile = 1;
+
+	const fill = /*@__PURE__*/ requireFillRange();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	const compile = (ast, options = {}) => {
+	  const walk = (node, parent = {}) => {
+	    const invalidBlock = utils.isInvalidBrace(parent);
+	    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+	    const invalid = invalidBlock === true || invalidNode === true;
+	    const prefix = options.escapeInvalid === true ? '\\' : '';
+	    let output = '';
+
+	    if (node.isOpen === true) {
+	      return prefix + node.value;
+	    }
+
+	    if (node.isClose === true) {
+	      console.log('node.isClose', prefix, node.value);
+	      return prefix + node.value;
+	    }
+
+	    if (node.type === 'open') {
+	      return invalid ? prefix + node.value : '(';
+	    }
+
+	    if (node.type === 'close') {
+	      return invalid ? prefix + node.value : ')';
+	    }
+
+	    if (node.type === 'comma') {
+	      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';
+	    }
+
+	    if (node.value) {
+	      return node.value;
+	    }
+
+	    if (node.nodes && node.ranges > 0) {
+	      const args = utils.reduce(node.nodes);
+	      const range = fill(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
+
+	      if (range.length !== 0) {
+	        return args.length > 1 && range.length > 1 ? `(${range})` : range;
+	      }
+	    }
+
+	    if (node.nodes) {
+	      for (const child of node.nodes) {
+	        output += walk(child, node);
+	      }
+	    }
+
+	    return output;
+	  };
+
+	  return walk(ast);
+	};
+
+	compile_1 = compile;
+	return compile_1;
+}
+
+var expand_1;
+var hasRequiredExpand;
+
+function requireExpand () {
+	if (hasRequiredExpand) return expand_1;
+	hasRequiredExpand = 1;
+
+	const fill = /*@__PURE__*/ requireFillRange();
+	const stringify = /*@__PURE__*/ requireStringify();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	const append = (queue = '', stash = '', enclose = false) => {
+	  const result = [];
+
+	  queue = [].concat(queue);
+	  stash = [].concat(stash);
+
+	  if (!stash.length) return queue;
+	  if (!queue.length) {
+	    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+	  }
+
+	  for (const item of queue) {
+	    if (Array.isArray(item)) {
+	      for (const value of item) {
+	        result.push(append(value, stash, enclose));
+	      }
+	    } else {
+	      for (let ele of stash) {
+	        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+	        result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+	      }
+	    }
+	  }
+	  return utils.flatten(result);
+	};
+
+	const expand = (ast, options = {}) => {
+	  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
+
+	  const walk = (node, parent = {}) => {
+	    node.queue = [];
+
+	    let p = parent;
+	    let q = parent.queue;
+
+	    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+	      p = p.parent;
+	      q = p.queue;
+	    }
+
+	    if (node.invalid || node.dollar) {
+	      q.push(append(q.pop(), stringify(node, options)));
+	      return;
+	    }
+
+	    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+	      q.push(append(q.pop(), ['{}']));
+	      return;
+	    }
+
+	    if (node.nodes && node.ranges > 0) {
+	      const args = utils.reduce(node.nodes);
+
+	      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+	        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+	      }
+
+	      let range = fill(...args, options);
+	      if (range.length === 0) {
+	        range = stringify(node, options);
+	      }
+
+	      q.push(append(q.pop(), range));
+	      node.nodes = [];
+	      return;
+	    }
+
+	    const enclose = utils.encloseBrace(node);
+	    let queue = node.queue;
+	    let block = node;
+
+	    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+	      block = block.parent;
+	      queue = block.queue;
+	    }
+
+	    for (let i = 0; i < node.nodes.length; i++) {
+	      const child = node.nodes[i];
+
+	      if (child.type === 'comma' && node.type === 'brace') {
+	        if (i === 1) queue.push('');
+	        queue.push('');
+	        continue;
+	      }
+
+	      if (child.type === 'close') {
+	        q.push(append(q.pop(), queue, enclose));
+	        continue;
+	      }
+
+	      if (child.value && child.type !== 'open') {
+	        queue.push(append(queue.pop(), child.value));
+	        continue;
+	      }
+
+	      if (child.nodes) {
+	        walk(child, node);
+	      }
+	    }
+
+	    return queue;
+	  };
+
+	  return utils.flatten(walk(ast));
+	};
+
+	expand_1 = expand;
+	return expand_1;
+}
+
+var constants$1;
+var hasRequiredConstants$1;
+
+function requireConstants$1 () {
+	if (hasRequiredConstants$1) return constants$1;
+	hasRequiredConstants$1 = 1;
+
+	constants$1 = {
+	  MAX_LENGTH: 10000,
+
+	  // Digits
+	  CHAR_0: '0', /* 0 */
+	  CHAR_9: '9', /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 'A', /* A */
+	  CHAR_LOWERCASE_A: 'a', /* a */
+	  CHAR_UPPERCASE_Z: 'Z', /* Z */
+	  CHAR_LOWERCASE_Z: 'z', /* z */
+
+	  CHAR_LEFT_PARENTHESES: '(', /* ( */
+	  CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+	  CHAR_ASTERISK: '*', /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: '&', /* & */
+	  CHAR_AT: '@', /* @ */
+	  CHAR_BACKSLASH: '\\', /* \ */
+	  CHAR_BACKTICK: '`', /* ` */
+	  CHAR_CARRIAGE_RETURN: '\r', /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+	  CHAR_COLON: ':', /* : */
+	  CHAR_COMMA: ',', /* , */
+	  CHAR_DOLLAR: '$', /* . */
+	  CHAR_DOT: '.', /* . */
+	  CHAR_DOUBLE_QUOTE: '"', /* " */
+	  CHAR_EQUAL: '=', /* = */
+	  CHAR_EXCLAMATION_MARK: '!', /* ! */
+	  CHAR_FORM_FEED: '\f', /* \f */
+	  CHAR_FORWARD_SLASH: '/', /* / */
+	  CHAR_HASH: '#', /* # */
+	  CHAR_HYPHEN_MINUS: '-', /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+	  CHAR_LEFT_CURLY_BRACE: '{', /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+	  CHAR_LINE_FEED: '\n', /* \n */
+	  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+	  CHAR_PERCENT: '%', /* % */
+	  CHAR_PLUS: '+', /* + */
+	  CHAR_QUESTION_MARK: '?', /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+	  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+	  CHAR_SEMICOLON: ';', /* ; */
+	  CHAR_SINGLE_QUOTE: '\'', /* ' */
+	  CHAR_SPACE: ' ', /*   */
+	  CHAR_TAB: '\t', /* \t */
+	  CHAR_UNDERSCORE: '_', /* _ */
+	  CHAR_VERTICAL_LINE: '|', /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+	};
+	return constants$1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const stringify = /*@__PURE__*/ requireStringify();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  CHAR_BACKSLASH, /* \ */
+	  CHAR_BACKTICK, /* ` */
+	  CHAR_COMMA, /* , */
+	  CHAR_DOT, /* . */
+	  CHAR_LEFT_PARENTHESES, /* ( */
+	  CHAR_RIGHT_PARENTHESES, /* ) */
+	  CHAR_LEFT_CURLY_BRACE, /* { */
+	  CHAR_RIGHT_CURLY_BRACE, /* } */
+	  CHAR_LEFT_SQUARE_BRACKET, /* [ */
+	  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+	  CHAR_DOUBLE_QUOTE, /* " */
+	  CHAR_SINGLE_QUOTE, /* ' */
+	  CHAR_NO_BREAK_SPACE,
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE
+	} = /*@__PURE__*/ requireConstants$1();
+
+	/**
+	 * parse
+	 */
+
+	const parse = (input, options = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  const opts = options || {};
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  if (input.length > max) {
+	    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+	  }
+
+	  const ast = { type: 'root', input, nodes: [] };
+	  const stack = [ast];
+	  let block = ast;
+	  let prev = ast;
+	  let brackets = 0;
+	  const length = input.length;
+	  let index = 0;
+	  let depth = 0;
+	  let value;
+
+	  /**
+	   * Helpers
+	   */
+
+	  const advance = () => input[index++];
+	  const push = node => {
+	    if (node.type === 'text' && prev.type === 'dot') {
+	      prev.type = 'text';
+	    }
+
+	    if (prev && prev.type === 'text' && node.type === 'text') {
+	      prev.value += node.value;
+	      return;
+	    }
+
+	    block.nodes.push(node);
+	    node.parent = block;
+	    node.prev = prev;
+	    prev = node;
+	    return node;
+	  };
+
+	  push({ type: 'bos' });
+
+	  while (index < length) {
+	    block = stack[stack.length - 1];
+	    value = advance();
+
+	    /**
+	     * Invalid chars
+	     */
+
+	    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped chars
+	     */
+
+	    if (value === CHAR_BACKSLASH) {
+	      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+	      continue;
+	    }
+
+	    /**
+	     * Right square bracket (literal): ']'
+	     */
+
+	    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+	      push({ type: 'text', value: '\\' + value });
+	      continue;
+	    }
+
+	    /**
+	     * Left square bracket: '['
+	     */
+
+	    if (value === CHAR_LEFT_SQUARE_BRACKET) {
+	      brackets++;
+
+	      let next;
+
+	      while (index < length && (next = advance())) {
+	        value += next;
+
+	        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+	          brackets++;
+	          continue;
+	        }
+
+	        if (next === CHAR_BACKSLASH) {
+	          value += advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          brackets--;
+
+	          if (brackets === 0) {
+	            break;
+	          }
+	        }
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === CHAR_LEFT_PARENTHESES) {
+	      block = push({ type: 'paren', nodes: [] });
+	      stack.push(block);
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    if (value === CHAR_RIGHT_PARENTHESES) {
+	      if (block.type !== 'paren') {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	      block = stack.pop();
+	      push({ type: 'text', value });
+	      block = stack[stack.length - 1];
+	      continue;
+	    }
+
+	    /**
+	     * Quotes: '|"|`
+	     */
+
+	    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+	      const open = value;
+	      let next;
+
+	      if (options.keepQuotes !== true) {
+	        value = '';
+	      }
+
+	      while (index < length && (next = advance())) {
+	        if (next === CHAR_BACKSLASH) {
+	          value += next + advance();
+	          continue;
+	        }
+
+	        if (next === open) {
+	          if (options.keepQuotes === true) value += next;
+	          break;
+	        }
+
+	        value += next;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Left curly brace: '{'
+	     */
+
+	    if (value === CHAR_LEFT_CURLY_BRACE) {
+	      depth++;
+
+	      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+	      const brace = {
+	        type: 'brace',
+	        open: true,
+	        close: false,
+	        dollar,
+	        depth,
+	        commas: 0,
+	        ranges: 0,
+	        nodes: []
+	      };
+
+	      block = push(brace);
+	      stack.push(block);
+	      push({ type: 'open', value });
+	      continue;
+	    }
+
+	    /**
+	     * Right curly brace: '}'
+	     */
+
+	    if (value === CHAR_RIGHT_CURLY_BRACE) {
+	      if (block.type !== 'brace') {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      const type = 'close';
+	      block = stack.pop();
+	      block.close = true;
+
+	      push({ type, value });
+	      depth--;
+
+	      block = stack[stack.length - 1];
+	      continue;
+	    }
+
+	    /**
+	     * Comma: ','
+	     */
+
+	    if (value === CHAR_COMMA && depth > 0) {
+	      if (block.ranges > 0) {
+	        block.ranges = 0;
+	        const open = block.nodes.shift();
+	        block.nodes = [open, { type: 'text', value: stringify(block) }];
+	      }
+
+	      push({ type: 'comma', value });
+	      block.commas++;
+	      continue;
+	    }
+
+	    /**
+	     * Dot: '.'
+	     */
+
+	    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+	      const siblings = block.nodes;
+
+	      if (depth === 0 || siblings.length === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      if (prev.type === 'dot') {
+	        block.range = [];
+	        prev.value += value;
+	        prev.type = 'range';
+
+	        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+	          block.invalid = true;
+	          block.ranges = 0;
+	          prev.type = 'text';
+	          continue;
+	        }
+
+	        block.ranges++;
+	        block.args = [];
+	        continue;
+	      }
+
+	      if (prev.type === 'range') {
+	        siblings.pop();
+
+	        const before = siblings[siblings.length - 1];
+	        before.value += prev.value + value;
+	        prev = before;
+	        block.ranges--;
+	        continue;
+	      }
+
+	      push({ type: 'dot', value });
+	      continue;
+	    }
+
+	    /**
+	     * Text
+	     */
+
+	    push({ type: 'text', value });
+	  }
+
+	  // Mark imbalanced braces and brackets as invalid
+	  do {
+	    block = stack.pop();
+
+	    if (block.type !== 'root') {
+	      block.nodes.forEach(node => {
+	        if (!node.nodes) {
+	          if (node.type === 'open') node.isOpen = true;
+	          if (node.type === 'close') node.isClose = true;
+	          if (!node.nodes) node.type = 'text';
+	          node.invalid = true;
+	        }
+	      });
+
+	      // get the location of the block on parent.nodes (block's siblings)
+	      const parent = stack[stack.length - 1];
+	      const index = parent.nodes.indexOf(block);
+	      // replace the (invalid) block with it's nodes
+	      parent.nodes.splice(index, 1, ...block.nodes);
+	    }
+	  } while (stack.length > 0);
+
+	  push({ type: 'eos' });
+	  return ast;
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+var braces_1;
+var hasRequiredBraces;
+
+function requireBraces () {
+	if (hasRequiredBraces) return braces_1;
+	hasRequiredBraces = 1;
+
+	const stringify = /*@__PURE__*/ requireStringify();
+	const compile = /*@__PURE__*/ requireCompile();
+	const expand = /*@__PURE__*/ requireExpand();
+	const parse = /*@__PURE__*/ requireParse();
+
+	/**
+	 * Expand the given pattern or create a regex-compatible string.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+	 * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {String}
+	 * @api public
+	 */
+
+	const braces = (input, options = {}) => {
+	  let output = [];
+
+	  if (Array.isArray(input)) {
+	    for (const pattern of input) {
+	      const result = braces.create(pattern, options);
+	      if (Array.isArray(result)) {
+	        output.push(...result);
+	      } else {
+	        output.push(result);
+	      }
+	    }
+	  } else {
+	    output = [].concat(braces.create(input, options));
+	  }
+
+	  if (options && options.expand === true && options.nodupes === true) {
+	    output = [...new Set(output)];
+	  }
+	  return output;
+	};
+
+	/**
+	 * Parse the given `str` with the given `options`.
+	 *
+	 * ```js
+	 * // braces.parse(pattern, [, options]);
+	 * const ast = braces.parse('a/{b,c}/d');
+	 * console.log(ast);
+	 * ```
+	 * @param {String} pattern Brace pattern to parse
+	 * @param {Object} options
+	 * @return {Object} Returns an AST
+	 * @api public
+	 */
+
+	braces.parse = (input, options = {}) => parse(input, options);
+
+	/**
+	 * Creates a braces string from an AST, or an AST node.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * let ast = braces.parse('foo/{a,b}/bar');
+	 * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+	 * ```
+	 * @param {String} `input` Brace pattern or AST.
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.stringify = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    return stringify(braces.parse(input, options), options);
+	  }
+	  return stringify(input, options);
+	};
+
+	/**
+	 * Compiles a brace pattern into a regex-compatible, optimized string.
+	 * This method is called by the main [braces](#braces) function by default.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.compile('a/{b,c}/d'));
+	 * //=> ['a/(b|c)/d']
+	 * ```
+	 * @param {String} `input` Brace pattern or AST.
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.compile = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    input = braces.parse(input, options);
+	  }
+	  return compile(input, options);
+	};
+
+	/**
+	 * Expands a brace pattern into an array. This method is called by the
+	 * main [braces](#braces) function when `options.expand` is true. Before
+	 * using this method it's recommended that you read the [performance notes](#performance))
+	 * and advantages of using [.compile](#compile) instead.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.expand('a/{b,c}/d'));
+	 * //=> ['a/b/d', 'a/c/d'];
+	 * ```
+	 * @param {String} `pattern` Brace pattern
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.expand = (input, options = {}) => {
+	  if (typeof input === 'string') {
+	    input = braces.parse(input, options);
+	  }
+
+	  let result = expand(input, options);
+
+	  // filter out empty strings if specified
+	  if (options.noempty === true) {
+	    result = result.filter(Boolean);
+	  }
+
+	  // filter out duplicates if specified
+	  if (options.nodupes === true) {
+	    result = [...new Set(result)];
+	  }
+
+	  return result;
+	};
+
+	/**
+	 * Processes a brace pattern and returns either an expanded array
+	 * (if `options.expand` is true), a highly optimized regex-compatible string.
+	 * This method is called by the main [braces](#braces) function.
+	 *
+	 * ```js
+	 * const braces = require('braces');
+	 * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+	 * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+	 * ```
+	 * @param {String} `pattern` Brace pattern
+	 * @param {Object} `options`
+	 * @return {Array} Returns an array of expanded values.
+	 * @api public
+	 */
+
+	braces.create = (input, options = {}) => {
+	  if (input === '' || input.length < 3) {
+	    return [input];
+	  }
+
+	  return options.expand !== true
+	    ? braces.compile(input, options)
+	    : braces.expand(input, options);
+	};
+
+	/**
+	 * Expose "braces"
+	 */
+
+	braces_1 = braces;
+	return braces_1;
+}
+
+const require$$0 = [
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"afdesign",
+	"afphoto",
+	"afpub",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+];
+
+var binaryExtensions;
+var hasRequiredBinaryExtensions;
+
+function requireBinaryExtensions () {
+	if (hasRequiredBinaryExtensions) return binaryExtensions;
+	hasRequiredBinaryExtensions = 1;
+	binaryExtensions = require$$0;
+	return binaryExtensions;
+}
+
+var isBinaryPath;
+var hasRequiredIsBinaryPath;
+
+function requireIsBinaryPath () {
+	if (hasRequiredIsBinaryPath) return isBinaryPath;
+	hasRequiredIsBinaryPath = 1;
+	const path = require$$0$1;
+	const binaryExtensions = /*@__PURE__*/ requireBinaryExtensions();
+
+	const extensions = new Set(binaryExtensions);
+
+	isBinaryPath = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
+	return isBinaryPath;
+}
+
+var constants = {};
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	(function (exports) {
+
+		const {sep} = require$$0$1;
+		const {platform} = process;
+		const os = require$$2$1;
+
+		exports.EV_ALL = 'all';
+		exports.EV_READY = 'ready';
+		exports.EV_ADD = 'add';
+		exports.EV_CHANGE = 'change';
+		exports.EV_ADD_DIR = 'addDir';
+		exports.EV_UNLINK = 'unlink';
+		exports.EV_UNLINK_DIR = 'unlinkDir';
+		exports.EV_RAW = 'raw';
+		exports.EV_ERROR = 'error';
+
+		exports.STR_DATA = 'data';
+		exports.STR_END = 'end';
+		exports.STR_CLOSE = 'close';
+
+		exports.FSEVENT_CREATED = 'created';
+		exports.FSEVENT_MODIFIED = 'modified';
+		exports.FSEVENT_DELETED = 'deleted';
+		exports.FSEVENT_MOVED = 'moved';
+		exports.FSEVENT_CLONED = 'cloned';
+		exports.FSEVENT_UNKNOWN = 'unknown';
+		exports.FSEVENT_FLAG_MUST_SCAN_SUBDIRS = 1;
+		exports.FSEVENT_TYPE_FILE = 'file';
+		exports.FSEVENT_TYPE_DIRECTORY = 'directory';
+		exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+
+		exports.KEY_LISTENERS = 'listeners';
+		exports.KEY_ERR = 'errHandlers';
+		exports.KEY_RAW = 'rawEmitters';
+		exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+
+		exports.DOT_SLASH = `.${sep}`;
+
+		exports.BACK_SLASH_RE = /\\/g;
+		exports.DOUBLE_SLASH_RE = /\/\//;
+		exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+		exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+		exports.REPLACER_RE = /^\.[/\\]/;
+
+		exports.SLASH = '/';
+		exports.SLASH_SLASH = '//';
+		exports.BRACE_START = '{';
+		exports.BANG = '!';
+		exports.ONE_DOT = '.';
+		exports.TWO_DOTS = '..';
+		exports.STAR = '*';
+		exports.GLOBSTAR = '**';
+		exports.ROOT_GLOBSTAR = '/**/*';
+		exports.SLASH_GLOBSTAR = '/**';
+		exports.DIR_SUFFIX = 'Dir';
+		exports.ANYMATCH_OPTS = {dot: true};
+		exports.STRING_TYPE = 'string';
+		exports.FUNCTION_TYPE = 'function';
+		exports.EMPTY_STR = '';
+		exports.EMPTY_FN = () => {};
+		exports.IDENTITY_FN = val => val;
+
+		exports.isWindows = platform === 'win32';
+		exports.isMacos = platform === 'darwin';
+		exports.isLinux = platform === 'linux';
+		exports.isIBMi = os.type() === 'OS400'; 
+	} (constants));
+	return constants;
+}
+
+var nodefsHandler;
+var hasRequiredNodefsHandler;
+
+function requireNodefsHandler () {
+	if (hasRequiredNodefsHandler) return nodefsHandler;
+	hasRequiredNodefsHandler = 1;
+
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const isBinaryPath = /*@__PURE__*/ requireIsBinaryPath();
+	const {
+	  isWindows,
+	  isLinux,
+	  EMPTY_FN,
+	  EMPTY_STR,
+	  KEY_LISTENERS,
+	  KEY_ERR,
+	  KEY_RAW,
+	  HANDLER_KEYS,
+	  EV_CHANGE,
+	  EV_ADD,
+	  EV_ADD_DIR,
+	  EV_ERROR,
+	  STR_DATA,
+	  STR_END,
+	  BRACE_START,
+	  STAR
+	} = /*@__PURE__*/ requireConstants();
+
+	const THROTTLE_MODE_WATCH = 'watch';
+
+	const open = promisify(fs.open);
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const close = promisify(fs.close);
+	const fsrealpath = promisify(fs.realpath);
+
+	const statMethods = { lstat, stat };
+
+	// TODO: emit errors properly. Example: EMFILE on Macos.
+	const foreach = (val, fn) => {
+	  if (val instanceof Set) {
+	    val.forEach(fn);
+	  } else {
+	    fn(val);
+	  }
+	};
+
+	const addAndConvert = (main, prop, item) => {
+	  let container = main[prop];
+	  if (!(container instanceof Set)) {
+	    main[prop] = container = new Set([container]);
+	  }
+	  container.add(item);
+	};
+
+	const clearItem = cont => key => {
+	  const set = cont[key];
+	  if (set instanceof Set) {
+	    set.clear();
+	  } else {
+	    delete cont[key];
+	  }
+	};
+
+	const delFromSet = (main, prop, item) => {
+	  const container = main[prop];
+	  if (container instanceof Set) {
+	    container.delete(item);
+	  } else if (container === item) {
+	    delete main[prop];
+	  }
+	};
+
+	const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+
+	/**
+	 * @typedef {String} Path
+	 */
+
+	// fs_watch helpers
+
+	// object to hold per-process fs_watch instances
+	// (may be shared across chokidar FSWatcher instances)
+
+	/**
+	 * @typedef {Object} FsWatchContainer
+	 * @property {Set} listeners
+	 * @property {Set} errHandlers
+	 * @property {Set} rawEmitters
+	 * @property {fs.FSWatcher=} watcher
+	 * @property {Boolean=} watcherUnusable
+	 */
+
+	/**
+	 * @type {Map<String,FsWatchContainer>}
+	 */
+	const FsWatchInstances = new Map();
+
+	/**
+	 * Instantiates the fs_watch interface
+	 * @param {String} path to be watched
+	 * @param {Object} options to be passed to fs_watch
+	 * @param {Function} listener main event handler
+	 * @param {Function} errHandler emits info about errors
+	 * @param {Function} emitRaw emits raw event data
+	 * @returns {fs.FSWatcher} new fsevents instance
+	 */
+	function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+	  const handleEvent = (rawEvent, evPath) => {
+	    listener(path);
+	    emitRaw(rawEvent, evPath, {watchedPath: path});
+
+	    // emit based on events occurring for files from a directory's watcher in
+	    // case the file's watcher misses it (and rely on throttling to de-dupe)
+	    if (evPath && path !== evPath) {
+	      fsWatchBroadcast(
+	        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
+	      );
+	    }
+	  };
+	  try {
+	    return fs.watch(path, options, handleEvent);
+	  } catch (error) {
+	    errHandler(error);
+	  }
+	}
+
+	/**
+	 * Helper for passing fs_watch event data to a collection of listeners
+	 * @param {Path} fullPath absolute path bound to fs_watch instance
+	 * @param {String} type listener type
+	 * @param {*=} val1 arguments to be passed to listeners
+	 * @param {*=} val2
+	 * @param {*=} val3
+	 */
+	const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+	  const cont = FsWatchInstances.get(fullPath);
+	  if (!cont) return;
+	  foreach(cont[type], (listener) => {
+	    listener(val1, val2, val3);
+	  });
+	};
+
+	/**
+	 * Instantiates the fs_watch interface or binds listeners
+	 * to an existing one covering the same file system entry
+	 * @param {String} path
+	 * @param {String} fullPath absolute path
+	 * @param {Object} options to be passed to fs_watch
+	 * @param {Object} handlers container for event listener functions
+	 */
+	const setFsWatchListener = (path, fullPath, options, handlers) => {
+	  const {listener, errHandler, rawEmitter} = handlers;
+	  let cont = FsWatchInstances.get(fullPath);
+
+	  /** @type {fs.FSWatcher=} */
+	  let watcher;
+	  if (!options.persistent) {
+	    watcher = createFsWatchInstance(
+	      path, options, listener, errHandler, rawEmitter
+	    );
+	    return watcher.close.bind(watcher);
+	  }
+	  if (cont) {
+	    addAndConvert(cont, KEY_LISTENERS, listener);
+	    addAndConvert(cont, KEY_ERR, errHandler);
+	    addAndConvert(cont, KEY_RAW, rawEmitter);
+	  } else {
+	    watcher = createFsWatchInstance(
+	      path,
+	      options,
+	      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+	      errHandler, // no need to use broadcast here
+	      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+	    );
+	    if (!watcher) return;
+	    watcher.on(EV_ERROR, async (error) => {
+	      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+	      cont.watcherUnusable = true; // documented since Node 10.4.1
+	      // Workaround for https://github.com/joyent/node/issues/4337
+	      if (isWindows && error.code === 'EPERM') {
+	        try {
+	          const fd = await open(path, 'r');
+	          await close(fd);
+	          broadcastErr(error);
+	        } catch (err) {}
+	      } else {
+	        broadcastErr(error);
+	      }
+	    });
+	    cont = {
+	      listeners: listener,
+	      errHandlers: errHandler,
+	      rawEmitters: rawEmitter,
+	      watcher
+	    };
+	    FsWatchInstances.set(fullPath, cont);
+	  }
+	  // const index = cont.listeners.indexOf(listener);
+
+	  // removes this instance's listeners and closes the underlying fs_watch
+	  // instance if there are no more listeners left
+	  return () => {
+	    delFromSet(cont, KEY_LISTENERS, listener);
+	    delFromSet(cont, KEY_ERR, errHandler);
+	    delFromSet(cont, KEY_RAW, rawEmitter);
+	    if (isEmptySet(cont.listeners)) {
+	      // Check to protect against issue gh-730.
+	      // if (cont.watcherUnusable) {
+	      cont.watcher.close();
+	      // }
+	      FsWatchInstances.delete(fullPath);
+	      HANDLER_KEYS.forEach(clearItem(cont));
+	      cont.watcher = undefined;
+	      Object.freeze(cont);
+	    }
+	  };
+	};
+
+	// fs_watchFile helpers
+
+	// object to hold per-process fs_watchFile instances
+	// (may be shared across chokidar FSWatcher instances)
+	const FsWatchFileInstances = new Map();
+
+	/**
+	 * Instantiates the fs_watchFile interface or binds listeners
+	 * to an existing one covering the same file system entry
+	 * @param {String} path to be watched
+	 * @param {String} fullPath absolute path
+	 * @param {Object} options options to be passed to fs_watchFile
+	 * @param {Object} handlers container for event listener functions
+	 * @returns {Function} closer
+	 */
+	const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+	  const {listener, rawEmitter} = handlers;
+	  let cont = FsWatchFileInstances.get(fullPath);
+
+	  const copts = cont && cont.options;
+	  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+	    fs.unwatchFile(fullPath);
+	    cont = undefined;
+	  }
+
+	  /* eslint-enable no-unused-vars, prefer-destructuring */
+
+	  if (cont) {
+	    addAndConvert(cont, KEY_LISTENERS, listener);
+	    addAndConvert(cont, KEY_RAW, rawEmitter);
+	  } else {
+	    // TODO
+	    // listeners.add(listener);
+	    // rawEmitters.add(rawEmitter);
+	    cont = {
+	      listeners: listener,
+	      rawEmitters: rawEmitter,
+	      options,
+	      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
+	        foreach(cont.rawEmitters, (rawEmitter) => {
+	          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
+	        });
+	        const currmtime = curr.mtimeMs;
+	        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+	          foreach(cont.listeners, (listener) => listener(path, curr));
+	        }
+	      })
+	    };
+	    FsWatchFileInstances.set(fullPath, cont);
+	  }
+	  // const index = cont.listeners.indexOf(listener);
+
+	  // Removes this instance's listeners and closes the underlying fs_watchFile
+	  // instance if there are no more listeners left.
+	  return () => {
+	    delFromSet(cont, KEY_LISTENERS, listener);
+	    delFromSet(cont, KEY_RAW, rawEmitter);
+	    if (isEmptySet(cont.listeners)) {
+	      FsWatchFileInstances.delete(fullPath);
+	      fs.unwatchFile(fullPath);
+	      cont.options = cont.watcher = undefined;
+	      Object.freeze(cont);
+	    }
+	  };
+	};
+
+	/**
+	 * @mixin
+	 */
+	class NodeFsHandler {
+
+	/**
+	 * @param {import("../index").FSWatcher} fsW
+	 */
+	constructor(fsW) {
+	  this.fsw = fsW;
+	  this._boundHandleError = (error) => fsW._handleError(error);
+	}
+
+	/**
+	 * Watch file for changes with fs_watchFile or fs_watch.
+	 * @param {String} path to file or dir
+	 * @param {Function} listener on fs change
+	 * @returns {Function} closer for the watcher instance
+	 */
+	_watchWithNodeFs(path, listener) {
+	  const opts = this.fsw.options;
+	  const directory = sysPath.dirname(path);
+	  const basename = sysPath.basename(path);
+	  const parent = this.fsw._getWatchedDir(directory);
+	  parent.add(basename);
+	  const absolutePath = sysPath.resolve(path);
+	  const options = {persistent: opts.persistent};
+	  if (!listener) listener = EMPTY_FN;
+
+	  let closer;
+	  if (opts.usePolling) {
+	    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+	      opts.binaryInterval : opts.interval;
+	    closer = setFsWatchFileListener(path, absolutePath, options, {
+	      listener,
+	      rawEmitter: this.fsw._emitRaw
+	    });
+	  } else {
+	    closer = setFsWatchListener(path, absolutePath, options, {
+	      listener,
+	      errHandler: this._boundHandleError,
+	      rawEmitter: this.fsw._emitRaw
+	    });
+	  }
+	  return closer;
+	}
+
+	/**
+	 * Watch a file and emit add event if warranted.
+	 * @param {Path} file Path
+	 * @param {fs.Stats} stats result of fs_stat
+	 * @param {Boolean} initialAdd was the file added at watch instantiation?
+	 * @returns {Function} closer for the watcher instance
+	 */
+	_handleFile(file, stats, initialAdd) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const dirname = sysPath.dirname(file);
+	  const basename = sysPath.basename(file);
+	  const parent = this.fsw._getWatchedDir(dirname);
+	  // stats is always present
+	  let prevStats = stats;
+
+	  // if the file is already being watched, do nothing
+	  if (parent.has(basename)) return;
+
+	  const listener = async (path, newStats) => {
+	    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+	    if (!newStats || newStats.mtimeMs === 0) {
+	      try {
+	        const newStats = await stat(file);
+	        if (this.fsw.closed) return;
+	        // Check that change event was not fired because of changed only accessTime.
+	        const at = newStats.atimeMs;
+	        const mt = newStats.mtimeMs;
+	        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+	          this.fsw._emit(EV_CHANGE, file, newStats);
+	        }
+	        if (isLinux && prevStats.ino !== newStats.ino) {
+	          this.fsw._closeFile(path);
+	          prevStats = newStats;
+	          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+	        } else {
+	          prevStats = newStats;
+	        }
+	      } catch (error) {
+	        // Fix issues where mtime is null but file is still present
+	        this.fsw._remove(dirname, basename);
+	      }
+	      // add is about to be emitted if file not already tracked in parent
+	    } else if (parent.has(basename)) {
+	      // Check that change event was not fired because of changed only accessTime.
+	      const at = newStats.atimeMs;
+	      const mt = newStats.mtimeMs;
+	      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+	        this.fsw._emit(EV_CHANGE, file, newStats);
+	      }
+	      prevStats = newStats;
+	    }
+	  };
+	  // kick off the watcher
+	  const closer = this._watchWithNodeFs(file, listener);
+
+	  // emit an add event if we're supposed to
+	  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+	    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
+	    this.fsw._emit(EV_ADD, file, stats);
+	  }
+
+	  return closer;
+	}
+
+	/**
+	 * Handle symlinks encountered while reading a dir.
+	 * @param {Object} entry returned by readdirp
+	 * @param {String} directory path of dir being read
+	 * @param {String} path of this item
+	 * @param {String} item basename of this item
+	 * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+	 */
+	async _handleSymlink(entry, directory, path, item) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const full = entry.fullPath;
+	  const dir = this.fsw._getWatchedDir(directory);
+
+	  if (!this.fsw.options.followSymlinks) {
+	    // watch symlink directly (don't follow) and detect changes
+	    this.fsw._incrReadyCount();
+
+	    let linkPath;
+	    try {
+	      linkPath = await fsrealpath(path);
+	    } catch (e) {
+	      this.fsw._emitReady();
+	      return true;
+	    }
+
+	    if (this.fsw.closed) return;
+	    if (dir.has(item)) {
+	      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+	        this.fsw._symlinkPaths.set(full, linkPath);
+	        this.fsw._emit(EV_CHANGE, path, entry.stats);
+	      }
+	    } else {
+	      dir.add(item);
+	      this.fsw._symlinkPaths.set(full, linkPath);
+	      this.fsw._emit(EV_ADD, path, entry.stats);
+	    }
+	    this.fsw._emitReady();
+	    return true;
+	  }
+
+	  // don't follow the same symlink more than once
+	  if (this.fsw._symlinkPaths.has(full)) {
+	    return true;
+	  }
+
+	  this.fsw._symlinkPaths.set(full, true);
+	}
+
+	_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+	  // Normalize the directory name on Windows
+	  directory = sysPath.join(directory, EMPTY_STR);
+
+	  if (!wh.hasGlob) {
+	    throttler = this.fsw._throttle('readdir', directory, 1000);
+	    if (!throttler) return;
+	  }
+
+	  const previous = this.fsw._getWatchedDir(wh.path);
+	  const current = new Set();
+
+	  let stream = this.fsw._readdirp(directory, {
+	    fileFilter: entry => wh.filterPath(entry),
+	    directoryFilter: entry => wh.filterDir(entry),
+	    depth: 0
+	  }).on(STR_DATA, async (entry) => {
+	    if (this.fsw.closed) {
+	      stream = undefined;
+	      return;
+	    }
+	    const item = entry.path;
+	    let path = sysPath.join(directory, item);
+	    current.add(item);
+
+	    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+	      return;
+	    }
+
+	    if (this.fsw.closed) {
+	      stream = undefined;
+	      return;
+	    }
+	    // Files that present in current directory snapshot
+	    // but absent in previous are added to watch list and
+	    // emit `add` event.
+	    if (item === target || !target && !previous.has(item)) {
+	      this.fsw._incrReadyCount();
+
+	      // ensure relativeness of path is preserved in case of watcher reuse
+	      path = sysPath.join(dir, sysPath.relative(dir, path));
+
+	      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+	    }
+	  }).on(EV_ERROR, this._boundHandleError);
+
+	  return new Promise(resolve =>
+	    stream.once(STR_END, () => {
+	      if (this.fsw.closed) {
+	        stream = undefined;
+	        return;
+	      }
+	      const wasThrottled = throttler ? throttler.clear() : false;
+
+	      resolve();
+
+	      // Files that absent in current directory snapshot
+	      // but present in previous emit `remove` event
+	      // and are removed from @watched[directory].
+	      previous.getChildren().filter((item) => {
+	        return item !== directory &&
+	          !current.has(item) &&
+	          // in case of intersecting globs;
+	          // a path may have been filtered out of this readdir, but
+	          // shouldn't be removed because it matches a different glob
+	          (!wh.hasGlob || wh.filterPath({
+	            fullPath: sysPath.resolve(directory, item)
+	          }));
+	      }).forEach((item) => {
+	        this.fsw._remove(directory, item);
+	      });
+
+	      stream = undefined;
+
+	      // one more time for any missed in case changes came in extremely quickly
+	      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+	    })
+	  );
+	}
+
+	/**
+	 * Read directory to add / remove files from `@watched` list and re-read it on change.
+	 * @param {String} dir fs path
+	 * @param {fs.Stats} stats
+	 * @param {Boolean} initialAdd
+	 * @param {Number} depth relative to user-supplied path
+	 * @param {String} target child path targeted for watch
+	 * @param {Object} wh Common watch helpers for this path
+	 * @param {String} realpath
+	 * @returns {Promise<Function>} closer for the watcher instance.
+	 */
+	async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+	  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+	  const tracked = parentDir.has(sysPath.basename(dir));
+	  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+	    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
+	  }
+
+	  // ensure dir is tracked (harmless if redundant)
+	  parentDir.add(sysPath.basename(dir));
+	  this.fsw._getWatchedDir(dir);
+	  let throttler;
+	  let closer;
+
+	  const oDepth = this.fsw.options.depth;
+	  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+	    if (!target) {
+	      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+	      if (this.fsw.closed) return;
+	    }
+
+	    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+	      // if current directory is removed, do nothing
+	      if (stats && stats.mtimeMs === 0) return;
+
+	      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+	    });
+	  }
+	  return closer;
+	}
+
+	/**
+	 * Handle added file, directory, or glob pattern.
+	 * Delegates call to _handleFile / _handleDir after checks.
+	 * @param {String} path to file or ir
+	 * @param {Boolean} initialAdd was the file added at watch instantiation?
+	 * @param {Object} priorWh depth relative to user-supplied path
+	 * @param {Number} depth Child path actually targeted for watch
+	 * @param {String=} target Child path actually targeted for watch
+	 * @returns {Promise}
+	 */
+	async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+	  const ready = this.fsw._emitReady;
+	  if (this.fsw._isIgnored(path) || this.fsw.closed) {
+	    ready();
+	    return false;
+	  }
+
+	  const wh = this.fsw._getWatchHelpers(path, depth);
+	  if (!wh.hasGlob && priorWh) {
+	    wh.hasGlob = priorWh.hasGlob;
+	    wh.globFilter = priorWh.globFilter;
+	    wh.filterPath = entry => priorWh.filterPath(entry);
+	    wh.filterDir = entry => priorWh.filterDir(entry);
+	  }
+
+	  // evaluate what is at the path we're being asked to watch
+	  try {
+	    const stats = await statMethods[wh.statMethod](wh.watchPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+	      ready();
+	      return false;
+	    }
+
+	    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START);
+	    let closer;
+	    if (stats.isDirectory()) {
+	      const absPath = sysPath.resolve(path);
+	      const targetPath = follow ? await fsrealpath(path) : path;
+	      if (this.fsw.closed) return;
+	      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+	      if (this.fsw.closed) return;
+	      // preserve this symlink's target path
+	      if (absPath !== targetPath && targetPath !== undefined) {
+	        this.fsw._symlinkPaths.set(absPath, targetPath);
+	      }
+	    } else if (stats.isSymbolicLink()) {
+	      const targetPath = follow ? await fsrealpath(path) : path;
+	      if (this.fsw.closed) return;
+	      const parent = sysPath.dirname(wh.watchPath);
+	      this.fsw._getWatchedDir(parent).add(wh.watchPath);
+	      this.fsw._emit(EV_ADD, wh.watchPath, stats);
+	      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+	      if (this.fsw.closed) return;
+
+	      // preserve this symlink's target path
+	      if (targetPath !== undefined) {
+	        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+	      }
+	    } else {
+	      closer = this._handleFile(wh.watchPath, stats, initialAdd);
+	    }
+	    ready();
+
+	    this.fsw._addPathCloser(path, closer);
+	    return false;
+
+	  } catch (error) {
+	    if (this.fsw._handleError(error)) {
+	      ready();
+	      return path;
+	    }
+	  }
+	}
+
+	}
+
+	nodefsHandler = NodeFsHandler;
+	return nodefsHandler;
+}
+
+var fseventsHandler = {exports: {}};
+
+const require$$3 = /*@__PURE__*/rollup.getAugmentedNamespace(fseventsImporter.fseventsImporter);
+
+var hasRequiredFseventsHandler;
+
+function requireFseventsHandler () {
+	if (hasRequiredFseventsHandler) return fseventsHandler.exports;
+	hasRequiredFseventsHandler = 1;
+
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+
+	let fsevents;
+	try {
+	  fsevents = require$$3.getFsEvents();
+	} catch (error) {
+	  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+	}
+
+	if (fsevents) {
+	  // TODO: real check
+	  const mtch = process.version.match(/v(\d+)\.(\d+)/);
+	  if (mtch && mtch[1] && mtch[2]) {
+	    const maj = Number.parseInt(mtch[1], 10);
+	    const min = Number.parseInt(mtch[2], 10);
+	    if (maj === 8 && min < 16) {
+	      fsevents = undefined;
+	    }
+	  }
+	}
+
+	const {
+	  EV_ADD,
+	  EV_CHANGE,
+	  EV_ADD_DIR,
+	  EV_UNLINK,
+	  EV_ERROR,
+	  STR_DATA,
+	  STR_END,
+	  FSEVENT_CREATED,
+	  FSEVENT_MODIFIED,
+	  FSEVENT_DELETED,
+	  FSEVENT_MOVED,
+	  // FSEVENT_CLONED,
+	  FSEVENT_UNKNOWN,
+	  FSEVENT_FLAG_MUST_SCAN_SUBDIRS,
+	  FSEVENT_TYPE_FILE,
+	  FSEVENT_TYPE_DIRECTORY,
+	  FSEVENT_TYPE_SYMLINK,
+
+	  ROOT_GLOBSTAR,
+	  DIR_SUFFIX,
+	  DOT_SLASH,
+	  FUNCTION_TYPE,
+	  EMPTY_FN,
+	  IDENTITY_FN
+	} = /*@__PURE__*/ requireConstants();
+
+	const Depth = (value) => isNaN(value) ? {} : {depth: value};
+
+	const stat = promisify(fs.stat);
+	const lstat = promisify(fs.lstat);
+	const realpath = promisify(fs.realpath);
+
+	const statMethods = { stat, lstat };
+
+	/**
+	 * @typedef {String} Path
+	 */
+
+	/**
+	 * @typedef {Object} FsEventsWatchContainer
+	 * @property {Set<Function>} listeners
+	 * @property {Function} rawEmitter
+	 * @property {{stop: Function}} watcher
+	 */
+
+	// fsevents instance helper functions
+	/**
+	 * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+	 * @type {Map<Path,FsEventsWatchContainer>}
+	 */
+	const FSEventsWatchers = new Map();
+
+	// Threshold of duplicate path prefixes at which to start
+	// consolidating going forward
+	const consolidateThreshhold = 10;
+
+	const wrongEventFlags = new Set([
+	  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
+	]);
+
+	/**
+	 * Instantiates the fsevents interface
+	 * @param {Path} path path to be watched
+	 * @param {Function} callback called when fsevents is bound and ready
+	 * @returns {{stop: Function}} new fsevents instance
+	 */
+	const createFSEventsInstance = (path, callback) => {
+	  const stop = fsevents.watch(path, callback);
+	  return {stop};
+	};
+
+	/**
+	 * Instantiates the fsevents interface or binds listeners to an existing one covering
+	 * the same file tree.
+	 * @param {Path} path           - to be watched
+	 * @param {Path} realPath       - real path for symlinks
+	 * @param {Function} listener   - called when fsevents emits events
+	 * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+	 * @returns {Function} closer
+	 */
+	function setFSEventsListener(path, realPath, listener, rawEmitter) {
+	  let watchPath = sysPath.extname(realPath) ? sysPath.dirname(realPath) : realPath;
+
+	  const parentPath = sysPath.dirname(watchPath);
+	  let cont = FSEventsWatchers.get(watchPath);
+
+	  // If we've accumulated a substantial number of paths that
+	  // could have been consolidated by watching one directory
+	  // above the current one, create a watcher on the parent
+	  // path instead, so that we do consolidate going forward.
+	  if (couldConsolidate(parentPath)) {
+	    watchPath = parentPath;
+	  }
+
+	  const resolvedPath = sysPath.resolve(path);
+	  const hasSymlink = resolvedPath !== realPath;
+
+	  const filteredListener = (fullPath, flags, info) => {
+	    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+	    if (
+	      fullPath === resolvedPath ||
+	      !fullPath.indexOf(resolvedPath + sysPath.sep)
+	    ) listener(fullPath, flags, info);
+	  };
+
+	  // check if there is already a watcher on a parent path
+	  // modifies `watchPath` to the parent path when it finds a match
+	  let watchedParent = false;
+	  for (const watchedPath of FSEventsWatchers.keys()) {
+	    if (realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep) === 0) {
+	      watchPath = watchedPath;
+	      cont = FSEventsWatchers.get(watchPath);
+	      watchedParent = true;
+	      break;
+	    }
+	  }
+
+	  if (cont || watchedParent) {
+	    cont.listeners.add(filteredListener);
+	  } else {
+	    cont = {
+	      listeners: new Set([filteredListener]),
+	      rawEmitter,
+	      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+	        if (!cont.listeners.size) return;
+	        if (flags & FSEVENT_FLAG_MUST_SCAN_SUBDIRS) return;
+	        const info = fsevents.getInfo(fullPath, flags);
+	        cont.listeners.forEach(list => {
+	          list(fullPath, flags, info);
+	        });
+
+	        cont.rawEmitter(info.event, fullPath, info);
+	      })
+	    };
+	    FSEventsWatchers.set(watchPath, cont);
+	  }
+
+	  // removes this instance's listeners and closes the underlying fsevents
+	  // instance if there are no more listeners left
+	  return () => {
+	    const lst = cont.listeners;
+
+	    lst.delete(filteredListener);
+	    if (!lst.size) {
+	      FSEventsWatchers.delete(watchPath);
+	      if (cont.watcher) return cont.watcher.stop().then(() => {
+	        cont.rawEmitter = cont.watcher = undefined;
+	        Object.freeze(cont);
+	      });
+	    }
+	  };
+	}
+
+	// Decide whether or not we should start a new higher-level
+	// parent watcher
+	const couldConsolidate = (path) => {
+	  let count = 0;
+	  for (const watchPath of FSEventsWatchers.keys()) {
+	    if (watchPath.indexOf(path) === 0) {
+	      count++;
+	      if (count >= consolidateThreshhold) {
+	        return true;
+	      }
+	    }
+	  }
+
+	  return false;
+	};
+
+	// returns boolean indicating whether fsevents can be used
+	const canUse = () => fsevents && FSEventsWatchers.size < 128;
+
+	// determines subdirectory traversal levels from root to path
+	const calcDepth = (path, root) => {
+	  let i = 0;
+	  while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
+	  return i;
+	};
+
+	// returns boolean indicating whether the fsevents' event info has the same type
+	// as the one returned by fs.stat
+	const sameTypes = (info, stats) => (
+	  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+	  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+	  info.type === FSEVENT_TYPE_FILE && stats.isFile()
+	);
+
+	/**
+	 * @mixin
+	 */
+	class FsEventsHandler {
+
+	/**
+	 * @param {import('../index').FSWatcher} fsw
+	 */
+	constructor(fsw) {
+	  this.fsw = fsw;
+	}
+	checkIgnored(path, stats) {
+	  const ipaths = this.fsw._ignoredPaths;
+	  if (this.fsw._isIgnored(path, stats)) {
+	    ipaths.add(path);
+	    if (stats && stats.isDirectory()) {
+	      ipaths.add(path + ROOT_GLOBSTAR);
+	    }
+	    return true;
+	  }
+
+	  ipaths.delete(path);
+	  ipaths.delete(path + ROOT_GLOBSTAR);
+	}
+
+	addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  const event = watchedDir.has(item) ? EV_CHANGE : EV_ADD;
+	  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	}
+
+	async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  try {
+	    const stats = await stat(path);
+	    if (this.fsw.closed) return;
+	    if (sameTypes(info, stats)) {
+	      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    } else {
+	      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    }
+	  } catch (error) {
+	    if (error.code === 'EACCES') {
+	      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    } else {
+	      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	    }
+	  }
+	}
+
+	handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+	  if (this.fsw.closed || this.checkIgnored(path)) return;
+
+	  if (event === EV_UNLINK) {
+	    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+	    // suppress unlink events on never before seen files
+	    if (isDirectory || watchedDir.has(item)) {
+	      this.fsw._remove(parent, item, isDirectory);
+	    }
+	  } else {
+	    if (event === EV_ADD) {
+	      // track new directories
+	      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+
+	      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+	        // push symlinks back to the top of the stack to get handled
+	        const curDepth = opts.depth === undefined ?
+	          undefined : calcDepth(fullPath, realPath) + 1;
+	        return this._addToFsEvents(path, false, true, curDepth);
+	      }
+
+	      // track new paths
+	      // (other than symlinks being followed, which will be tracked soon)
+	      this.fsw._getWatchedDir(parent).add(item);
+	    }
+	    /**
+	     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+	     */
+	    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+	    this.fsw._emit(eventName, path);
+	    if (eventName === EV_ADD_DIR) this._addToFsEvents(path, false, true);
+	  }
+	}
+
+	/**
+	 * Handle symlinks encountered during directory scan
+	 * @param {String} watchPath  - file/dir path to be watched with fsevents
+	 * @param {String} realPath   - real path (in case of symlinks)
+	 * @param {Function} transform  - path transformer
+	 * @param {Function} globFilter - path filter in case a glob pattern was provided
+	 * @returns {Function} closer for the watcher instance
+	*/
+	_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+	  if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+	  const opts = this.fsw.options;
+	  const watchCallback = async (fullPath, flags, info) => {
+	    if (this.fsw.closed) return;
+	    if (
+	      opts.depth !== undefined &&
+	      calcDepth(fullPath, realPath) > opts.depth
+	    ) return;
+	    const path = transform(sysPath.join(
+	      watchPath, sysPath.relative(watchPath, fullPath)
+	    ));
+	    if (globFilter && !globFilter(path)) return;
+	    // ensure directories are tracked
+	    const parent = sysPath.dirname(path);
+	    const item = sysPath.basename(path);
+	    const watchedDir = this.fsw._getWatchedDir(
+	      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+	    );
+
+	    // correct for wrong events emitted
+	    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
+	      if (typeof opts.ignored === FUNCTION_TYPE) {
+	        let stats;
+	        try {
+	          stats = await stat(path);
+	        } catch (error) {}
+	        if (this.fsw.closed) return;
+	        if (this.checkIgnored(path, stats)) return;
+	        if (sameTypes(info, stats)) {
+	          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	        } else {
+	          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	        }
+	      } else {
+	        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      }
+	    } else {
+	      switch (info.event) {
+	      case FSEVENT_CREATED:
+	      case FSEVENT_MODIFIED:
+	        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      case FSEVENT_DELETED:
+	      case FSEVENT_MOVED:
+	        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+	      }
+	    }
+	  };
+
+	  const closer = setFSEventsListener(
+	    watchPath,
+	    realPath,
+	    watchCallback,
+	    this.fsw._emitRaw
+	  );
+
+	  this.fsw._emitReady();
+	  return closer;
+	}
+
+	/**
+	 * Handle symlinks encountered during directory scan
+	 * @param {String} linkPath path to symlink
+	 * @param {String} fullPath absolute path to the symlink
+	 * @param {Function} transform pre-existing path transformer
+	 * @param {Number} curDepth level of subdirectories traversed to where symlink is
+	 * @returns {Promise<void>}
+	 */
+	async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+	  // don't follow the same symlink more than once
+	  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+
+	  this.fsw._symlinkPaths.set(fullPath, true);
+	  this.fsw._incrReadyCount();
+
+	  try {
+	    const linkTarget = await realpath(linkPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(linkTarget)) {
+	      return this.fsw._emitReady();
+	    }
+
+	    this.fsw._incrReadyCount();
+
+	    // add the linkTarget for watching with a wrapper for transform
+	    // that causes emitted paths to incorporate the link's path
+	    this._addToFsEvents(linkTarget || linkPath, (path) => {
+	      let aliasedPath = linkPath;
+	      if (linkTarget && linkTarget !== DOT_SLASH) {
+	        aliasedPath = path.replace(linkTarget, linkPath);
+	      } else if (path !== DOT_SLASH) {
+	        aliasedPath = sysPath.join(linkPath, path);
+	      }
+	      return transform(aliasedPath);
+	    }, false, curDepth);
+	  } catch(error) {
+	    if (this.fsw._handleError(error)) {
+	      return this.fsw._emitReady();
+	    }
+	  }
+	}
+
+	/**
+	 *
+	 * @param {Path} newPath
+	 * @param {fs.Stats} stats
+	 */
+	emitAdd(newPath, stats, processPath, opts, forceAdd) {
+	  const pp = processPath(newPath);
+	  const isDir = stats.isDirectory();
+	  const dirObj = this.fsw._getWatchedDir(sysPath.dirname(pp));
+	  const base = sysPath.basename(pp);
+
+	  // ensure empty dirs get tracked
+	  if (isDir) this.fsw._getWatchedDir(pp);
+	  if (dirObj.has(base)) return;
+	  dirObj.add(base);
+
+	  if (!opts.ignoreInitial || forceAdd === true) {
+	    this.fsw._emit(isDir ? EV_ADD_DIR : EV_ADD, pp, stats);
+	  }
+	}
+
+	initWatch(realPath, path, wh, processPath) {
+	  if (this.fsw.closed) return;
+	  const closer = this._watchWithFsEvents(
+	    wh.watchPath,
+	    sysPath.resolve(realPath || wh.watchPath),
+	    processPath,
+	    wh.globFilter
+	  );
+	  this.fsw._addPathCloser(path, closer);
+	}
+
+	/**
+	 * Handle added path with fsevents
+	 * @param {String} path file/dir path or glob pattern
+	 * @param {Function|Boolean=} transform converts working path to what the user expects
+	 * @param {Boolean=} forceAdd ensure add is emitted
+	 * @param {Number=} priorDepth Level of subdirectories already traversed.
+	 * @returns {Promise<void>}
+	 */
+	async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+	  if (this.fsw.closed) {
+	    return;
+	  }
+	  const opts = this.fsw.options;
+	  const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
+
+	  const wh = this.fsw._getWatchHelpers(path);
+
+	  // evaluate what is at the path we're being asked to watch
+	  try {
+	    const stats = await statMethods[wh.statMethod](wh.watchPath);
+	    if (this.fsw.closed) return;
+	    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+	      throw null;
+	    }
+	    if (stats.isDirectory()) {
+	      // emit addDir unless this is a glob parent
+	      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+
+	      // don't recurse further if it would exceed depth setting
+	      if (priorDepth && priorDepth > opts.depth) return;
+
+	      // scan the contents of the dir
+	      this.fsw._readdirp(wh.watchPath, {
+	        fileFilter: entry => wh.filterPath(entry),
+	        directoryFilter: entry => wh.filterDir(entry),
+	        ...Depth(opts.depth - (priorDepth || 0))
+	      }).on(STR_DATA, (entry) => {
+	        // need to check filterPath on dirs b/c filterDir is less restrictive
+	        if (this.fsw.closed) {
+	          return;
+	        }
+	        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+
+	        const joinedPath = sysPath.join(wh.watchPath, entry.path);
+	        const {fullPath} = entry;
+
+	        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+	          // preserve the current depth here since it can't be derived from
+	          // real paths past the symlink
+	          const curDepth = opts.depth === undefined ?
+	            undefined : calcDepth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;
+
+	          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+	        } else {
+	          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+	        }
+	      }).on(EV_ERROR, EMPTY_FN).on(STR_END, () => {
+	        this.fsw._emitReady();
+	      });
+	    } else {
+	      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+	      this.fsw._emitReady();
+	    }
+	  } catch (error) {
+	    if (!error || this.fsw._handleError(error)) {
+	      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
+	      this.fsw._emitReady();
+	      this.fsw._emitReady();
+	    }
+	  }
+
+	  if (opts.persistent && forceAdd !== true) {
+	    if (typeof transform === FUNCTION_TYPE) {
+	      // realpath has already been resolved
+	      this.initWatch(undefined, path, wh, processPath);
+	    } else {
+	      let realPath;
+	      try {
+	        realPath = await realpath(wh.watchPath);
+	      } catch (e) {}
+	      this.initWatch(realPath, path, wh, processPath);
+	    }
+	  }
+	}
+
+	}
+
+	fseventsHandler.exports = FsEventsHandler;
+	fseventsHandler.exports.canUse = canUse;
+	return fseventsHandler.exports;
+}
+
+var hasRequiredChokidar;
+
+function requireChokidar () {
+	if (hasRequiredChokidar) return chokidar$1;
+	hasRequiredChokidar = 1;
+
+	const { EventEmitter } = require$$0$3;
+	const fs = require$$0$2;
+	const sysPath = require$$0$1;
+	const { promisify } = require$$2;
+	const readdirp = /*@__PURE__*/ requireReaddirp();
+	const anymatch = /*@__PURE__*/ requireAnymatch().default;
+	const globParent = /*@__PURE__*/ requireGlobParent();
+	const isGlob = /*@__PURE__*/ requireIsGlob();
+	const braces = /*@__PURE__*/ requireBraces();
+	const normalizePath = /*@__PURE__*/ requireNormalizePath();
+
+	const NodeFsHandler = /*@__PURE__*/ requireNodefsHandler();
+	const FsEventsHandler = /*@__PURE__*/ requireFseventsHandler();
+	const {
+	  EV_ALL,
+	  EV_READY,
+	  EV_ADD,
+	  EV_CHANGE,
+	  EV_UNLINK,
+	  EV_ADD_DIR,
+	  EV_UNLINK_DIR,
+	  EV_RAW,
+	  EV_ERROR,
+
+	  STR_CLOSE,
+	  STR_END,
+
+	  BACK_SLASH_RE,
+	  DOUBLE_SLASH_RE,
+	  SLASH_OR_BACK_SLASH_RE,
+	  DOT_RE,
+	  REPLACER_RE,
+
+	  SLASH,
+	  SLASH_SLASH,
+	  BRACE_START,
+	  BANG,
+	  ONE_DOT,
+	  TWO_DOTS,
+	  GLOBSTAR,
+	  SLASH_GLOBSTAR,
+	  ANYMATCH_OPTS,
+	  STRING_TYPE,
+	  FUNCTION_TYPE,
+	  EMPTY_STR,
+	  EMPTY_FN,
+
+	  isWindows,
+	  isMacos,
+	  isIBMi
+	} = /*@__PURE__*/ requireConstants();
+
+	const stat = promisify(fs.stat);
+	const readdir = promisify(fs.readdir);
+
+	/**
+	 * @typedef {String} Path
+	 * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+	 * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+	 */
+
+	/**
+	 *
+	 * @typedef {Object} WatchHelpers
+	 * @property {Boolean} followSymlinks
+	 * @property {'stat'|'lstat'} statMethod
+	 * @property {Path} path
+	 * @property {Path} watchPath
+	 * @property {Function} entryPath
+	 * @property {Boolean} hasGlob
+	 * @property {Object} globFilter
+	 * @property {Function} filterPath
+	 * @property {Function} filterDir
+	 */
+
+	const arrify = (value = []) => Array.isArray(value) ? value : [value];
+	const flatten = (list, result = []) => {
+	  list.forEach(item => {
+	    if (Array.isArray(item)) {
+	      flatten(item, result);
+	    } else {
+	      result.push(item);
+	    }
+	  });
+	  return result;
+	};
+
+	const unifyPaths = (paths_) => {
+	  /**
+	   * @type {Array<String>}
+	   */
+	  const paths = flatten(arrify(paths_));
+	  if (!paths.every(p => typeof p === STRING_TYPE)) {
+	    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+	  }
+	  return paths.map(normalizePathToUnix);
+	};
+
+	// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+	//     because "//StoragePC/DrivePool/Movies" is a valid network path
+	const toUnix = (string) => {
+	  let str = string.replace(BACK_SLASH_RE, SLASH);
+	  let prepend = false;
+	  if (str.startsWith(SLASH_SLASH)) {
+	    prepend = true;
+	  }
+	  while (str.match(DOUBLE_SLASH_RE)) {
+	    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+	  }
+	  if (prepend) {
+	    str = SLASH + str;
+	  }
+	  return str;
+	};
+
+	// Our version of upath.normalize
+	// TODO: this is not equal to path-normalize module - investigate why
+	const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+
+	const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+	  if (typeof path !== STRING_TYPE) return path;
+	  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+	};
+
+	const getAbsolutePath = (path, cwd) => {
+	  if (sysPath.isAbsolute(path)) {
+	    return path;
+	  }
+	  if (path.startsWith(BANG)) {
+	    return BANG + sysPath.join(cwd, path.slice(1));
+	  }
+	  return sysPath.join(cwd, path);
+	};
+
+	const undef = (opts, key) => opts[key] === undefined;
+
+	/**
+	 * Directory entry.
+	 * @property {Path} path
+	 * @property {Set<Path>} items
+	 */
+	class DirEntry {
+	  /**
+	   * @param {Path} dir
+	   * @param {Function} removeWatcher
+	   */
+	  constructor(dir, removeWatcher) {
+	    this.path = dir;
+	    this._removeWatcher = removeWatcher;
+	    /** @type {Set<Path>} */
+	    this.items = new Set();
+	  }
+
+	  add(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+	  }
+
+	  async remove(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    items.delete(item);
+	    if (items.size > 0) return;
+
+	    const dir = this.path;
+	    try {
+	      await readdir(dir);
+	    } catch (err) {
+	      if (this._removeWatcher) {
+	        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+	      }
+	    }
+	  }
+
+	  has(item) {
+	    const {items} = this;
+	    if (!items) return;
+	    return items.has(item);
+	  }
+
+	  /**
+	   * @returns {Array<String>}
+	   */
+	  getChildren() {
+	    const {items} = this;
+	    if (!items) return;
+	    return [...items.values()];
+	  }
+
+	  dispose() {
+	    this.items.clear();
+	    delete this.path;
+	    delete this._removeWatcher;
+	    delete this.items;
+	    Object.freeze(this);
+	  }
+	}
+
+	const STAT_METHOD_F = 'stat';
+	const STAT_METHOD_L = 'lstat';
+	class WatchHelper {
+	  constructor(path, watchPath, follow, fsw) {
+	    this.fsw = fsw;
+	    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+	    this.watchPath = watchPath;
+	    this.fullWatchPath = sysPath.resolve(watchPath);
+	    this.hasGlob = watchPath !== path;
+	    /** @type {object|boolean} */
+	    if (path === EMPTY_STR) this.hasGlob = false;
+	    this.globSymlink = this.hasGlob && follow ? undefined : false;
+	    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
+	    this.dirParts = this.getDirParts(path);
+	    this.dirParts.forEach((parts) => {
+	      if (parts.length > 1) parts.pop();
+	    });
+	    this.followSymlinks = follow;
+	    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+	  }
+
+	  checkGlobSymlink(entry) {
+	    // only need to resolve once
+	    // first entry should always have entry.parentDir === EMPTY_STR
+	    if (this.globSymlink === undefined) {
+	      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
+	        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+	    }
+
+	    if (this.globSymlink) {
+	      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+	    }
+
+	    return entry.fullPath;
+	  }
+
+	  entryPath(entry) {
+	    return sysPath.join(this.watchPath,
+	      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+	    );
+	  }
+
+	  filterPath(entry) {
+	    const {stats} = entry;
+	    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+	    const resolvedPath = this.entryPath(entry);
+	    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
+	      this.globFilter(resolvedPath) : true;
+	    return matchesGlob &&
+	      this.fsw._isntIgnored(resolvedPath, stats) &&
+	      this.fsw._hasReadPermissions(stats);
+	  }
+
+	  getDirParts(path) {
+	    if (!this.hasGlob) return [];
+	    const parts = [];
+	    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+	    expandedPath.forEach((path) => {
+	      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+	    });
+	    return parts;
+	  }
+
+	  filterDir(entry) {
+	    if (this.hasGlob) {
+	      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+	      let globstar = false;
+	      this.unmatchedGlob = !this.dirParts.some((parts) => {
+	        return parts.every((part, i) => {
+	          if (part === GLOBSTAR) globstar = true;
+	          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+	        });
+	      });
+	    }
+	    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+	  }
+	}
+
+	/**
+	 * Watches files & directories for changes. Emitted events:
+	 * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+	 *
+	 *     new FSWatcher()
+	 *       .add(directories)
+	 *       .on('add', path => log('File', path, 'was added'))
+	 */
+	class FSWatcher extends EventEmitter {
+	// Not indenting methods for history sake; for now.
+	constructor(_opts) {
+	  super();
+
+	  const opts = {};
+	  if (_opts) Object.assign(opts, _opts); // for frozen objects
+
+	  /** @type {Map<String, DirEntry>} */
+	  this._watched = new Map();
+	  /** @type {Map<String, Array>} */
+	  this._closers = new Map();
+	  /** @type {Set<String>} */
+	  this._ignoredPaths = new Set();
+
+	  /** @type {Map<ThrottleType, Map>} */
+	  this._throttled = new Map();
+
+	  /** @type {Map<Path, String|Boolean>} */
+	  this._symlinkPaths = new Map();
+
+	  this._streams = new Set();
+	  this.closed = false;
+
+	  // Set up default options.
+	  if (undef(opts, 'persistent')) opts.persistent = true;
+	  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
+	  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
+	  if (undef(opts, 'interval')) opts.interval = 100;
+	  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
+	  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
+	  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+
+	  // Enable fsevents on OS X when polling isn't explicitly enabled.
+	  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+
+	  // If we can't use fsevents, ensure the options reflect it's disabled.
+	  const canUseFsEvents = FsEventsHandler.canUse();
+	  if (!canUseFsEvents) opts.useFsEvents = false;
+
+	  // Use polling on Mac if not using fsevents.
+	  // Other platforms use non-polling fs_watch.
+	  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
+	    opts.usePolling = isMacos;
+	  }
+
+	  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+	  if(isIBMi) {
+	    opts.usePolling = true;
+	  }
+
+	  // Global override (useful for end-developers that need to force polling for all
+	  // instances of chokidar, regardless of usage/dependency depth)
+	  const envPoll = process.env.CHOKIDAR_USEPOLLING;
+	  if (envPoll !== undefined) {
+	    const envLower = envPoll.toLowerCase();
+
+	    if (envLower === 'false' || envLower === '0') {
+	      opts.usePolling = false;
+	    } else if (envLower === 'true' || envLower === '1') {
+	      opts.usePolling = true;
+	    } else {
+	      opts.usePolling = !!envLower;
+	    }
+	  }
+	  const envInterval = process.env.CHOKIDAR_INTERVAL;
+	  if (envInterval) {
+	    opts.interval = Number.parseInt(envInterval, 10);
+	  }
+
+	  // Editor atomic write normalization enabled by default with fs.watch
+	  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+	  if (opts.atomic) this._pendingUnlinks = new Map();
+
+	  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+
+	  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
+	  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+	  const awf = opts.awaitWriteFinish;
+	  if (awf) {
+	    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
+	    if (!awf.pollInterval) awf.pollInterval = 100;
+	    this._pendingWrites = new Map();
+	  }
+	  if (opts.ignored) opts.ignored = arrify(opts.ignored);
+
+	  let readyCalls = 0;
+	  this._emitReady = () => {
+	    readyCalls++;
+	    if (readyCalls >= this._readyCount) {
+	      this._emitReady = EMPTY_FN;
+	      this._readyEmitted = true;
+	      // use process.nextTick to allow time for listener to be bound
+	      process.nextTick(() => this.emit(EV_READY));
+	    }
+	  };
+	  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+	  this._readyEmitted = false;
+	  this.options = opts;
+
+	  // Initialize with proper watcher.
+	  if (opts.useFsEvents) {
+	    this._fsEventsHandler = new FsEventsHandler(this);
+	  } else {
+	    this._nodeFsHandler = new NodeFsHandler(this);
+	  }
+
+	  // You’re frozen when your heart’s not open.
+	  Object.freeze(opts);
+	}
+
+	// Public methods
+
+	/**
+	 * Adds paths to be watched on an existing FSWatcher instance
+	 * @param {Path|Array<Path>} paths_
+	 * @param {String=} _origAdd private; for handling non-existent paths to be watched
+	 * @param {Boolean=} _internal private; indicates a non-user add
+	 * @returns {FSWatcher} for chaining
+	 */
+	add(paths_, _origAdd, _internal) {
+	  const {cwd, disableGlobbing} = this.options;
+	  this.closed = false;
+	  let paths = unifyPaths(paths_);
+	  if (cwd) {
+	    paths = paths.map((path) => {
+	      const absPath = getAbsolutePath(path, cwd);
+
+	      // Check `path` instead of `absPath` because the cwd portion can't be a glob
+	      if (disableGlobbing || !isGlob(path)) {
+	        return absPath;
+	      }
+	      return normalizePath(absPath);
+	    });
+	  }
+
+	  // set aside negated glob strings
+	  paths = paths.filter((path) => {
+	    if (path.startsWith(BANG)) {
+	      this._ignoredPaths.add(path.slice(1));
+	      return false;
+	    }
+
+	    // if a path is being added that was previously ignored, stop ignoring it
+	    this._ignoredPaths.delete(path);
+	    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+
+	    // reset the cached userIgnored anymatch fn
+	    // to make ignoredPaths changes effective
+	    this._userIgnored = undefined;
+
+	    return true;
+	  });
+
+	  if (this.options.useFsEvents && this._fsEventsHandler) {
+	    if (!this._readyCount) this._readyCount = paths.length;
+	    if (this.options.persistent) this._readyCount += paths.length;
+	    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+	  } else {
+	    if (!this._readyCount) this._readyCount = 0;
+	    this._readyCount += paths.length;
+	    Promise.all(
+	      paths.map(async path => {
+	        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+	        if (res) this._emitReady();
+	        return res;
+	      })
+	    ).then(results => {
+	      if (this.closed) return;
+	      results.filter(item => item).forEach(item => {
+	        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+	      });
+	    });
+	  }
+
+	  return this;
+	}
+
+	/**
+	 * Close watchers or start ignoring events from specified paths.
+	 * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+	 * @returns {FSWatcher} for chaining
+	*/
+	unwatch(paths_) {
+	  if (this.closed) return this;
+	  const paths = unifyPaths(paths_);
+	  const {cwd} = this.options;
+
+	  paths.forEach((path) => {
+	    // convert to absolute path unless relative path already matches
+	    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+	      if (cwd) path = sysPath.join(cwd, path);
+	      path = sysPath.resolve(path);
+	    }
+
+	    this._closePath(path);
+
+	    this._ignoredPaths.add(path);
+	    if (this._watched.has(path)) {
+	      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+	    }
+
+	    // reset the cached userIgnored anymatch fn
+	    // to make ignoredPaths changes effective
+	    this._userIgnored = undefined;
+	  });
+
+	  return this;
+	}
+
+	/**
+	 * Close watchers and remove all listeners from watched paths.
+	 * @returns {Promise<void>}.
+	*/
+	close() {
+	  if (this.closed) return this._closePromise;
+	  this.closed = true;
+
+	  // Memory management.
+	  this.removeAllListeners();
+	  const closers = [];
+	  this._closers.forEach(closerList => closerList.forEach(closer => {
+	    const promise = closer();
+	    if (promise instanceof Promise) closers.push(promise);
+	  }));
+	  this._streams.forEach(stream => stream.destroy());
+	  this._userIgnored = undefined;
+	  this._readyCount = 0;
+	  this._readyEmitted = false;
+	  this._watched.forEach(dirent => dirent.dispose());
+	  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
+	    this[`_${key}`].clear();
+	  });
+
+	  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+	  return this._closePromise;
+	}
+
+	/**
+	 * Expose list of watched paths
+	 * @returns {Object} for chaining
+	*/
+	getWatched() {
+	  const watchList = {};
+	  this._watched.forEach((entry, dir) => {
+	    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+	    watchList[key || ONE_DOT] = entry.getChildren().sort();
+	  });
+	  return watchList;
+	}
+
+	emitWithAll(event, args) {
+	  this.emit(...args);
+	  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+	}
+
+	// Common helpers
+	// --------------
+
+	/**
+	 * Normalize and emit events.
+	 * Calling _emit DOES NOT MEAN emit() would be called!
+	 * @param {EventName} event Type of event
+	 * @param {Path} path File or directory path
+	 * @param {*=} val1 arguments to be passed with event
+	 * @param {*=} val2
+	 * @param {*=} val3
+	 * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	 */
+	async _emit(event, path, val1, val2, val3) {
+	  if (this.closed) return;
+
+	  const opts = this.options;
+	  if (isWindows) path = sysPath.normalize(path);
+	  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+	  /** @type Array<any> */
+	  const args = [event, path];
+	  if (val3 !== undefined) args.push(val1, val2, val3);
+	  else if (val2 !== undefined) args.push(val1, val2);
+	  else if (val1 !== undefined) args.push(val1);
+
+	  const awf = opts.awaitWriteFinish;
+	  let pw;
+	  if (awf && (pw = this._pendingWrites.get(path))) {
+	    pw.lastChange = new Date();
+	    return this;
+	  }
+
+	  if (opts.atomic) {
+	    if (event === EV_UNLINK) {
+	      this._pendingUnlinks.set(path, args);
+	      setTimeout(() => {
+	        this._pendingUnlinks.forEach((entry, path) => {
+	          this.emit(...entry);
+	          this.emit(EV_ALL, ...entry);
+	          this._pendingUnlinks.delete(path);
+	        });
+	      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+	      return this;
+	    }
+	    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+	      event = args[0] = EV_CHANGE;
+	      this._pendingUnlinks.delete(path);
+	    }
+	  }
+
+	  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+	    const awfEmit = (err, stats) => {
+	      if (err) {
+	        event = args[0] = EV_ERROR;
+	        args[1] = err;
+	        this.emitWithAll(event, args);
+	      } else if (stats) {
+	        // if stats doesn't exist the file must have been deleted
+	        if (args.length > 2) {
+	          args[2] = stats;
+	        } else {
+	          args.push(stats);
+	        }
+	        this.emitWithAll(event, args);
+	      }
+	    };
+
+	    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+	    return this;
+	  }
+
+	  if (event === EV_CHANGE) {
+	    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+	    if (isThrottled) return this;
+	  }
+
+	  if (opts.alwaysStat && val1 === undefined &&
+	    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
+	  ) {
+	    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+	    let stats;
+	    try {
+	      stats = await stat(fullPath);
+	    } catch (err) {}
+	    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+	    if (!stats || this.closed) return;
+	    args.push(stats);
+	  }
+	  this.emitWithAll(event, args);
+
+	  return this;
+	}
+
+	/**
+	 * Common handler for errors
+	 * @param {Error} error
+	 * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+	 */
+	_handleError(error) {
+	  const code = error && error.code;
+	  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
+	    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
+	  ) {
+	    this.emit(EV_ERROR, error);
+	  }
+	  return error || this.closed;
+	}
+
+	/**
+	 * Helper utility for throttling
+	 * @param {ThrottleType} actionType type being throttled
+	 * @param {Path} path being acted upon
+	 * @param {Number} timeout duration of time to suppress duplicate actions
+	 * @returns {Object|false} tracking object or false if action should be suppressed
+	 */
+	_throttle(actionType, path, timeout) {
+	  if (!this._throttled.has(actionType)) {
+	    this._throttled.set(actionType, new Map());
+	  }
+
+	  /** @type {Map<Path, Object>} */
+	  const action = this._throttled.get(actionType);
+	  /** @type {Object} */
+	  const actionPath = action.get(path);
+
+	  if (actionPath) {
+	    actionPath.count++;
+	    return false;
+	  }
+
+	  let timeoutObject;
+	  const clear = () => {
+	    const item = action.get(path);
+	    const count = item ? item.count : 0;
+	    action.delete(path);
+	    clearTimeout(timeoutObject);
+	    if (item) clearTimeout(item.timeoutObject);
+	    return count;
+	  };
+	  timeoutObject = setTimeout(clear, timeout);
+	  const thr = {timeoutObject, clear, count: 0};
+	  action.set(path, thr);
+	  return thr;
+	}
+
+	_incrReadyCount() {
+	  return this._readyCount++;
+	}
+
+	/**
+	 * Awaits write operation to finish.
+	 * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+	 * @param {Path} path being acted upon
+	 * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+	 * @param {EventName} event
+	 * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+	 */
+	_awaitWriteFinish(path, threshold, event, awfEmit) {
+	  let timeoutHandler;
+
+	  let fullPath = path;
+	  if (this.options.cwd && !sysPath.isAbsolute(path)) {
+	    fullPath = sysPath.join(this.options.cwd, path);
+	  }
+
+	  const now = new Date();
+
+	  const awaitWriteFinish = (prevStat) => {
+	    fs.stat(fullPath, (err, curStat) => {
+	      if (err || !this._pendingWrites.has(path)) {
+	        if (err && err.code !== 'ENOENT') awfEmit(err);
+	        return;
+	      }
+
+	      const now = Number(new Date());
+
+	      if (prevStat && curStat.size !== prevStat.size) {
+	        this._pendingWrites.get(path).lastChange = now;
+	      }
+	      const pw = this._pendingWrites.get(path);
+	      const df = now - pw.lastChange;
+
+	      if (df >= threshold) {
+	        this._pendingWrites.delete(path);
+	        awfEmit(undefined, curStat);
+	      } else {
+	        timeoutHandler = setTimeout(
+	          awaitWriteFinish,
+	          this.options.awaitWriteFinish.pollInterval,
+	          curStat
+	        );
+	      }
+	    });
+	  };
+
+	  if (!this._pendingWrites.has(path)) {
+	    this._pendingWrites.set(path, {
+	      lastChange: now,
+	      cancelWait: () => {
+	        this._pendingWrites.delete(path);
+	        clearTimeout(timeoutHandler);
+	        return event;
+	      }
+	    });
+	    timeoutHandler = setTimeout(
+	      awaitWriteFinish,
+	      this.options.awaitWriteFinish.pollInterval
+	    );
+	  }
+	}
+
+	_getGlobIgnored() {
+	  return [...this._ignoredPaths.values()];
+	}
+
+	/**
+	 * Determines whether user has asked to ignore this path.
+	 * @param {Path} path filepath or dir
+	 * @param {fs.Stats=} stats result of fs.stat
+	 * @returns {Boolean}
+	 */
+	_isIgnored(path, stats) {
+	  if (this.options.atomic && DOT_RE.test(path)) return true;
+	  if (!this._userIgnored) {
+	    const {cwd} = this.options;
+	    const ign = this.options.ignored;
+
+	    const ignored = ign && ign.map(normalizeIgnored(cwd));
+	    const paths = arrify(ignored)
+	      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+	      .map((path) => path + SLASH_GLOBSTAR);
+	    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+	    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+	  }
+
+	  return this._userIgnored([path, stats]);
+	}
+
+	_isntIgnored(path, stat) {
+	  return !this._isIgnored(path, stat);
+	}
+
+	/**
+	 * Provides a set of common helpers and properties relating to symlink and glob handling.
+	 * @param {Path} path file, directory, or glob pattern being watched
+	 * @param {Number=} depth at any depth > 0, this isn't a glob
+	 * @returns {WatchHelper} object containing helpers for this path
+	 */
+	_getWatchHelpers(path, depth) {
+	  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+	  const follow = this.options.followSymlinks;
+
+	  return new WatchHelper(path, watchPath, follow, this);
+	}
+
+	// Directory helpers
+	// -----------------
+
+	/**
+	 * Provides directory tracking objects
+	 * @param {String} directory path of the directory
+	 * @returns {DirEntry} the directory's tracking object
+	 */
+	_getWatchedDir(directory) {
+	  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+	  const dir = sysPath.resolve(directory);
+	  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+	  return this._watched.get(dir);
+	}
+
+	// File helpers
+	// ------------
+
+	/**
+	 * Check for read permissions.
+	 * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+	 * @param {fs.Stats} stats - object, result of fs_stat
+	 * @returns {Boolean} indicates whether the file can be read
+	*/
+	_hasReadPermissions(stats) {
+	  if (this.options.ignorePermissionErrors) return true;
+
+	  // stats.mode may be bigint
+	  const md = stats && Number.parseInt(stats.mode, 10);
+	  const st = md & 0o777;
+	  const it = Number.parseInt(st.toString(8)[0], 10);
+	  return Boolean(4 & it);
+	}
+
+	/**
+	 * Handles emitting unlink events for
+	 * files and directories, and via recursion, for
+	 * files and directories within directories that are unlinked
+	 * @param {String} directory within which the following item is located
+	 * @param {String} item      base path of item/directory
+	 * @returns {void}
+	*/
+	_remove(directory, item, isDirectory) {
+	  // if what is being deleted is a directory, get that directory's paths
+	  // for recursive deleting and cleaning of watched object
+	  // if it is not a directory, nestedDirectoryChildren will be empty array
+	  const path = sysPath.join(directory, item);
+	  const fullPath = sysPath.resolve(path);
+	  isDirectory = isDirectory != null
+	    ? isDirectory
+	    : this._watched.has(path) || this._watched.has(fullPath);
+
+	  // prevent duplicate handling in case of arriving here nearly simultaneously
+	  // via multiple paths (such as _handleFile and _handleDir)
+	  if (!this._throttle('remove', path, 100)) return;
+
+	  // if the only watched file is removed, watch for its return
+	  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+	    this.add(directory, item, true);
+	  }
+
+	  // This will create a new entry in the watched object in either case
+	  // so we got to do the directory check beforehand
+	  const wp = this._getWatchedDir(path);
+	  const nestedDirectoryChildren = wp.getChildren();
+
+	  // Recursively remove children directories / files.
+	  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+
+	  // Check if item was on the watched list and remove it
+	  const parent = this._getWatchedDir(directory);
+	  const wasTracked = parent.has(item);
+	  parent.remove(item);
+
+	  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+	  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+	  // but never removed from the map in case the path was deleted.
+	  // This leads to an incorrect state if the path was recreated:
+	  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+	  if (this._symlinkPaths.has(fullPath)) {
+	    this._symlinkPaths.delete(fullPath);
+	  }
+
+	  // If we wait for this file to be fully written, cancel the wait.
+	  let relPath = path;
+	  if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+	  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+	    const event = this._pendingWrites.get(relPath).cancelWait();
+	    if (event === EV_ADD) return;
+	  }
+
+	  // The Entry will either be a directory that just got removed
+	  // or a bogus entry to a file, in either case we have to remove it
+	  this._watched.delete(path);
+	  this._watched.delete(fullPath);
+	  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+	  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+
+	  // Avoid conflicts if we later create another file with the same name
+	  if (!this.options.useFsEvents) {
+	    this._closePath(path);
+	  }
+	}
+
+	/**
+	 * Closes all watchers for a path
+	 * @param {Path} path
+	 */
+	_closePath(path) {
+	  this._closeFile(path);
+	  const dir = sysPath.dirname(path);
+	  this._getWatchedDir(dir).remove(sysPath.basename(path));
+	}
+
+	/**
+	 * Closes only file-specific watchers
+	 * @param {Path} path
+	 */
+	_closeFile(path) {
+	  const closers = this._closers.get(path);
+	  if (!closers) return;
+	  closers.forEach(closer => closer());
+	  this._closers.delete(path);
+	}
+
+	/**
+	 *
+	 * @param {Path} path
+	 * @param {Function} closer
+	 */
+	_addPathCloser(path, closer) {
+	  if (!closer) return;
+	  let list = this._closers.get(path);
+	  if (!list) {
+	    list = [];
+	    this._closers.set(path, list);
+	  }
+	  list.push(closer);
+	}
+
+	_readdirp(root, opts) {
+	  if (this.closed) return;
+	  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
+	  let stream = readdirp(root, options);
+	  this._streams.add(stream);
+	  stream.once(STR_CLOSE, () => {
+	    stream = undefined;
+	  });
+	  stream.once(STR_END, () => {
+	    if (stream) {
+	      this._streams.delete(stream);
+	      stream = undefined;
+	    }
+	  });
+	  return stream;
+	}
+
+	}
+
+	// Export FSWatcher class
+	chokidar$1.FSWatcher = FSWatcher;
+
+	/**
+	 * Instantiates watcher with paths to be tracked.
+	 * @param {String|Array<String>} paths file/directory paths and/or globs
+	 * @param {Object=} options chokidar opts
+	 * @returns an instance of FSWatcher for chaining.
+	 */
+	const watch = (paths, options) => {
+	  const watcher = new FSWatcher(options);
+	  watcher.add(paths);
+	  return watcher;
+	};
+
+	chokidar$1.watch = watch;
+	return chokidar$1;
+}
+
+var chokidarExports = /*@__PURE__*/ requireChokidar();
+const chokidar = /*@__PURE__*/rollup.getDefaultExportFromCjs(chokidarExports);
+
+exports.chokidar = chokidar;
+//# sourceMappingURL=index.js.map
diff --git a/node_modules/rollup/dist/shared/loadConfigFile.js b/node_modules/rollup/dist/shared/loadConfigFile.js
new file mode 100644
index 0000000..363716d
--- /dev/null
+++ b/node_modules/rollup/dist/shared/loadConfigFile.js
@@ -0,0 +1,553 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const promises = require('node:fs/promises');
+const path = require('node:path');
+const process$1 = require('node:process');
+const node_url = require('node:url');
+const rollup = require('./rollup.js');
+const parseAst_js = require('./parseAst.js');
+const getLogFilter_js = require('../getLogFilter.js');
+
+function batchWarnings(command) {
+    const silent = !!command.silent;
+    const logFilter = generateLogFilter(command);
+    let count = 0;
+    const deferredWarnings = new Map();
+    let warningOccurred = false;
+    const add = (warning) => {
+        count += 1;
+        warningOccurred = true;
+        if (silent)
+            return;
+        if (warning.code in deferredHandlers) {
+            rollup.getOrCreate(deferredWarnings, warning.code, rollup.getNewArray).push(warning);
+        }
+        else if (warning.code in immediateHandlers) {
+            immediateHandlers[warning.code](warning);
+        }
+        else {
+            title(warning.message);
+            defaultBody(warning);
+        }
+    };
+    return {
+        add,
+        get count() {
+            return count;
+        },
+        flush() {
+            if (count === 0 || silent)
+                return;
+            const codes = [...deferredWarnings.keys()].sort((a, b) => deferredWarnings.get(b).length - deferredWarnings.get(a).length);
+            for (const code of codes) {
+                deferredHandlers[code](deferredWarnings.get(code));
+            }
+            deferredWarnings.clear();
+            count = 0;
+        },
+        log(level, log) {
+            if (!logFilter(log))
+                return;
+            switch (level) {
+                case parseAst_js.LOGLEVEL_WARN: {
+                    return add(log);
+                }
+                case parseAst_js.LOGLEVEL_DEBUG: {
+                    if (!silent) {
+                        rollup.stderr(rollup.bold(rollup.blue(log.message)));
+                        defaultBody(log);
+                    }
+                    return;
+                }
+                default: {
+                    if (!silent) {
+                        rollup.stderr(rollup.bold(rollup.cyan(log.message)));
+                        defaultBody(log);
+                    }
+                }
+            }
+        },
+        get warningOccurred() {
+            return warningOccurred;
+        }
+    };
+}
+const immediateHandlers = {
+    MISSING_NODE_BUILTINS(warning) {
+        title(`Missing shims for Node.js built-ins`);
+        rollup.stderr(`Creating a browser bundle that depends on ${parseAst_js.printQuotedStringList(warning.ids)}. You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`);
+    },
+    UNKNOWN_OPTION(warning) {
+        title(`You have passed an unrecognized option`);
+        rollup.stderr(warning.message);
+    }
+};
+const deferredHandlers = {
+    CIRCULAR_DEPENDENCY(warnings) {
+        title(`Circular dependenc${warnings.length > 1 ? 'ies' : 'y'}`);
+        const displayed = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
+        for (const warning of displayed) {
+            rollup.stderr(warning.ids.map(parseAst_js.relativeId).join(' -> '));
+        }
+        if (warnings.length > displayed.length) {
+            rollup.stderr(`...and ${warnings.length - displayed.length} more`);
+        }
+    },
+    EMPTY_BUNDLE(warnings) {
+        title(`Generated${warnings.length === 1 ? ' an' : ''} empty ${warnings.length > 1 ? 'chunks' : 'chunk'}`);
+        rollup.stderr(parseAst_js.printQuotedStringList(warnings.map(warning => warning.names[0])));
+    },
+    EVAL(warnings) {
+        title('Use of eval is strongly discouraged');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_AVOIDING_EVAL));
+        showTruncatedWarnings(warnings);
+    },
+    MISSING_EXPORT(warnings) {
+        title('Missing exports');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_NAME_IS_NOT_EXPORTED));
+        for (const warning of warnings) {
+            rollup.stderr(rollup.bold(parseAst_js.relativeId(warning.id)));
+            rollup.stderr(`${warning.binding} is not exported by ${parseAst_js.relativeId(warning.exporter)}`);
+            rollup.stderr(rollup.gray(warning.frame));
+        }
+    },
+    MISSING_GLOBAL_NAME(warnings) {
+        title(`Missing global variable ${warnings.length > 1 ? 'names' : 'name'}`);
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_OUTPUT_GLOBALS));
+        rollup.stderr(`Use "output.globals" to specify browser global variable names corresponding to external modules:`);
+        for (const warning of warnings) {
+            rollup.stderr(`${rollup.bold(warning.id)} (guessing "${warning.names[0]}")`);
+        }
+    },
+    MIXED_EXPORTS(warnings) {
+        title('Mixing named and default exports');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_OUTPUT_EXPORTS));
+        rollup.stderr(rollup.bold('The following entry modules are using named and default exports together:'));
+        warnings.sort((a, b) => (a.id < b.id ? -1 : 1));
+        const displayedWarnings = warnings.length > 5 ? warnings.slice(0, 3) : warnings;
+        for (const warning of displayedWarnings) {
+            rollup.stderr(parseAst_js.relativeId(warning.id));
+        }
+        if (displayedWarnings.length < warnings.length) {
+            rollup.stderr(`...and ${warnings.length - displayedWarnings.length} other entry modules`);
+        }
+        rollup.stderr(`\nConsumers of your bundle will have to use chunk.default to access their default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning.`);
+    },
+    NAMESPACE_CONFLICT(warnings) {
+        title(`Conflicting re-exports`);
+        for (const warning of warnings) {
+            rollup.stderr(`"${rollup.bold(parseAst_js.relativeId(warning.reexporter))}" re-exports "${warning.binding}" from both "${parseAst_js.relativeId(warning.ids[0])}" and "${parseAst_js.relativeId(warning.ids[1])}" (will be ignored).`);
+        }
+    },
+    PLUGIN_WARNING(warnings) {
+        const nestedByPlugin = nest(warnings, 'plugin');
+        for (const { items } of nestedByPlugin) {
+            const nestedByMessage = nest(items, 'message');
+            let lastUrl = '';
+            for (const { key: message, items } of nestedByMessage) {
+                title(message);
+                for (const warning of items) {
+                    if (warning.url && warning.url !== lastUrl)
+                        info((lastUrl = warning.url));
+                    const loc = formatLocation(warning);
+                    if (loc) {
+                        rollup.stderr(rollup.bold(loc));
+                    }
+                    if (warning.frame)
+                        info(warning.frame);
+                }
+            }
+        }
+    },
+    SOURCEMAP_BROKEN(warnings) {
+        title(`Broken sourcemap`);
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT));
+        const plugins = [...new Set(warnings.map(({ plugin }) => plugin).filter(Boolean))];
+        rollup.stderr(`Plugins that transform code (such as ${parseAst_js.printQuotedStringList(plugins)}) should generate accompanying sourcemaps.`);
+    },
+    THIS_IS_UNDEFINED(warnings) {
+        title('"this" has been rewritten to "undefined"');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_THIS_IS_UNDEFINED));
+        showTruncatedWarnings(warnings);
+    },
+    UNRESOLVED_IMPORT(warnings) {
+        title('Unresolved dependencies');
+        info(parseAst_js.getRollupUrl(parseAst_js.URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY));
+        const dependencies = new Map();
+        for (const warning of warnings) {
+            rollup.getOrCreate(dependencies, parseAst_js.relativeId(warning.exporter), rollup.getNewArray).push(parseAst_js.relativeId(warning.id));
+        }
+        for (const [dependency, importers] of dependencies) {
+            rollup.stderr(`${rollup.bold(dependency)} (imported by ${parseAst_js.printQuotedStringList(importers)})`);
+        }
+    },
+    UNUSED_EXTERNAL_IMPORT(warnings) {
+        title('Unused external imports');
+        for (const warning of warnings) {
+            rollup.stderr(warning.names +
+                ' imported from external module "' +
+                warning.exporter +
+                '" but never used in ' +
+                parseAst_js.printQuotedStringList(warning.ids.map(parseAst_js.relativeId)) +
+                '.');
+        }
+    }
+};
+function defaultBody(log) {
+    if (log.url) {
+        info(parseAst_js.getRollupUrl(log.url));
+    }
+    const loc = formatLocation(log);
+    if (loc) {
+        rollup.stderr(rollup.bold(loc));
+    }
+    if (log.frame)
+        info(log.frame);
+}
+function title(string_) {
+    rollup.stderr(rollup.bold(rollup.yellow(`(!) ${string_}`)));
+}
+function info(url) {
+    rollup.stderr(rollup.gray(url));
+}
+function nest(array, property) {
+    const nested = [];
+    const lookup = new Map();
+    for (const item of array) {
+        const key = item[property];
+        rollup.getOrCreate(lookup, key, () => {
+            const items = {
+                items: [],
+                key
+            };
+            nested.push(items);
+            return items;
+        }).items.push(item);
+    }
+    return nested;
+}
+function showTruncatedWarnings(warnings) {
+    const nestedByModule = nest(warnings, 'id');
+    const displayedByModule = nestedByModule.length > 5 ? nestedByModule.slice(0, 3) : nestedByModule;
+    for (const { key: id, items } of displayedByModule) {
+        rollup.stderr(rollup.bold(parseAst_js.relativeId(id)));
+        rollup.stderr(rollup.gray(items[0].frame));
+        if (items.length > 1) {
+            rollup.stderr(`...and ${items.length - 1} other ${items.length > 2 ? 'occurrences' : 'occurrence'}`);
+        }
+    }
+    if (nestedByModule.length > displayedByModule.length) {
+        rollup.stderr(`\n...and ${nestedByModule.length - displayedByModule.length} other files`);
+    }
+}
+function generateLogFilter(command) {
+    const filters = rollup.ensureArray(command.filterLogs).flatMap(filter => String(filter).split(','));
+    if (process.env.ROLLUP_FILTER_LOGS) {
+        filters.push(...process.env.ROLLUP_FILTER_LOGS.split(','));
+    }
+    return getLogFilter_js.getLogFilter(filters);
+}
+function formatLocation(log) {
+    const id = log.loc?.file || log.id;
+    if (!id)
+        return null;
+    return log.loc ? `${id}:${log.loc.line}:${log.loc.column}` : id;
+}
+
+const stdinName = '-';
+let stdinResult = null;
+function stdinPlugin(argument) {
+    const suffix = typeof argument == 'string' && argument.length > 0 ? '.' + argument : '';
+    return {
+        load(id) {
+            if (id === stdinName || id.startsWith(stdinName + '.')) {
+                return stdinResult || (stdinResult = readStdin());
+            }
+        },
+        name: 'stdin',
+        resolveId(id) {
+            if (id === stdinName) {
+                return id + suffix;
+            }
+        }
+    };
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process$1.stdin.setEncoding('utf8');
+        process$1.stdin
+            .on('data', chunk => chunks.push(chunk))
+            .on('end', () => {
+            const result = chunks.join('');
+            resolve(result);
+        })
+            .on('error', error => {
+            reject(error);
+        });
+    });
+}
+
+function waitForInputPlugin() {
+    return {
+        async buildStart(options) {
+            const inputSpecifiers = Array.isArray(options.input)
+                ? options.input
+                : Object.keys(options.input);
+            let lastAwaitedSpecifier = null;
+            checkSpecifiers: while (true) {
+                for (const specifier of inputSpecifiers) {
+                    if ((await this.resolve(specifier)) === null) {
+                        if (lastAwaitedSpecifier !== specifier) {
+                            rollup.stderr(`waiting for input ${rollup.bold(specifier)}...`);
+                            lastAwaitedSpecifier = specifier;
+                        }
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        continue checkSpecifiers;
+                    }
+                }
+                break;
+            }
+        },
+        name: 'wait-for-input'
+    };
+}
+
+async function addCommandPluginsToInputOptions(inputOptions, command) {
+    if (command.stdin !== false) {
+        inputOptions.plugins.push(stdinPlugin(command.stdin));
+    }
+    if (command.waitForBundleInput === true) {
+        inputOptions.plugins.push(waitForInputPlugin());
+    }
+    await addPluginsFromCommandOption(command.plugin, inputOptions);
+}
+async function addPluginsFromCommandOption(commandPlugin, inputOptions) {
+    if (commandPlugin) {
+        const plugins = await rollup.normalizePluginOption(commandPlugin);
+        for (const plugin of plugins) {
+            if (/[={}]/.test(plugin)) {
+                // -p plugin=value
+                // -p "{transform(c,i){...}}"
+                await loadAndRegisterPlugin(inputOptions, plugin);
+            }
+            else {
+                // split out plugins joined by commas
+                // -p node-resolve,commonjs,buble
+                for (const p of plugin.split(',')) {
+                    await loadAndRegisterPlugin(inputOptions, p);
+                }
+            }
+        }
+    }
+}
+async function loadAndRegisterPlugin(inputOptions, pluginText) {
+    let plugin = null;
+    let pluginArgument = undefined;
+    if (pluginText[0] === '{') {
+        // -p "{transform(c,i){...}}"
+        plugin = new Function('return ' + pluginText);
+    }
+    else {
+        const match = pluginText.match(/^([\w./:@\\^{|}-]+)(=(.*))?$/);
+        if (match) {
+            // -p plugin
+            // -p plugin=arg
+            pluginText = match[1];
+            pluginArgument = new Function('return ' + match[3])();
+        }
+        else {
+            throw new Error(`Invalid --plugin argument format: ${JSON.stringify(pluginText)}`);
+        }
+        if (!/^\.|^rollup-plugin-|[/@\\]/.test(pluginText)) {
+            // Try using plugin prefix variations first if applicable.
+            // Prefix order is significant - left has higher precedence.
+            for (const prefix of ['@rollup/plugin-', 'rollup-plugin-']) {
+                try {
+                    plugin = await requireOrImport(prefix + pluginText);
+                    break;
+                }
+                catch {
+                    // if this does not work, we try requiring the actual name below
+                }
+            }
+        }
+        if (!plugin) {
+            try {
+                if (pluginText[0] == '.')
+                    pluginText = path.resolve(pluginText);
+                // Windows absolute paths must be specified as file:// protocol URL
+                // Note that we do not have coverage for Windows-only code paths
+                else if (/^[A-Za-z]:\\/.test(pluginText)) {
+                    pluginText = node_url.pathToFileURL(path.resolve(pluginText)).href;
+                }
+                plugin = await requireOrImport(pluginText);
+            }
+            catch (error) {
+                throw new Error(`Cannot load plugin "${pluginText}": ${error.message}.`);
+            }
+        }
+    }
+    // some plugins do not use `module.exports` for their entry point,
+    // in which case we try the named default export and the plugin name
+    if (typeof plugin === 'object') {
+        plugin = plugin.default || plugin[getCamelizedPluginBaseName(pluginText)];
+    }
+    if (!plugin) {
+        throw new Error(`Cannot find entry for plugin "${pluginText}". The plugin needs to export a function either as "default" or "${getCamelizedPluginBaseName(pluginText)}" for Rollup to recognize it.`);
+    }
+    inputOptions.plugins.push(typeof plugin === 'function' ? plugin.call(plugin, pluginArgument) : plugin);
+}
+function getCamelizedPluginBaseName(pluginText) {
+    return (pluginText.match(/(@rollup\/plugin-|rollup-plugin-)(.+)$/)?.[2] || pluginText)
+        .split(/[/\\]/)
+        .slice(-1)[0]
+        .split('.')[0]
+        .split('-')
+        .map((part, index) => (index === 0 || !part ? part : part[0].toUpperCase() + part.slice(1)))
+        .join('');
+}
+async function requireOrImport(pluginPath) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(pluginPath);
+    }
+    catch {
+        return import(pluginPath);
+    }
+}
+
+const loadConfigFile = async (fileName, commandOptions = {}, watchMode = false) => {
+    const configs = await getConfigList(getDefaultFromCjs(await getConfigFileExport(fileName, commandOptions, watchMode)), commandOptions);
+    const warnings = batchWarnings(commandOptions);
+    try {
+        const normalizedConfigs = [];
+        for (const config of configs) {
+            const options = await rollup.mergeOptions(config, watchMode, commandOptions, warnings.log);
+            await addCommandPluginsToInputOptions(options, commandOptions);
+            normalizedConfigs.push(options);
+        }
+        return { options: normalizedConfigs, warnings };
+    }
+    catch (error_) {
+        warnings.flush();
+        throw error_;
+    }
+};
+async function getConfigFileExport(fileName, commandOptions, watchMode) {
+    if (commandOptions.configPlugin || commandOptions.bundleConfigAsCjs) {
+        try {
+            return await loadTranspiledConfigFile(fileName, commandOptions);
+        }
+        catch (error_) {
+            if (error_.message.includes('not defined in ES module scope')) {
+                return parseAst_js.error(parseAst_js.logCannotBundleConfigAsEsm(error_));
+            }
+            throw error_;
+        }
+    }
+    let cannotLoadEsm = false;
+    const handleWarning = (warning) => {
+        if (warning.message.includes('To load an ES module')) {
+            cannotLoadEsm = true;
+        }
+    };
+    process$1.on('warning', handleWarning);
+    try {
+        const fileUrl = node_url.pathToFileURL(fileName);
+        if (watchMode) {
+            // We are adding the current date to allow reloads in watch mode
+            fileUrl.search = `?${Date.now()}`;
+        }
+        return (await import(fileUrl.href)).default;
+    }
+    catch (error_) {
+        if (cannotLoadEsm) {
+            return parseAst_js.error(parseAst_js.logCannotLoadConfigAsCjs(error_));
+        }
+        if (error_.message.includes('not defined in ES module scope')) {
+            return parseAst_js.error(parseAst_js.logCannotLoadConfigAsEsm(error_));
+        }
+        throw error_;
+    }
+    finally {
+        process$1.off('warning', handleWarning);
+    }
+}
+function getDefaultFromCjs(namespace) {
+    return namespace.default || namespace;
+}
+async function loadTranspiledConfigFile(fileName, commandOptions) {
+    const { bundleConfigAsCjs, configPlugin, silent } = commandOptions;
+    const warnings = batchWarnings(commandOptions);
+    const inputOptions = {
+        external: (id) => (id[0] !== '.' && !path.isAbsolute(id)) || id.slice(-5) === '.json',
+        input: fileName,
+        onwarn: warnings.add,
+        plugins: [],
+        treeshake: false
+    };
+    await addPluginsFromCommandOption(configPlugin, inputOptions);
+    const bundle = await rollup.rollup(inputOptions);
+    const { output: [{ code }] } = await bundle.generate({
+        exports: 'named',
+        format: bundleConfigAsCjs ? 'cjs' : 'es',
+        plugins: [
+            {
+                name: 'transpile-import-meta',
+                resolveImportMeta(property, { moduleId }) {
+                    if (property === 'url') {
+                        return `'${node_url.pathToFileURL(moduleId).href}'`;
+                    }
+                    if (property == 'filename') {
+                        return `'${moduleId}'`;
+                    }
+                    if (property == 'dirname') {
+                        return `'${path.dirname(moduleId)}'`;
+                    }
+                    if (property == null) {
+                        return `{url:'${node_url.pathToFileURL(moduleId).href}', filename: '${moduleId}', dirname: '${path.dirname(moduleId)}'}`;
+                    }
+                }
+            }
+        ]
+    });
+    if (!silent && warnings.count > 0) {
+        rollup.stderr(rollup.bold(`loaded ${parseAst_js.relativeId(fileName)} with warnings`));
+        warnings.flush();
+    }
+    return loadConfigFromWrittenFile(path.join(path.dirname(fileName), `rollup.config-${Date.now()}.${bundleConfigAsCjs ? 'cjs' : 'mjs'}`), code);
+}
+async function loadConfigFromWrittenFile(bundledFileName, bundledCode) {
+    await promises.writeFile(bundledFileName, bundledCode);
+    try {
+        return (await import(node_url.pathToFileURL(bundledFileName).href)).default;
+    }
+    finally {
+        promises.unlink(bundledFileName).catch(error => console.warn(error?.message || error));
+    }
+}
+async function getConfigList(configFileExport, commandOptions) {
+    const config = await (typeof configFileExport === 'function'
+        ? configFileExport(commandOptions)
+        : configFileExport);
+    if (Object.keys(config).length === 0) {
+        return parseAst_js.error(parseAst_js.logMissingConfig());
+    }
+    return Array.isArray(config) ? config : [config];
+}
+
+exports.addCommandPluginsToInputOptions = addCommandPluginsToInputOptions;
+exports.batchWarnings = batchWarnings;
+exports.loadConfigFile = loadConfigFile;
+exports.stdinName = stdinName;
+//# sourceMappingURL=loadConfigFile.js.map
diff --git a/node_modules/rollup/dist/shared/parseAst.js b/node_modules/rollup/dist/shared/parseAst.js
new file mode 100644
index 0000000..65b62be
--- /dev/null
+++ b/node_modules/rollup/dist/shared/parseAst.js
@@ -0,0 +1,2297 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const native_js = require('../native.js');
+const path = require('node:path');
+
+/** @typedef {import('./types').Location} Location */
+
+/**
+ * @param {import('./types').Range} range
+ * @param {number} index
+ */
+function rangeContains(range, index) {
+	return range.start <= index && index < range.end;
+}
+
+/**
+ * @param {string} source
+ * @param {import('./types').Options} [options]
+ */
+function getLocator(source, options = {}) {
+	const { offsetLine = 0, offsetColumn = 0 } = options;
+
+	let start = 0;
+	const ranges = source.split('\n').map((line, i) => {
+		const end = start + line.length + 1;
+
+		/** @type {import('./types').Range} */
+		const range = { start, end, line: i };
+
+		start = end;
+		return range;
+	});
+
+	let i = 0;
+
+	/**
+	 * @param {string | number} search
+	 * @param {number} [index]
+	 * @returns {Location | undefined}
+	 */
+	function locator(search, index) {
+		if (typeof search === 'string') {
+			search = source.indexOf(search, index ?? 0);
+		}
+
+		if (search === -1) return undefined;
+
+		let range = ranges[i];
+
+		const d = search >= range.end ? 1 : -1;
+
+		while (range) {
+			if (rangeContains(range, search)) {
+				return {
+					line: offsetLine + range.line,
+					column: offsetColumn + search - range.start,
+					character: search
+				};
+			}
+
+			i += d;
+			range = ranges[i];
+		}
+	}
+
+	return locator;
+}
+
+/**
+ * @param {string} source
+ * @param {string | number} search
+ * @param {import('./types').Options} [options]
+ * @returns {Location | undefined}
+ */
+function locate(source, search, options) {
+	return getLocator(source, options)(search, options && options.startIndex);
+}
+
+function spaces(index) {
+    let result = '';
+    while (index--)
+        result += ' ';
+    return result;
+}
+function tabsToSpaces(value) {
+    return value.replace(/^\t+/, match => match.split('\t').join('  '));
+}
+const LINE_TRUNCATE_LENGTH = 120;
+const MIN_CHARACTERS_SHOWN_AFTER_LOCATION = 10;
+const ELLIPSIS = '...';
+function getCodeFrame(source, line, column) {
+    let lines = source.split('\n');
+    // Needed if a plugin did not generate correct sourcemaps
+    if (line > lines.length)
+        return '';
+    const maxLineLength = Math.max(tabsToSpaces(lines[line - 1].slice(0, column)).length +
+        MIN_CHARACTERS_SHOWN_AFTER_LOCATION +
+        ELLIPSIS.length, LINE_TRUNCATE_LENGTH);
+    const frameStart = Math.max(0, line - 3);
+    let frameEnd = Math.min(line + 2, lines.length);
+    lines = lines.slice(frameStart, frameEnd);
+    while (!/\S/.test(lines[lines.length - 1])) {
+        lines.pop();
+        frameEnd -= 1;
+    }
+    const digits = String(frameEnd).length;
+    return lines
+        .map((sourceLine, index) => {
+        const isErrorLine = frameStart + index + 1 === line;
+        let lineNumber = String(index + frameStart + 1);
+        while (lineNumber.length < digits)
+            lineNumber = ` ${lineNumber}`;
+        let displayedLine = tabsToSpaces(sourceLine);
+        if (displayedLine.length > maxLineLength) {
+            displayedLine = `${displayedLine.slice(0, maxLineLength - ELLIPSIS.length)}${ELLIPSIS}`;
+        }
+        if (isErrorLine) {
+            const indicator = spaces(digits + 2 + tabsToSpaces(sourceLine.slice(0, column)).length) + '^';
+            return `${lineNumber}: ${displayedLine}\n${indicator}`;
+        }
+        return `${lineNumber}: ${displayedLine}`;
+    })
+        .join('\n');
+}
+
+const LOGLEVEL_SILENT = 'silent';
+const LOGLEVEL_ERROR = 'error';
+const LOGLEVEL_WARN = 'warn';
+const LOGLEVEL_INFO = 'info';
+const LOGLEVEL_DEBUG = 'debug';
+const logLevelPriority = {
+    [LOGLEVEL_DEBUG]: 0,
+    [LOGLEVEL_INFO]: 1,
+    [LOGLEVEL_SILENT]: 3,
+    [LOGLEVEL_WARN]: 2
+};
+
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Za-z]:)?[/\\|])/;
+const RELATIVE_PATH_REGEX = /^\.?\.(\/|$)/;
+function isAbsolute(path) {
+    return ABSOLUTE_PATH_REGEX.test(path);
+}
+function isRelative(path) {
+    return RELATIVE_PATH_REGEX.test(path);
+}
+const BACKSLASH_REGEX = /\\/g;
+function normalize(path) {
+    return path.replace(BACKSLASH_REGEX, '/');
+}
+
+function printQuotedStringList(list, verbs) {
+    const isSingleItem = list.length <= 1;
+    const quotedList = list.map(item => `"${item}"`);
+    let output = isSingleItem
+        ? quotedList[0]
+        : `${quotedList.slice(0, -1).join(', ')} and ${quotedList.slice(-1)[0]}`;
+    if (verbs) {
+        output += ` ${isSingleItem ? verbs[0] : verbs[1]}`;
+    }
+    return output;
+}
+
+const ANY_SLASH_REGEX = /[/\\]/;
+function relative(from, to) {
+    const fromParts = from.split(ANY_SLASH_REGEX).filter(Boolean);
+    const toParts = to.split(ANY_SLASH_REGEX).filter(Boolean);
+    if (fromParts[0] === '.')
+        fromParts.shift();
+    if (toParts[0] === '.')
+        toParts.shift();
+    while (fromParts[0] && toParts[0] && fromParts[0] === toParts[0]) {
+        fromParts.shift();
+        toParts.shift();
+    }
+    while (toParts[0] === '..' && fromParts.length > 0) {
+        toParts.shift();
+        fromParts.pop();
+    }
+    while (fromParts.pop()) {
+        toParts.unshift('..');
+    }
+    return toParts.join('/');
+}
+
+function getAliasName(id) {
+    const base = path.basename(id);
+    return base.slice(0, Math.max(0, base.length - path.extname(id).length));
+}
+function relativeId(id) {
+    if (!isAbsolute(id))
+        return id;
+    return relative(path.resolve(), id);
+}
+function isPathFragment(name) {
+    // starting with "/", "./", "../", "C:/"
+    return (name[0] === '/' || (name[0] === '.' && (name[1] === '/' || name[1] === '.')) || isAbsolute(name));
+}
+const UPPER_DIR_REGEX = /^(\.\.\/)*\.\.$/;
+function getImportPath(importerId, targetPath, stripJsExtension, ensureFileName) {
+    while (targetPath.startsWith('../')) {
+        targetPath = targetPath.slice(3);
+        importerId = '_/' + importerId;
+    }
+    let relativePath = normalize(relative(path.dirname(importerId), targetPath));
+    if (stripJsExtension && relativePath.endsWith('.js')) {
+        relativePath = relativePath.slice(0, -3);
+    }
+    if (ensureFileName) {
+        if (relativePath === '')
+            return '../' + path.basename(targetPath);
+        if (UPPER_DIR_REGEX.test(relativePath)) {
+            return [...relativePath.split('/'), '..', path.basename(targetPath)].join('/');
+        }
+    }
+    return relativePath ? (relativePath.startsWith('..') ? relativePath : './' + relativePath) : '.';
+}
+
+function isValidUrl(url) {
+    try {
+        new URL(url);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+function getRollupUrl(snippet) {
+    return `https://rollupjs.org/${snippet}`;
+}
+function addTrailingSlashIfMissed(url) {
+    if (!url.endsWith('/')) {
+        return url + '/';
+    }
+    return url;
+}
+
+// troubleshooting
+const URL_AVOIDING_EVAL = 'troubleshooting/#avoiding-eval';
+const URL_NAME_IS_NOT_EXPORTED = 'troubleshooting/#error-name-is-not-exported-by-module';
+const URL_THIS_IS_UNDEFINED = 'troubleshooting/#error-this-is-undefined';
+const URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY = 'troubleshooting/#warning-treating-module-as-external-dependency';
+const URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT = 'troubleshooting/#warning-sourcemap-is-likely-to-be-incorrect';
+// configuration-options
+const URL_JSX = 'configuration-options/#jsx';
+const URL_OUTPUT_AMD_ID = 'configuration-options/#output-amd-id';
+const URL_OUTPUT_AMD_BASEPATH = 'configuration-options/#output-amd-basepath';
+const URL_OUTPUT_DIR = 'configuration-options/#output-dir';
+const URL_OUTPUT_EXPORTS = 'configuration-options/#output-exports';
+const URL_OUTPUT_EXTEND = 'configuration-options/#output-extend';
+const URL_OUTPUT_EXTERNALIMPORTATTRIBUTES = 'configuration-options/#output-externalimportattributes';
+const URL_OUTPUT_FORMAT = 'configuration-options/#output-format';
+const URL_OUTPUT_GENERATEDCODE = 'configuration-options/#output-generatedcode';
+const URL_OUTPUT_GLOBALS = 'configuration-options/#output-globals';
+const URL_OUTPUT_INLINEDYNAMICIMPORTS = 'configuration-options/#output-inlinedynamicimports';
+const URL_OUTPUT_INTEROP = 'configuration-options/#output-interop';
+const URL_OUTPUT_MANUALCHUNKS = 'configuration-options/#output-manualchunks';
+const URL_OUTPUT_NAME = 'configuration-options/#output-name';
+const URL_OUTPUT_SOURCEMAPBASEURL = 'configuration-options/#output-sourcemapbaseurl';
+const URL_OUTPUT_SOURCEMAPFILE = 'configuration-options/#output-sourcemapfile';
+const URL_PRESERVEENTRYSIGNATURES = 'configuration-options/#preserveentrysignatures';
+const URL_TREESHAKE = 'configuration-options/#treeshake';
+const URL_TREESHAKE_PURE = 'configuration-options/#pure';
+const URL_TREESHAKE_NOSIDEEFFECTS = 'configuration-options/#no-side-effects';
+const URL_TREESHAKE_MODULESIDEEFFECTS = 'configuration-options/#treeshake-modulesideeffects';
+const URL_WATCH = 'configuration-options/#watch';
+// command-line-interface
+const URL_BUNDLE_CONFIG_AS_CJS = 'command-line-interface/#bundleconfigascjs';
+const URL_CONFIGURATION_FILES = 'command-line-interface/#configuration-files';
+const URL_GENERATEBUNDLE = 'plugin-development/#generatebundle';
+
+function error(base) {
+    throw base instanceof Error ? base : getRollupError(base);
+}
+function getRollupError(base) {
+    augmentLogMessage(base);
+    const errorInstance = Object.assign(new Error(base.message), base);
+    Object.defineProperty(errorInstance, 'name', {
+        value: 'RollupError',
+        writable: true
+    });
+    return errorInstance;
+}
+function augmentCodeLocation(properties, pos, source, id) {
+    if (typeof pos === 'object') {
+        const { line, column } = pos;
+        properties.loc = { column, file: id, line };
+    }
+    else {
+        properties.pos = pos;
+        const location = locate(source, pos, { offsetLine: 1 });
+        if (!location) {
+            return;
+        }
+        const { line, column } = location;
+        properties.loc = { column, file: id, line };
+    }
+    if (properties.frame === undefined) {
+        const { line, column } = properties.loc;
+        properties.frame = getCodeFrame(source, line, column);
+    }
+}
+const symbolAugmented = Symbol('augmented');
+function augmentLogMessage(log) {
+    // Make sure to only augment the log message once
+    if (!(log.plugin || log.loc) || log[symbolAugmented]) {
+        return;
+    }
+    log[symbolAugmented] = true;
+    let prefix = '';
+    if (log.plugin) {
+        prefix += `[plugin ${log.plugin}] `;
+    }
+    const id = log.id || log.loc?.file;
+    if (id) {
+        const position = log.loc ? ` (${log.loc.line}:${log.loc.column})` : '';
+        prefix += `${relativeId(id)}${position}: `;
+    }
+    const oldMessage = log.message;
+    log.message = prefix + log.message;
+    tweakStackMessage(log, oldMessage);
+}
+// Error codes should be sorted alphabetically while errors should be sorted by
+// error code below
+const ADDON_ERROR = 'ADDON_ERROR', ALREADY_CLOSED = 'ALREADY_CLOSED', AMBIGUOUS_EXTERNAL_NAMESPACES = 'AMBIGUOUS_EXTERNAL_NAMESPACES', ANONYMOUS_PLUGIN_CACHE = 'ANONYMOUS_PLUGIN_CACHE', ASSET_NOT_FINALISED = 'ASSET_NOT_FINALISED', ASSET_NOT_FOUND = 'ASSET_NOT_FOUND', ASSET_SOURCE_ALREADY_SET = 'ASSET_SOURCE_ALREADY_SET', ASSET_SOURCE_MISSING = 'ASSET_SOURCE_MISSING', BAD_LOADER = 'BAD_LOADER', CANNOT_CALL_NAMESPACE = 'CANNOT_CALL_NAMESPACE', CANNOT_EMIT_FROM_OPTIONS_HOOK = 'CANNOT_EMIT_FROM_OPTIONS_HOOK', CHUNK_NOT_GENERATED = 'CHUNK_NOT_GENERATED', CHUNK_INVALID = 'CHUNK_INVALID', CIRCULAR_DEPENDENCY = 'CIRCULAR_DEPENDENCY', CIRCULAR_REEXPORT = 'CIRCULAR_REEXPORT', CONST_REASSIGN = 'CONST_REASSIGN', CYCLIC_CROSS_CHUNK_REEXPORT = 'CYCLIC_CROSS_CHUNK_REEXPORT', DEPRECATED_FEATURE = 'DEPRECATED_FEATURE', DUPLICATE_ARGUMENT_NAME = 'DUPLICATE_ARGUMENT_NAME', DUPLICATE_EXPORT = 'DUPLICATE_EXPORT', DUPLICATE_IMPORT_OPTIONS = 'DUPLICATE_IMPORT_OPTIONS', DUPLICATE_PLUGIN_NAME = 'DUPLICATE_PLUGIN_NAME', EMPTY_BUNDLE = 'EMPTY_BUNDLE', EVAL = 'EVAL', EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS = 'EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS', EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES = 'EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES', EXTERNAL_SYNTHETIC_EXPORTS = 'EXTERNAL_SYNTHETIC_EXPORTS', FAIL_AFTER_WARNINGS = 'FAIL_AFTER_WARNINGS', FILE_NAME_CONFLICT = 'FILE_NAME_CONFLICT', FILE_NOT_FOUND = 'FILE_NOT_FOUND', FIRST_SIDE_EFFECT = 'FIRST_SIDE_EFFECT', ILLEGAL_IDENTIFIER_AS_NAME = 'ILLEGAL_IDENTIFIER_AS_NAME', ILLEGAL_REASSIGNMENT = 'ILLEGAL_REASSIGNMENT', INCONSISTENT_IMPORT_ATTRIBUTES = 'INCONSISTENT_IMPORT_ATTRIBUTES', INVALID_ANNOTATION = 'INVALID_ANNOTATION', INPUT_HOOK_IN_OUTPUT_PLUGIN = 'INPUT_HOOK_IN_OUTPUT_PLUGIN', INVALID_CHUNK = 'INVALID_CHUNK', INVALID_CONFIG_MODULE_FORMAT = 'INVALID_CONFIG_MODULE_FORMAT', INVALID_EXPORT_OPTION = 'INVALID_EXPORT_OPTION', INVALID_EXTERNAL_ID = 'INVALID_EXTERNAL_ID', INVALID_IMPORT_ATTRIBUTE = 'INVALID_IMPORT_ATTRIBUTE', INVALID_LOG_POSITION = 'INVALID_LOG_POSITION', INVALID_OPTION = 'INVALID_OPTION', INVALID_PLUGIN_HOOK = 'INVALID_PLUGIN_HOOK', INVALID_ROLLUP_PHASE = 'INVALID_ROLLUP_PHASE', INVALID_SETASSETSOURCE = 'INVALID_SETASSETSOURCE', INVALID_TLA_FORMAT = 'INVALID_TLA_FORMAT', MISSING_CONFIG = 'MISSING_CONFIG', MISSING_EXPORT = 'MISSING_EXPORT', MISSING_EXTERNAL_CONFIG = 'MISSING_EXTERNAL_CONFIG', MISSING_GLOBAL_NAME = 'MISSING_GLOBAL_NAME', MISSING_IMPLICIT_DEPENDANT = 'MISSING_IMPLICIT_DEPENDANT', MISSING_JSX_EXPORT = 'MISSING_JSX_EXPORT', MISSING_NAME_OPTION_FOR_IIFE_EXPORT = 'MISSING_NAME_OPTION_FOR_IIFE_EXPORT', MISSING_NODE_BUILTINS = 'MISSING_NODE_BUILTINS', MISSING_OPTION = 'MISSING_OPTION', MIXED_EXPORTS = 'MIXED_EXPORTS', MODULE_LEVEL_DIRECTIVE = 'MODULE_LEVEL_DIRECTIVE', NAMESPACE_CONFLICT = 'NAMESPACE_CONFLICT', NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE = 'NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE', ONLY_INLINE_SOURCEMAPS = 'ONLY_INLINE_SOURCEMAPS', OPTIMIZE_CHUNK_STATUS = 'OPTIMIZE_CHUNK_STATUS', PARSE_ERROR = 'PARSE_ERROR', PLUGIN_ERROR = 'PLUGIN_ERROR', REDECLARATION_ERROR = 'REDECLARATION_ERROR', RESERVED_NAMESPACE = 'RESERVED_NAMESPACE', SHIMMED_EXPORT = 'SHIMMED_EXPORT', SOURCEMAP_BROKEN = 'SOURCEMAP_BROKEN', SOURCEMAP_ERROR = 'SOURCEMAP_ERROR', SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT = 'SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT', THIS_IS_UNDEFINED = 'THIS_IS_UNDEFINED', UNEXPECTED_NAMED_IMPORT = 'UNEXPECTED_NAMED_IMPORT', UNKNOWN_OPTION = 'UNKNOWN_OPTION', UNRESOLVED_ENTRY = 'UNRESOLVED_ENTRY', UNRESOLVED_IMPORT = 'UNRESOLVED_IMPORT', UNUSED_EXTERNAL_IMPORT = 'UNUSED_EXTERNAL_IMPORT', VALIDATION_ERROR = 'VALIDATION_ERROR';
+function logAddonNotGenerated(message, hook, plugin) {
+    return {
+        code: ADDON_ERROR,
+        message: `Could not retrieve "${hook}". Check configuration of plugin "${plugin}".
+\tError Message: ${message}`
+    };
+}
+function logAlreadyClosed() {
+    return {
+        code: ALREADY_CLOSED,
+        message: 'Bundle is already closed, no more calls to "generate" or "write" are allowed.'
+    };
+}
+function logAmbiguousExternalNamespaces(binding, reexportingModule, usedModule, sources) {
+    return {
+        binding,
+        code: AMBIGUOUS_EXTERNAL_NAMESPACES,
+        ids: sources,
+        message: `Ambiguous external namespace resolution: "${relativeId(reexportingModule)}" re-exports "${binding}" from one of the external modules ${printQuotedStringList(sources.map(module => relativeId(module)))}, guessing "${relativeId(usedModule)}".`,
+        reexporter: reexportingModule
+    };
+}
+function logAnonymousPluginCache() {
+    return {
+        code: ANONYMOUS_PLUGIN_CACHE,
+        message: 'A plugin is trying to use the Rollup cache but is not declaring a plugin name or cacheKey.'
+    };
+}
+function logAssetNotFinalisedForFileName(name) {
+    return {
+        code: ASSET_NOT_FINALISED,
+        message: `Plugin error - Unable to get file name for asset "${name}". Ensure that the source is set and that generate is called first. If you reference assets via import.meta.ROLLUP_FILE_URL_<referenceId>, you need to either have set their source after "renderStart" or need to provide an explicit "fileName" when emitting them.`
+    };
+}
+function logAssetReferenceIdNotFoundForSetSource(assetReferenceId) {
+    return {
+        code: ASSET_NOT_FOUND,
+        message: `Plugin error - Unable to set the source for unknown asset "${assetReferenceId}".`
+    };
+}
+function logAssetSourceAlreadySet(name) {
+    return {
+        code: ASSET_SOURCE_ALREADY_SET,
+        message: `Unable to set the source for asset "${name}", source already set.`
+    };
+}
+function logNoAssetSourceSet(assetName) {
+    return {
+        code: ASSET_SOURCE_MISSING,
+        message: `Plugin error creating asset "${assetName}" - no asset source set.`
+    };
+}
+function logBadLoader(id) {
+    return {
+        code: BAD_LOADER,
+        message: `Error loading "${relativeId(id)}": plugin load hook should return a string, a { code, map } object, or nothing/null.`
+    };
+}
+function logCannotCallNamespace(name) {
+    return {
+        code: CANNOT_CALL_NAMESPACE,
+        message: `Cannot call a namespace ("${name}").`
+    };
+}
+function logCannotEmitFromOptionsHook() {
+    return {
+        code: CANNOT_EMIT_FROM_OPTIONS_HOOK,
+        message: `Cannot emit files or set asset sources in the "outputOptions" hook, use the "renderStart" hook instead.`
+    };
+}
+function logChunkNotGeneratedForFileName(name) {
+    return {
+        code: CHUNK_NOT_GENERATED,
+        message: `Plugin error - Unable to get file name for emitted chunk "${name}". You can only get file names once chunks have been generated after the "renderStart" hook.`
+    };
+}
+function logChunkInvalid({ fileName, code }, { pos, message }) {
+    const errorProperties = {
+        code: CHUNK_INVALID,
+        message: `Chunk "${fileName}" is not valid JavaScript: ${message}.`
+    };
+    augmentCodeLocation(errorProperties, pos, code, fileName);
+    return errorProperties;
+}
+function logCircularDependency(cyclePath) {
+    return {
+        code: CIRCULAR_DEPENDENCY,
+        ids: cyclePath,
+        message: `Circular dependency: ${cyclePath.map(relativeId).join(' -> ')}`
+    };
+}
+function logCircularReexport(exportName, exporter) {
+    return {
+        code: CIRCULAR_REEXPORT,
+        exporter,
+        message: `"${exportName}" cannot be exported from "${relativeId(exporter)}" as it is a reexport that references itself.`
+    };
+}
+function logCyclicCrossChunkReexport(exportName, exporter, reexporter, importer, preserveModules) {
+    return {
+        code: CYCLIC_CROSS_CHUNK_REEXPORT,
+        exporter,
+        id: importer,
+        message: `Export "${exportName}" of module "${relativeId(exporter)}" was reexported through module "${relativeId(reexporter)}" while both modules are dependencies of each other and will end up in different chunks by current Rollup settings. This scenario is not well supported at the moment as it will produce a circular dependency between chunks and will likely lead to broken execution order.\nEither change the import in "${relativeId(importer)}" to point directly to the exporting module or ${preserveModules ? 'do not use "output.preserveModules"' : 'reconfigure "output.manualChunks"'} to ensure these modules end up in the same chunk.`,
+        reexporter
+    };
+}
+function logDeprecation(deprecation, urlSnippet, plugin) {
+    return {
+        code: DEPRECATED_FEATURE,
+        message: deprecation,
+        url: getRollupUrl(urlSnippet),
+        ...({})
+    };
+}
+function logConstVariableReassignError() {
+    return {
+        code: CONST_REASSIGN,
+        message: 'Cannot reassign a variable declared with `const`'
+    };
+}
+function logDuplicateArgumentNameError(name) {
+    return {
+        code: DUPLICATE_ARGUMENT_NAME,
+        message: `Duplicate argument name "${name}"`
+    };
+}
+function logDuplicateExportError(name) {
+    return { code: DUPLICATE_EXPORT, message: `Duplicate export "${name}"` };
+}
+function logDuplicateImportOptions() {
+    return {
+        code: DUPLICATE_IMPORT_OPTIONS,
+        message: 'Either use --input, or pass input path as argument'
+    };
+}
+function logDuplicatePluginName(plugin) {
+    return {
+        code: DUPLICATE_PLUGIN_NAME,
+        message: `The plugin name ${plugin} is being used twice in the same build. Plugin names must be distinct or provide a cacheKey (please post an issue to the plugin if you are a plugin user).`
+    };
+}
+function logEmptyChunk(chunkName) {
+    return {
+        code: EMPTY_BUNDLE,
+        message: `Generated an empty chunk: "${chunkName}".`,
+        names: [chunkName]
+    };
+}
+function logEval(id) {
+    return {
+        code: EVAL,
+        id,
+        message: `Use of eval in "${relativeId(id)}" is strongly discouraged as it poses security risks and may cause issues with minification.`,
+        url: getRollupUrl(URL_AVOIDING_EVAL)
+    };
+}
+function logExternalSyntheticExports(id, importer) {
+    return {
+        code: EXTERNAL_SYNTHETIC_EXPORTS,
+        exporter: id,
+        message: `External "${id}" cannot have "syntheticNamedExports" enabled (imported by "${relativeId(importer)}").`
+    };
+}
+function logFailAfterWarnings() {
+    return {
+        code: FAIL_AFTER_WARNINGS,
+        message: 'Warnings occurred and --failAfterWarnings flag present.'
+    };
+}
+function logFileNameConflict(fileName) {
+    return {
+        code: FILE_NAME_CONFLICT,
+        message: `The emitted file "${fileName}" overwrites a previously emitted file of the same name.`
+    };
+}
+function logFileReferenceIdNotFoundForFilename(assetReferenceId) {
+    return {
+        code: FILE_NOT_FOUND,
+        message: `Plugin error - Unable to get file name for unknown file "${assetReferenceId}".`
+    };
+}
+function logFirstSideEffect(source, id, { line, column }) {
+    return {
+        code: FIRST_SIDE_EFFECT,
+        message: `First side effect in ${relativeId(id)} is at (${line}:${column})\n${getCodeFrame(source, line, column)}`
+    };
+}
+function logIllegalIdentifierAsName(name) {
+    return {
+        code: ILLEGAL_IDENTIFIER_AS_NAME,
+        message: `Given name "${name}" is not a legal JS identifier. If you need this, you can try "output.extend: true".`,
+        url: getRollupUrl(URL_OUTPUT_EXTEND)
+    };
+}
+function logIllegalImportReassignment(name, importingId) {
+    return {
+        code: ILLEGAL_REASSIGNMENT,
+        message: `Illegal reassignment of import "${name}" in "${relativeId(importingId)}".`
+    };
+}
+function logInconsistentImportAttributes(existingAttributes, newAttributes, source, importer) {
+    return {
+        code: INCONSISTENT_IMPORT_ATTRIBUTES,
+        message: `Module "${relativeId(importer)}" tried to import "${relativeId(source)}" with ${formatAttributes(newAttributes)} attributes, but it was already imported elsewhere with ${formatAttributes(existingAttributes)} attributes. Please ensure that import attributes for the same module are always consistent.`
+    };
+}
+const formatAttributes = (attributes) => {
+    const entries = Object.entries(attributes);
+    if (entries.length === 0)
+        return 'no';
+    return entries.map(([key, value]) => `"${key}": "${value}"`).join(', ');
+};
+function logInvalidAnnotation(comment, id, type) {
+    return {
+        code: INVALID_ANNOTATION,
+        id,
+        message: `A comment\n\n"${comment}"\n\nin "${relativeId(id)}" contains an annotation that Rollup cannot interpret due to the position of the comment. The comment will be removed to avoid issues.`,
+        url: getRollupUrl(type === 'noSideEffects' ? URL_TREESHAKE_NOSIDEEFFECTS : URL_TREESHAKE_PURE)
+    };
+}
+function logInputHookInOutputPlugin(pluginName, hookName) {
+    return {
+        code: INPUT_HOOK_IN_OUTPUT_PLUGIN,
+        message: `The "${hookName}" hook used by the output plugin ${pluginName} is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.`
+    };
+}
+function logCannotAssignModuleToChunk(moduleId, assignToAlias, currentAlias) {
+    return {
+        code: INVALID_CHUNK,
+        message: `Cannot assign "${relativeId(moduleId)}" to the "${assignToAlias}" chunk as it is already in the "${currentAlias}" chunk.`
+    };
+}
+function tweakStackMessage(error, oldMessage) {
+    if (!error.stack) {
+        return error;
+    }
+    error.stack = error.stack.replace(oldMessage, error.message);
+    return error;
+}
+function logCannotBundleConfigAsEsm(originalError) {
+    return tweakStackMessage({
+        cause: originalError,
+        code: INVALID_CONFIG_MODULE_FORMAT,
+        message: `Rollup transpiled your configuration to an  ES module even though it appears to contain CommonJS elements. To resolve this, you can pass the "--bundleConfigAsCjs" flag to Rollup or change your configuration to only contain valid ESM code.\n\nOriginal error: ${originalError.message}`,
+        stack: originalError.stack,
+        url: getRollupUrl(URL_BUNDLE_CONFIG_AS_CJS)
+    }, originalError.message);
+}
+function logCannotLoadConfigAsCjs(originalError) {
+    return tweakStackMessage({
+        cause: originalError,
+        code: INVALID_CONFIG_MODULE_FORMAT,
+        message: `Node tried to load your configuration file as CommonJS even though it is likely an ES module. To resolve this, change the extension of your configuration to ".mjs", set "type": "module" in your package.json file or pass the "--bundleConfigAsCjs" flag.\n\nOriginal error: ${originalError.message}`,
+        stack: originalError.stack,
+        url: getRollupUrl(URL_BUNDLE_CONFIG_AS_CJS)
+    }, originalError.message);
+}
+function logCannotLoadConfigAsEsm(originalError) {
+    return tweakStackMessage({
+        cause: originalError,
+        code: INVALID_CONFIG_MODULE_FORMAT,
+        message: `Node tried to load your configuration as an ES module even though it is likely CommonJS. To resolve this, change the extension of your configuration to ".cjs" or pass the "--bundleConfigAsCjs" flag.\n\nOriginal error: ${originalError.message}`,
+        stack: originalError.stack,
+        url: getRollupUrl(URL_BUNDLE_CONFIG_AS_CJS)
+    }, originalError.message);
+}
+function logInvalidExportOptionValue(optionValue) {
+    return {
+        code: INVALID_EXPORT_OPTION,
+        message: `"output.exports" must be "default", "named", "none", "auto", or left unspecified (defaults to "auto"), received "${optionValue}".`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logIncompatibleExportOptionValue(optionValue, keys, entryModule) {
+    return {
+        code: INVALID_EXPORT_OPTION,
+        message: `"${optionValue}" was specified for "output.exports", but entry module "${relativeId(entryModule)}" has the following exports: ${printQuotedStringList(keys)}`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logInternalIdCannotBeExternal(source, importer) {
+    return {
+        code: INVALID_EXTERNAL_ID,
+        message: `"${source}" is imported as an external by "${relativeId(importer)}", but is already an existing non-external module id.`
+    };
+}
+function logImportOptionsAreInvalid(importer) {
+    return {
+        code: INVALID_IMPORT_ATTRIBUTE,
+        message: `Rollup could not statically analyze the options argument of a dynamic import in "${relativeId(importer)}". Dynamic import options need to be an object with a nested attributes object.`
+    };
+}
+function logImportAttributeIsInvalid(importer) {
+    return {
+        code: INVALID_IMPORT_ATTRIBUTE,
+        message: `Rollup could not statically analyze an import attribute of a dynamic import in "${relativeId(importer)}". Import attributes need to have string keys and values. The attribute will be removed.`
+    };
+}
+function logInvalidLogPosition(plugin) {
+    return {
+        code: INVALID_LOG_POSITION,
+        message: `Plugin "${plugin}" tried to add a file position to a log or warning. This is only supported in the "transform" hook at the moment and will be ignored.`
+    };
+}
+function logInvalidOption(option, urlSnippet, explanation, value) {
+    return {
+        code: INVALID_OPTION,
+        message: `Invalid value ${value === undefined ? '' : `${JSON.stringify(value)} `}for option "${option}" - ${explanation}.`,
+        url: getRollupUrl(urlSnippet)
+    };
+}
+function logInvalidAddonPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a string, a function hook or an object with a "handler" string or function.`,
+        plugin
+    };
+}
+function logInvalidFunctionPluginHook(hook, plugin) {
+    return {
+        code: INVALID_PLUGIN_HOOK,
+        hook,
+        message: `Error running plugin hook "${hook}" for plugin "${plugin}", expected a function hook or an object with a "handler" function.`,
+        plugin
+    };
+}
+function logInvalidRollupPhaseForChunkEmission() {
+    return {
+        code: INVALID_ROLLUP_PHASE,
+        message: `Cannot emit chunks after module loading has finished.`
+    };
+}
+function logInvalidSetAssetSourceCall() {
+    return {
+        code: INVALID_SETASSETSOURCE,
+        message: `setAssetSource cannot be called in transform for caching reasons. Use emitFile with a source, or call setAssetSource in another hook.`
+    };
+}
+function logInvalidFormatForTopLevelAwait(id, format) {
+    return {
+        code: INVALID_TLA_FORMAT,
+        id,
+        message: `Module format "${format}" does not support top-level await. Use the "es" or "system" output formats rather.`
+    };
+}
+function logMissingConfig() {
+    return {
+        code: MISSING_CONFIG,
+        message: 'Config file must export an options object, or an array of options objects',
+        url: getRollupUrl(URL_CONFIGURATION_FILES)
+    };
+}
+function logMissingEntryExport(binding, exporter) {
+    return {
+        binding,
+        code: MISSING_EXPORT,
+        exporter,
+        message: `Exported variable "${binding}" is not defined in "${relativeId(exporter)}".`,
+        url: getRollupUrl(URL_NAME_IS_NOT_EXPORTED)
+    };
+}
+function logMissingExport(binding, importingModule, exporter) {
+    const isJson = path.extname(exporter) === '.json';
+    return {
+        binding,
+        code: MISSING_EXPORT,
+        exporter,
+        id: importingModule,
+        message: `"${binding}" is not exported by "${relativeId(exporter)}", imported by "${relativeId(importingModule)}".${isJson ? ' (Note that you need @rollup/plugin-json to import JSON files)' : ''}`,
+        url: getRollupUrl(URL_NAME_IS_NOT_EXPORTED)
+    };
+}
+function logMissingExternalConfig(file) {
+    return {
+        code: MISSING_EXTERNAL_CONFIG,
+        message: `Could not resolve config file "${file}"`
+    };
+}
+function logMissingGlobalName(externalId, guess) {
+    return {
+        code: MISSING_GLOBAL_NAME,
+        id: externalId,
+        message: `No name was provided for external module "${externalId}" in "output.globals" – guessing "${guess}".`,
+        names: [guess],
+        url: getRollupUrl(URL_OUTPUT_GLOBALS)
+    };
+}
+function logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" cannot be external.`
+    };
+}
+function logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore) {
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(unresolvedId)}" that should be implicitly loaded before "${relativeId(implicitlyLoadedBefore)}" could not be resolved.`
+    };
+}
+function logImplicitDependantIsNotIncluded(module) {
+    const implicitDependencies = [...module.implicitlyLoadedBefore]
+        .map(dependency => relativeId(dependency.id))
+        .sort();
+    return {
+        code: MISSING_IMPLICIT_DEPENDANT,
+        message: `Module "${relativeId(module.id)}" that should be implicitly loaded before ${printQuotedStringList(implicitDependencies)} is not included in the module graph. Either it was not imported by an included module or only via a tree-shaken dynamic import, or no imported bindings were used and it had otherwise no side-effects.`
+    };
+}
+function logMissingJsxExport(name, exporter, importer) {
+    return {
+        code: MISSING_JSX_EXPORT,
+        exporter,
+        id: importer,
+        message: `Export "${name}" is not defined in module "${relativeId(exporter)}" even though it is needed in "${relativeId(importer)}" to provide JSX syntax. Please check your "jsx" option.`,
+        names: [name],
+        url: getRollupUrl(URL_JSX)
+    };
+}
+function logMissingNameOptionForIifeExport() {
+    return {
+        code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
+        message: `If you do not supply "output.name", you may not be able to access the exports of an IIFE bundle.`,
+        url: getRollupUrl(URL_OUTPUT_NAME)
+    };
+}
+function logMissingNameOptionForUmdExport() {
+    return {
+        code: MISSING_NAME_OPTION_FOR_IIFE_EXPORT,
+        message: 'You must supply "output.name" for UMD bundles that have exports so that the exports are accessible in environments without a module loader.',
+        url: getRollupUrl(URL_OUTPUT_NAME)
+    };
+}
+function logMissingNodeBuiltins(externalBuiltins) {
+    return {
+        code: MISSING_NODE_BUILTINS,
+        ids: externalBuiltins,
+        message: `Creating a browser bundle that depends on Node.js built-in modules (${printQuotedStringList(externalBuiltins)}). You might need to include https://github.com/FredKSchott/rollup-plugin-polyfill-node`
+    };
+}
+function logMissingFileOrDirOption() {
+    return {
+        code: MISSING_OPTION,
+        message: 'You must specify "output.file" or "output.dir" for the build.',
+        url: getRollupUrl(URL_OUTPUT_DIR)
+    };
+}
+function logMixedExport(facadeModuleId, name) {
+    return {
+        code: MIXED_EXPORTS,
+        id: facadeModuleId,
+        message: `Entry module "${relativeId(facadeModuleId)}" is using named and default exports together. Consumers of your bundle will have to use \`${name || 'chunk'}.default\` to access the default export, which may not be what you want. Use \`output.exports: "named"\` to disable this warning.`,
+        url: getRollupUrl(URL_OUTPUT_EXPORTS)
+    };
+}
+function logModuleLevelDirective(directive, id) {
+    return {
+        code: MODULE_LEVEL_DIRECTIVE,
+        id,
+        message: `Module level directives cause errors when bundled, "${directive}" in "${relativeId(id)}" was ignored.`
+    };
+}
+function logNamespaceConflict(binding, reexportingModuleId, sources) {
+    return {
+        binding,
+        code: NAMESPACE_CONFLICT,
+        ids: sources,
+        message: `Conflicting namespaces: "${relativeId(reexportingModuleId)}" re-exports "${binding}" from one of the modules ${printQuotedStringList(sources.map(moduleId => relativeId(moduleId)))} (will be ignored).`,
+        reexporter: reexportingModuleId
+    };
+}
+function logNoTransformMapOrAstWithoutCode(pluginName) {
+    return {
+        code: NO_TRANSFORM_MAP_OR_AST_WITHOUT_CODE,
+        message: `The plugin "${pluginName}" returned a "map" or "ast" without returning ` +
+            'a "code". This will be ignored.'
+    };
+}
+function logOnlyInlineSourcemapsForStdout() {
+    return {
+        code: ONLY_INLINE_SOURCEMAPS,
+        message: 'Only inline sourcemaps are supported when bundling to stdout.'
+    };
+}
+function logOptimizeChunkStatus(chunks, smallChunks, pointInTime) {
+    return {
+        code: OPTIMIZE_CHUNK_STATUS,
+        message: `${pointInTime}, there are\n` +
+            `${chunks} chunks, of which\n` +
+            `${smallChunks} are below minChunkSize.`
+    };
+}
+function logParseError(message, pos) {
+    return { code: PARSE_ERROR, message, pos };
+}
+function logRedeclarationError(name) {
+    return {
+        code: REDECLARATION_ERROR,
+        message: `Identifier "${name}" has already been declared`
+    };
+}
+function logReservedNamespace(namespace) {
+    return {
+        code: RESERVED_NAMESPACE,
+        message: `You have overided reserved namespace "${namespace}"`
+    };
+}
+function logModuleParseError(error, moduleId) {
+    let message = error.message.replace(/ \(\d+:\d+\)$/, '');
+    if (moduleId.endsWith('.json')) {
+        message += ' (Note that you need @rollup/plugin-json to import JSON files)';
+    }
+    else if (!moduleId.endsWith('.js')) {
+        message += ' (Note that you need plugins to import files that are not JavaScript)';
+    }
+    return tweakStackMessage({
+        cause: error,
+        code: PARSE_ERROR,
+        id: moduleId,
+        message,
+        stack: error.stack
+    }, error.message);
+}
+function logPluginError(error, plugin, { hook, id } = {}) {
+    const code = error.code;
+    if (!error.pluginCode &&
+        code != null &&
+        (typeof code !== 'string' || !code.startsWith('PLUGIN_'))) {
+        error.pluginCode = code;
+    }
+    error.code = PLUGIN_ERROR;
+    error.plugin = plugin;
+    if (hook) {
+        error.hook = hook;
+    }
+    if (id) {
+        error.id = id;
+    }
+    return error;
+}
+function logShimmedExport(id, binding) {
+    return {
+        binding,
+        code: SHIMMED_EXPORT,
+        exporter: id,
+        message: `Missing export "${binding}" has been shimmed in module "${relativeId(id)}".`
+    };
+}
+function logSourcemapBroken(plugin) {
+    return {
+        code: SOURCEMAP_BROKEN,
+        message: `Sourcemap is likely to be incorrect: a plugin (${plugin}) was used to transform files, but didn't generate a sourcemap for the transformation. Consult the plugin documentation for help`,
+        plugin,
+        url: getRollupUrl(URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT)
+    };
+}
+function logConflictingSourcemapSources(filename) {
+    return {
+        code: SOURCEMAP_BROKEN,
+        message: `Multiple conflicting contents for sourcemap source ${filename}`
+    };
+}
+function logInvalidSourcemapForError(error, id, column, line, pos) {
+    return {
+        cause: error,
+        code: SOURCEMAP_ERROR,
+        id,
+        loc: {
+            column,
+            file: id,
+            line
+        },
+        message: `Error when using sourcemap for reporting an error: ${error.message}`,
+        pos
+    };
+}
+function logSyntheticNamedExportsNeedNamespaceExport(id, syntheticNamedExportsOption) {
+    return {
+        code: SYNTHETIC_NAMED_EXPORTS_NEED_NAMESPACE_EXPORT,
+        exporter: id,
+        message: `Module "${relativeId(id)}" that is marked with \`syntheticNamedExports: ${JSON.stringify(syntheticNamedExportsOption)}\` needs ${typeof syntheticNamedExportsOption === 'string' && syntheticNamedExportsOption !== 'default'
+            ? `an explicit export named "${syntheticNamedExportsOption}"`
+            : 'a default export'} that does not reexport an unresolved named export of the same module.`
+    };
+}
+function logThisIsUndefined() {
+    return {
+        code: THIS_IS_UNDEFINED,
+        message: `The 'this' keyword is equivalent to 'undefined' at the top level of an ES module, and has been rewritten`,
+        url: getRollupUrl(URL_THIS_IS_UNDEFINED)
+    };
+}
+function logUnexpectedNamedImport(id, imported, isReexport) {
+    const importType = isReexport ? 'reexport' : 'import';
+    return {
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `The named export "${imported}" was ${importType}ed from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". Either remove or change this ${importType} or change the value of the "output.interop" option.`,
+        url: getRollupUrl(URL_OUTPUT_INTEROP)
+    };
+}
+function logUnexpectedNamespaceReexport(id) {
+    return {
+        code: UNEXPECTED_NAMED_IMPORT,
+        exporter: id,
+        message: `There was a namespace "*" reexport from the external module "${relativeId(id)}" even though its interop type is "defaultOnly". This will be ignored as namespace reexports only reexport named exports. If this is not intended, either remove or change this reexport or change the value of the "output.interop" option.`,
+        url: getRollupUrl(URL_OUTPUT_INTEROP)
+    };
+}
+function logUnknownOption(optionType, unknownOptions, validOptions) {
+    return {
+        code: UNKNOWN_OPTION,
+        message: `Unknown ${optionType}: ${unknownOptions.join(', ')}. Allowed options: ${validOptions.join(', ')}`
+    };
+}
+function logEntryCannotBeExternal(unresolvedId) {
+    return {
+        code: UNRESOLVED_ENTRY,
+        message: `Entry module "${relativeId(unresolvedId)}" cannot be external.`
+    };
+}
+function logExternalModulesCannotBeIncludedInManualChunks(source) {
+    return {
+        code: EXTERNAL_MODULES_CANNOT_BE_INCLUDED_IN_MANUAL_CHUNKS,
+        message: `"${source}" cannot be included in manualChunks because it is resolved as an external module by the "external" option or plugins.`
+    };
+}
+function logExternalModulesCannotBeTransformedToModules(source) {
+    return {
+        code: EXTERNAL_MODULES_CANNOT_BE_TRANSFORMED_TO_MODULES,
+        message: `${source} is resolved as a module now, but it was an external module before. Please check whether there are conflicts in your Rollup options "external" and "manualChunks", manualChunks cannot include external modules.`
+    };
+}
+function logUnresolvedEntry(unresolvedId) {
+    return {
+        code: UNRESOLVED_ENTRY,
+        message: `Could not resolve entry module "${relativeId(unresolvedId)}".`
+    };
+}
+function logUnresolvedImport(source, importer) {
+    return {
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `Could not resolve "${source}" from "${relativeId(importer)}"`
+    };
+}
+function logUnresolvedImportTreatedAsExternal(source, importer) {
+    return {
+        code: UNRESOLVED_IMPORT,
+        exporter: source,
+        id: importer,
+        message: `"${source}" is imported by "${relativeId(importer)}", but could not be resolved – treating it as an external dependency.`,
+        url: getRollupUrl(URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY)
+    };
+}
+function logUnusedExternalImports(externalId, names, importers) {
+    return {
+        code: UNUSED_EXTERNAL_IMPORT,
+        exporter: externalId,
+        ids: importers,
+        message: `${printQuotedStringList(names, [
+            'is',
+            'are'
+        ])} imported from external module "${externalId}" but never used in ${printQuotedStringList(importers.map(importer => relativeId(importer)))}.`,
+        names
+    };
+}
+function logFailedValidation(message) {
+    return {
+        code: VALIDATION_ERROR,
+        message
+    };
+}
+function warnDeprecation(deprecation, urlSnippet, activeDeprecation, options, plugin) {
+    warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, options.onLog, options.strictDeprecations);
+}
+function warnDeprecationWithOptions(deprecation, urlSnippet, activeDeprecation, log, strictDeprecations, plugin) {
+    if (activeDeprecation || strictDeprecations) {
+        const warning = logDeprecation(deprecation, urlSnippet);
+        if (strictDeprecations) {
+            return error(warning);
+        }
+        log(LOGLEVEL_WARN, warning);
+    }
+}
+
+const BLANK = Object.freeze(Object.create(null));
+const EMPTY_OBJECT = Object.freeze({});
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_SET = Object.freeze(new (class extends Set {
+    add() {
+        throw new Error('Cannot add to empty set');
+    }
+})());
+
+// This file is generated by scripts/generate-node-types.js.
+// Do not edit this file directly.
+const ArrowFunctionExpression = 'ArrowFunctionExpression';
+const BlockStatement = 'BlockStatement';
+const CallExpression = 'CallExpression';
+const CatchClause = 'CatchClause';
+const ExportDefaultDeclaration = 'ExportDefaultDeclaration';
+const ExpressionStatement = 'ExpressionStatement';
+const Identifier = 'Identifier';
+const Literal = 'Literal';
+const PanicError = 'PanicError';
+const ParseError = 'ParseError';
+const Program = 'Program';
+const Property = 'Property';
+const ReturnStatement = 'ReturnStatement';
+const StaticBlock = 'StaticBlock';
+const TemplateLiteral = 'TemplateLiteral';
+const VariableDeclarator = 'VariableDeclarator';
+
+// This file is generated by scripts/generate-string-constants.js.
+// Do not edit this file directly.
+const FIXED_STRINGS = [
+    'var',
+    'let',
+    'const',
+    'init',
+    'get',
+    'set',
+    'constructor',
+    'method',
+    '-',
+    '+',
+    '!',
+    '~',
+    'typeof',
+    'void',
+    'delete',
+    '++',
+    '--',
+    '==',
+    '!=',
+    '===',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '<<',
+    '>>',
+    '>>>',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '|',
+    '^',
+    '&',
+    '||',
+    '&&',
+    'in',
+    'instanceof',
+    '**',
+    '??',
+    '=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '<<=',
+    '>>=',
+    '>>>=',
+    '|=',
+    '^=',
+    '&=',
+    '**=',
+    '&&=',
+    '||=',
+    '??=',
+    'pure',
+    'noSideEffects',
+    'sourcemap',
+    'using',
+    'await using'
+];
+
+const ANNOTATION_KEY = '_rollupAnnotations';
+const INVALID_ANNOTATION_KEY = '_rollupRemoved';
+const convertAnnotations = (position, buffer) => {
+    if (position === 0)
+        return EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        list.push(convertAnnotation(buffer[position++], buffer));
+    }
+    return list;
+};
+const convertAnnotation = (position, buffer) => {
+    const start = buffer[position++];
+    const end = buffer[position++];
+    const type = FIXED_STRINGS[buffer[position]];
+    return { end, start, type };
+};
+
+// This file is generated by scripts/generate-buffer-to-ast.js.
+// Do not edit this file directly.
+function convertProgram(buffer) {
+    const node = convertNode(0, buffer);
+    switch (node.type) {
+        case PanicError: {
+            return error(getRollupError(logParseError(node.message)));
+        }
+        case ParseError: {
+            return error(getRollupError(logParseError(node.message, node.start)));
+        }
+        default: {
+            return node;
+        }
+    }
+}
+/* eslint-disable sort-keys */
+const nodeConverters = [
+    function panicError(position, buffer) {
+        return {
+            type: 'PanicError',
+            start: buffer[position],
+            end: buffer[position + 1],
+            message: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function parseError(position, buffer) {
+        return {
+            type: 'ParseError',
+            start: buffer[position],
+            end: buffer[position + 1],
+            message: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function arrayExpression(position, buffer) {
+        return {
+            type: 'ArrayExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            elements: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function arrayPattern(position, buffer) {
+        return {
+            type: 'ArrayPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            elements: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function arrowFunctionExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'ArrowFunctionExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            expression: (flags & 2) === 2,
+            generator: (flags & 4) === 4,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            params: convertNodeList(buffer[position + 4], buffer),
+            body: convertNode(buffer[position + 5], buffer),
+            id: null
+        };
+    },
+    function assignmentExpression(position, buffer) {
+        return {
+            type: 'AssignmentExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function assignmentPattern(position, buffer) {
+        return {
+            type: 'AssignmentPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            left: convertNode(buffer[position + 2], buffer),
+            right: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function awaitExpression(position, buffer) {
+        return {
+            type: 'AwaitExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function binaryExpression(position, buffer) {
+        return {
+            type: 'BinaryExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function blockStatement(position, buffer) {
+        return {
+            type: 'BlockStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function breakStatement(position, buffer) {
+        const labelPosition = buffer[position + 2];
+        return {
+            type: 'BreakStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: labelPosition === 0 ? null : convertNode(labelPosition, buffer)
+        };
+    },
+    function callExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'CallExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            optional: (flags & 1) === 1,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            callee: convertNode(buffer[position + 4], buffer),
+            arguments: convertNodeList(buffer[position + 5], buffer)
+        };
+    },
+    function catchClause(position, buffer) {
+        const parameterPosition = buffer[position + 2];
+        return {
+            type: 'CatchClause',
+            start: buffer[position],
+            end: buffer[position + 1],
+            param: parameterPosition === 0 ? null : convertNode(parameterPosition, buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function chainExpression(position, buffer) {
+        return {
+            type: 'ChainExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function classBody(position, buffer) {
+        return {
+            type: 'ClassBody',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function classDeclaration(position, buffer) {
+        const idPosition = buffer[position + 3];
+        const superClassPosition = buffer[position + 4];
+        return {
+            type: 'ClassDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            decorators: convertNodeList(buffer[position + 2], buffer),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            superClass: superClassPosition === 0 ? null : convertNode(superClassPosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function classExpression(position, buffer) {
+        const idPosition = buffer[position + 3];
+        const superClassPosition = buffer[position + 4];
+        return {
+            type: 'ClassExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            decorators: convertNodeList(buffer[position + 2], buffer),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            superClass: superClassPosition === 0 ? null : convertNode(superClassPosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function conditionalExpression(position, buffer) {
+        return {
+            type: 'ConditionalExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            consequent: convertNode(buffer[position + 3], buffer),
+            alternate: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function continueStatement(position, buffer) {
+        const labelPosition = buffer[position + 2];
+        return {
+            type: 'ContinueStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: labelPosition === 0 ? null : convertNode(labelPosition, buffer)
+        };
+    },
+    function debuggerStatement(position, buffer) {
+        return {
+            type: 'DebuggerStatement',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function decorator(position, buffer) {
+        return {
+            type: 'Decorator',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function directive(position, buffer) {
+        return {
+            type: 'ExpressionStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            directive: buffer.convertString(buffer[position + 2]),
+            expression: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function doWhileStatement(position, buffer) {
+        return {
+            type: 'DoWhileStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNode(buffer[position + 2], buffer),
+            test: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function emptyStatement(position, buffer) {
+        return {
+            type: 'EmptyStatement',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function exportAllDeclaration(position, buffer) {
+        const exportedPosition = buffer[position + 2];
+        return {
+            type: 'ExportAllDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            exported: exportedPosition === 0 ? null : convertNode(exportedPosition, buffer),
+            source: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function exportDefaultDeclaration(position, buffer) {
+        return {
+            type: 'ExportDefaultDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            declaration: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function exportNamedDeclaration(position, buffer) {
+        const sourcePosition = buffer[position + 3];
+        const declarationPosition = buffer[position + 5];
+        return {
+            type: 'ExportNamedDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            specifiers: convertNodeList(buffer[position + 2], buffer),
+            source: sourcePosition === 0 ? null : convertNode(sourcePosition, buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer),
+            declaration: declarationPosition === 0 ? null : convertNode(declarationPosition, buffer)
+        };
+    },
+    function exportSpecifier(position, buffer) {
+        const local = convertNode(buffer[position + 2], buffer);
+        const exportedPosition = buffer[position + 3];
+        return {
+            type: 'ExportSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local,
+            exported: exportedPosition === 0 ? { ...local } : convertNode(exportedPosition, buffer)
+        };
+    },
+    function expressionStatement(position, buffer) {
+        return {
+            type: 'ExpressionStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function forInStatement(position, buffer) {
+        return {
+            type: 'ForInStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            left: convertNode(buffer[position + 2], buffer),
+            right: convertNode(buffer[position + 3], buffer),
+            body: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function forOfStatement(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'ForOfStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            await: (flags & 1) === 1,
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function forStatement(position, buffer) {
+        const initPosition = buffer[position + 2];
+        const testPosition = buffer[position + 3];
+        const updatePosition = buffer[position + 4];
+        return {
+            type: 'ForStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            init: initPosition === 0 ? null : convertNode(initPosition, buffer),
+            test: testPosition === 0 ? null : convertNode(testPosition, buffer),
+            update: updatePosition === 0 ? null : convertNode(updatePosition, buffer),
+            body: convertNode(buffer[position + 5], buffer)
+        };
+    },
+    function functionDeclaration(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        const idPosition = buffer[position + 4];
+        return {
+            type: 'FunctionDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            generator: (flags & 2) === 2,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            params: convertNodeList(buffer[position + 5], buffer),
+            body: convertNode(buffer[position + 6], buffer),
+            expression: false
+        };
+    },
+    function functionExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const annotations = convertAnnotations(buffer[position + 3], buffer);
+        const idPosition = buffer[position + 4];
+        return {
+            type: 'FunctionExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            async: (flags & 1) === 1,
+            generator: (flags & 2) === 2,
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            id: idPosition === 0 ? null : convertNode(idPosition, buffer),
+            params: convertNodeList(buffer[position + 5], buffer),
+            body: convertNode(buffer[position + 6], buffer),
+            expression: false
+        };
+    },
+    function identifier(position, buffer) {
+        return {
+            type: 'Identifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function ifStatement(position, buffer) {
+        const alternatePosition = buffer[position + 4];
+        return {
+            type: 'IfStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            consequent: convertNode(buffer[position + 3], buffer),
+            alternate: alternatePosition === 0 ? null : convertNode(alternatePosition, buffer)
+        };
+    },
+    function importAttribute(position, buffer) {
+        return {
+            type: 'ImportAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            key: convertNode(buffer[position + 2], buffer),
+            value: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function importDeclaration(position, buffer) {
+        return {
+            type: 'ImportDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            specifiers: convertNodeList(buffer[position + 2], buffer),
+            source: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function importDefaultSpecifier(position, buffer) {
+        return {
+            type: 'ImportDefaultSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function importExpression(position, buffer) {
+        const optionsPosition = buffer[position + 3];
+        return {
+            type: 'ImportExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            source: convertNode(buffer[position + 2], buffer),
+            options: optionsPosition === 0 ? null : convertNode(optionsPosition, buffer)
+        };
+    },
+    function importNamespaceSpecifier(position, buffer) {
+        return {
+            type: 'ImportNamespaceSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            local: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function importSpecifier(position, buffer) {
+        const importedPosition = buffer[position + 2];
+        const local = convertNode(buffer[position + 3], buffer);
+        return {
+            type: 'ImportSpecifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            imported: importedPosition === 0 ? { ...local } : convertNode(importedPosition, buffer),
+            local
+        };
+    },
+    function jsxAttribute(position, buffer) {
+        const valuePosition = buffer[position + 3];
+        return {
+            type: 'JSXAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: convertNode(buffer[position + 2], buffer),
+            value: valuePosition === 0 ? null : convertNode(valuePosition, buffer)
+        };
+    },
+    function jsxClosingElement(position, buffer) {
+        return {
+            type: 'JSXClosingElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxClosingFragment(position, buffer) {
+        return {
+            type: 'JSXClosingFragment',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function jsxElement(position, buffer) {
+        const closingElementPosition = buffer[position + 4];
+        return {
+            type: 'JSXElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            openingElement: convertNode(buffer[position + 2], buffer),
+            children: convertNodeList(buffer[position + 3], buffer),
+            closingElement: closingElementPosition === 0 ? null : convertNode(closingElementPosition, buffer)
+        };
+    },
+    function jsxEmptyExpression(position, buffer) {
+        return {
+            type: 'JSXEmptyExpression',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function jsxExpressionContainer(position, buffer) {
+        return {
+            type: 'JSXExpressionContainer',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxFragment(position, buffer) {
+        return {
+            type: 'JSXFragment',
+            start: buffer[position],
+            end: buffer[position + 1],
+            openingFragment: convertNode(buffer[position + 2], buffer),
+            children: convertNodeList(buffer[position + 3], buffer),
+            closingFragment: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function jsxIdentifier(position, buffer) {
+        return {
+            type: 'JSXIdentifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function jsxMemberExpression(position, buffer) {
+        return {
+            type: 'JSXMemberExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            object: convertNode(buffer[position + 2], buffer),
+            property: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function jsxNamespacedName(position, buffer) {
+        return {
+            type: 'JSXNamespacedName',
+            start: buffer[position],
+            end: buffer[position + 1],
+            namespace: convertNode(buffer[position + 2], buffer),
+            name: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function jsxOpeningElement(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'JSXOpeningElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            selfClosing: (flags & 1) === 1,
+            name: convertNode(buffer[position + 3], buffer),
+            attributes: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function jsxOpeningFragment(position, buffer) {
+        return {
+            type: 'JSXOpeningFragment',
+            start: buffer[position],
+            end: buffer[position + 1],
+            attributes: [],
+            selfClosing: false
+        };
+    },
+    function jsxSpreadAttribute(position, buffer) {
+        return {
+            type: 'JSXSpreadAttribute',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxSpreadChild(position, buffer) {
+        return {
+            type: 'JSXSpreadChild',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expression: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function jsxText(position, buffer) {
+        return {
+            type: 'JSXText',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value: buffer.convertString(buffer[position + 2]),
+            raw: buffer.convertString(buffer[position + 3])
+        };
+    },
+    function labeledStatement(position, buffer) {
+        return {
+            type: 'LabeledStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            label: convertNode(buffer[position + 2], buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function literalBigInt(position, buffer) {
+        const bigint = buffer.convertString(buffer[position + 2]);
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            bigint,
+            raw: buffer.convertString(buffer[position + 3]),
+            value: BigInt(bigint)
+        };
+    },
+    function literalBoolean(position, buffer) {
+        const flags = buffer[position + 2];
+        const value = (flags & 1) === 1;
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value,
+            raw: value ? 'true' : 'false'
+        };
+    },
+    function literalNull(position, buffer) {
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: 'null',
+            value: null
+        };
+    },
+    function literalNumber(position, buffer) {
+        const rawPosition = buffer[position + 2];
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: rawPosition === 0 ? undefined : buffer.convertString(rawPosition),
+            value: new DataView(buffer.buffer).getFloat64((position + 3) << 2, true)
+        };
+    },
+    function literalRegExp(position, buffer) {
+        const flags = buffer.convertString(buffer[position + 2]);
+        const pattern = buffer.convertString(buffer[position + 3]);
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            raw: `/${pattern}/${flags}`,
+            regex: { flags, pattern },
+            value: new RegExp(pattern, flags)
+        };
+    },
+    function literalString(position, buffer) {
+        const rawPosition = buffer[position + 3];
+        return {
+            type: 'Literal',
+            start: buffer[position],
+            end: buffer[position + 1],
+            value: buffer.convertString(buffer[position + 2]),
+            raw: rawPosition === 0 ? undefined : buffer.convertString(rawPosition)
+        };
+    },
+    function logicalExpression(position, buffer) {
+        return {
+            type: 'LogicalExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            left: convertNode(buffer[position + 3], buffer),
+            right: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function memberExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'MemberExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            computed: (flags & 1) === 1,
+            optional: (flags & 2) === 2,
+            object: convertNode(buffer[position + 3], buffer),
+            property: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function metaProperty(position, buffer) {
+        return {
+            type: 'MetaProperty',
+            start: buffer[position],
+            end: buffer[position + 1],
+            meta: convertNode(buffer[position + 2], buffer),
+            property: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function methodDefinition(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'MethodDefinition',
+            start: buffer[position],
+            end: buffer[position + 1],
+            static: (flags & 1) === 1,
+            computed: (flags & 2) === 2,
+            decorators: convertNodeList(buffer[position + 3], buffer),
+            key: convertNode(buffer[position + 4], buffer),
+            value: convertNode(buffer[position + 5], buffer),
+            kind: FIXED_STRINGS[buffer[position + 6]]
+        };
+    },
+    function newExpression(position, buffer) {
+        const annotations = convertAnnotations(buffer[position + 2], buffer);
+        return {
+            type: 'NewExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            ...(annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {}),
+            callee: convertNode(buffer[position + 3], buffer),
+            arguments: convertNodeList(buffer[position + 4], buffer)
+        };
+    },
+    function objectExpression(position, buffer) {
+        return {
+            type: 'ObjectExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            properties: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function objectPattern(position, buffer) {
+        return {
+            type: 'ObjectPattern',
+            start: buffer[position],
+            end: buffer[position + 1],
+            properties: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function privateIdentifier(position, buffer) {
+        return {
+            type: 'PrivateIdentifier',
+            start: buffer[position],
+            end: buffer[position + 1],
+            name: buffer.convertString(buffer[position + 2])
+        };
+    },
+    function program(position, buffer) {
+        const invalidAnnotations = convertAnnotations(buffer[position + 3], buffer);
+        return {
+            type: 'Program',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer),
+            ...(invalidAnnotations.length > 0 ? { [INVALID_ANNOTATION_KEY]: invalidAnnotations } : {}),
+            sourceType: 'module'
+        };
+    },
+    function property(position, buffer) {
+        const flags = buffer[position + 2];
+        const keyPosition = buffer[position + 3];
+        const value = convertNode(buffer[position + 4], buffer);
+        return {
+            type: 'Property',
+            start: buffer[position],
+            end: buffer[position + 1],
+            method: (flags & 1) === 1,
+            shorthand: (flags & 2) === 2,
+            computed: (flags & 4) === 4,
+            key: keyPosition === 0 ? { ...value } : convertNode(keyPosition, buffer),
+            value,
+            kind: FIXED_STRINGS[buffer[position + 5]]
+        };
+    },
+    function propertyDefinition(position, buffer) {
+        const flags = buffer[position + 2];
+        const valuePosition = buffer[position + 5];
+        return {
+            type: 'PropertyDefinition',
+            start: buffer[position],
+            end: buffer[position + 1],
+            static: (flags & 1) === 1,
+            computed: (flags & 2) === 2,
+            decorators: convertNodeList(buffer[position + 3], buffer),
+            key: convertNode(buffer[position + 4], buffer),
+            value: valuePosition === 0 ? null : convertNode(valuePosition, buffer)
+        };
+    },
+    function restElement(position, buffer) {
+        return {
+            type: 'RestElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function returnStatement(position, buffer) {
+        const argumentPosition = buffer[position + 2];
+        return {
+            type: 'ReturnStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: argumentPosition === 0 ? null : convertNode(argumentPosition, buffer)
+        };
+    },
+    function sequenceExpression(position, buffer) {
+        return {
+            type: 'SequenceExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            expressions: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function spreadElement(position, buffer) {
+        return {
+            type: 'SpreadElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function staticBlock(position, buffer) {
+        return {
+            type: 'StaticBlock',
+            start: buffer[position],
+            end: buffer[position + 1],
+            body: convertNodeList(buffer[position + 2], buffer)
+        };
+    },
+    function superElement(position, buffer) {
+        return {
+            type: 'Super',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function switchCase(position, buffer) {
+        const testPosition = buffer[position + 2];
+        return {
+            type: 'SwitchCase',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: testPosition === 0 ? null : convertNode(testPosition, buffer),
+            consequent: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function switchStatement(position, buffer) {
+        return {
+            type: 'SwitchStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            discriminant: convertNode(buffer[position + 2], buffer),
+            cases: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function taggedTemplateExpression(position, buffer) {
+        return {
+            type: 'TaggedTemplateExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            tag: convertNode(buffer[position + 2], buffer),
+            quasi: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function templateElement(position, buffer) {
+        const flags = buffer[position + 2];
+        const cookedPosition = buffer[position + 3];
+        const cooked = cookedPosition === 0 ? undefined : buffer.convertString(cookedPosition);
+        const raw = buffer.convertString(buffer[position + 4]);
+        return {
+            type: 'TemplateElement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            tail: (flags & 1) === 1,
+            value: { cooked, raw }
+        };
+    },
+    function templateLiteral(position, buffer) {
+        return {
+            type: 'TemplateLiteral',
+            start: buffer[position],
+            end: buffer[position + 1],
+            quasis: convertNodeList(buffer[position + 2], buffer),
+            expressions: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function thisExpression(position, buffer) {
+        return {
+            type: 'ThisExpression',
+            start: buffer[position],
+            end: buffer[position + 1]
+        };
+    },
+    function throwStatement(position, buffer) {
+        return {
+            type: 'ThrowStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            argument: convertNode(buffer[position + 2], buffer)
+        };
+    },
+    function tryStatement(position, buffer) {
+        const handlerPosition = buffer[position + 3];
+        const finalizerPosition = buffer[position + 4];
+        return {
+            type: 'TryStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            block: convertNode(buffer[position + 2], buffer),
+            handler: handlerPosition === 0 ? null : convertNode(handlerPosition, buffer),
+            finalizer: finalizerPosition === 0 ? null : convertNode(finalizerPosition, buffer)
+        };
+    },
+    function unaryExpression(position, buffer) {
+        return {
+            type: 'UnaryExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            operator: FIXED_STRINGS[buffer[position + 2]],
+            argument: convertNode(buffer[position + 3], buffer),
+            prefix: true
+        };
+    },
+    function updateExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        return {
+            type: 'UpdateExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            prefix: (flags & 1) === 1,
+            operator: FIXED_STRINGS[buffer[position + 3]],
+            argument: convertNode(buffer[position + 4], buffer)
+        };
+    },
+    function variableDeclaration(position, buffer) {
+        return {
+            type: 'VariableDeclaration',
+            start: buffer[position],
+            end: buffer[position + 1],
+            kind: FIXED_STRINGS[buffer[position + 2]],
+            declarations: convertNodeList(buffer[position + 3], buffer)
+        };
+    },
+    function variableDeclarator(position, buffer) {
+        const initPosition = buffer[position + 3];
+        return {
+            type: 'VariableDeclarator',
+            start: buffer[position],
+            end: buffer[position + 1],
+            id: convertNode(buffer[position + 2], buffer),
+            init: initPosition === 0 ? null : convertNode(initPosition, buffer)
+        };
+    },
+    function whileStatement(position, buffer) {
+        return {
+            type: 'WhileStatement',
+            start: buffer[position],
+            end: buffer[position + 1],
+            test: convertNode(buffer[position + 2], buffer),
+            body: convertNode(buffer[position + 3], buffer)
+        };
+    },
+    function yieldExpression(position, buffer) {
+        const flags = buffer[position + 2];
+        const argumentPosition = buffer[position + 3];
+        return {
+            type: 'YieldExpression',
+            start: buffer[position],
+            end: buffer[position + 1],
+            delegate: (flags & 1) === 1,
+            argument: argumentPosition === 0 ? null : convertNode(argumentPosition, buffer)
+        };
+    }
+];
+function convertNode(position, buffer) {
+    const nodeType = buffer[position];
+    const converter = nodeConverters[nodeType];
+    /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
+    if (!converter) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    return converter(position + 1, buffer);
+}
+function convertNodeList(position, buffer) {
+    if (position === 0)
+        return EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(nodePosition, buffer) : null);
+    }
+    return list;
+}
+
+function getAstBuffer(astBuffer) {
+    const array = new Uint32Array(astBuffer.buffer);
+    let convertString;
+    if (typeof Buffer !== 'undefined' && astBuffer instanceof Buffer) {
+        convertString = (position) => {
+            const length = array[position++];
+            const bytePosition = position << 2;
+            return astBuffer.toString('utf8', bytePosition, bytePosition + length);
+        };
+    }
+    else {
+        const textDecoder = new TextDecoder();
+        convertString = (position) => {
+            const length = array[position++];
+            const bytePosition = position << 2;
+            return textDecoder.decode(astBuffer.subarray(bytePosition, bytePosition + length));
+        };
+    }
+    return Object.assign(array, { convertString });
+}
+
+const parseAst = (input, { allowReturnOutsideFunction = false, jsx = false } = {}) => convertProgram(getAstBuffer(native_js.parse(input, allowReturnOutsideFunction, jsx)));
+const parseAstAsync = async (input, { allowReturnOutsideFunction = false, jsx = false, signal } = {}) => convertProgram(getAstBuffer(await native_js.parseAsync(input, allowReturnOutsideFunction, jsx, signal)));
+
+exports.ANNOTATION_KEY = ANNOTATION_KEY;
+exports.ArrowFunctionExpression = ArrowFunctionExpression;
+exports.BLANK = BLANK;
+exports.BlockStatement = BlockStatement;
+exports.CallExpression = CallExpression;
+exports.CatchClause = CatchClause;
+exports.EMPTY_ARRAY = EMPTY_ARRAY;
+exports.EMPTY_OBJECT = EMPTY_OBJECT;
+exports.EMPTY_SET = EMPTY_SET;
+exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
+exports.ExpressionStatement = ExpressionStatement;
+exports.FIXED_STRINGS = FIXED_STRINGS;
+exports.INVALID_ANNOTATION_KEY = INVALID_ANNOTATION_KEY;
+exports.Identifier = Identifier;
+exports.LOGLEVEL_DEBUG = LOGLEVEL_DEBUG;
+exports.LOGLEVEL_ERROR = LOGLEVEL_ERROR;
+exports.LOGLEVEL_INFO = LOGLEVEL_INFO;
+exports.LOGLEVEL_WARN = LOGLEVEL_WARN;
+exports.Literal = Literal;
+exports.Program = Program;
+exports.Property = Property;
+exports.ReturnStatement = ReturnStatement;
+exports.StaticBlock = StaticBlock;
+exports.TemplateLiteral = TemplateLiteral;
+exports.URL_AVOIDING_EVAL = URL_AVOIDING_EVAL;
+exports.URL_GENERATEBUNDLE = URL_GENERATEBUNDLE;
+exports.URL_JSX = URL_JSX;
+exports.URL_NAME_IS_NOT_EXPORTED = URL_NAME_IS_NOT_EXPORTED;
+exports.URL_OUTPUT_AMD_BASEPATH = URL_OUTPUT_AMD_BASEPATH;
+exports.URL_OUTPUT_AMD_ID = URL_OUTPUT_AMD_ID;
+exports.URL_OUTPUT_DIR = URL_OUTPUT_DIR;
+exports.URL_OUTPUT_EXPORTS = URL_OUTPUT_EXPORTS;
+exports.URL_OUTPUT_EXTERNALIMPORTATTRIBUTES = URL_OUTPUT_EXTERNALIMPORTATTRIBUTES;
+exports.URL_OUTPUT_FORMAT = URL_OUTPUT_FORMAT;
+exports.URL_OUTPUT_GENERATEDCODE = URL_OUTPUT_GENERATEDCODE;
+exports.URL_OUTPUT_GLOBALS = URL_OUTPUT_GLOBALS;
+exports.URL_OUTPUT_INLINEDYNAMICIMPORTS = URL_OUTPUT_INLINEDYNAMICIMPORTS;
+exports.URL_OUTPUT_INTEROP = URL_OUTPUT_INTEROP;
+exports.URL_OUTPUT_MANUALCHUNKS = URL_OUTPUT_MANUALCHUNKS;
+exports.URL_OUTPUT_SOURCEMAPBASEURL = URL_OUTPUT_SOURCEMAPBASEURL;
+exports.URL_OUTPUT_SOURCEMAPFILE = URL_OUTPUT_SOURCEMAPFILE;
+exports.URL_PRESERVEENTRYSIGNATURES = URL_PRESERVEENTRYSIGNATURES;
+exports.URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT = URL_SOURCEMAP_IS_LIKELY_TO_BE_INCORRECT;
+exports.URL_THIS_IS_UNDEFINED = URL_THIS_IS_UNDEFINED;
+exports.URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY = URL_TREATING_MODULE_AS_EXTERNAL_DEPENDENCY;
+exports.URL_TREESHAKE = URL_TREESHAKE;
+exports.URL_TREESHAKE_MODULESIDEEFFECTS = URL_TREESHAKE_MODULESIDEEFFECTS;
+exports.URL_WATCH = URL_WATCH;
+exports.VariableDeclarator = VariableDeclarator;
+exports.addTrailingSlashIfMissed = addTrailingSlashIfMissed;
+exports.augmentCodeLocation = augmentCodeLocation;
+exports.augmentLogMessage = augmentLogMessage;
+exports.convertAnnotations = convertAnnotations;
+exports.convertNode = convertNode;
+exports.error = error;
+exports.getAliasName = getAliasName;
+exports.getAstBuffer = getAstBuffer;
+exports.getImportPath = getImportPath;
+exports.getRollupError = getRollupError;
+exports.getRollupUrl = getRollupUrl;
+exports.isAbsolute = isAbsolute;
+exports.isPathFragment = isPathFragment;
+exports.isRelative = isRelative;
+exports.isValidUrl = isValidUrl;
+exports.locate = locate;
+exports.logAddonNotGenerated = logAddonNotGenerated;
+exports.logAlreadyClosed = logAlreadyClosed;
+exports.logAmbiguousExternalNamespaces = logAmbiguousExternalNamespaces;
+exports.logAnonymousPluginCache = logAnonymousPluginCache;
+exports.logAssetNotFinalisedForFileName = logAssetNotFinalisedForFileName;
+exports.logAssetReferenceIdNotFoundForSetSource = logAssetReferenceIdNotFoundForSetSource;
+exports.logAssetSourceAlreadySet = logAssetSourceAlreadySet;
+exports.logBadLoader = logBadLoader;
+exports.logCannotAssignModuleToChunk = logCannotAssignModuleToChunk;
+exports.logCannotBundleConfigAsEsm = logCannotBundleConfigAsEsm;
+exports.logCannotCallNamespace = logCannotCallNamespace;
+exports.logCannotEmitFromOptionsHook = logCannotEmitFromOptionsHook;
+exports.logCannotLoadConfigAsCjs = logCannotLoadConfigAsCjs;
+exports.logCannotLoadConfigAsEsm = logCannotLoadConfigAsEsm;
+exports.logChunkInvalid = logChunkInvalid;
+exports.logChunkNotGeneratedForFileName = logChunkNotGeneratedForFileName;
+exports.logCircularDependency = logCircularDependency;
+exports.logCircularReexport = logCircularReexport;
+exports.logConflictingSourcemapSources = logConflictingSourcemapSources;
+exports.logConstVariableReassignError = logConstVariableReassignError;
+exports.logCyclicCrossChunkReexport = logCyclicCrossChunkReexport;
+exports.logDuplicateArgumentNameError = logDuplicateArgumentNameError;
+exports.logDuplicateExportError = logDuplicateExportError;
+exports.logDuplicateImportOptions = logDuplicateImportOptions;
+exports.logDuplicatePluginName = logDuplicatePluginName;
+exports.logEmptyChunk = logEmptyChunk;
+exports.logEntryCannotBeExternal = logEntryCannotBeExternal;
+exports.logEval = logEval;
+exports.logExternalModulesCannotBeIncludedInManualChunks = logExternalModulesCannotBeIncludedInManualChunks;
+exports.logExternalModulesCannotBeTransformedToModules = logExternalModulesCannotBeTransformedToModules;
+exports.logExternalSyntheticExports = logExternalSyntheticExports;
+exports.logFailAfterWarnings = logFailAfterWarnings;
+exports.logFailedValidation = logFailedValidation;
+exports.logFileNameConflict = logFileNameConflict;
+exports.logFileReferenceIdNotFoundForFilename = logFileReferenceIdNotFoundForFilename;
+exports.logFirstSideEffect = logFirstSideEffect;
+exports.logIllegalIdentifierAsName = logIllegalIdentifierAsName;
+exports.logIllegalImportReassignment = logIllegalImportReassignment;
+exports.logImplicitDependantCannotBeExternal = logImplicitDependantCannotBeExternal;
+exports.logImplicitDependantIsNotIncluded = logImplicitDependantIsNotIncluded;
+exports.logImportAttributeIsInvalid = logImportAttributeIsInvalid;
+exports.logImportOptionsAreInvalid = logImportOptionsAreInvalid;
+exports.logIncompatibleExportOptionValue = logIncompatibleExportOptionValue;
+exports.logInconsistentImportAttributes = logInconsistentImportAttributes;
+exports.logInputHookInOutputPlugin = logInputHookInOutputPlugin;
+exports.logInternalIdCannotBeExternal = logInternalIdCannotBeExternal;
+exports.logInvalidAddonPluginHook = logInvalidAddonPluginHook;
+exports.logInvalidAnnotation = logInvalidAnnotation;
+exports.logInvalidExportOptionValue = logInvalidExportOptionValue;
+exports.logInvalidFormatForTopLevelAwait = logInvalidFormatForTopLevelAwait;
+exports.logInvalidFunctionPluginHook = logInvalidFunctionPluginHook;
+exports.logInvalidLogPosition = logInvalidLogPosition;
+exports.logInvalidOption = logInvalidOption;
+exports.logInvalidRollupPhaseForChunkEmission = logInvalidRollupPhaseForChunkEmission;
+exports.logInvalidSetAssetSourceCall = logInvalidSetAssetSourceCall;
+exports.logInvalidSourcemapForError = logInvalidSourcemapForError;
+exports.logLevelPriority = logLevelPriority;
+exports.logMissingConfig = logMissingConfig;
+exports.logMissingEntryExport = logMissingEntryExport;
+exports.logMissingExport = logMissingExport;
+exports.logMissingExternalConfig = logMissingExternalConfig;
+exports.logMissingFileOrDirOption = logMissingFileOrDirOption;
+exports.logMissingGlobalName = logMissingGlobalName;
+exports.logMissingJsxExport = logMissingJsxExport;
+exports.logMissingNameOptionForIifeExport = logMissingNameOptionForIifeExport;
+exports.logMissingNameOptionForUmdExport = logMissingNameOptionForUmdExport;
+exports.logMissingNodeBuiltins = logMissingNodeBuiltins;
+exports.logMixedExport = logMixedExport;
+exports.logModuleLevelDirective = logModuleLevelDirective;
+exports.logModuleParseError = logModuleParseError;
+exports.logNamespaceConflict = logNamespaceConflict;
+exports.logNoAssetSourceSet = logNoAssetSourceSet;
+exports.logNoTransformMapOrAstWithoutCode = logNoTransformMapOrAstWithoutCode;
+exports.logOnlyInlineSourcemapsForStdout = logOnlyInlineSourcemapsForStdout;
+exports.logOptimizeChunkStatus = logOptimizeChunkStatus;
+exports.logParseError = logParseError;
+exports.logPluginError = logPluginError;
+exports.logRedeclarationError = logRedeclarationError;
+exports.logReservedNamespace = logReservedNamespace;
+exports.logShimmedExport = logShimmedExport;
+exports.logSourcemapBroken = logSourcemapBroken;
+exports.logSyntheticNamedExportsNeedNamespaceExport = logSyntheticNamedExportsNeedNamespaceExport;
+exports.logThisIsUndefined = logThisIsUndefined;
+exports.logUnexpectedNamedImport = logUnexpectedNamedImport;
+exports.logUnexpectedNamespaceReexport = logUnexpectedNamespaceReexport;
+exports.logUnknownOption = logUnknownOption;
+exports.logUnresolvedEntry = logUnresolvedEntry;
+exports.logUnresolvedImplicitDependant = logUnresolvedImplicitDependant;
+exports.logUnresolvedImport = logUnresolvedImport;
+exports.logUnresolvedImportTreatedAsExternal = logUnresolvedImportTreatedAsExternal;
+exports.logUnusedExternalImports = logUnusedExternalImports;
+exports.normalize = normalize;
+exports.parseAst = parseAst;
+exports.parseAstAsync = parseAstAsync;
+exports.printQuotedStringList = printQuotedStringList;
+exports.relative = relative;
+exports.relativeId = relativeId;
+exports.warnDeprecation = warnDeprecation;
+//# sourceMappingURL=parseAst.js.map
diff --git a/node_modules/rollup/dist/shared/rollup.js b/node_modules/rollup/dist/shared/rollup.js
new file mode 100644
index 0000000..2dfd6d5
--- /dev/null
+++ b/node_modules/rollup/dist/shared/rollup.js
@@ -0,0 +1,22179 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+const parseAst_js = require('./parseAst.js');
+const process$1 = require('node:process');
+const tty = require('tty');
+const path = require('node:path');
+const require$$0 = require('path');
+const native_js = require('../native.js');
+const node_perf_hooks = require('node:perf_hooks');
+const promises = require('node:fs/promises');
+
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
+
+var version = "4.24.0";
+
+function ensureArray$1(items) {
+    if (Array.isArray(items)) {
+        return items.filter(Boolean);
+    }
+    if (items) {
+        return [items];
+    }
+    return [];
+}
+
+var BuildPhase;
+(function (BuildPhase) {
+    BuildPhase[BuildPhase["LOAD_AND_PARSE"] = 0] = "LOAD_AND_PARSE";
+    BuildPhase[BuildPhase["ANALYSE"] = 1] = "ANALYSE";
+    BuildPhase[BuildPhase["GENERATE"] = 2] = "GENERATE";
+})(BuildPhase || (BuildPhase = {}));
+
+let textEncoder;
+const getHash64 = input => native_js.xxhashBase64Url(ensureBuffer(input));
+const getHash36 = input => native_js.xxhashBase36(ensureBuffer(input));
+const getHash16 = input => native_js.xxhashBase16(ensureBuffer(input));
+const hasherByType = {
+    base36: getHash36,
+    base64: getHash64,
+    hex: getHash16
+};
+function ensureBuffer(input) {
+    if (typeof input === 'string') {
+        if (typeof Buffer === 'undefined') {
+            textEncoder ??= new TextEncoder();
+            return textEncoder.encode(input);
+        }
+        return Buffer.from(input);
+    }
+    return input;
+}
+
+function getOrCreate(map, key, init) {
+    const existing = map.get(key);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const value = init();
+    map.set(key, value);
+    return value;
+}
+function getNewSet() {
+    return new Set();
+}
+function getNewArray() {
+    return [];
+}
+
+const chars$1 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const base = 64;
+function toBase64(value) {
+    let outString = '';
+    do {
+        const currentDigit = value % base;
+        value = (value / base) | 0;
+        outString = chars$1[currentDigit] + outString;
+    } while (value !== 0);
+    return outString;
+}
+
+// Four random characters from the private use area to minimize risk of
+// conflicts
+const hashPlaceholderLeft = '!~{';
+const hashPlaceholderRight = '}~';
+const hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
+// This is the size of a 128-bits xxhash with base64url encoding
+const MAX_HASH_SIZE = 22;
+const DEFAULT_HASH_SIZE = 8;
+const getHashPlaceholderGenerator = () => {
+    let nextIndex = 0;
+    return (optionName, hashSize) => {
+        if (hashSize > MAX_HASH_SIZE) {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`Hashes cannot be longer than ${MAX_HASH_SIZE} characters, received ${hashSize}. Check the "${optionName}" option.`));
+        }
+        const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, '0')}${hashPlaceholderRight}`;
+        if (placeholder.length > hashSize) {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`To generate hashes for this number of chunks (currently ${nextIndex}), you need a minimum hash size of ${placeholder.length}, received ${hashSize}. Check the "${optionName}" option.`));
+        }
+        return placeholder;
+    };
+};
+const REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${MAX_HASH_SIZE - hashPlaceholderOverhead}}${hashPlaceholderRight}`, 'g');
+const replacePlaceholders = (code, hashesByPlaceholder) => code.replace(REPLACER_REGEX, placeholder => hashesByPlaceholder.get(placeholder) || placeholder);
+const replaceSinglePlaceholder = (code, placeholder, value) => code.replace(REPLACER_REGEX, match => (match === placeholder ? value : match));
+const replacePlaceholdersWithDefaultAndGetContainedPlaceholders = (code, placeholders) => {
+    const containedPlaceholders = new Set();
+    const transformedCode = code.replace(REPLACER_REGEX, placeholder => {
+        if (placeholders.has(placeholder)) {
+            containedPlaceholders.add(placeholder);
+            return `${hashPlaceholderLeft}${'0'.repeat(placeholder.length - hashPlaceholderOverhead)}${hashPlaceholderRight}`;
+        }
+        return placeholder;
+    });
+    return { containedPlaceholders, transformedCode };
+};
+
+const lowercaseBundleKeys = Symbol('bundleKeys');
+const FILE_PLACEHOLDER = {
+    type: 'placeholder'
+};
+const getOutputBundle = (outputBundleBase) => {
+    const reservedLowercaseBundleKeys = new Set();
+    return new Proxy(outputBundleBase, {
+        deleteProperty(target, key) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.delete(key.toLowerCase());
+            }
+            return Reflect.deleteProperty(target, key);
+        },
+        get(target, key) {
+            if (key === lowercaseBundleKeys) {
+                return reservedLowercaseBundleKeys;
+            }
+            return Reflect.get(target, key);
+        },
+        set(target, key, value) {
+            if (typeof key === 'string') {
+                reservedLowercaseBundleKeys.add(key.toLowerCase());
+            }
+            return Reflect.set(target, key, value);
+        }
+    });
+};
+const removeUnreferencedAssets = (outputBundle) => {
+    const unreferencedAssets = new Set();
+    const bundleEntries = Object.values(outputBundle);
+    for (const asset of bundleEntries) {
+        if (asset.type === 'asset' && asset.needsCodeReference) {
+            unreferencedAssets.add(asset.fileName);
+        }
+    }
+    for (const chunk of bundleEntries) {
+        if (chunk.type === 'chunk') {
+            for (const referencedFile of chunk.referencedFiles) {
+                if (unreferencedAssets.has(referencedFile)) {
+                    unreferencedAssets.delete(referencedFile);
+                }
+            }
+        }
+    }
+    for (const file of unreferencedAssets) {
+        delete outputBundle[file];
+    }
+};
+
+function renderNamePattern(pattern, patternName, replacements) {
+    if (parseAst_js.isPathFragment(pattern))
+        return parseAst_js.error(parseAst_js.logFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
+    return pattern.replace(/\[(\w+)(:\d+)?]/g, (_match, type, size) => {
+        if (!replacements.hasOwnProperty(type) || (size && type !== 'hash')) {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`"[${type}${size || ''}]" is not a valid placeholder in the "${patternName}" pattern.`));
+        }
+        const replacement = replacements[type](size && Number.parseInt(size.slice(1)));
+        if (parseAst_js.isPathFragment(replacement))
+            return parseAst_js.error(parseAst_js.logFailedValidation(`Invalid substitution "${replacement}" for placeholder "[${type}]" in "${patternName}" pattern, can be neither absolute nor relative path.`));
+        return replacement;
+    });
+}
+function makeUnique(name, { [lowercaseBundleKeys]: reservedLowercaseBundleKeys }) {
+    if (!reservedLowercaseBundleKeys.has(name.toLowerCase()))
+        return name;
+    const extension = path.extname(name);
+    name = name.slice(0, Math.max(0, name.length - extension.length));
+    let uniqueName, uniqueIndex = 1;
+    while (reservedLowercaseBundleKeys.has((uniqueName = name + ++uniqueIndex + extension).toLowerCase()))
+        ;
+    return uniqueName;
+}
+
+function generateAssetFileName(name, names, source, originalFileName, originalFileNames, sourceHash, outputOptions, bundle, inputOptions) {
+    const emittedName = outputOptions.sanitizeFileName(name || 'asset');
+    return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === 'function'
+        ? outputOptions.assetFileNames({
+            // Additionally, this should be non-enumerable in the next major
+            get name() {
+                parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets when generating the file name is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, inputOptions);
+                return name;
+            },
+            names,
+            // Additionally, this should be non-enumerable in the next major
+            get originalFileName() {
+                parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets when generating the file name is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, inputOptions);
+                return originalFileName;
+            },
+            originalFileNames,
+            source,
+            type: 'asset'
+        })
+        : outputOptions.assetFileNames, 'output.assetFileNames', {
+        ext: () => path.extname(emittedName).slice(1),
+        extname: () => path.extname(emittedName),
+        hash: size => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
+        name: () => emittedName.slice(0, Math.max(0, emittedName.length - path.extname(emittedName).length))
+    }), bundle);
+}
+function reserveFileNameInBundle(fileName, { bundle }, log) {
+    if (bundle[lowercaseBundleKeys].has(fileName.toLowerCase())) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logFileNameConflict(fileName));
+    }
+    else {
+        bundle[fileName] = FILE_PLACEHOLDER;
+    }
+}
+const emittedFileTypes = new Set(['chunk', 'asset', 'prebuilt-chunk']);
+function hasValidType(emittedFile) {
+    return Boolean(emittedFile &&
+        emittedFileTypes.has(emittedFile.type));
+}
+function hasValidName(emittedFile) {
+    const validatedName = emittedFile.fileName || emittedFile.name;
+    return !validatedName || (typeof validatedName === 'string' && !parseAst_js.isPathFragment(validatedName));
+}
+function getValidSource(source, emittedFile, fileReferenceId) {
+    if (!(typeof source === 'string' || source instanceof Uint8Array)) {
+        const assetName = emittedFile.fileName || emittedFile.name || fileReferenceId;
+        return parseAst_js.error(parseAst_js.logFailedValidation(`Could not set source for ${typeof assetName === 'string' ? `asset "${assetName}"` : 'unnamed asset'}, asset source needs to be a string, Uint8Array or Buffer.`));
+    }
+    return source;
+}
+function getAssetFileName(file, referenceId) {
+    if (typeof file.fileName !== 'string') {
+        return parseAst_js.error(parseAst_js.logAssetNotFinalisedForFileName(file.name || referenceId));
+    }
+    return file.fileName;
+}
+function getChunkFileName(file, facadeChunkByModule) {
+    if (file.fileName) {
+        return file.fileName;
+    }
+    if (facadeChunkByModule) {
+        return facadeChunkByModule.get(file.module).getFileName();
+    }
+    return parseAst_js.error(parseAst_js.logChunkNotGeneratedForFileName(file.fileName || file.name));
+}
+class FileEmitter {
+    constructor(graph, options, baseFileEmitter) {
+        this.graph = graph;
+        this.options = options;
+        this.facadeChunkByModule = null;
+        this.nextIdBase = 1;
+        this.output = null;
+        this.outputFileEmitters = [];
+        this.emitFile = (emittedFile) => {
+            if (!hasValidType(emittedFile)) {
+                return parseAst_js.error(parseAst_js.logFailedValidation(`Emitted files must be of type "asset", "chunk" or "prebuilt-chunk", received "${emittedFile && emittedFile.type}".`));
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return this.emitPrebuiltChunk(emittedFile);
+            }
+            if (!hasValidName(emittedFile)) {
+                return parseAst_js.error(parseAst_js.logFailedValidation(`The "fileName" or "name" properties of emitted chunks and assets must be strings that are neither absolute nor relative paths, received "${emittedFile.fileName || emittedFile.name}".`));
+            }
+            if (emittedFile.type === 'chunk') {
+                return this.emitChunk(emittedFile);
+            }
+            return this.emitAsset(emittedFile);
+        };
+        this.finaliseAssets = () => {
+            for (const [referenceId, emittedFile] of this.filesByReferenceId) {
+                if (emittedFile.type === 'asset' && typeof emittedFile.fileName !== 'string')
+                    return parseAst_js.error(parseAst_js.logNoAssetSourceSet(emittedFile.name || referenceId));
+            }
+        };
+        this.getFileName = (fileReferenceId) => {
+            const emittedFile = this.filesByReferenceId.get(fileReferenceId);
+            if (!emittedFile)
+                return parseAst_js.error(parseAst_js.logFileReferenceIdNotFoundForFilename(fileReferenceId));
+            if (emittedFile.type === 'chunk') {
+                return getChunkFileName(emittedFile, this.facadeChunkByModule);
+            }
+            if (emittedFile.type === 'prebuilt-chunk') {
+                return emittedFile.fileName;
+            }
+            return getAssetFileName(emittedFile, fileReferenceId);
+        };
+        this.setAssetSource = (referenceId, requestedSource) => {
+            const consumedFile = this.filesByReferenceId.get(referenceId);
+            if (!consumedFile)
+                return parseAst_js.error(parseAst_js.logAssetReferenceIdNotFoundForSetSource(referenceId));
+            if (consumedFile.type !== 'asset') {
+                return parseAst_js.error(parseAst_js.logFailedValidation(`Asset sources can only be set for emitted assets but "${referenceId}" is an emitted chunk.`));
+            }
+            if (consumedFile.source !== undefined) {
+                return parseAst_js.error(parseAst_js.logAssetSourceAlreadySet(consumedFile.name || referenceId));
+            }
+            const source = getValidSource(requestedSource, consumedFile, referenceId);
+            if (this.output) {
+                this.finalizeAdditionalAsset(consumedFile, source, this.output);
+            }
+            else {
+                consumedFile.source = source;
+                for (const emitter of this.outputFileEmitters) {
+                    emitter.finalizeAdditionalAsset(consumedFile, source, emitter.output);
+                }
+            }
+        };
+        this.setChunkInformation = (facadeChunkByModule) => {
+            this.facadeChunkByModule = facadeChunkByModule;
+        };
+        this.setOutputBundle = (bundle, outputOptions) => {
+            const getHash = hasherByType[outputOptions.hashCharacters];
+            const output = (this.output = {
+                bundle,
+                fileNamesBySourceHash: new Map(),
+                getHash,
+                outputOptions
+            });
+            for (const emittedFile of this.filesByReferenceId.values()) {
+                if (emittedFile.fileName) {
+                    reserveFileNameInBundle(emittedFile.fileName, output, this.options.onLog);
+                }
+            }
+            const consumedAssetsByHash = new Map();
+            for (const consumedFile of this.filesByReferenceId.values()) {
+                if (consumedFile.type === 'asset' && consumedFile.source !== undefined) {
+                    if (consumedFile.fileName) {
+                        this.finalizeAdditionalAsset(consumedFile, consumedFile.source, output);
+                    }
+                    else {
+                        const sourceHash = getHash(consumedFile.source);
+                        getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
+                    }
+                }
+                else if (consumedFile.type === 'prebuilt-chunk') {
+                    this.output.bundle[consumedFile.fileName] = this.createPrebuiltChunk(consumedFile);
+                }
+            }
+            for (const [sourceHash, consumedFiles] of consumedAssetsByHash) {
+                this.finalizeAssetsWithSameSource(consumedFiles, sourceHash, output);
+            }
+        };
+        this.filesByReferenceId = baseFileEmitter
+            ? new Map(baseFileEmitter.filesByReferenceId)
+            : new Map();
+        baseFileEmitter?.addOutputFileEmitter(this);
+    }
+    addOutputFileEmitter(outputFileEmitter) {
+        this.outputFileEmitters.push(outputFileEmitter);
+    }
+    assignReferenceId(file, idBase) {
+        let referenceId = idBase;
+        do {
+            referenceId = getHash64(referenceId).slice(0, 8).replaceAll('-', '$');
+        } while (this.filesByReferenceId.has(referenceId) ||
+            this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
+        file.referenceId = referenceId;
+        this.filesByReferenceId.set(referenceId, file);
+        for (const { filesByReferenceId } of this.outputFileEmitters) {
+            filesByReferenceId.set(referenceId, file);
+        }
+        return referenceId;
+    }
+    createPrebuiltChunk(prebuiltChunk) {
+        return {
+            code: prebuiltChunk.code,
+            dynamicImports: [],
+            exports: prebuiltChunk.exports || [],
+            facadeModuleId: null,
+            fileName: prebuiltChunk.fileName,
+            implicitlyLoadedBefore: [],
+            importedBindings: {},
+            imports: [],
+            isDynamicEntry: false,
+            isEntry: false,
+            isImplicitEntry: false,
+            map: prebuiltChunk.map || null,
+            moduleIds: [],
+            modules: {},
+            name: prebuiltChunk.fileName,
+            preliminaryFileName: prebuiltChunk.fileName,
+            referencedFiles: [],
+            sourcemapFileName: prebuiltChunk.sourcemapFileName || null,
+            type: 'chunk'
+        };
+    }
+    emitAsset(emittedAsset) {
+        const source = emittedAsset.source === undefined
+            ? undefined
+            : getValidSource(emittedAsset.source, emittedAsset, null);
+        const originalFileName = emittedAsset.originalFileName || null;
+        if (typeof originalFileName === 'string') {
+            this.graph.watchFiles[originalFileName] = true;
+        }
+        const consumedAsset = {
+            fileName: emittedAsset.fileName,
+            name: emittedAsset.name,
+            needsCodeReference: !!emittedAsset.needsCodeReference,
+            originalFileName,
+            referenceId: '',
+            source,
+            type: 'asset'
+        };
+        const referenceId = this.assignReferenceId(consumedAsset, emittedAsset.fileName || emittedAsset.name || String(this.nextIdBase++));
+        if (this.output) {
+            this.emitAssetWithReferenceId(consumedAsset, this.output);
+        }
+        else {
+            for (const fileEmitter of this.outputFileEmitters) {
+                fileEmitter.emitAssetWithReferenceId(consumedAsset, fileEmitter.output);
+            }
+        }
+        return referenceId;
+    }
+    emitAssetWithReferenceId(consumedAsset, output) {
+        const { fileName, source } = consumedAsset;
+        if (fileName) {
+            reserveFileNameInBundle(fileName, output, this.options.onLog);
+        }
+        if (source !== undefined) {
+            this.finalizeAdditionalAsset(consumedAsset, source, output);
+        }
+    }
+    emitChunk(emittedChunk) {
+        if (this.graph.phase > BuildPhase.LOAD_AND_PARSE) {
+            return parseAst_js.error(parseAst_js.logInvalidRollupPhaseForChunkEmission());
+        }
+        if (typeof emittedChunk.id !== 'string') {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`Emitted chunks need to have a valid string id, received "${emittedChunk.id}"`));
+        }
+        const consumedChunk = {
+            fileName: emittedChunk.fileName,
+            module: null,
+            name: emittedChunk.name || emittedChunk.id,
+            referenceId: '',
+            type: 'chunk'
+        };
+        this.graph.moduleLoader
+            .emitChunk(emittedChunk)
+            .then(module => (consumedChunk.module = module))
+            .catch(() => {
+            // Avoid unhandled Promise rejection as the error will be thrown later
+            // once module loading has finished
+        });
+        return this.assignReferenceId(consumedChunk, emittedChunk.id);
+    }
+    emitPrebuiltChunk(emitPrebuiltChunk) {
+        if (typeof emitPrebuiltChunk.code !== 'string') {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`Emitted prebuilt chunks need to have a valid string code, received "${emitPrebuiltChunk.code}".`));
+        }
+        if (typeof emitPrebuiltChunk.fileName !== 'string' ||
+            parseAst_js.isPathFragment(emitPrebuiltChunk.fileName)) {
+            return parseAst_js.error(parseAst_js.logFailedValidation(`The "fileName" property of emitted prebuilt chunks must be strings that are neither absolute nor relative paths, received "${emitPrebuiltChunk.fileName}".`));
+        }
+        const consumedPrebuiltChunk = {
+            code: emitPrebuiltChunk.code,
+            exports: emitPrebuiltChunk.exports,
+            fileName: emitPrebuiltChunk.fileName,
+            map: emitPrebuiltChunk.map,
+            referenceId: '',
+            type: 'prebuilt-chunk'
+        };
+        const referenceId = this.assignReferenceId(consumedPrebuiltChunk, consumedPrebuiltChunk.fileName);
+        if (this.output) {
+            this.output.bundle[consumedPrebuiltChunk.fileName] =
+                this.createPrebuiltChunk(consumedPrebuiltChunk);
+        }
+        return referenceId;
+    }
+    finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySourceHash, getHash, outputOptions }) {
+        let { fileName, name, needsCodeReference, originalFileName, referenceId } = consumedFile;
+        // Deduplicate assets if an explicit fileName is not provided
+        if (!fileName) {
+            const sourceHash = getHash(source);
+            fileName = fileNamesBySourceHash.get(sourceHash);
+            if (!fileName) {
+                fileName = generateAssetFileName(name, name ? [name] : [], source, originalFileName, originalFileName ? [originalFileName] : [], sourceHash, outputOptions, bundle, this.options);
+                fileNamesBySourceHash.set(sourceHash, fileName);
+            }
+        }
+        // We must not modify the original assets to avoid interaction between outputs
+        const assetWithFileName = { ...consumedFile, fileName, source };
+        this.filesByReferenceId.set(referenceId, assetWithFileName);
+        const existingAsset = bundle[fileName];
+        if (existingAsset?.type === 'asset') {
+            existingAsset.needsCodeReference &&= needsCodeReference;
+            if (name) {
+                existingAsset.names.push(name);
+            }
+            if (originalFileName) {
+                existingAsset.originalFileNames.push(originalFileName);
+            }
+        }
+        else {
+            const { options } = this;
+            bundle[fileName] = {
+                fileName,
+                get name() {
+                    // Additionally, this should be non-enumerable in the next major
+                    parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                    return name;
+                },
+                names: name ? [name] : [],
+                needsCodeReference,
+                get originalFileName() {
+                    // Additionally, this should be non-enumerable in the next major
+                    parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                    return originalFileName;
+                },
+                originalFileNames: originalFileName ? [originalFileName] : [],
+                source,
+                type: 'asset'
+            };
+        }
+    }
+    finalizeAssetsWithSameSource(consumedFiles, sourceHash, { bundle, fileNamesBySourceHash, outputOptions }) {
+        const { names, originalFileNames } = getNamesFromAssets(consumedFiles);
+        let fileName = '';
+        let usedConsumedFile;
+        let needsCodeReference = true;
+        for (const consumedFile of consumedFiles) {
+            needsCodeReference &&= consumedFile.needsCodeReference;
+            const assetFileName = generateAssetFileName(consumedFile.name, names, consumedFile.source, consumedFile.originalFileName, originalFileNames, sourceHash, outputOptions, bundle, this.options);
+            if (!fileName ||
+                assetFileName.length < fileName.length ||
+                (assetFileName.length === fileName.length && assetFileName < fileName)) {
+                fileName = assetFileName;
+                usedConsumedFile = consumedFile;
+            }
+        }
+        fileNamesBySourceHash.set(sourceHash, fileName);
+        for (const consumedFile of consumedFiles) {
+            // We must not modify the original assets to avoid interaction between outputs
+            const assetWithFileName = { ...consumedFile, fileName };
+            this.filesByReferenceId.set(consumedFile.referenceId, assetWithFileName);
+        }
+        const { options } = this;
+        bundle[fileName] = {
+            fileName,
+            get name() {
+                // Additionally, this should be non-enumerable in the next major
+                parseAst_js.warnDeprecation('Accessing the "name" property of emitted assets in the bundle is deprecated. Use the "names" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.name;
+            },
+            names,
+            needsCodeReference,
+            get originalFileName() {
+                // Additionally, this should be non-enumerable in the next major
+                parseAst_js.warnDeprecation('Accessing the "originalFileName" property of emitted assets in the bundle is deprecated. Use the "originalFileNames" property instead.', parseAst_js.URL_GENERATEBUNDLE, false, options);
+                return usedConsumedFile.originalFileName;
+            },
+            originalFileNames,
+            source: usedConsumedFile.source,
+            type: 'asset'
+        };
+    }
+}
+function getNamesFromAssets(consumedFiles) {
+    const names = [];
+    const originalFileNames = [];
+    for (const { name, originalFileName } of consumedFiles) {
+        if (typeof name === 'string') {
+            names.push(name);
+        }
+        if (originalFileName) {
+            originalFileNames.push(originalFileName);
+        }
+    }
+    originalFileNames.sort();
+    // Sort by length first and then alphabetically so that the order is stable
+    // and the shortest names come first
+    names.sort((a, b) => a.length - b.length || (a > b ? 1 : a === b ? 0 : -1));
+    return { names, originalFileNames };
+}
+
+const doNothing = () => { };
+
+async function asyncFlatten(array) {
+    do {
+        array = (await Promise.all(array)).flat(Infinity);
+    } while (array.some((v) => v?.then));
+    return array;
+}
+
+const getOnLog = (config, logLevel, printLog = defaultPrintLog) => {
+    const { onwarn, onLog } = config;
+    const defaultOnLog = getDefaultOnLog(printLog, onwarn);
+    if (onLog) {
+        const minimalPriority = parseAst_js.logLevelPriority[logLevel];
+        return (level, log) => onLog(level, addLogToString(log), (level, handledLog) => {
+            if (level === parseAst_js.LOGLEVEL_ERROR) {
+                return parseAst_js.error(normalizeLog(handledLog));
+            }
+            if (parseAst_js.logLevelPriority[level] >= minimalPriority) {
+                defaultOnLog(level, normalizeLog(handledLog));
+            }
+        });
+    }
+    return defaultOnLog;
+};
+const getDefaultOnLog = (printLog, onwarn) => onwarn
+    ? (level, log) => {
+        if (level === parseAst_js.LOGLEVEL_WARN) {
+            onwarn(addLogToString(log), warning => printLog(parseAst_js.LOGLEVEL_WARN, normalizeLog(warning)));
+        }
+        else {
+            printLog(level, log);
+        }
+    }
+    : printLog;
+const addLogToString = (log) => {
+    Object.defineProperty(log, 'toString', {
+        value: () => log.message,
+        writable: true
+    });
+    return log;
+};
+const normalizeLog = (log) => typeof log === 'string'
+    ? { message: log }
+    : typeof log === 'function'
+        ? normalizeLog(log())
+        : log;
+const defaultPrintLog = (level, { message }) => {
+    switch (level) {
+        case parseAst_js.LOGLEVEL_WARN: {
+            return console.warn(message);
+        }
+        case parseAst_js.LOGLEVEL_DEBUG: {
+            return console.debug(message);
+        }
+        default: {
+            return console.info(message);
+        }
+    }
+};
+function warnUnknownOptions(passedOptions, validOptions, optionType, log, ignoredKeys = /$./) {
+    const validOptionSet = new Set(validOptions);
+    const unknownOptions = Object.keys(passedOptions).filter(key => !(validOptionSet.has(key) || ignoredKeys.test(key)));
+    if (unknownOptions.length > 0) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnknownOption(optionType, unknownOptions, [...validOptionSet].sort()));
+    }
+}
+const treeshakePresets = {
+    recommended: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: false
+    },
+    safest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: true,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => true,
+        propertyReadSideEffects: true,
+        tryCatchDeoptimization: true,
+        unknownGlobalSideEffects: true
+    },
+    smallest: {
+        annotations: true,
+        correctVarValueBeforeDeclaration: false,
+        manualPureFunctions: parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: () => false,
+        propertyReadSideEffects: false,
+        tryCatchDeoptimization: false,
+        unknownGlobalSideEffects: false
+    }
+};
+const jsxPresets = {
+    preserve: {
+        factory: null,
+        fragment: null,
+        importSource: null,
+        mode: 'preserve'
+    },
+    'preserve-react': {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'preserve'
+    },
+    react: {
+        factory: 'React.createElement',
+        fragment: 'React.Fragment',
+        importSource: 'react',
+        mode: 'classic'
+    },
+    'react-jsx': {
+        factory: 'React.createElement',
+        importSource: 'react',
+        jsxImportSource: 'react/jsx-runtime',
+        mode: 'automatic'
+    }
+};
+const generatedCodePresets = {
+    es2015: {
+        arrowFunctions: true,
+        constBindings: true,
+        objectShorthand: true,
+        reservedNamesAsProps: true,
+        symbols: true
+    },
+    es5: {
+        arrowFunctions: false,
+        constBindings: false,
+        objectShorthand: false,
+        reservedNamesAsProps: true,
+        symbols: false
+    }
+};
+const objectifyOption = (value) => value && typeof value === 'object' ? value : {};
+const objectifyOptionWithPresets = (presets, optionName, urlSnippet, additionalValues) => (value) => {
+    if (typeof value === 'string') {
+        const preset = presets[value];
+        if (preset) {
+            return preset;
+        }
+        parseAst_js.error(parseAst_js.logInvalidOption(optionName, urlSnippet, `valid values are ${additionalValues}${parseAst_js.printQuotedStringList(Object.keys(presets))}. You can also supply an object for more fine-grained control`, value));
+    }
+    return objectifyOption(value);
+};
+const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalValues) => {
+    const presetName = value?.preset;
+    if (presetName) {
+        const preset = presets[presetName];
+        if (preset) {
+            return { ...preset, ...value };
+        }
+        else {
+            parseAst_js.error(parseAst_js.logInvalidOption(`${optionName}.preset`, urlSnippet, `valid values are ${parseAst_js.printQuotedStringList(Object.keys(presets))}`, presetName));
+        }
+    }
+    return objectifyOptionWithPresets(presets, optionName, urlSnippet, additionalValues)(value);
+};
+const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
+
+function getLogHandler(level, code, logger, pluginName, logLevel) {
+    if (parseAst_js.logLevelPriority[level] < parseAst_js.logLevelPriority[logLevel]) {
+        return doNothing;
+    }
+    return (log, pos) => {
+        if (pos != null) {
+            logger(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidLogPosition(pluginName));
+        }
+        log = normalizeLog(log);
+        if (log.code && !log.pluginCode) {
+            log.pluginCode = log.code;
+        }
+        log.code = code;
+        log.plugin = pluginName;
+        logger(level, log);
+    };
+}
+
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
+
+function createPluginCache(cache) {
+    return {
+        delete(id) {
+            return delete cache[id];
+        },
+        get(id) {
+            const item = cache[id];
+            if (!item)
+                return;
+            item[0] = 0;
+            return item[1];
+        },
+        has(id) {
+            const item = cache[id];
+            if (!item)
+                return false;
+            item[0] = 0;
+            return true;
+        },
+        set(id, value) {
+            cache[id] = [0, value];
+        }
+    };
+}
+function getTrackedPluginCache(pluginCache, onUse) {
+    return {
+        delete(id) {
+            onUse();
+            return pluginCache.delete(id);
+        },
+        get(id) {
+            onUse();
+            return pluginCache.get(id);
+        },
+        has(id) {
+            onUse();
+            return pluginCache.has(id);
+        },
+        set(id, value) {
+            onUse();
+            return pluginCache.set(id, value);
+        }
+    };
+}
+const NO_CACHE = {
+    delete() {
+        return false;
+    },
+    get() {
+        return undefined;
+    },
+    has() {
+        return false;
+    },
+    set() { }
+};
+function uncacheablePluginError(pluginName) {
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
+        return parseAst_js.error(parseAst_js.logAnonymousPluginCache());
+    }
+    return parseAst_js.error(parseAst_js.logDuplicatePluginName(pluginName));
+}
+function getCacheForUncacheablePlugin(pluginName) {
+    return {
+        delete() {
+            return uncacheablePluginError(pluginName);
+        },
+        get() {
+            return uncacheablePluginError(pluginName);
+        },
+        has() {
+            return uncacheablePluginError(pluginName);
+        },
+        set() {
+            return uncacheablePluginError(pluginName);
+        }
+    };
+}
+
+function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, existingPluginNames) {
+    const { logLevel, onLog } = options;
+    let cacheable = true;
+    if (typeof plugin.cacheKey !== 'string') {
+        if (plugin.name.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+            plugin.name.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX) ||
+            existingPluginNames.has(plugin.name)) {
+            cacheable = false;
+        }
+        else {
+            existingPluginNames.add(plugin.name);
+        }
+    }
+    let cacheInstance;
+    if (!pluginCache) {
+        cacheInstance = NO_CACHE;
+    }
+    else if (cacheable) {
+        const cacheKey = plugin.cacheKey || plugin.name;
+        cacheInstance = createPluginCache(pluginCache[cacheKey] || (pluginCache[cacheKey] = Object.create(null)));
+    }
+    else {
+        cacheInstance = getCacheForUncacheablePlugin(plugin.name);
+    }
+    return {
+        addWatchFile(id) {
+            graph.watchFiles[id] = true;
+        },
+        cache: cacheInstance,
+        debug: getLogHandler(parseAst_js.LOGLEVEL_DEBUG, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
+        emitFile: fileEmitter.emitFile.bind(fileEmitter),
+        error(error_) {
+            return parseAst_js.error(parseAst_js.logPluginError(normalizeLog(error_), plugin.name));
+        },
+        getFileName: fileEmitter.getFileName,
+        getModuleIds: () => graph.modulesById.keys(),
+        getModuleInfo: graph.getModuleInfo,
+        getWatchFiles: () => Object.keys(graph.watchFiles),
+        info: getLogHandler(parseAst_js.LOGLEVEL_INFO, 'PLUGIN_LOG', onLog, plugin.name, logLevel),
+        load(resolvedId) {
+            return graph.moduleLoader.preloadModule(resolvedId);
+        },
+        meta: {
+            rollupVersion: version,
+            watchMode: graph.watchMode
+        },
+        parse: parseAst_js.parseAst,
+        resolve(source, importer, { attributes, custom, isEntry, skipSelf } = parseAst_js.BLANK) {
+            skipSelf ??= true;
+            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || parseAst_js.EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
+        },
+        setAssetSource: fileEmitter.setAssetSource,
+        warn: getLogHandler(parseAst_js.LOGLEVEL_WARN, 'PLUGIN_WARNING', onLog, plugin.name, logLevel)
+    };
+}
+
+// This will make sure no input hook is omitted
+const inputHookNames = {
+    buildEnd: 1,
+    buildStart: 1,
+    closeBundle: 1,
+    closeWatcher: 1,
+    load: 1,
+    moduleParsed: 1,
+    onLog: 1,
+    options: 1,
+    resolveDynamicImport: 1,
+    resolveId: 1,
+    shouldTransformCachedModule: 1,
+    transform: 1,
+    watchChange: 1
+};
+const inputHooks = Object.keys(inputHookNames);
+class PluginDriver {
+    constructor(graph, options, userPlugins, pluginCache, basePluginDriver) {
+        this.graph = graph;
+        this.options = options;
+        this.pluginCache = pluginCache;
+        this.sortedPlugins = new Map();
+        this.unfulfilledActions = new Set();
+        this.fileEmitter = new FileEmitter(graph, options, basePluginDriver && basePluginDriver.fileEmitter);
+        this.emitFile = this.fileEmitter.emitFile.bind(this.fileEmitter);
+        this.getFileName = this.fileEmitter.getFileName.bind(this.fileEmitter);
+        this.finaliseAssets = this.fileEmitter.finaliseAssets.bind(this.fileEmitter);
+        this.setChunkInformation = this.fileEmitter.setChunkInformation.bind(this.fileEmitter);
+        this.setOutputBundle = this.fileEmitter.setOutputBundle.bind(this.fileEmitter);
+        this.plugins = [...(basePluginDriver ? basePluginDriver.plugins : []), ...userPlugins];
+        const existingPluginNames = new Set();
+        this.pluginContexts = new Map(this.plugins.map(plugin => [
+            plugin,
+            getPluginContext(plugin, pluginCache, graph, options, this.fileEmitter, existingPluginNames)
+        ]));
+        if (basePluginDriver) {
+            for (const plugin of userPlugins) {
+                for (const hook of inputHooks) {
+                    if (hook in plugin) {
+                        options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInputHookInOutputPlugin(plugin.name, hook));
+                    }
+                }
+            }
+        }
+    }
+    createOutputPluginDriver(plugins) {
+        return new PluginDriver(this.graph, this.options, plugins, this.pluginCache, this);
+    }
+    getUnfulfilledHookActions() {
+        return this.unfulfilledActions;
+    }
+    // chains, first non-null result stops and returns
+    hookFirst(hookName, parameters, replaceContext, skipped) {
+        return this.hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped).then(result => result && result[0]);
+    }
+    // chains, first non-null result stops and returns result and last plugin
+    async hookFirstAndGetPlugin(hookName, parameters, replaceContext, skipped) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (skipped?.has(plugin))
+                continue;
+            const result = await this.runHook(hookName, parameters, plugin, replaceContext);
+            if (result != null)
+                return [result, plugin];
+        }
+        return null;
+    }
+    // chains synchronously, first non-null result stops and returns
+    hookFirstSync(hookName, parameters, replaceContext) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+    // parallel, ignores returns
+    async hookParallel(hookName, parameters, replaceContext) {
+        const parallelPromises = [];
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            if (plugin[hookName].sequential) {
+                await Promise.all(parallelPromises);
+                parallelPromises.length = 0;
+                await this.runHook(hookName, parameters, plugin, replaceContext);
+            }
+            else {
+                parallelPromises.push(this.runHook(hookName, parameters, plugin, replaceContext));
+            }
+        }
+        await Promise.all(parallelPromises);
+    }
+    // chains, reduces returned value, handling the reduced value as the first hook argument
+    hookReduceArg0(hookName, [argument0, ...rest], reduce, replaceContext) {
+        let promise = Promise.resolve(argument0);
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(argument0 => this.runHook(hookName, [argument0, ...rest], plugin, replaceContext).then(result => reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin)));
+        }
+        return promise;
+    }
+    // chains synchronously, reduces returned value, handling the reduced value as the first hook argument
+    hookReduceArg0Sync(hookName, [argument0, ...rest], reduce, replaceContext) {
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const parameters = [argument0, ...rest];
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            argument0 = reduce.call(this.pluginContexts.get(plugin), argument0, result, plugin);
+        }
+        return argument0;
+    }
+    // chains, reduces returned value to type string, handling the reduced value separately. permits hooks as values.
+    async hookReduceValue(hookName, initialValue, parameters, reducer) {
+        const results = [];
+        const parallelResults = [];
+        for (const plugin of this.getSortedPlugins(hookName, validateAddonPluginHandler)) {
+            if (plugin[hookName].sequential) {
+                results.push(...(await Promise.all(parallelResults)));
+                parallelResults.length = 0;
+                results.push(await this.runHook(hookName, parameters, plugin));
+            }
+            else {
+                parallelResults.push(this.runHook(hookName, parameters, plugin));
+            }
+        }
+        results.push(...(await Promise.all(parallelResults)));
+        return results.reduce(reducer, await initialValue);
+    }
+    // chains synchronously, reduces returned value to type T, handling the reduced value separately. permits hooks as values.
+    hookReduceValueSync(hookName, initialValue, parameters, reduce, replaceContext) {
+        let accumulator = initialValue;
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            const result = this.runHookSync(hookName, parameters, plugin, replaceContext);
+            accumulator = reduce.call(this.pluginContexts.get(plugin), accumulator, result, plugin);
+        }
+        return accumulator;
+    }
+    // chains, ignores returns
+    hookSeq(hookName, parameters, replaceContext) {
+        let promise = Promise.resolve();
+        for (const plugin of this.getSortedPlugins(hookName)) {
+            promise = promise.then(() => this.runHook(hookName, parameters, plugin, replaceContext));
+        }
+        return promise.then(noReturn);
+    }
+    getSortedPlugins(hookName, validateHandler) {
+        return getOrCreate(this.sortedPlugins, hookName, () => getSortedValidatedPlugins(hookName, this.plugins, validateHandler));
+    }
+    // Implementation signature
+    runHook(hookName, parameters, plugin, replaceContext) {
+        // We always filter for plugins that support the hook before running it
+        const hook = plugin[hookName];
+        const handler = typeof hook === 'object' ? hook.handler : hook;
+        let context = this.pluginContexts.get(plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
+        }
+        let action = null;
+        return Promise.resolve()
+            .then(() => {
+            if (typeof handler !== 'function') {
+                return handler;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            const hookResult = handler.apply(context, parameters);
+            if (!hookResult?.then) {
+                // short circuit for non-thenables and non-Promises
+                return hookResult;
+            }
+            // Track pending hook actions to properly error out when
+            // unfulfilled promises cause rollup to abruptly and confusingly
+            // exit with a successful 0 return code but without producing any
+            // output, errors or warnings.
+            action = [plugin.name, hookName, parameters];
+            this.unfulfilledActions.add(action);
+            // Although it would be more elegant to just return hookResult here
+            // and put the .then() handler just above the .catch() handler below,
+            // doing so would subtly change the defacto async event dispatch order
+            // which at least one test and some plugins in the wild may depend on.
+            return Promise.resolve(hookResult).then(result => {
+                // action was fulfilled
+                this.unfulfilledActions.delete(action);
+                return result;
+            });
+        })
+            .catch(error_ => {
+            if (action !== null) {
+                // action considered to be fulfilled since error being handled
+                this.unfulfilledActions.delete(action);
+            }
+            return parseAst_js.error(parseAst_js.logPluginError(error_, plugin.name, { hook: hookName }));
+        });
+    }
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    runHookSync(hookName, parameters, plugin, replaceContext) {
+        const hook = plugin[hookName];
+        const handler = typeof hook === 'object' ? hook.handler : hook;
+        let context = this.pluginContexts.get(plugin);
+        if (replaceContext) {
+            context = replaceContext(context, plugin);
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            return handler.apply(context, parameters);
+        }
+        catch (error_) {
+            return parseAst_js.error(parseAst_js.logPluginError(error_, plugin.name, { hook: hookName }));
+        }
+    }
+}
+function getSortedValidatedPlugins(hookName, plugins, validateHandler = validateFunctionPluginHandler) {
+    const pre = [];
+    const normal = [];
+    const post = [];
+    for (const plugin of plugins) {
+        const hook = plugin[hookName];
+        if (hook) {
+            if (typeof hook === 'object') {
+                validateHandler(hook.handler, hookName, plugin);
+                if (hook.order === 'pre') {
+                    pre.push(plugin);
+                    continue;
+                }
+                if (hook.order === 'post') {
+                    post.push(plugin);
+                    continue;
+                }
+            }
+            else {
+                validateHandler(hook, hookName, plugin);
+            }
+            normal.push(plugin);
+        }
+    }
+    return [...pre, ...normal, ...post];
+}
+function validateFunctionPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'function') {
+        parseAst_js.error(parseAst_js.logInvalidFunctionPluginHook(hookName, plugin.name));
+    }
+}
+function validateAddonPluginHandler(handler, hookName, plugin) {
+    if (typeof handler !== 'string' && typeof handler !== 'function') {
+        return parseAst_js.error(parseAst_js.logInvalidAddonPluginHook(hookName, plugin.name));
+    }
+}
+function noReturn() { }
+
+function getLogger(plugins, onLog, watchMode, logLevel) {
+    plugins = getSortedValidatedPlugins('onLog', plugins);
+    const minimalPriority = parseAst_js.logLevelPriority[logLevel];
+    const logger = (level, log, skipped = parseAst_js.EMPTY_SET) => {
+        parseAst_js.augmentLogMessage(log);
+        const logPriority = parseAst_js.logLevelPriority[level];
+        if (logPriority < minimalPriority) {
+            return;
+        }
+        for (const plugin of plugins) {
+            if (skipped.has(plugin))
+                continue;
+            const { onLog: pluginOnLog } = plugin;
+            const getLogHandler = (level) => {
+                if (parseAst_js.logLevelPriority[level] < minimalPriority) {
+                    return doNothing;
+                }
+                return log => logger(level, normalizeLog(log), new Set(skipped).add(plugin));
+            };
+            const handler = 'handler' in pluginOnLog ? pluginOnLog.handler : pluginOnLog;
+            if (handler.call({
+                debug: getLogHandler(parseAst_js.LOGLEVEL_DEBUG),
+                error: (log) => parseAst_js.error(normalizeLog(log)),
+                info: getLogHandler(parseAst_js.LOGLEVEL_INFO),
+                meta: { rollupVersion: version, watchMode },
+                warn: getLogHandler(parseAst_js.LOGLEVEL_WARN)
+            }, level, log) === false) {
+                return;
+            }
+        }
+        onLog(level, log);
+    };
+    return logger;
+}
+
+const commandAliases = {
+    c: 'config',
+    d: 'dir',
+    e: 'external',
+    f: 'format',
+    g: 'globals',
+    h: 'help',
+    i: 'input',
+    m: 'sourcemap',
+    n: 'name',
+    o: 'file',
+    p: 'plugin',
+    v: 'version',
+    w: 'watch'
+};
+const EMPTY_COMMAND_OPTIONS = { external: [], globals: undefined };
+async function mergeOptions(config, watchMode, rawCommandOptions = EMPTY_COMMAND_OPTIONS, printLog) {
+    const command = getCommandOptions(rawCommandOptions);
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || parseAst_js.LOGLEVEL_INFO;
+    const onLog = getOnLog(config, logLevel, printLog);
+    const log = getLogger(plugins, onLog, watchMode, logLevel);
+    const inputOptions = mergeInputOptions(config, command, plugins, log, onLog);
+    if (command.output) {
+        Object.assign(command, command.output);
+    }
+    const outputOptionsArray = ensureArray$1(config.output);
+    if (outputOptionsArray.length === 0)
+        outputOptionsArray.push({});
+    const outputOptions = await Promise.all(outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, log)));
+    warnUnknownOptions(command, [
+        ...Object.keys(inputOptions),
+        ...Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapIgnoreList' && option !== 'sourcemapPathTransform'),
+        ...Object.keys(commandAliases),
+        'bundleConfigAsCjs',
+        'config',
+        'configPlugin',
+        'environment',
+        'failAfterWarnings',
+        'filterLogs',
+        'forceExit',
+        'plugin',
+        'silent',
+        'stdin',
+        'waitForBundleInput'
+    ], 'CLI flags', log, /^_$|output$|config/);
+    inputOptions.output = outputOptions;
+    return inputOptions;
+}
+function getCommandOptions(rawCommandOptions) {
+    const external = rawCommandOptions.external && typeof rawCommandOptions.external === 'string'
+        ? rawCommandOptions.external.split(',')
+        : [];
+    return {
+        ...rawCommandOptions,
+        external,
+        globals: typeof rawCommandOptions.globals === 'string'
+            ? rawCommandOptions.globals.split(',').reduce((globals, globalDefinition) => {
+                const [id, variableName] = globalDefinition.split(':');
+                globals[id] = variableName;
+                if (!external.includes(id)) {
+                    external.push(id);
+                }
+                return globals;
+            }, Object.create(null))
+            : undefined
+    };
+}
+function mergeInputOptions(config, overrides, plugins, log, onLog) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const inputOptions = {
+        cache: config.cache,
+        context: getOption('context'),
+        experimentalCacheExpiry: getOption('experimentalCacheExpiry'),
+        experimentalLogSideEffects: getOption('experimentalLogSideEffects'),
+        external: getExternal(config, overrides),
+        input: getOption('input') || [],
+        jsx: getObjectOption(config, overrides, 'jsx', objectifyOptionWithPresets(jsxPresets, 'jsx', parseAst_js.URL_JSX, 'false, ')),
+        logLevel: getOption('logLevel'),
+        makeAbsoluteExternalsRelative: getOption('makeAbsoluteExternalsRelative'),
+        maxParallelFileOps: getOption('maxParallelFileOps'),
+        moduleContext: getOption('moduleContext'),
+        onLog,
+        onwarn: undefined,
+        perf: getOption('perf'),
+        plugins,
+        preserveEntrySignatures: getOption('preserveEntrySignatures'),
+        preserveSymlinks: getOption('preserveSymlinks'),
+        shimMissingExports: getOption('shimMissingExports'),
+        strictDeprecations: getOption('strictDeprecations'),
+        treeshake: getObjectOption(config, overrides, 'treeshake', objectifyOptionWithPresets(treeshakePresets, 'treeshake', parseAst_js.URL_TREESHAKE, 'false, true, ')),
+        watch: getWatch(config, overrides)
+    };
+    warnUnknownOptions(config, Object.keys(inputOptions), 'input options', log, /^output$/);
+    return inputOptions;
+}
+const getExternal = (config, overrides) => {
+    const configExternal = config.external;
+    return typeof configExternal === 'function'
+        ? (source, importer, isResolved) => configExternal(source, importer, isResolved) || overrides.external.includes(source)
+        : [...ensureArray$1(configExternal), ...overrides.external];
+};
+const getObjectOption = (config, overrides, name, objectifyValue = objectifyOption) => {
+    const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
+    const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
+    if (commandOption !== undefined) {
+        return commandOption && { ...configOption, ...commandOption };
+    }
+    return configOption;
+};
+const getWatch = (config, overrides) => config.watch !== false && getObjectOption(config, overrides, 'watch');
+const isWatchEnabled = (optionValue) => {
+    if (Array.isArray(optionValue)) {
+        return optionValue.reduce((result, value) => (typeof value === 'boolean' ? value : result), false);
+    }
+    return optionValue === true;
+};
+const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
+    if (!optionValue) {
+        return optionValue;
+    }
+    if (Array.isArray(optionValue)) {
+        return optionValue.reduce((result, value) => value && result && { ...result, ...objectifyValue(value) }, {});
+    }
+    return objectifyValue(optionValue);
+};
+async function mergeOutputOptions(config, overrides, log) {
+    const getOption = (name) => overrides[name] ?? config[name];
+    const outputOptions = {
+        amd: getObjectOption(config, overrides, 'amd'),
+        assetFileNames: getOption('assetFileNames'),
+        banner: getOption('banner'),
+        chunkFileNames: getOption('chunkFileNames'),
+        compact: getOption('compact'),
+        dir: getOption('dir'),
+        dynamicImportInCjs: getOption('dynamicImportInCjs'),
+        entryFileNames: getOption('entryFileNames'),
+        esModule: getOption('esModule'),
+        experimentalMinChunkSize: getOption('experimentalMinChunkSize'),
+        exports: getOption('exports'),
+        extend: getOption('extend'),
+        externalImportAssertions: getOption('externalImportAssertions'),
+        externalImportAttributes: getOption('externalImportAttributes'),
+        externalLiveBindings: getOption('externalLiveBindings'),
+        file: getOption('file'),
+        footer: getOption('footer'),
+        format: getOption('format'),
+        freeze: getOption('freeze'),
+        generatedCode: getObjectOption(config, overrides, 'generatedCode', objectifyOptionWithPresets(generatedCodePresets, 'output.generatedCode', parseAst_js.URL_OUTPUT_GENERATEDCODE, '')),
+        globals: getOption('globals'),
+        hashCharacters: getOption('hashCharacters'),
+        hoistTransitiveImports: getOption('hoistTransitiveImports'),
+        importAttributesKey: getOption('importAttributesKey'),
+        indent: getOption('indent'),
+        inlineDynamicImports: getOption('inlineDynamicImports'),
+        interop: getOption('interop'),
+        intro: getOption('intro'),
+        manualChunks: getOption('manualChunks'),
+        minifyInternalExports: getOption('minifyInternalExports'),
+        name: getOption('name'),
+        noConflict: getOption('noConflict'),
+        outro: getOption('outro'),
+        paths: getOption('paths'),
+        plugins: await normalizePluginOption(config.plugins),
+        preserveModules: getOption('preserveModules'),
+        preserveModulesRoot: getOption('preserveModulesRoot'),
+        reexportProtoFromExternal: getOption('reexportProtoFromExternal'),
+        sanitizeFileName: getOption('sanitizeFileName'),
+        sourcemap: getOption('sourcemap'),
+        sourcemapBaseUrl: getOption('sourcemapBaseUrl'),
+        sourcemapExcludeSources: getOption('sourcemapExcludeSources'),
+        sourcemapFile: getOption('sourcemapFile'),
+        sourcemapFileNames: getOption('sourcemapFileNames'),
+        sourcemapIgnoreList: getOption('sourcemapIgnoreList'),
+        sourcemapPathTransform: getOption('sourcemapPathTransform'),
+        strict: getOption('strict'),
+        systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate'),
+        virtualDirname: getOption('virtualDirname')
+    };
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', log);
+    return outputOptions;
+}
+
+const {
+  env = {},
+  argv = [],
+  platform = "",
+} = typeof process === "undefined" ? {} : process;
+
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env.TERM === "dumb";
+
+const isCompatibleTerminal =
+  tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled &&
+  (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: String }),
+        {}
+      );
+
+const {
+  reset,
+  bold: bold$1,
+  dim: dim$1,
+  italic,
+  underline: underline$1,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red: red$1,
+  green: green$1,
+  yellow: yellow$1,
+  blue,
+  magenta,
+  cyan: cyan$1,
+  white,
+  gray: gray$1,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright,
+} = createColors();
+
+// @see https://no-color.org
+// @see https://www.npmjs.com/package/chalk
+const { bold, cyan, dim, gray, green, red, underline, yellow } = createColors({
+    useColor: process$1.env.FORCE_COLOR !== '0' && !process$1.env.NO_COLOR
+});
+
+// log to stderr to keep `rollup main.js > bundle.js` from breaking
+const stderr = (...parameters) => process$1.stderr.write(`${parameters.join('')}\n`);
+function handleError(error, recover = false) {
+    const name = error.name || error.cause?.name;
+    const nameSection = name ? `${name}: ` : '';
+    const pluginSection = error.plugin ? `(plugin ${error.plugin}) ` : '';
+    const message = `${pluginSection}${nameSection}${error.message}`;
+    const outputLines = [bold(red(`[!] ${bold(message.toString())}`))];
+    if (error.url) {
+        outputLines.push(cyan(error.url));
+    }
+    if (error.loc) {
+        outputLines.push(`${parseAst_js.relativeId((error.loc.file || error.id))} (${error.loc.line}:${error.loc.column})`);
+    }
+    else if (error.id) {
+        outputLines.push(parseAst_js.relativeId(error.id));
+    }
+    if (error.frame) {
+        outputLines.push(dim(error.frame));
+    }
+    if (error.stack) {
+        outputLines.push(dim(error.stack?.replace(`${nameSection}${error.message}\n`, '')));
+    }
+    // ES2022: Error.prototype.cause is optional
+    if (error.cause) {
+        let cause = error.cause;
+        const causeErrorLines = [];
+        let indent = '';
+        while (cause) {
+            indent += '  ';
+            const message = cause.stack || cause;
+            causeErrorLines.push(...`[cause] ${message}`.split('\n').map(line => indent + line));
+            cause = cause.cause;
+        }
+        outputLines.push(dim(causeErrorLines.join('\n')));
+    }
+    outputLines.push('', '');
+    stderr(outputLines.join('\n'));
+    if (!recover)
+        process$1.exit(1);
+}
+
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
+function decode(mappings) {
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(';');
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while (reader.pos < semi) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
+                sorted = false;
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                }
+                else {
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
+            else {
+                seg = [genColumn];
+            }
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+function encode(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0)
+            writer.write(semicolon);
+        if (line.length === 0)
+            continue;
+        let genColumn = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (j > 0)
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+                continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4)
+                continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+
+	has(n) {
+		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+	}
+}
+
+let Chunk$1 = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+
+		this.intro = '';
+		this.outro = '';
+
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+
+		{
+			this.previous = null;
+			this.next = null;
+		}
+	}
+
+	appendLeft(content) {
+		this.outro += content;
+	}
+
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+
+		return chunk;
+	}
+
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = '';
+			this.outro = '';
+		}
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	}
+
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
+	split(index) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+
+		this.original = originalBefore;
+
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = '';
+
+		this.end = index;
+
+		if (this.edited) {
+			// after split we should save the edit content record into the correct chunk
+			// to make sure sourcemap correct
+			// For example:
+			// '  test'.trim()
+			//     split   -> '  ' + 'test'
+			//   ✔️ edit    -> '' + 'test'
+			//   ✖️ edit    -> 'test' + '' 
+			// TODO is this block necessary?...
+			newChunk.edit('', false);
+			this.content = '';
+		} else {
+			this.content = originalBefore;
+		}
+
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+
+		return newChunk;
+	}
+
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit('', undefined, true);
+				if (this.edited) {
+					// save the change, if it has been edited
+					this.edit(trimmed, this.storeName, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.intro = this.intro.replace(rx, '');
+			if (this.intro.length) return true;
+		}
+	}
+
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) {
+					// save the change, if it has been edited
+					newChunk.edit(trimmed, this.storeName, true);
+				}
+				this.edit('', undefined, true);
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.outro = this.outro.replace(rx, '');
+			if (this.outro.length) return true;
+		}
+	}
+};
+
+function getBtoa() {
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
+}
+
+const btoa = /*#__PURE__*/ getBtoa();
+
+class SourceMap {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+	}
+}
+
+function guessIndent(code) {
+	const lines = code.split('\n');
+
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+	if (tabbed.length === 0 && spaced.length === 0) {
+		return null;
+	}
+
+	// More lines tabbed than spaced? Assume tabs, and
+	// default to tabs in the case of a tie (or nothing
+	// to go on)
+	if (tabbed.length >= spaced.length) {
+		return '\t';
+	}
+
+	// Otherwise, we need to guess the multiple
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+
+	return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+
+	fromParts.pop(); // get dirname
+
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = '..';
+	}
+
+	return fromParts.concat(toParts).join('/');
+}
+
+const toString = Object.prototype.toString;
+
+function isObject(thing) {
+	return toString.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+	const originalLines = source.split('\n');
+	const lineOffsets = [];
+
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
+		}
+		const line = i - 1;
+		const column = index - lineOffsets[line];
+		return { line, column };
+	};
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
+			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+			if (nameIndex >= 0) {
+				segment.push(nameIndex);
+			}
+			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+
+		this.pending = null;
+	}
+
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
+
+		while (originalCharIndex < chunk.end) {
+			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+				if (this.hires === 'boundary') {
+					// in hires "boundary", group segments per word boundary than per char
+					if (wordRegex.test(original[originalCharIndex])) {
+						// for first char in the boundary found, start the boundary by pushing a segment
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						// for non-word char, end the boundary by pushing a segment
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+				} else {
+					this.rawSegments.push(segment);
+				}
+			}
+
+			if (original[originalCharIndex] === '\n') {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+			} else {
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+
+			originalCharIndex += 1;
+		}
+
+		this.pending = null;
+	}
+
+	advance(str) {
+		if (!str) return;
+
+		const lines = str.split('\n');
+
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+}
+
+const n = '\n';
+
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false,
+};
+
+class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk$1(0, string.length, string);
+
+		Object.defineProperties(this, {
+			original: { writable: true, value: string },
+			outro: { writable: true, value: '' },
+			intro: { writable: true, value: '' },
+			firstChunk: { writable: true, value: chunk },
+			lastChunk: { writable: true, value: chunk },
+			lastSearchedChunk: { writable: true, value: chunk },
+			byStart: { writable: true, value: {} },
+			byEnd: { writable: true, value: {} },
+			filename: { writable: true, value: options.filename },
+			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+			sourcemapLocations: { writable: true, value: new BitSet() },
+			storedNames: { writable: true, value: {} },
+			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
+		});
+
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+
+	append(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.outro += content;
+		return this;
+	}
+
+	appendLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.appendLeft(content);
+		} else {
+			this.intro += content;
+		}
+		return this;
+	}
+
+	appendRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.appendRight(content);
+		} else {
+			this.outro += content;
+		}
+		return this;
+	}
+
+	clone() {
+		const cloned = new MagicString(this.original, { filename: this.filename });
+
+		let originalChunk = this.firstChunk;
+		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+
+				clonedChunk = nextClonedChunk;
+			}
+
+			originalChunk = nextOriginalChunk;
+		}
+
+		cloned.lastChunk = clonedChunk;
+
+		if (this.indentExclusionRanges) {
+			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		}
+
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+
+		return cloned;
+	}
+
+	generateDecodedMap(options) {
+		options = options || {};
+
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+
+		const locate = getLocator(this.original);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+
+			if (chunk.edited) {
+				mappings.addEdit(
+					sourceIndex,
+					chunk.content,
+					loc,
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
+				);
+			} else {
+				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			}
+
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? '\t' : this.indentStr;
+	}
+
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = undefined;
+		}
+
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
+
+		if (indentStr === '') return this; // noop
+
+		options = options || {};
+
+		// Process exclusion ranges
+		const isExcluded = {};
+
+		if (options.exclude) {
+			const exclusions =
+				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+			exclusions.forEach((exclusion) => {
+				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+					isExcluded[i] = true;
+				}
+			});
+		}
+
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+
+		this.intro = this.intro.replace(pattern, replacer);
+
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+
+		while (chunk) {
+			const end = chunk.end;
+
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+
+					if (chunk.content.length) {
+						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					}
+				}
+			} else {
+				charIndex = chunk.start;
+
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+
+						if (char === '\n') {
+							shouldIndentNextCharacter = true;
+						} else if (char !== '\r' && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+
+							if (charIndex === chunk.start) {
+								chunk.prependRight(indentStr);
+							} else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+
+					charIndex += 1;
+				}
+			}
+
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+
+		this.outro = this.outro.replace(pattern, replacer);
+
+		return this;
+	}
+
+	insert() {
+		throw new Error(
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+		);
+	}
+
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn(
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft(index, content);
+	}
+
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn(
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertRight = true;
+		}
+
+		return this.prependRight(index, content);
+	}
+
+	move(start, end, index) {
+		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+		this._split(start);
+		this._split(end);
+		this._split(index);
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+
+		first.previous = newLeft;
+		last.next = newRight || null;
+
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
+		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (end > this.original.length) throw new Error('end is out of bounds');
+		if (start === end)
+			throw new Error(
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+			);
+
+		this._split(start);
+		this._split(end);
+
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn(
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+				); // eslint-disable-line no-console
+				warned.storeName = true;
+			}
+
+			options = { storeName: true };
+		}
+		const storeName = options !== undefined ? options.storeName : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
+
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true,
+			});
+		}
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) {
+					throw new Error('Cannot overwrite across a split point');
+				}
+				chunk = chunk.next;
+				chunk.edit('', false);
+			}
+
+			first.edit(content, storeName, !overwrite);
+		} else {
+			// must be inserting at the end
+			const newChunk = new Chunk$1(start, end, '').edit(content, storeName);
+
+			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+
+	prepend(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.intro = content + this.intro;
+		return this;
+	}
+
+	prependLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.prependLeft(content);
+		} else {
+			this.intro = content + this.intro;
+		}
+		return this;
+	}
+
+	prependRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.prependRight(content);
+		} else {
+			this.outro = content + this.outro;
+		}
+		return this;
+	}
+
+	remove(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit('');
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	reset(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while ((chunk = chunk.previous));
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return '';
+	}
+
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while ((chunk = chunk.previous));
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+
+	slice(start = 0, end = this.original.length) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		let result = '';
+
+		// find start chunk
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			// found end chunk before start
+			if (chunk.start < end && chunk.end >= end) {
+				return result;
+			}
+
+			chunk = chunk.next;
+		}
+
+		if (chunk && chunk.edited && chunk.start !== start)
+			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+				result += chunk.intro;
+			}
+
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end)
+				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+			result += chunk.content.slice(sliceStart, sliceEnd);
+
+			if (chunk.outro && (!containsEnd || chunk.end === end)) {
+				result += chunk.outro;
+			}
+
+			if (containsEnd) {
+				break;
+			}
+
+			chunk = chunk.next;
+		}
+
+		return result;
+	}
+
+	// TODO deprecate this? not really very useful
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+
+		return clone;
+	}
+
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+
+		let chunk = this.lastSearchedChunk;
+		const searchForward = index > chunk.end;
+
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+		}
+	}
+
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			// zero-length edited chunks are a special case (overlapping replacements)
+			const loc = getLocator(this.original)(index);
+			throw new Error(
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+			);
+		}
+
+		const newChunk = chunk.split(index);
+
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+
+	toString() {
+		let str = this.intro;
+
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+
+		return str + this.outro;
+	}
+
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do {
+			if (
+				(chunk.intro.length && chunk.intro.trim()) ||
+				(chunk.content.length && chunk.content.trim()) ||
+				(chunk.outro.length && chunk.outro.trim())
+			)
+				return false;
+		} while ((chunk = chunk.next));
+		return true;
+	}
+
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		} while ((chunk = chunk.next));
+		return length;
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		let chunk = this.lastChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+
+			// if chunk was trimmed, we have a new lastChunk
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) {
+					this.lastChunk = chunk.next;
+				}
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		let chunk = this.firstChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+
+			if (chunk.end !== end) {
+				// special case...
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === 'string') {
+				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+					if (i === '$') return '$';
+					if (i === '&') return match[0];
+					const num = +i;
+					if (num < match.length) return match[+i];
+					return `$${i}`;
+				});
+			} else {
+				return replacement(...match, match.index, str, match.groups);
+			}
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while ((match = re.exec(str))) {
+				matches.push(match);
+			}
+			return matches;
+		}
+		if (searchValue.global) {
+			const matches = matchAll(searchValue, this.original);
+			matches.forEach((match) => {
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
+					this.overwrite(
+						match.index,
+						match.index + match[0].length,
+						replacement
+					);
+				}
+			}
+		}
+		return this;
+	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+}
+
+const hasOwnProp = Object.prototype.hasOwnProperty;
+
+let Bundle$1 = class Bundle {
+	constructor(options = {}) {
+		this.intro = options.intro || '';
+		this.separator = options.separator !== undefined ? options.separator : '\n';
+		this.sources = [];
+		this.uniqueSources = [];
+		this.uniqueSourceIndexByFilename = {};
+	}
+
+	addSource(source) {
+		if (source instanceof MagicString) {
+			return this.addSource({
+				content: source,
+				filename: source.filename,
+				separator: this.separator,
+			});
+		}
+
+		if (!isObject(source) || !source.content) {
+			throw new Error(
+				'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`',
+			);
+		}
+
+		['filename', 'ignoreList', 'indentExclusionRanges', 'separator'].forEach((option) => {
+			if (!hasOwnProp.call(source, option)) source[option] = source.content[option];
+		});
+
+		if (source.separator === undefined) {
+			// TODO there's a bunch of this sort of thing, needs cleaning up
+			source.separator = this.separator;
+		}
+
+		if (source.filename) {
+			if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
+				this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
+				this.uniqueSources.push({ filename: source.filename, content: source.content.original });
+			} else {
+				const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
+				if (source.content.original !== uniqueSource.content) {
+					throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
+				}
+			}
+		}
+
+		this.sources.push(source);
+		return this;
+	}
+
+	append(str, options) {
+		this.addSource({
+			content: new MagicString(str),
+			separator: (options && options.separator) || '',
+		});
+
+		return this;
+	}
+
+	clone() {
+		const bundle = new Bundle({
+			intro: this.intro,
+			separator: this.separator,
+		});
+
+		this.sources.forEach((source) => {
+			bundle.addSource({
+				filename: source.filename,
+				content: source.content.clone(),
+				separator: source.separator,
+			});
+		});
+
+		return bundle;
+	}
+
+	generateDecodedMap(options = {}) {
+		const names = [];
+		let x_google_ignoreList = undefined;
+		this.sources.forEach((source) => {
+			Object.keys(source.content.storedNames).forEach((name) => {
+				if (!~names.indexOf(name)) names.push(name);
+			});
+		});
+
+		const mappings = new Mappings(options.hires);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.sources.forEach((source, i) => {
+			if (i > 0) {
+				mappings.advance(this.separator);
+			}
+
+			const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
+			const magicString = source.content;
+			const locate = getLocator(magicString.original);
+
+			if (magicString.intro) {
+				mappings.advance(magicString.intro);
+			}
+
+			magicString.firstChunk.eachNext((chunk) => {
+				const loc = locate(chunk.start);
+
+				if (chunk.intro.length) mappings.advance(chunk.intro);
+
+				if (source.filename) {
+					if (chunk.edited) {
+						mappings.addEdit(
+							sourceIndex,
+							chunk.content,
+							loc,
+							chunk.storeName ? names.indexOf(chunk.original) : -1,
+						);
+					} else {
+						mappings.addUneditedChunk(
+							sourceIndex,
+							chunk,
+							magicString.original,
+							loc,
+							magicString.sourcemapLocations,
+						);
+					}
+				} else {
+					mappings.advance(chunk.content);
+				}
+
+				if (chunk.outro.length) mappings.advance(chunk.outro);
+			});
+
+			if (magicString.outro) {
+				mappings.advance(magicString.outro);
+			}
+
+			if (source.ignoreList && sourceIndex !== -1) {
+				if (x_google_ignoreList === undefined) {
+					x_google_ignoreList = [];
+				}
+				x_google_ignoreList.push(sourceIndex);
+			}
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: this.uniqueSources.map((source) => {
+				return options.file ? getRelativePath(options.file, source.filename) : source.filename;
+			}),
+			sourcesContent: this.uniqueSources.map((source) => {
+				return options.includeContent ? source.content : null;
+			}),
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	getIndentString() {
+		const indentStringCounts = {};
+
+		this.sources.forEach((source) => {
+			const indentStr = source.content._getRawIndentString();
+
+			if (indentStr === null) return;
+
+			if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
+			indentStringCounts[indentStr] += 1;
+		});
+
+		return (
+			Object.keys(indentStringCounts).sort((a, b) => {
+				return indentStringCounts[a] - indentStringCounts[b];
+			})[0] || '\t'
+		);
+	}
+
+	indent(indentStr) {
+		if (!arguments.length) {
+			indentStr = this.getIndentString();
+		}
+
+		if (indentStr === '') return this; // noop
+
+		let trailingNewline = !this.intro || this.intro.slice(-1) === '\n';
+
+		this.sources.forEach((source, i) => {
+			const separator = source.separator !== undefined ? source.separator : this.separator;
+			const indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator));
+
+			source.content.indent(indentStr, {
+				exclude: source.indentExclusionRanges,
+				indentStart, //: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
+			});
+
+			trailingNewline = source.content.lastChar() === '\n';
+		});
+
+		if (this.intro) {
+			this.intro =
+				indentStr +
+				this.intro.replace(/^[^\n]/gm, (match, index) => {
+					return index > 0 ? indentStr + match : match;
+				});
+		}
+
+		return this;
+	}
+
+	prepend(str) {
+		this.intro = str + this.intro;
+		return this;
+	}
+
+	toString() {
+		const body = this.sources
+			.map((source, i) => {
+				const separator = source.separator !== undefined ? source.separator : this.separator;
+				const str = (i > 0 ? separator : '') + source.content.toString();
+
+				return str;
+			})
+			.join('');
+
+		return this.intro + body;
+	}
+
+	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
+		if (this.sources.some((source) => !source.content.isEmpty())) return false;
+		return true;
+	}
+
+	length() {
+		return this.sources.reduce(
+			(length, source) => length + source.content.length(),
+			this.intro.length,
+		);
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimStart(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+		this.intro = this.intro.replace(rx, '');
+
+		if (!this.intro) {
+			let source;
+			let i = 0;
+
+			do {
+				source = this.sources[i++];
+				if (!source) {
+					break;
+				}
+			} while (!source.content.trimStartAborted(charType));
+		}
+
+		return this;
+	}
+
+	trimEnd(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		let source;
+		let i = this.sources.length - 1;
+
+		do {
+			source = this.sources[i--];
+			if (!source) {
+				this.intro = this.intro.replace(rx, '');
+				break;
+			}
+		} while (!source.content.trimEndAborted(charType));
+
+		return this;
+	}
+};
+
+function treeshakeNode(node, code, start, end) {
+    code.remove(start, end);
+    node.removeAnnotations(code);
+}
+
+const NO_SEMICOLON = { isNoStatement: true };
+// This assumes there are only white-space and comments between start and the string we are looking for
+function findFirstOccurrenceOutsideComment(code, searchString, start = 0) {
+    let searchPos, charCodeAfterSlash;
+    searchPos = code.indexOf(searchString, start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start >= searchPos)
+            return searchPos;
+        charCodeAfterSlash = code.charCodeAt(++start);
+        ++start;
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        start =
+            charCodeAfterSlash === 47 /*"/"*/
+                ? code.indexOf('\n', start) + 1
+                : code.indexOf('*/', start) + 2;
+        if (start > searchPos) {
+            searchPos = code.indexOf(searchString, start);
+        }
+    }
+}
+const NON_WHITESPACE = /\S/g;
+function findNonWhiteSpace(code, index) {
+    NON_WHITESPACE.lastIndex = index;
+    const result = NON_WHITESPACE.exec(code);
+    return result.index;
+}
+const WHITESPACE = /\s/;
+function findLastWhiteSpaceReverse(code, start, end) {
+    while (true) {
+        if (start >= end) {
+            return end;
+        }
+        if (WHITESPACE.test(code[end - 1])) {
+            end--;
+        }
+        else {
+            return end;
+        }
+    }
+}
+// This assumes "code" only contains white-space and comments
+// Returns position of line-comment if applicable
+function findFirstLineBreakOutsideComment(code) {
+    let lineBreakPos, charCodeAfterSlash, start = 0;
+    lineBreakPos = code.indexOf('\n', start);
+    while (true) {
+        start = code.indexOf('/', start);
+        if (start === -1 || start > lineBreakPos)
+            return [lineBreakPos, lineBreakPos + 1];
+        // With our assumption, '/' always starts a comment. Determine comment type:
+        charCodeAfterSlash = code.charCodeAt(start + 1);
+        if (charCodeAfterSlash === 47 /*"/"*/)
+            return [start, lineBreakPos + 1];
+        start = code.indexOf('*/', start + 2) + 2;
+        if (start > lineBreakPos) {
+            lineBreakPos = code.indexOf('\n', start);
+        }
+    }
+}
+function renderStatementList(statements, code, start, end, options) {
+    let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
+    let nextNode = statements[0];
+    let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
+    if (nextNodeNeedsBoundaries) {
+        nextNodeStart =
+            start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start))[1];
+    }
+    for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
+        currentNode = nextNode;
+        currentNodeStart = nextNodeStart;
+        currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
+        nextNode = statements[nextIndex];
+        nextNodeNeedsBoundaries =
+            nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
+        if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
+            nextNodeStart =
+                currentNode.end +
+                    findFirstLineBreakOutsideComment(code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start))[1];
+            if (currentNode.included) {
+                if (currentNodeNeedsBoundaries) {
+                    currentNode.render(code, options, {
+                        end: nextNodeStart,
+                        start: currentNodeStart
+                    });
+                }
+                else {
+                    currentNode.render(code, options);
+                }
+            }
+            else {
+                treeshakeNode(currentNode, code, currentNodeStart, nextNodeStart);
+            }
+        }
+        else {
+            currentNode.render(code, options);
+        }
+    }
+}
+// This assumes that the first character is not part of the first node
+function getCommaSeparatedNodesWithBoundaries(nodes, code, start, end) {
+    const splitUpNodes = [];
+    let node, nextNodeStart, contentEnd, char;
+    let separator = start - 1;
+    for (const nextNode of nodes) {
+        if (node !== undefined) {
+            separator =
+                node.end +
+                    findFirstOccurrenceOutsideComment(code.original.slice(node.end, nextNode.start), ',');
+        }
+        nextNodeStart = contentEnd =
+            separator +
+                1 +
+                findFirstLineBreakOutsideComment(code.original.slice(separator + 1, nextNode.start))[1];
+        while (((char = code.original.charCodeAt(nextNodeStart)),
+            char === 32 /*" "*/ || char === 9 /*"\t"*/ || char === 10 /*"\n"*/ || char === 13) /*"\r"*/)
+            nextNodeStart++;
+        if (node !== undefined) {
+            splitUpNodes.push({
+                contentEnd,
+                end: nextNodeStart,
+                node,
+                separator,
+                start
+            });
+        }
+        node = nextNode;
+        start = nextNodeStart;
+    }
+    splitUpNodes.push({
+        contentEnd: end,
+        end,
+        node: node,
+        separator: null,
+        start
+    });
+    return splitUpNodes;
+}
+// This assumes there are only white-space and comments between start and end
+function removeLineBreaks(code, start, end) {
+    while (true) {
+        const [removeStart, removeEnd] = findFirstLineBreakOutsideComment(code.original.slice(start, end));
+        if (removeStart === -1) {
+            break;
+        }
+        code.remove(start + removeStart, (start += removeEnd));
+    }
+}
+
+function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
+    if (exportedVariables.length === 1 &&
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        const variable = exportedVariables[0];
+        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
+    }
+    else {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
+        }
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
+    }
+}
+// This is only invoked if there is exactly one export name
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
+    code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getDirectReturnIifeLeft } = options.snippets;
+    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getPropertyAccess } = options.snippets;
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const { _ } = options.snippets;
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
+
+/**
+ *
+ * @param {NodeWithPropertyDefinition} node
+ * @param {NodeWithPropertyDefinition} parent
+ * @returns {boolean}
+ */
+function is_reference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
+
+	if (node.type === 'Identifier') {
+		if (!parent) return true;
+
+		switch (parent.type) {
+			// disregard `bar` in `foo.bar`
+			case 'MemberExpression': return parent.computed || node === parent.object;
+
+			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+			case 'MethodDefinition': return parent.computed;
+
+			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+			case 'PropertyDefinition': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+			case 'Property': return parent.computed || node === parent.value;
+
+			// disregard the `bar` in `export { foo as bar }` or
+			// the foo in `import { foo as bar }`
+			case 'ExportSpecifier':
+			case 'ImportSpecifier': return node === parent.local;
+
+			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+			case 'LabeledStatement':
+			case 'BreakStatement':
+			case 'ContinueStatement': return false;
+			default: return true;
+		}
+	}
+
+	return false;
+}
+
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
+        }
+        currentFunctions[PureFunctionKey] = true;
+    }
+    return pureFunctions;
+};
+
+const UnknownKey = Symbol('Unknown Key');
+const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
+const UnknownInteger = Symbol('Unknown Integer');
+const SymbolToStringTag = Symbol('Symbol.toStringTag');
+const EMPTY_PATH = [];
+const UNKNOWN_PATH = [UnknownKey];
+// For deoptimizations, this means we are modifying an unknown property but did
+// not lose track of the object or are creating a setter/getter;
+// For assignment effects it means we do not check for setter/getter effects
+// but only if something is mutated that is included, which is relevant for
+// Object.defineProperty
+const UNKNOWN_NON_ACCESSOR_PATH = [UnknownNonAccessorKey];
+const UNKNOWN_INTEGER_PATH = [UnknownInteger];
+const EntitiesKey = Symbol('Entities');
+class PathTracker {
+    constructor() {
+        this.entityPaths = Object.create(null, {
+            [EntitiesKey]: { value: new Set() }
+        });
+    }
+    trackEntityAtPathAndGetIfTracked(path, entity) {
+        const trackedEntities = this.getEntities(path);
+        if (trackedEntities.has(entity))
+            return true;
+        trackedEntities.add(entity);
+        return false;
+    }
+    withTrackedEntityAtPath(path, entity, onUntracked, returnIfTracked) {
+        const trackedEntities = this.getEntities(path);
+        if (trackedEntities.has(entity))
+            return returnIfTracked;
+        trackedEntities.add(entity);
+        const result = onUntracked();
+        trackedEntities.delete(entity);
+        return result;
+    }
+    getEntities(path) {
+        let currentPaths = this.entityPaths;
+        for (const pathSegment of path) {
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Set() } });
+        }
+        return currentPaths[EntitiesKey];
+    }
+}
+const SHARED_RECURSION_TRACKER = new PathTracker();
+class DiscriminatedPathTracker {
+    constructor() {
+        this.entityPaths = Object.create(null, {
+            [EntitiesKey]: { value: new Map() }
+        });
+    }
+    trackEntityAtPathAndGetIfTracked(path, discriminator, entity) {
+        let currentPaths = this.entityPaths;
+        for (const pathSegment of path) {
+            currentPaths = currentPaths[pathSegment] =
+                currentPaths[pathSegment] ||
+                    Object.create(null, { [EntitiesKey]: { value: new Map() } });
+        }
+        const trackedEntities = getOrCreate(currentPaths[EntitiesKey], discriminator, (getNewSet));
+        if (trackedEntities.has(entity))
+            return true;
+        trackedEntities.add(entity);
+        return false;
+    }
+}
+
+function isFlagSet(flags, flag) {
+    return (flags & flag) !== 0;
+}
+function setFlag(flags, flag, value) {
+    return (flags & ~flag) | (-value & flag);
+}
+
+const UnknownValue = Symbol('Unknown Value');
+const UnknownTruthyValue = Symbol('Unknown Truthy Value');
+class ExpressionEntity {
+    constructor() {
+        this.flags = 0;
+    }
+    get included() {
+        return isFlagSet(this.flags, 1 /* Flag.included */);
+    }
+    set included(value) {
+        this.flags = setFlag(this.flags, 1 /* Flag.included */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, _path, _recursionTracker) {
+        deoptimizeInteraction(interaction);
+    }
+    deoptimizePath(_path) { }
+    /**
+     * If possible it returns a stringifyable literal value for this node that
+     * can be used for inlining or comparing values. Otherwise, it should return
+     * UnknownValue.
+     */
+    getLiteralValueAtPath(_path, _recursionTracker, _origin) {
+        return UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(_path, _interaction, _recursionTracker, _origin) {
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
+        return true;
+    }
+    include(_context, _includeChildrenRecursively, _options) {
+        this.included = true;
+    }
+    includeCallArguments(context, parameters) {
+        for (const argument of parameters) {
+            argument.include(context, false);
+        }
+    }
+    shouldBeIncluded(_context) {
+        return true;
+    }
+}
+const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
+})();
+const UNKNOWN_RETURN_EXPRESSION = [
+    UNKNOWN_EXPRESSION,
+    false
+];
+const deoptimizeInteraction = (interaction) => {
+    for (const argument of interaction.args) {
+        argument?.deoptimizePath(UNKNOWN_PATH);
+    }
+};
+
+const INTERACTION_ACCESSED = 0;
+const INTERACTION_ASSIGNED = 1;
+const INTERACTION_CALLED = 2;
+const NODE_INTERACTION_UNKNOWN_ACCESS = {
+    args: [null],
+    type: INTERACTION_ACCESSED
+};
+const NODE_INTERACTION_UNKNOWN_ASSIGNMENT = {
+    args: [null, UNKNOWN_EXPRESSION],
+    type: INTERACTION_ASSIGNED
+};
+// While this is technically a call without arguments, we can compare against
+// this reference in places where precise values or this argument would make a
+// difference
+const NODE_INTERACTION_UNKNOWN_CALL = {
+    args: [null],
+    type: INTERACTION_CALLED,
+    withNew: false
+};
+
+class Variable extends ExpressionEntity {
+    markReassigned() {
+        this.isReassigned = true;
+    }
+    constructor(name) {
+        super();
+        this.name = name;
+        this.alwaysRendered = false;
+        this.forbiddenNames = null;
+        this.globalName = null;
+        this.initReached = false;
+        this.isId = false;
+        this.kind = null;
+        this.renderBaseName = null;
+        this.renderName = null;
+        this.isReassigned = false;
+        this.onlyFunctionCallUsed = true;
+    }
+    /**
+     * Binds identifiers that reference this variable to this variable.
+     * Necessary to be able to change variable names.
+     */
+    addReference(_identifier) { }
+    /**
+     * Check if the identifier variable is only used as function call
+     * @returns true if the variable is only used as function call
+     */
+    getOnlyFunctionCallUsed() {
+        return this.onlyFunctionCallUsed;
+    }
+    /**
+     * Collect the places where the identifier variable is used
+     * @param usedPlace Where the variable is used
+     */
+    addUsedPlace(usedPlace) {
+        const isFunctionCall = usedPlace.parent.type === parseAst_js.CallExpression &&
+            usedPlace.parent.callee === usedPlace;
+        if (!isFunctionCall && usedPlace.parent.type !== parseAst_js.ExportDefaultDeclaration) {
+            this.onlyFunctionCallUsed = false;
+        }
+    }
+    /**
+     * Prevent this variable from being renamed to this name to avoid name
+     * collisions
+     */
+    forbidName(name) {
+        (this.forbiddenNames ||= new Set()).add(name);
+    }
+    getBaseVariableName() {
+        return (this.renderedLikeHoisted?.getBaseVariableName() ||
+            this.renderBaseName ||
+            this.renderName ||
+            this.name);
+    }
+    getName(getPropertyAccess, useOriginalName) {
+        if (this.globalName) {
+            return this.globalName;
+        }
+        if (useOriginalName?.(this)) {
+            return this.name;
+        }
+        if (this.renderedLikeHoisted) {
+            return this.renderedLikeHoisted.getName(getPropertyAccess, useOriginalName);
+        }
+        const name = this.renderName || this.name;
+        return this.renderBaseName ? `${this.renderBaseName}${getPropertyAccess(name)}` : name;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }, _context) {
+        return type !== INTERACTION_ACCESSED || path.length > 0;
+    }
+    /**
+     * Marks this variable as being part of the bundle, which is usually the case
+     * when one of its identifiers becomes part of the bundle. Returns true if it
+     * has not been included previously. Once a variable is included, it should
+     * take care all its declarations are included.
+     */
+    include() {
+        this.included = true;
+        this.renderedLikeHoisted?.include();
+    }
+    /**
+     * Links the rendered name of this variable to another variable and includes
+     * this variable if the other variable is included.
+     */
+    renderLikeHoisted(variable) {
+        this.renderedLikeHoisted = variable;
+    }
+    markCalledFromTryStatement() { }
+    setRenderNames(baseName, name) {
+        this.renderBaseName = baseName;
+        this.renderName = name;
+    }
+}
+
+class ExternalVariable extends Variable {
+    constructor(module, name) {
+        super(name);
+        this.referenced = false;
+        this.module = module;
+        this.isNamespace = name === '*';
+    }
+    addReference(identifier) {
+        this.referenced = true;
+        if (this.name === 'default' || this.name === '*') {
+            this.module.suggestName(identifier.name);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.isNamespace ? 1 : 0);
+    }
+    include() {
+        super.include();
+        this.module.used = true;
+    }
+}
+
+function cacheObjectGetters(object, getterProperties) {
+    for (const property of getterProperties) {
+        const propertyGetter = Object.getOwnPropertyDescriptor(object, property).get;
+        Object.defineProperty(object, property, {
+            get() {
+                const value = propertyGetter.call(object);
+                // This replaces the getter with a fixed value for subsequent calls
+                Object.defineProperty(object, property, { value });
+                return value;
+            }
+        });
+    }
+}
+
+const RESERVED_NAMES = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'NaN',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield'
+]);
+
+const illegalCharacters = /[^\w$]/g;
+const startsWithDigit = (value) => /\d/.test(value[0]);
+const needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES.has(value) || value === 'arguments';
+function isLegal(value) {
+    if (needsEscape(value)) {
+        return false;
+    }
+    return !illegalCharacters.test(value);
+}
+function makeLegal(value) {
+    value = value
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(illegalCharacters, '_');
+    if (needsEscape(value))
+        value = `_${value}`;
+    return value || '_';
+}
+const VALID_IDENTIFIER_REGEXP = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+const NUMBER_REGEXP = /^(?:0|[1-9]\d*)$/;
+function stringifyObjectKeyIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key === '__proto__' ? '["__proto__"]' : key;
+    }
+    if (NUMBER_REGEXP.test(key) && +key <= Number.MAX_SAFE_INTEGER) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+function stringifyIdentifierIfNeeded(key) {
+    if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+
+class ExternalModule {
+    constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath, attributes) {
+        this.options = options;
+        this.id = id;
+        this.renormalizeRenderPath = renormalizeRenderPath;
+        this.dynamicImporters = [];
+        this.execIndex = Infinity;
+        this.exportedVariables = new Map();
+        this.importers = [];
+        this.reexported = false;
+        this.used = false;
+        this.declarations = new Map();
+        this.mostCommonSuggestion = 0;
+        this.nameSuggestions = new Map();
+        this.suggestedVariableName = makeLegal(id.split(/[/\\]/).pop());
+        const { importers, dynamicImporters } = this;
+        this.info = {
+            ast: null,
+            attributes,
+            code: null,
+            dynamicallyImportedIdResolutions: parseAst_js.EMPTY_ARRAY,
+            dynamicallyImportedIds: parseAst_js.EMPTY_ARRAY,
+            get dynamicImporters() {
+                return dynamicImporters.sort();
+            },
+            exportedBindings: null,
+            exports: null,
+            hasDefaultExport: null,
+            id,
+            implicitlyLoadedAfterOneOf: parseAst_js.EMPTY_ARRAY,
+            implicitlyLoadedBefore: parseAst_js.EMPTY_ARRAY,
+            importedIdResolutions: parseAst_js.EMPTY_ARRAY,
+            importedIds: parseAst_js.EMPTY_ARRAY,
+            get importers() {
+                return importers.sort();
+            },
+            isEntry: false,
+            isExternal: true,
+            isIncluded: null,
+            meta,
+            moduleSideEffects,
+            syntheticNamedExports: false
+        };
+    }
+    cacheInfoGetters() {
+        cacheObjectGetters(this.info, ['dynamicImporters', 'importers']);
+    }
+    getVariableForExportName(name) {
+        const declaration = this.declarations.get(name);
+        if (declaration)
+            return [declaration];
+        const externalVariable = new ExternalVariable(this, name);
+        this.declarations.set(name, externalVariable);
+        this.exportedVariables.set(externalVariable, name);
+        return [externalVariable];
+    }
+    suggestName(name) {
+        const value = (this.nameSuggestions.get(name) ?? 0) + 1;
+        this.nameSuggestions.set(name, value);
+        if (value > this.mostCommonSuggestion) {
+            this.mostCommonSuggestion = value;
+            this.suggestedVariableName = name;
+        }
+    }
+    warnUnusedImports() {
+        const unused = [...this.declarations]
+            .filter(([name, declaration]) => name !== '*' && !declaration.included && !this.reexported && !declaration.referenced)
+            .map(([name]) => name);
+        if (unused.length === 0)
+            return;
+        const importersSet = new Set();
+        for (const name of unused) {
+            for (const importer of this.declarations.get(name).module.importers) {
+                importersSet.add(importer);
+            }
+        }
+        const importersArray = [...importersSet];
+        this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnusedExternalImports(this.id, unused, importersArray));
+    }
+}
+
+function markModuleAndImpureDependenciesAsExecuted(baseModule) {
+    baseModule.isExecuted = true;
+    const modules = [baseModule];
+    const visitedModules = new Set();
+    for (const module of modules) {
+        for (const dependency of [...module.dependencies, ...module.implicitlyLoadedBefore]) {
+            if (!(dependency instanceof ExternalModule) &&
+                !dependency.isExecuted &&
+                (dependency.info.moduleSideEffects || module.implicitlyLoadedBefore.has(dependency)) &&
+                !visitedModules.has(dependency.id)) {
+                dependency.isExecuted = true;
+                visitedModules.add(dependency.id);
+                modules.push(dependency);
+            }
+        }
+    }
+}
+
+function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
+    return Object.create(inheritedDescriptions, memberDescriptions);
+}
+const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEntity {
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+})();
+const returnsUnknown = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_EXPRESSION
+    }
+};
+const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalBooleanMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsBoolean = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_BOOLEAN
+    }
+};
+const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalNumberMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsNumber = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_NUMBER
+    }
+};
+const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity {
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length === 1) {
+            return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+})();
+const returnsString = {
+    value: {
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const stringReplace = {
+    value: {
+        hasEffectsWhenCalled({ args }, context) {
+            const argument1 = args[2];
+            return (args.length < 3 ||
+                (typeof argument1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
+                    deoptimizeCache() { }
+                }) === 'symbol' &&
+                    argument1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
+        },
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const objectMembers = assembleMemberDescriptions({
+    hasOwnProperty: returnsBoolean,
+    isPrototypeOf: returnsBoolean,
+    propertyIsEnumerable: returnsBoolean,
+    toLocaleString: returnsString,
+    toString: returnsString,
+    valueOf: returnsUnknown
+});
+const literalBooleanMembers = assembleMemberDescriptions({
+    valueOf: returnsBoolean
+}, objectMembers);
+const literalNumberMembers = assembleMemberDescriptions({
+    toExponential: returnsString,
+    toFixed: returnsString,
+    toLocaleString: returnsString,
+    toPrecision: returnsString,
+    valueOf: returnsNumber
+}, objectMembers);
+/**
+ * RegExp are stateful when they have the global or sticky flags set.
+ * But if we actually don't use them, the side effect does not matter.
+ * the check logic in `hasEffectsOnInteractionAtPath`.
+ */
+const literalRegExpMembers = assembleMemberDescriptions({
+    exec: returnsUnknown,
+    test: returnsBoolean
+}, objectMembers);
+const literalStringMembers = assembleMemberDescriptions({
+    anchor: returnsString,
+    at: returnsUnknown,
+    big: returnsString,
+    blink: returnsString,
+    bold: returnsString,
+    charAt: returnsString,
+    charCodeAt: returnsNumber,
+    codePointAt: returnsUnknown,
+    concat: returnsString,
+    endsWith: returnsBoolean,
+    fixed: returnsString,
+    fontcolor: returnsString,
+    fontsize: returnsString,
+    includes: returnsBoolean,
+    indexOf: returnsNumber,
+    italics: returnsString,
+    lastIndexOf: returnsNumber,
+    link: returnsString,
+    localeCompare: returnsNumber,
+    match: returnsUnknown,
+    matchAll: returnsUnknown,
+    normalize: returnsString,
+    padEnd: returnsString,
+    padStart: returnsString,
+    repeat: returnsString,
+    replace: stringReplace,
+    replaceAll: stringReplace,
+    search: returnsNumber,
+    slice: returnsString,
+    small: returnsString,
+    split: returnsUnknown,
+    startsWith: returnsBoolean,
+    strike: returnsString,
+    sub: returnsString,
+    substr: returnsString,
+    substring: returnsString,
+    sup: returnsString,
+    toLocaleLowerCase: returnsString,
+    toLocaleUpperCase: returnsString,
+    toLowerCase: returnsString,
+    toString: returnsString, // overrides the toString() method of the Object object; it does not inherit Object.prototype.toString()
+    toUpperCase: returnsString,
+    trim: returnsString,
+    trimEnd: returnsString,
+    trimLeft: returnsString,
+    trimRight: returnsString,
+    trimStart: returnsString,
+    valueOf: returnsString
+}, objectMembers);
+function getLiteralMembersForValue(value) {
+    if (value instanceof RegExp) {
+        return literalRegExpMembers;
+    }
+    switch (typeof value) {
+        case 'boolean': {
+            return literalBooleanMembers;
+        }
+        case 'number': {
+            return literalNumberMembers;
+        }
+        case 'string': {
+            return literalStringMembers;
+        }
+    }
+    return Object.create(null);
+}
+function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
+    if (typeof memberName !== 'string' || !members[memberName]) {
+        return true;
+    }
+    return members[memberName].hasEffectsWhenCalled?.(interaction, context) || false;
+}
+function getMemberReturnExpressionWhenCalled(members, memberName) {
+    if (typeof memberName !== 'string' || !members[memberName])
+        return UNKNOWN_RETURN_EXPRESSION;
+    return [members[memberName].returns, false];
+}
+
+// This file is generated by scripts/generate-child-node-keys.js.
+// Do not edit this file directly.
+const childNodeKeys = {
+    ArrayExpression: ['elements'],
+    ArrayPattern: ['elements'],
+    ArrowFunctionExpression: ['params', 'body'],
+    AssignmentExpression: ['left', 'right'],
+    AssignmentPattern: ['left', 'right'],
+    AwaitExpression: ['argument'],
+    BinaryExpression: ['left', 'right'],
+    BlockStatement: ['body'],
+    BreakStatement: ['label'],
+    CallExpression: ['callee', 'arguments'],
+    CatchClause: ['param', 'body'],
+    ChainExpression: ['expression'],
+    ClassBody: ['body'],
+    ClassDeclaration: ['decorators', 'id', 'superClass', 'body'],
+    ClassExpression: ['decorators', 'id', 'superClass', 'body'],
+    ConditionalExpression: ['test', 'consequent', 'alternate'],
+    ContinueStatement: ['label'],
+    DebuggerStatement: [],
+    Decorator: ['expression'],
+    DoWhileStatement: ['body', 'test'],
+    EmptyStatement: [],
+    ExportAllDeclaration: ['exported', 'source', 'attributes'],
+    ExportDefaultDeclaration: ['declaration'],
+    ExportNamedDeclaration: ['specifiers', 'source', 'attributes', 'declaration'],
+    ExportSpecifier: ['local', 'exported'],
+    ExpressionStatement: ['expression'],
+    ForInStatement: ['left', 'right', 'body'],
+    ForOfStatement: ['left', 'right', 'body'],
+    ForStatement: ['init', 'test', 'update', 'body'],
+    FunctionDeclaration: ['id', 'params', 'body'],
+    FunctionExpression: ['id', 'params', 'body'],
+    Identifier: [],
+    IfStatement: ['test', 'consequent', 'alternate'],
+    ImportAttribute: ['key', 'value'],
+    ImportDeclaration: ['specifiers', 'source', 'attributes'],
+    ImportDefaultSpecifier: ['local'],
+    ImportExpression: ['source', 'options'],
+    ImportNamespaceSpecifier: ['local'],
+    ImportSpecifier: ['imported', 'local'],
+    JSXAttribute: ['name', 'value'],
+    JSXClosingElement: ['name'],
+    JSXClosingFragment: [],
+    JSXElement: ['openingElement', 'children', 'closingElement'],
+    JSXEmptyExpression: [],
+    JSXExpressionContainer: ['expression'],
+    JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+    JSXIdentifier: [],
+    JSXMemberExpression: ['object', 'property'],
+    JSXNamespacedName: ['namespace', 'name'],
+    JSXOpeningElement: ['name', 'attributes'],
+    JSXOpeningFragment: [],
+    JSXSpreadAttribute: ['argument'],
+    JSXSpreadChild: ['expression'],
+    JSXText: [],
+    LabeledStatement: ['label', 'body'],
+    Literal: [],
+    LogicalExpression: ['left', 'right'],
+    MemberExpression: ['object', 'property'],
+    MetaProperty: ['meta', 'property'],
+    MethodDefinition: ['decorators', 'key', 'value'],
+    NewExpression: ['callee', 'arguments'],
+    ObjectExpression: ['properties'],
+    ObjectPattern: ['properties'],
+    PanicError: [],
+    ParseError: [],
+    PrivateIdentifier: [],
+    Program: ['body'],
+    Property: ['key', 'value'],
+    PropertyDefinition: ['decorators', 'key', 'value'],
+    RestElement: ['argument'],
+    ReturnStatement: ['argument'],
+    SequenceExpression: ['expressions'],
+    SpreadElement: ['argument'],
+    StaticBlock: ['body'],
+    Super: [],
+    SwitchCase: ['test', 'consequent'],
+    SwitchStatement: ['discriminant', 'cases'],
+    TaggedTemplateExpression: ['tag', 'quasi'],
+    TemplateElement: [],
+    TemplateLiteral: ['quasis', 'expressions'],
+    ThisExpression: [],
+    ThrowStatement: ['argument'],
+    TryStatement: ['block', 'handler', 'finalizer'],
+    UnaryExpression: ['argument'],
+    UpdateExpression: ['argument'],
+    VariableDeclaration: ['declarations'],
+    VariableDeclarator: ['id', 'init'],
+    WhileStatement: ['test', 'body'],
+    YieldExpression: ['argument']
+};
+
+function createInclusionContext() {
+    return {
+        brokenFlow: false,
+        hasBreak: false,
+        hasContinue: false,
+        includedCallArguments: new Set(),
+        includedLabels: new Set()
+    };
+}
+function createHasEffectsContext() {
+    return {
+        accessed: new PathTracker(),
+        assigned: new PathTracker(),
+        brokenFlow: false,
+        called: new DiscriminatedPathTracker(),
+        hasBreak: false,
+        hasContinue: false,
+        ignore: {
+            breaks: false,
+            continues: false,
+            labels: new Set(),
+            returnYield: false,
+            this: false
+        },
+        includedLabels: new Set(),
+        instantiated: new DiscriminatedPathTracker(),
+        replacedVariableInits: new Map()
+    };
+}
+
+const INCLUDE_PARAMETERS = 'variables';
+const IS_SKIPPED_CHAIN = Symbol('IS_SKIPPED_CHAIN');
+class NodeBase extends ExpressionEntity {
+    /**
+     * Nodes can apply custom deoptimizations once they become part of the
+     * executed code. To do this, they must initialize this as false, implement
+     * applyDeoptimizations and call this from include and hasEffects if they have
+     * custom handlers
+     */
+    get deoptimized() {
+        return isFlagSet(this.flags, 2 /* Flag.deoptimized */);
+    }
+    set deoptimized(value) {
+        this.flags = setFlag(this.flags, 2 /* Flag.deoptimized */, value);
+    }
+    constructor(parent, parentScope) {
+        super();
+        this.parent = parent;
+        this.scope = parentScope;
+        this.createScope(parentScope);
+    }
+    addExportedVariables(_variables, _exportNamesByVariable) { }
+    /**
+     * Override this to bind assignments to variables and do any initialisations
+     * that require the scopes to be populated with variables.
+     */
+    bind() {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.bind();
+                }
+            }
+            else if (value) {
+                value.bind();
+            }
+        }
+    }
+    /**
+     * Override if this node should receive a different scope than the parent
+     * scope.
+     */
+    createScope(parentScope) {
+        this.scope = parentScope;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child?.hasEffects(context))
+                        return true;
+                }
+            }
+            else if (value.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    hasEffectsAsAssignmentTarget(context, _checkAccess) {
+        return (this.hasEffects(context) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    include(context, includeChildrenRecursively, _options) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.include(context, includeChildrenRecursively);
+                }
+            }
+            else {
+                value.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
+        this.include(context, includeChildrenRecursively);
+    }
+    /**
+     * Override to perform special initialisation steps after the scope is
+     * initialised
+     */
+    initialise() {
+        this.scope.context.magicString.addSourcemapLocation(this.start);
+        this.scope.context.magicString.addSourcemapLocation(this.end);
+    }
+    parseNode(esTreeNode) {
+        for (const [key, value] of Object.entries(esTreeNode)) {
+            // Skip properties defined on the class already.
+            // This way, we can override this function to add custom initialisation and then call super.parseNode
+            // Note: this doesn't skip properties with defined getters/setters which we use to pack wrap booleans
+            // in bitfields. Those are still assigned from the value in the esTreeNode.
+            if (this.hasOwnProperty(key))
+                continue;
+            if (key.charCodeAt(0) === 95 /* _ */) {
+                if (key === parseAst_js.ANNOTATION_KEY) {
+                    this.annotations = value;
+                }
+                else if (key === parseAst_js.INVALID_ANNOTATION_KEY) {
+                    this.invalidAnnotations = value;
+                }
+            }
+            else if (typeof value !== 'object' || value === null) {
+                this[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                this[key] = [];
+                for (const child of value) {
+                    this[key].push(child === null
+                        ? null
+                        : new (this.scope.context.getNodeConstructor(child.type))(this, this.scope).parseNode(child));
+                }
+            }
+            else {
+                this[key] = new (this.scope.context.getNodeConstructor(value.type))(this, this.scope).parseNode(value);
+            }
+        }
+        // extend child keys for unknown node types
+        childNodeKeys[esTreeNode.type] ||= createChildNodeKeysForNode(esTreeNode);
+        this.initialise();
+        return this;
+    }
+    removeAnnotations(code) {
+        if (this.annotations) {
+            for (const annotation of this.annotations) {
+                code.remove(annotation.start, annotation.end);
+            }
+        }
+    }
+    render(code, options) {
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.render(code, options);
+                }
+            }
+            else {
+                value.render(code, options);
+            }
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = { args: [null, value], type: INTERACTION_ASSIGNED };
+    }
+    shouldBeIncluded(context) {
+        return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
+    }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const key of childNodeKeys[this.type]) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child?.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+function createChildNodeKeysForNode(esTreeNode) {
+    return Object.keys(esTreeNode).filter(key => typeof esTreeNode[key] === 'object' && key.charCodeAt(0) !== 95 /* _ */);
+}
+
+class SpreadElement extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 0) {
+            this.argument.deoptimizeArgumentsOnInteractionAtPath(interaction, [UnknownKey, ...path], recursionTracker);
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (this.argument.hasEffects(context) ||
+            (propertyReadSideEffects &&
+                (propertyReadSideEffects === 'always' ||
+                    this.argument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context))));
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        // Only properties of properties of the argument could become subject to reassignment
+        // This will also reassign the return values of iterators
+        this.argument.deoptimizePath([UnknownKey, UnknownKey]);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class Method extends ExpressionEntity {
+    constructor(description) {
+        super();
+        this.description = description;
+    }
+    deoptimizeArgumentsOnInteractionAtPath({ args, type }, path) {
+        if (type === INTERACTION_CALLED && path.length === 0) {
+            if (this.description.mutatesSelfAsArray) {
+                args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+            }
+            if (this.description.mutatesArgs) {
+                for (let index = 1; index < args.length; index++) {
+                    args[index].deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path, { args }) {
+        if (path.length > 0) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return [
+            this.description.returnsPrimitive ||
+                (this.description.returns === 'self'
+                    ? args[0] || UNKNOWN_EXPRESSION
+                    : this.description.returns()),
+            false
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (path.length > (type === INTERACTION_ACCESSED ? 1 : 0)) {
+            return true;
+        }
+        if (type === INTERACTION_CALLED) {
+            const { args } = interaction;
+            if (this.description.mutatesSelfAsArray === true &&
+                args[0]?.hasEffectsOnInteractionAtPath(UNKNOWN_INTEGER_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)) {
+                return true;
+            }
+            if (this.description.callsArgs) {
+                for (const argumentIndex of this.description.callsArgs) {
+                    if (args[argumentIndex + 1]?.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+const METHOD_RETURNS_BOOLEAN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
+    })
+];
+const METHOD_RETURNS_STRING = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_STRING
+    })
+];
+const METHOD_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: false,
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+
+const INTEGER_REG_EXP = /^\d+$/;
+class ObjectEntity extends ExpressionEntity {
+    get hasLostTrack() {
+        return isFlagSet(this.flags, 2048 /* Flag.hasLostTrack */);
+    }
+    set hasLostTrack(value) {
+        this.flags = setFlag(this.flags, 2048 /* Flag.hasLostTrack */, value);
+    }
+    get hasUnknownDeoptimizedInteger() {
+        return isFlagSet(this.flags, 4096 /* Flag.hasUnknownDeoptimizedInteger */);
+    }
+    set hasUnknownDeoptimizedInteger(value) {
+        this.flags = setFlag(this.flags, 4096 /* Flag.hasUnknownDeoptimizedInteger */, value);
+    }
+    get hasUnknownDeoptimizedProperty() {
+        return isFlagSet(this.flags, 8192 /* Flag.hasUnknownDeoptimizedProperty */);
+    }
+    set hasUnknownDeoptimizedProperty(value) {
+        this.flags = setFlag(this.flags, 8192 /* Flag.hasUnknownDeoptimizedProperty */, value);
+    }
+    // If a PropertyMap is used, this will be taken as propertiesAndGettersByKey
+    // and we assume there are no setters or getters
+    constructor(properties, prototypeExpression, immutable = false) {
+        super();
+        this.prototypeExpression = prototypeExpression;
+        this.immutable = immutable;
+        this.additionalExpressionsToBeDeoptimized = new Set();
+        this.allProperties = [];
+        this.deoptimizedPaths = Object.create(null);
+        this.expressionsToBeDeoptimizedByKey = Object.create(null);
+        this.gettersByKey = Object.create(null);
+        this.propertiesAndGettersByKey = Object.create(null);
+        this.propertiesAndSettersByKey = Object.create(null);
+        this.settersByKey = Object.create(null);
+        this.unknownIntegerProps = [];
+        this.unmatchableGetters = [];
+        this.unmatchablePropertiesAndGetters = [];
+        this.unmatchableSetters = [];
+        if (Array.isArray(properties)) {
+            this.buildPropertyMaps(properties);
+        }
+        else {
+            this.propertiesAndGettersByKey = this.propertiesAndSettersByKey = properties;
+            for (const propertiesForKey of Object.values(properties)) {
+                this.allProperties.push(...propertiesForKey);
+            }
+        }
+    }
+    deoptimizeAllProperties(noAccessors) {
+        const isDeoptimized = this.hasLostTrack || this.hasUnknownDeoptimizedProperty;
+        if (noAccessors) {
+            this.hasUnknownDeoptimizedProperty = true;
+        }
+        else {
+            this.hasLostTrack = true;
+        }
+        if (isDeoptimized) {
+            return;
+        }
+        for (const properties of [
+            ...Object.values(this.propertiesAndGettersByKey),
+            ...Object.values(this.settersByKey)
+        ]) {
+            for (const property of properties) {
+                property.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        // While the prototype itself cannot be mutated, each property can
+        this.prototypeExpression?.deoptimizePath([UnknownKey, UnknownKey]);
+        this.deoptimizeCachedEntities();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        const [key, ...subPath] = path;
+        const { args, type } = interaction;
+        if (this.hasLostTrack ||
+            // single paths that are deoptimized will not become getters or setters
+            ((type === INTERACTION_CALLED || path.length > 1) &&
+                (this.hasUnknownDeoptimizedProperty ||
+                    (typeof key === 'string' && this.deoptimizedPaths[key])))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        const [propertiesForExactMatchByKey, relevantPropertiesByKey, relevantUnmatchableProperties] = type === INTERACTION_CALLED || path.length > 1
+            ? [
+                this.propertiesAndGettersByKey,
+                this.propertiesAndGettersByKey,
+                this.unmatchablePropertiesAndGetters
+            ]
+            : type === INTERACTION_ACCESSED
+                ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
+                : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
+        if (typeof key === 'string') {
+            if (propertiesForExactMatchByKey[key]) {
+                const properties = relevantPropertiesByKey[key];
+                if (properties) {
+                    for (const property of properties) {
+                        property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                    }
+                }
+                if (!this.immutable) {
+                    for (const argument of args) {
+                        if (argument) {
+                            this.additionalExpressionsToBeDeoptimized.add(argument);
+                        }
+                    }
+                }
+                return;
+            }
+            for (const property of relevantUnmatchableProperties) {
+                property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+            }
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const property of this.unknownIntegerProps) {
+                    property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                }
+            }
+        }
+        else {
+            for (const properties of [
+                ...Object.values(relevantPropertiesByKey),
+                relevantUnmatchableProperties
+            ]) {
+                for (const property of properties) {
+                    property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+                }
+            }
+            for (const property of this.unknownIntegerProps) {
+                property.deoptimizeArgumentsOnInteractionAtPath(interaction, subPath, recursionTracker);
+            }
+        }
+        if (!this.immutable) {
+            for (const argument of args) {
+                if (argument) {
+                    this.additionalExpressionsToBeDeoptimized.add(argument);
+                }
+            }
+        }
+        this.prototypeExpression?.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeIntegerProperties() {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            this.hasUnknownDeoptimizedInteger) {
+            return;
+        }
+        this.hasUnknownDeoptimizedInteger = true;
+        for (const [key, propertiesAndGetters] of Object.entries(this.propertiesAndGettersByKey)) {
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const property of propertiesAndGetters) {
+                    property.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+        this.deoptimizeCachedIntegerEntities();
+    }
+    // Assumption: If only a specific path is deoptimized, no accessors are created
+    deoptimizePath(path) {
+        if (this.hasLostTrack || this.immutable) {
+            return;
+        }
+        const key = path[0];
+        if (path.length === 1) {
+            if (key === UnknownInteger) {
+                return this.deoptimizeIntegerProperties();
+            }
+            else if (typeof key !== 'string') {
+                return this.deoptimizeAllProperties(key === UnknownNonAccessorKey);
+            }
+            if (!this.deoptimizedPaths[key]) {
+                this.deoptimizedPaths[key] = true;
+                // we only deoptimizeCache exact matches as in all other cases,
+                // we do not return a literal value or return expression
+                const expressionsToBeDeoptimized = this.expressionsToBeDeoptimizedByKey[key];
+                if (expressionsToBeDeoptimized) {
+                    for (const expression of expressionsToBeDeoptimized) {
+                        expression.deoptimizeCache();
+                    }
+                }
+            }
+        }
+        const subPath = path.length === 1 ? UNKNOWN_PATH : path.slice(1);
+        for (const property of typeof key === 'string'
+            ? [
+                ...(this.propertiesAndGettersByKey[key] || this.unmatchablePropertiesAndGetters),
+                ...(this.settersByKey[key] || this.unmatchableSetters)
+            ]
+            : this.allProperties) {
+            property.deoptimizePath(subPath);
+        }
+        this.prototypeExpression?.deoptimizePath(path.length === 1 ? [...path, UnknownKey] : path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length === 0) {
+            return UnknownTruthyValue;
+        }
+        const key = path[0];
+        const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
+        if (expressionAtPath) {
+            return expressionAtPath.getLiteralValueAtPath(path.slice(1), recursionTracker, origin);
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (path.length === 1) {
+            return undefined;
+        }
+        return UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (path.length === 0) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        const [key, ...subPath] = path;
+        const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
+        if (expressionAtPath) {
+            return expressionAtPath.getReturnExpressionWhenCalledAtPath(subPath, interaction, recursionTracker, origin);
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const [key, ...subPath] = path;
+        if (subPath.length > 0 || interaction.type === INTERACTION_CALLED) {
+            const expressionAtPath = this.getMemberExpression(key);
+            if (expressionAtPath) {
+                return expressionAtPath.hasEffectsOnInteractionAtPath(subPath, interaction, context);
+            }
+            if (this.prototypeExpression) {
+                return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            return true;
+        }
+        if (key === UnknownNonAccessorKey)
+            return false;
+        if (this.hasLostTrack)
+            return true;
+        const [propertiesAndAccessorsByKey, accessorsByKey, unmatchableAccessors] = interaction.type === INTERACTION_ACCESSED
+            ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
+            : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
+        if (typeof key === 'string') {
+            if (propertiesAndAccessorsByKey[key]) {
+                const accessors = accessorsByKey[key];
+                if (accessors) {
+                    for (const accessor of accessors) {
+                        if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
+                            return true;
+                    }
+                }
+                return false;
+            }
+            for (const accessor of unmatchableAccessors) {
+                if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            for (const accessors of [...Object.values(accessorsByKey), unmatchableAccessors]) {
+                for (const accessor of accessors) {
+                    if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
+                        return true;
+                }
+            }
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        return false;
+    }
+    buildPropertyMaps(properties) {
+        const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchableGetters, unmatchableSetters } = this;
+        const unmatchablePropertiesAndSetters = [];
+        for (let index = properties.length - 1; index >= 0; index--) {
+            const { key, kind, property } = properties[index];
+            allProperties.push(property);
+            if (typeof key === 'string') {
+                if (kind === 'set') {
+                    if (!propertiesAndSettersByKey[key]) {
+                        propertiesAndSettersByKey[key] = [property, ...unmatchablePropertiesAndSetters];
+                        settersByKey[key] = [property, ...unmatchableSetters];
+                    }
+                }
+                else if (kind === 'get') {
+                    if (!propertiesAndGettersByKey[key]) {
+                        propertiesAndGettersByKey[key] = [property, ...unmatchablePropertiesAndGetters];
+                        gettersByKey[key] = [property, ...unmatchableGetters];
+                    }
+                }
+                else {
+                    if (!propertiesAndSettersByKey[key]) {
+                        propertiesAndSettersByKey[key] = [property, ...unmatchablePropertiesAndSetters];
+                    }
+                    if (!propertiesAndGettersByKey[key]) {
+                        propertiesAndGettersByKey[key] = [property, ...unmatchablePropertiesAndGetters];
+                    }
+                }
+            }
+            else {
+                if (key === UnknownInteger) {
+                    unknownIntegerProps.push(property);
+                    continue;
+                }
+                if (kind === 'set')
+                    unmatchableSetters.push(property);
+                if (kind === 'get')
+                    unmatchableGetters.push(property);
+                if (kind !== 'get')
+                    unmatchablePropertiesAndSetters.push(property);
+                if (kind !== 'set')
+                    unmatchablePropertiesAndGetters.push(property);
+            }
+        }
+    }
+    deoptimizeCachedEntities() {
+        for (const expressionsToBeDeoptimized of Object.values(this.expressionsToBeDeoptimizedByKey)) {
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+        for (const expression of this.additionalExpressionsToBeDeoptimized) {
+            expression.deoptimizePath(UNKNOWN_PATH);
+        }
+    }
+    deoptimizeCachedIntegerEntities() {
+        for (const [key, expressionsToBeDeoptimized] of Object.entries(this.expressionsToBeDeoptimizedByKey)) {
+            if (INTEGER_REG_EXP.test(key)) {
+                for (const expression of expressionsToBeDeoptimized) {
+                    expression.deoptimizeCache();
+                }
+            }
+        }
+        for (const expression of this.additionalExpressionsToBeDeoptimized) {
+            expression.deoptimizePath(UNKNOWN_INTEGER_PATH);
+        }
+    }
+    getMemberExpression(key) {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            typeof key !== 'string' ||
+            (this.hasUnknownDeoptimizedInteger && INTEGER_REG_EXP.test(key)) ||
+            this.deoptimizedPaths[key]) {
+            return UNKNOWN_EXPRESSION;
+        }
+        const properties = this.propertiesAndGettersByKey[key];
+        if (properties?.length === 1) {
+            return properties[0];
+        }
+        if (properties ||
+            this.unmatchablePropertiesAndGetters.length > 0 ||
+            (this.unknownIntegerProps.length > 0 && INTEGER_REG_EXP.test(key))) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return null;
+    }
+    getMemberExpressionAndTrackDeopt(key, origin) {
+        if (typeof key !== 'string') {
+            return UNKNOWN_EXPRESSION;
+        }
+        const expression = this.getMemberExpression(key);
+        if (!(expression === UNKNOWN_EXPRESSION || this.immutable)) {
+            const expressionsToBeDeoptimized = (this.expressionsToBeDeoptimizedByKey[key] =
+                this.expressionsToBeDeoptimizedByKey[key] || []);
+            expressionsToBeDeoptimized.push(origin);
+        }
+        return expression;
+    }
+}
+
+const isInteger = (property) => typeof property === 'string' && /^\d+$/.test(property);
+// This makes sure unknown properties are not handled as "undefined" but as
+// "unknown" but without access side effects. An exception is done for numeric
+// properties as we do not expect new builtin properties to be numbers, this
+// will improve tree-shaking for out-of-bounds array properties
+const OBJECT_PROTOTYPE_FALLBACK = new (class ObjectPrototypeFallbackExpression extends ExpressionEntity {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        if (interaction.type === INTERACTION_CALLED && path.length === 1 && !isInteger(path[0])) {
+            deoptimizeInteraction(interaction);
+        }
+    }
+    getLiteralValueAtPath(path) {
+        // We ignore number properties as we do not expect new properties to be
+        // numbers and also want to keep handling out-of-bound array elements as
+        // "undefined"
+        return path.length === 1 && isInteger(path[0]) ? undefined : UnknownValue;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type === INTERACTION_CALLED;
+    }
+})();
+const OBJECT_PROTOTYPE = new ObjectEntity({
+    __proto__: null,
+    hasOwnProperty: METHOD_RETURNS_BOOLEAN,
+    isPrototypeOf: METHOD_RETURNS_BOOLEAN,
+    propertyIsEnumerable: METHOD_RETURNS_BOOLEAN,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
+    valueOf: METHOD_RETURNS_UNKNOWN
+}, OBJECT_PROTOTYPE_FALLBACK, true);
+
+const NEW_ARRAY_PROPERTIES = [
+    { key: UnknownInteger, kind: 'init', property: UNKNOWN_EXPRESSION },
+    { key: 'length', kind: 'init', property: UNKNOWN_LITERAL_NUMBER }
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
+        returnsPrimitive: null
+    })
+];
+const METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: true,
+        mutatesSelfAsArray: true,
+        returns: null,
+        returnsPrimitive: UNKNOWN_LITERAL_NUMBER
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_MUTATES_SELF_RETURNS_SELF = [
+    new Method({
+        callsArgs: null,
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: 'self',
+        returnsPrimitive: null
+    })
+];
+const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF = [
+    new Method({
+        callsArgs: [0],
+        mutatesArgs: false,
+        mutatesSelfAsArray: true,
+        returns: 'self',
+        returnsPrimitive: null
+    })
+];
+const ARRAY_PROTOTYPE = new ObjectEntity({
+    __proto__: null,
+    // We assume that accessors have effects as we do not track the accessed value afterwards
+    at: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN,
+    concat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    copyWithin: METHOD_MUTATES_SELF_RETURNS_SELF,
+    entries: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    every: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
+    fill: METHOD_MUTATES_SELF_RETURNS_SELF,
+    filter: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    find: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    findLast: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findLastIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    includes: METHOD_RETURNS_BOOLEAN,
+    indexOf: METHOD_RETURNS_NUMBER,
+    join: METHOD_RETURNS_STRING,
+    keys: METHOD_RETURNS_UNKNOWN,
+    lastIndexOf: METHOD_RETURNS_NUMBER,
+    map: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    pop: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
+    push: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
+    reduce: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    reduceRight: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    reverse: METHOD_MUTATES_SELF_RETURNS_SELF,
+    shift: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
+    slice: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    some: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
+    sort: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF,
+    splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
+    toLocaleString: METHOD_RETURNS_STRING,
+    toString: METHOD_RETURNS_STRING,
+    unshift: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
+    values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
+}, OBJECT_PROTOTYPE, true);
+
+class ArrayExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (element && (hasSpread || element instanceof SpreadElement)) {
+                hasSpread = true;
+                element.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        const properties = [
+            { key: 'length', kind: 'init', property: UNKNOWN_LITERAL_NUMBER }
+        ];
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (hasSpread || element instanceof SpreadElement) {
+                if (element) {
+                    hasSpread = true;
+                    properties.unshift({ key: UnknownInteger, kind: 'init', property: element });
+                }
+            }
+            else if (element) {
+                properties.push({ key: String(index), kind: 'init', property: element });
+            }
+            else {
+                properties.push({ key: String(index), kind: 'init', property: UNDEFINED_EXPRESSION });
+            }
+        }
+        return (this.objectEntity = new ObjectEntity(properties, ARRAY_PROTOTYPE));
+    }
+}
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const getTruthyLiteralValue = () => UnknownTruthyValue;
+const returnFalse = () => false;
+const returnTrue = () => true;
+const PURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnFalse
+};
+const IMPURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnTrue
+};
+const PURE_WITH_ARRAY = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }) {
+        return args.length > 1 && !(args[1] instanceof ArrayExpression);
+    }
+};
+const GETTER_ACCESS = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }, context) {
+        const [_thisArgument, firstArgument] = args;
+        return (!(firstArgument instanceof ExpressionEntity) ||
+            firstArgument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+};
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
+};
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
+};
+/* PURE FUNCTION IF FIRST ARG DOES NOT CONTAIN A GETTER */
+const PF_NO_GETTER = {
+    __proto__: null,
+    [ValueProperties]: GETTER_ACCESS
+};
+/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
+const MUTATES_ARG_WITHOUT_ACCESSOR = {
+    __proto__: null,
+    [ValueProperties]: {
+        deoptimizeArgumentsOnCall({ args: [, firstArgument] }) {
+            firstArgument?.deoptimizePath(UNKNOWN_PATH);
+        },
+        getLiteralValue: getTruthyLiteralValue,
+        hasEffectsWhenCalled({ args }, context) {
+            return (args.length <= 1 ||
+                args[1].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
+        }
+    }
+};
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
+};
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
+};
+const PC_WITH_ARRAY = {
+    __proto__: null,
+    [ValueProperties]: PURE_WITH_ARRAY,
+    prototype: O
+};
+const ARRAY_TYPE = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    from: O,
+    of: PF,
+    prototype: O
+};
+const INTL_MEMBER = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    supportedLocalesOf: PC
+};
+const knownGlobals = {
+    // Placeholders for global objects to avoid shape mutations
+    global: O,
+    globalThis: O,
+    self: O,
+    window: O,
+    // Common globals
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    Array: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        from: O,
+        isArray: PF,
+        of: PF,
+        prototype: O
+    },
+    ArrayBuffer: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isView: PF,
+        prototype: O
+    },
+    AggregateError: PC_WITH_ARRAY,
+    Atomics: O,
+    BigInt: C,
+    BigInt64Array: C,
+    BigUint64Array: C,
+    Boolean: PC,
+    constructor: C,
+    DataView: PC,
+    Date: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        now: PF,
+        parse: PF,
+        prototype: O,
+        UTC: PF
+    },
+    decodeURI: PF,
+    decodeURIComponent: PF,
+    encodeURI: PF,
+    encodeURIComponent: PF,
+    Error: PC,
+    escape: PF,
+    eval: O,
+    EvalError: PC,
+    FinalizationRegistry: C,
+    Float32Array: ARRAY_TYPE,
+    Float64Array: ARRAY_TYPE,
+    Function: C,
+    hasOwnProperty: O,
+    Infinity: O,
+    Int16Array: ARRAY_TYPE,
+    Int32Array: ARRAY_TYPE,
+    Int8Array: ARRAY_TYPE,
+    isFinite: PF,
+    isNaN: PF,
+    isPrototypeOf: O,
+    JSON: O,
+    Map: PC_WITH_ARRAY,
+    Math: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        abs: PF,
+        acos: PF,
+        acosh: PF,
+        asin: PF,
+        asinh: PF,
+        atan: PF,
+        atan2: PF,
+        atanh: PF,
+        cbrt: PF,
+        ceil: PF,
+        clz32: PF,
+        cos: PF,
+        cosh: PF,
+        exp: PF,
+        expm1: PF,
+        floor: PF,
+        fround: PF,
+        hypot: PF,
+        imul: PF,
+        log: PF,
+        log10: PF,
+        log1p: PF,
+        log2: PF,
+        max: PF,
+        min: PF,
+        pow: PF,
+        random: PF,
+        round: PF,
+        sign: PF,
+        sin: PF,
+        sinh: PF,
+        sqrt: PF,
+        tan: PF,
+        tanh: PF,
+        trunc: PF
+    },
+    NaN: O,
+    Number: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isFinite: PF,
+        isInteger: PF,
+        isNaN: PF,
+        isSafeInteger: PF,
+        parseFloat: PF,
+        parseInt: PF,
+        prototype: O
+    },
+    Object: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        create: PF,
+        // Technically those can throw in certain situations, but we ignore this as
+        // code that relies on this will hopefully wrap this in a try-catch, which
+        // deoptimizes everything anyway
+        defineProperty: MUTATES_ARG_WITHOUT_ACCESSOR,
+        defineProperties: MUTATES_ARG_WITHOUT_ACCESSOR,
+        freeze: MUTATES_ARG_WITHOUT_ACCESSOR,
+        getOwnPropertyDescriptor: PF,
+        getOwnPropertyDescriptors: PF,
+        getOwnPropertyNames: PF,
+        getOwnPropertySymbols: PF,
+        getPrototypeOf: PF,
+        hasOwn: PF,
+        is: PF,
+        isExtensible: PF,
+        isFrozen: PF,
+        isSealed: PF,
+        keys: PF,
+        fromEntries: O,
+        entries: PF_NO_GETTER,
+        values: PF_NO_GETTER,
+        prototype: O
+    },
+    parseFloat: PF,
+    parseInt: PF,
+    Promise: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        all: O,
+        allSettled: O,
+        any: O,
+        prototype: O,
+        race: O,
+        reject: O,
+        resolve: O
+    },
+    propertyIsEnumerable: O,
+    Proxy: O,
+    RangeError: PC,
+    ReferenceError: PC,
+    Reflect: O,
+    RegExp: PC,
+    Set: PC_WITH_ARRAY,
+    SharedArrayBuffer: C,
+    String: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        fromCharCode: PF,
+        fromCodePoint: PF,
+        prototype: O,
+        raw: PF
+    },
+    Symbol: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        for: PF,
+        keyFor: PF,
+        prototype: O,
+        toStringTag: {
+            __proto__: null,
+            [ValueProperties]: {
+                deoptimizeArgumentsOnCall: doNothing,
+                getLiteralValue() {
+                    return SymbolToStringTag;
+                },
+                hasEffectsWhenCalled: returnTrue
+            }
+        }
+    },
+    SyntaxError: PC,
+    toLocaleString: O,
+    toString: O,
+    TypeError: PC,
+    Uint16Array: ARRAY_TYPE,
+    Uint32Array: ARRAY_TYPE,
+    Uint8Array: ARRAY_TYPE,
+    Uint8ClampedArray: ARRAY_TYPE,
+    // Technically, this is a global, but it needs special handling
+    // undefined: ?,
+    unescape: PF,
+    URIError: PC,
+    valueOf: O,
+    WeakMap: PC_WITH_ARRAY,
+    WeakRef: C,
+    WeakSet: PC_WITH_ARRAY,
+    // Additional globals shared by Node and Browser that are not strictly part of the language
+    clearInterval: C,
+    clearTimeout: C,
+    console: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        assert: C,
+        clear: C,
+        count: C,
+        countReset: C,
+        debug: C,
+        dir: C,
+        dirxml: C,
+        error: C,
+        exception: C,
+        group: C,
+        groupCollapsed: C,
+        groupEnd: C,
+        info: C,
+        log: C,
+        table: C,
+        time: C,
+        timeEnd: C,
+        timeLog: C,
+        trace: C,
+        warn: C
+    },
+    Intl: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        Collator: INTL_MEMBER,
+        DateTimeFormat: INTL_MEMBER,
+        DisplayNames: INTL_MEMBER,
+        ListFormat: INTL_MEMBER,
+        Locale: INTL_MEMBER,
+        NumberFormat: INTL_MEMBER,
+        PluralRules: INTL_MEMBER,
+        RelativeTimeFormat: INTL_MEMBER,
+        Segmenter: INTL_MEMBER
+    },
+    setInterval: C,
+    setTimeout: C,
+    TextDecoder: C,
+    TextEncoder: C,
+    URL: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        prototype: O,
+        canParse: PF
+    },
+    URLSearchParams: C,
+    // Browser specific globals
+    AbortController: C,
+    AbortSignal: C,
+    addEventListener: O,
+    alert: O,
+    AnalyserNode: C,
+    Animation: C,
+    AnimationEvent: C,
+    applicationCache: O,
+    ApplicationCache: C,
+    ApplicationCacheErrorEvent: C,
+    atob: O,
+    Attr: C,
+    Audio: C,
+    AudioBuffer: C,
+    AudioBufferSourceNode: C,
+    AudioContext: C,
+    AudioDestinationNode: C,
+    AudioListener: C,
+    AudioNode: C,
+    AudioParam: C,
+    AudioProcessingEvent: C,
+    AudioScheduledSourceNode: C,
+    AudioWorkletNode: C,
+    BarProp: C,
+    BaseAudioContext: C,
+    BatteryManager: C,
+    BeforeUnloadEvent: C,
+    BiquadFilterNode: C,
+    Blob: C,
+    BlobEvent: C,
+    blur: O,
+    BroadcastChannel: C,
+    btoa: O,
+    ByteLengthQueuingStrategy: C,
+    Cache: C,
+    caches: O,
+    CacheStorage: C,
+    cancelAnimationFrame: O,
+    cancelIdleCallback: O,
+    CanvasCaptureMediaStreamTrack: C,
+    CanvasGradient: C,
+    CanvasPattern: C,
+    CanvasRenderingContext2D: C,
+    ChannelMergerNode: C,
+    ChannelSplitterNode: C,
+    CharacterData: C,
+    clientInformation: O,
+    ClipboardEvent: C,
+    close: O,
+    closed: O,
+    CloseEvent: C,
+    Comment: C,
+    CompositionEvent: C,
+    confirm: O,
+    ConstantSourceNode: C,
+    ConvolverNode: C,
+    CountQueuingStrategy: C,
+    createImageBitmap: O,
+    Credential: C,
+    CredentialsContainer: C,
+    crypto: O,
+    Crypto: C,
+    CryptoKey: C,
+    CSS: C,
+    CSSConditionRule: C,
+    CSSFontFaceRule: C,
+    CSSGroupingRule: C,
+    CSSImportRule: C,
+    CSSKeyframeRule: C,
+    CSSKeyframesRule: C,
+    CSSMediaRule: C,
+    CSSNamespaceRule: C,
+    CSSPageRule: C,
+    CSSRule: C,
+    CSSRuleList: C,
+    CSSStyleDeclaration: C,
+    CSSStyleRule: C,
+    CSSStyleSheet: C,
+    CSSSupportsRule: C,
+    CustomElementRegistry: C,
+    customElements: O,
+    CustomEvent: {
+        __proto__: null,
+        [ValueProperties]: {
+            deoptimizeArgumentsOnCall({ args }) {
+                args[2]?.deoptimizePath(['detail']);
+            },
+            getLiteralValue: getTruthyLiteralValue,
+            hasEffectsWhenCalled: returnFalse
+        },
+        prototype: O
+    },
+    DataTransfer: C,
+    DataTransferItem: C,
+    DataTransferItemList: C,
+    defaultstatus: O,
+    defaultStatus: O,
+    DelayNode: C,
+    DeviceMotionEvent: C,
+    DeviceOrientationEvent: C,
+    devicePixelRatio: O,
+    dispatchEvent: O,
+    document: O,
+    Document: C,
+    DocumentFragment: C,
+    DocumentType: C,
+    DOMError: C,
+    DOMException: C,
+    DOMImplementation: C,
+    DOMMatrix: C,
+    DOMMatrixReadOnly: C,
+    DOMParser: C,
+    DOMPoint: C,
+    DOMPointReadOnly: C,
+    DOMQuad: C,
+    DOMRect: C,
+    DOMRectReadOnly: C,
+    DOMStringList: C,
+    DOMStringMap: C,
+    DOMTokenList: C,
+    DragEvent: C,
+    DynamicsCompressorNode: C,
+    Element: C,
+    ErrorEvent: C,
+    Event: C,
+    EventSource: C,
+    EventTarget: C,
+    external: O,
+    fetch: O,
+    File: C,
+    FileList: C,
+    FileReader: C,
+    find: O,
+    focus: O,
+    FocusEvent: C,
+    FontFace: C,
+    FontFaceSetLoadEvent: C,
+    FormData: C,
+    frames: O,
+    GainNode: C,
+    Gamepad: C,
+    GamepadButton: C,
+    GamepadEvent: C,
+    getComputedStyle: O,
+    getSelection: O,
+    HashChangeEvent: C,
+    Headers: C,
+    history: O,
+    History: C,
+    HTMLAllCollection: C,
+    HTMLAnchorElement: C,
+    HTMLAreaElement: C,
+    HTMLAudioElement: C,
+    HTMLBaseElement: C,
+    HTMLBodyElement: C,
+    HTMLBRElement: C,
+    HTMLButtonElement: C,
+    HTMLCanvasElement: C,
+    HTMLCollection: C,
+    HTMLContentElement: C,
+    HTMLDataElement: C,
+    HTMLDataListElement: C,
+    HTMLDetailsElement: C,
+    HTMLDialogElement: C,
+    HTMLDirectoryElement: C,
+    HTMLDivElement: C,
+    HTMLDListElement: C,
+    HTMLDocument: C,
+    HTMLElement: C,
+    HTMLEmbedElement: C,
+    HTMLFieldSetElement: C,
+    HTMLFontElement: C,
+    HTMLFormControlsCollection: C,
+    HTMLFormElement: C,
+    HTMLFrameElement: C,
+    HTMLFrameSetElement: C,
+    HTMLHeadElement: C,
+    HTMLHeadingElement: C,
+    HTMLHRElement: C,
+    HTMLHtmlElement: C,
+    HTMLIFrameElement: C,
+    HTMLImageElement: C,
+    HTMLInputElement: C,
+    HTMLLabelElement: C,
+    HTMLLegendElement: C,
+    HTMLLIElement: C,
+    HTMLLinkElement: C,
+    HTMLMapElement: C,
+    HTMLMarqueeElement: C,
+    HTMLMediaElement: C,
+    HTMLMenuElement: C,
+    HTMLMetaElement: C,
+    HTMLMeterElement: C,
+    HTMLModElement: C,
+    HTMLObjectElement: C,
+    HTMLOListElement: C,
+    HTMLOptGroupElement: C,
+    HTMLOptionElement: C,
+    HTMLOptionsCollection: C,
+    HTMLOutputElement: C,
+    HTMLParagraphElement: C,
+    HTMLParamElement: C,
+    HTMLPictureElement: C,
+    HTMLPreElement: C,
+    HTMLProgressElement: C,
+    HTMLQuoteElement: C,
+    HTMLScriptElement: C,
+    HTMLSelectElement: C,
+    HTMLShadowElement: C,
+    HTMLSlotElement: C,
+    HTMLSourceElement: C,
+    HTMLSpanElement: C,
+    HTMLStyleElement: C,
+    HTMLTableCaptionElement: C,
+    HTMLTableCellElement: C,
+    HTMLTableColElement: C,
+    HTMLTableElement: C,
+    HTMLTableRowElement: C,
+    HTMLTableSectionElement: C,
+    HTMLTemplateElement: C,
+    HTMLTextAreaElement: C,
+    HTMLTimeElement: C,
+    HTMLTitleElement: C,
+    HTMLTrackElement: C,
+    HTMLUListElement: C,
+    HTMLUnknownElement: C,
+    HTMLVideoElement: C,
+    IDBCursor: C,
+    IDBCursorWithValue: C,
+    IDBDatabase: C,
+    IDBFactory: C,
+    IDBIndex: C,
+    IDBKeyRange: C,
+    IDBObjectStore: C,
+    IDBOpenDBRequest: C,
+    IDBRequest: C,
+    IDBTransaction: C,
+    IDBVersionChangeEvent: C,
+    IdleDeadline: C,
+    IIRFilterNode: C,
+    Image: C,
+    ImageBitmap: C,
+    ImageBitmapRenderingContext: C,
+    ImageCapture: C,
+    ImageData: C,
+    indexedDB: O,
+    innerHeight: O,
+    innerWidth: O,
+    InputEvent: C,
+    IntersectionObserver: C,
+    IntersectionObserverEntry: C,
+    isSecureContext: O,
+    KeyboardEvent: C,
+    KeyframeEffect: C,
+    length: O,
+    localStorage: O,
+    location: O,
+    Location: C,
+    locationbar: O,
+    matchMedia: O,
+    MediaDeviceInfo: C,
+    MediaDevices: C,
+    MediaElementAudioSourceNode: C,
+    MediaEncryptedEvent: C,
+    MediaError: C,
+    MediaKeyMessageEvent: C,
+    MediaKeySession: C,
+    MediaKeyStatusMap: C,
+    MediaKeySystemAccess: C,
+    MediaList: C,
+    MediaQueryList: C,
+    MediaQueryListEvent: C,
+    MediaRecorder: C,
+    MediaSettingsRange: C,
+    MediaSource: C,
+    MediaStream: C,
+    MediaStreamAudioDestinationNode: C,
+    MediaStreamAudioSourceNode: C,
+    MediaStreamEvent: C,
+    MediaStreamTrack: C,
+    MediaStreamTrackEvent: C,
+    menubar: O,
+    MessageChannel: C,
+    MessageEvent: C,
+    MessagePort: C,
+    MIDIAccess: C,
+    MIDIConnectionEvent: C,
+    MIDIInput: C,
+    MIDIInputMap: C,
+    MIDIMessageEvent: C,
+    MIDIOutput: C,
+    MIDIOutputMap: C,
+    MIDIPort: C,
+    MimeType: C,
+    MimeTypeArray: C,
+    MouseEvent: C,
+    moveBy: O,
+    moveTo: O,
+    MutationEvent: C,
+    MutationObserver: C,
+    MutationRecord: C,
+    name: O,
+    NamedNodeMap: C,
+    NavigationPreloadManager: C,
+    navigator: O,
+    Navigator: C,
+    NetworkInformation: C,
+    Node: C,
+    NodeFilter: O,
+    NodeIterator: C,
+    NodeList: C,
+    Notification: C,
+    OfflineAudioCompletionEvent: C,
+    OfflineAudioContext: C,
+    offscreenBuffering: O,
+    OffscreenCanvas: C,
+    open: O,
+    openDatabase: O,
+    Option: C,
+    origin: O,
+    OscillatorNode: C,
+    outerHeight: O,
+    outerWidth: O,
+    PageTransitionEvent: C,
+    pageXOffset: O,
+    pageYOffset: O,
+    PannerNode: C,
+    parent: O,
+    Path2D: C,
+    PaymentAddress: C,
+    PaymentRequest: C,
+    PaymentRequestUpdateEvent: C,
+    PaymentResponse: C,
+    performance: O,
+    Performance: C,
+    PerformanceEntry: C,
+    PerformanceLongTaskTiming: C,
+    PerformanceMark: C,
+    PerformanceMeasure: C,
+    PerformanceNavigation: C,
+    PerformanceNavigationTiming: C,
+    PerformanceObserver: C,
+    PerformanceObserverEntryList: C,
+    PerformancePaintTiming: C,
+    PerformanceResourceTiming: C,
+    PerformanceTiming: C,
+    PeriodicWave: C,
+    Permissions: C,
+    PermissionStatus: C,
+    personalbar: O,
+    PhotoCapabilities: C,
+    Plugin: C,
+    PluginArray: C,
+    PointerEvent: C,
+    PopStateEvent: C,
+    postMessage: O,
+    Presentation: C,
+    PresentationAvailability: C,
+    PresentationConnection: C,
+    PresentationConnectionAvailableEvent: C,
+    PresentationConnectionCloseEvent: C,
+    PresentationConnectionList: C,
+    PresentationReceiver: C,
+    PresentationRequest: C,
+    print: O,
+    ProcessingInstruction: C,
+    ProgressEvent: C,
+    PromiseRejectionEvent: C,
+    prompt: O,
+    PushManager: C,
+    PushSubscription: C,
+    PushSubscriptionOptions: C,
+    queueMicrotask: O,
+    RadioNodeList: C,
+    Range: C,
+    ReadableStream: C,
+    RemotePlayback: C,
+    removeEventListener: O,
+    Request: C,
+    requestAnimationFrame: O,
+    requestIdleCallback: O,
+    resizeBy: O,
+    ResizeObserver: C,
+    ResizeObserverEntry: C,
+    resizeTo: O,
+    Response: C,
+    RTCCertificate: C,
+    RTCDataChannel: C,
+    RTCDataChannelEvent: C,
+    RTCDtlsTransport: C,
+    RTCIceCandidate: C,
+    RTCIceTransport: C,
+    RTCPeerConnection: C,
+    RTCPeerConnectionIceEvent: C,
+    RTCRtpReceiver: C,
+    RTCRtpSender: C,
+    RTCSctpTransport: C,
+    RTCSessionDescription: C,
+    RTCStatsReport: C,
+    RTCTrackEvent: C,
+    screen: O,
+    Screen: C,
+    screenLeft: O,
+    ScreenOrientation: C,
+    screenTop: O,
+    screenX: O,
+    screenY: O,
+    ScriptProcessorNode: C,
+    scroll: O,
+    scrollbars: O,
+    scrollBy: O,
+    scrollTo: O,
+    scrollX: O,
+    scrollY: O,
+    SecurityPolicyViolationEvent: C,
+    Selection: C,
+    ServiceWorker: C,
+    ServiceWorkerContainer: C,
+    ServiceWorkerRegistration: C,
+    sessionStorage: O,
+    ShadowRoot: C,
+    SharedWorker: C,
+    SourceBuffer: C,
+    SourceBufferList: C,
+    speechSynthesis: O,
+    SpeechSynthesisEvent: C,
+    SpeechSynthesisUtterance: C,
+    StaticRange: C,
+    status: O,
+    statusbar: O,
+    StereoPannerNode: C,
+    stop: O,
+    Storage: C,
+    StorageEvent: C,
+    StorageManager: C,
+    styleMedia: O,
+    StyleSheet: C,
+    StyleSheetList: C,
+    SubtleCrypto: C,
+    SVGAElement: C,
+    SVGAngle: C,
+    SVGAnimatedAngle: C,
+    SVGAnimatedBoolean: C,
+    SVGAnimatedEnumeration: C,
+    SVGAnimatedInteger: C,
+    SVGAnimatedLength: C,
+    SVGAnimatedLengthList: C,
+    SVGAnimatedNumber: C,
+    SVGAnimatedNumberList: C,
+    SVGAnimatedPreserveAspectRatio: C,
+    SVGAnimatedRect: C,
+    SVGAnimatedString: C,
+    SVGAnimatedTransformList: C,
+    SVGAnimateElement: C,
+    SVGAnimateMotionElement: C,
+    SVGAnimateTransformElement: C,
+    SVGAnimationElement: C,
+    SVGCircleElement: C,
+    SVGClipPathElement: C,
+    SVGComponentTransferFunctionElement: C,
+    SVGDefsElement: C,
+    SVGDescElement: C,
+    SVGDiscardElement: C,
+    SVGElement: C,
+    SVGEllipseElement: C,
+    SVGFEBlendElement: C,
+    SVGFEColorMatrixElement: C,
+    SVGFEComponentTransferElement: C,
+    SVGFECompositeElement: C,
+    SVGFEConvolveMatrixElement: C,
+    SVGFEDiffuseLightingElement: C,
+    SVGFEDisplacementMapElement: C,
+    SVGFEDistantLightElement: C,
+    SVGFEDropShadowElement: C,
+    SVGFEFloodElement: C,
+    SVGFEFuncAElement: C,
+    SVGFEFuncBElement: C,
+    SVGFEFuncGElement: C,
+    SVGFEFuncRElement: C,
+    SVGFEGaussianBlurElement: C,
+    SVGFEImageElement: C,
+    SVGFEMergeElement: C,
+    SVGFEMergeNodeElement: C,
+    SVGFEMorphologyElement: C,
+    SVGFEOffsetElement: C,
+    SVGFEPointLightElement: C,
+    SVGFESpecularLightingElement: C,
+    SVGFESpotLightElement: C,
+    SVGFETileElement: C,
+    SVGFETurbulenceElement: C,
+    SVGFilterElement: C,
+    SVGForeignObjectElement: C,
+    SVGGElement: C,
+    SVGGeometryElement: C,
+    SVGGradientElement: C,
+    SVGGraphicsElement: C,
+    SVGImageElement: C,
+    SVGLength: C,
+    SVGLengthList: C,
+    SVGLinearGradientElement: C,
+    SVGLineElement: C,
+    SVGMarkerElement: C,
+    SVGMaskElement: C,
+    SVGMatrix: C,
+    SVGMetadataElement: C,
+    SVGMPathElement: C,
+    SVGNumber: C,
+    SVGNumberList: C,
+    SVGPathElement: C,
+    SVGPatternElement: C,
+    SVGPoint: C,
+    SVGPointList: C,
+    SVGPolygonElement: C,
+    SVGPolylineElement: C,
+    SVGPreserveAspectRatio: C,
+    SVGRadialGradientElement: C,
+    SVGRect: C,
+    SVGRectElement: C,
+    SVGScriptElement: C,
+    SVGSetElement: C,
+    SVGStopElement: C,
+    SVGStringList: C,
+    SVGStyleElement: C,
+    SVGSVGElement: C,
+    SVGSwitchElement: C,
+    SVGSymbolElement: C,
+    SVGTextContentElement: C,
+    SVGTextElement: C,
+    SVGTextPathElement: C,
+    SVGTextPositioningElement: C,
+    SVGTitleElement: C,
+    SVGTransform: C,
+    SVGTransformList: C,
+    SVGTSpanElement: C,
+    SVGUnitTypes: C,
+    SVGUseElement: C,
+    SVGViewElement: C,
+    TaskAttributionTiming: C,
+    Text: C,
+    TextEvent: C,
+    TextMetrics: C,
+    TextTrack: C,
+    TextTrackCue: C,
+    TextTrackCueList: C,
+    TextTrackList: C,
+    TimeRanges: C,
+    toolbar: O,
+    top: O,
+    Touch: C,
+    TouchEvent: C,
+    TouchList: C,
+    TrackEvent: C,
+    TransitionEvent: C,
+    TreeWalker: C,
+    UIEvent: C,
+    ValidityState: C,
+    visualViewport: O,
+    VisualViewport: C,
+    VTTCue: C,
+    WaveShaperNode: C,
+    WebAssembly: O,
+    WebGL2RenderingContext: C,
+    WebGLActiveInfo: C,
+    WebGLBuffer: C,
+    WebGLContextEvent: C,
+    WebGLFramebuffer: C,
+    WebGLProgram: C,
+    WebGLQuery: C,
+    WebGLRenderbuffer: C,
+    WebGLRenderingContext: C,
+    WebGLSampler: C,
+    WebGLShader: C,
+    WebGLShaderPrecisionFormat: C,
+    WebGLSync: C,
+    WebGLTexture: C,
+    WebGLTransformFeedback: C,
+    WebGLUniformLocation: C,
+    WebGLVertexArrayObject: C,
+    WebSocket: C,
+    WheelEvent: C,
+    Window: C,
+    Worker: C,
+    WritableStream: C,
+    XMLDocument: C,
+    XMLHttpRequest: C,
+    XMLHttpRequestEventTarget: C,
+    XMLHttpRequestUpload: C,
+    XMLSerializer: C,
+    XPathEvaluator: C,
+    XPathExpression: C,
+    XPathResult: C,
+    XSLTProcessor: C
+};
+for (const global of ['window', 'global', 'self', 'globalThis']) {
+    knownGlobals[global] = knownGlobals;
+}
+function getGlobalAtPath(path) {
+    let currentGlobal = knownGlobals;
+    for (const pathSegment of path) {
+        if (typeof pathSegment !== 'string') {
+            return null;
+        }
+        currentGlobal = currentGlobal[pathSegment];
+        if (!currentGlobal) {
+            return null;
+        }
+    }
+    return currentGlobal[ValueProperties];
+}
+
+class GlobalVariable extends Variable {
+    constructor(name) {
+        super(name);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
+        this.markReassigned();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        switch (interaction.type) {
+            // While there is no point in testing these cases as at the moment, they
+            // are also covered via other means, we keep them for completeness
+            case INTERACTION_ACCESSED:
+            case INTERACTION_ASSIGNED: {
+                if (!getGlobalAtPath([this.name, ...path].slice(0, -1))) {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                if (globalAtPath) {
+                    globalAtPath.deoptimizeArgumentsOnCall(interaction);
+                }
+                else {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+        }
+    }
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return globalAtPath ? globalAtPath.getLiteralValue() : UnknownValue;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (path.length === 0) {
+                    // Technically, "undefined" is a global variable of sorts
+                    return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+                }
+                return !getGlobalAtPath([this.name, ...path].slice(0, -1));
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
+            }
+        }
+    }
+}
+
+class LocalVariable extends Variable {
+    constructor(name, declarator, init, context, kind) {
+        super(name);
+        this.init = init;
+        this.calledFromTryStatement = false;
+        this.additionalInitializers = null;
+        this.expressionsToBeDeoptimized = [];
+        this.declarations = declarator ? [declarator] : [];
+        this.deoptimizationTracker = context.deoptimizationTracker;
+        this.module = context.module;
+        this.kind = kind;
+    }
+    addDeclaration(identifier, init) {
+        this.declarations.push(identifier);
+        this.markInitializersForDeoptimization().push(init);
+    }
+    consolidateInitializers() {
+        if (this.additionalInitializers) {
+            for (const initializer of this.additionalInitializers) {
+                initializer.deoptimizePath(UNKNOWN_PATH);
+            }
+            this.additionalInitializers = null;
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.isReassigned) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker), undefined);
+    }
+    deoptimizePath(path) {
+        if (this.isReassigned ||
+            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        if (path.length === 0) {
+            this.markReassigned();
+            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            this.init.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.init.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (this.isReassigned)
+                    return true;
+                return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                if (this.included)
+                    return true;
+                if (path.length === 0)
+                    return false;
+                if (this.isReassigned)
+                    return true;
+                return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_CALLED: {
+                if (this.isReassigned)
+                    return true;
+                return (!(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.included) {
+            super.include();
+            for (const declaration of this.declarations) {
+                // If node is a default export, it can save a tree-shaking run to include the full declaration now
+                if (!declaration.included)
+                    declaration.include(createInclusionContext(), false);
+                let node = declaration.parent;
+                while (!node.included) {
+                    // We do not want to properly include parents in case they are part of a dead branch
+                    // in which case .include() might pull in more dead code
+                    node.included = true;
+                    if (node.type === parseAst_js.Program)
+                        break;
+                    node = node.parent;
+                }
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.isReassigned || context.includedCallArguments.has(this.init)) {
+            for (const argument of parameters) {
+                argument.include(context, false);
+            }
+        }
+        else {
+            context.includedCallArguments.add(this.init);
+            this.init.includeCallArguments(context, parameters);
+            context.includedCallArguments.delete(this.init);
+        }
+    }
+    markCalledFromTryStatement() {
+        this.calledFromTryStatement = true;
+    }
+    markInitializersForDeoptimization() {
+        if (this.additionalInitializers === null) {
+            this.additionalInitializers = [this.init];
+            this.init = UNKNOWN_EXPRESSION;
+            this.markReassigned();
+        }
+        return this.additionalInitializers;
+    }
+}
+
+const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
+class IdentifierBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.isVariableReference = false;
+    }
+    get isTDZAccess() {
+        if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
+            return null;
+        }
+        return isFlagSet(this.flags, 8 /* Flag.tdzAccess */);
+    }
+    set isTDZAccess(value) {
+        this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
+        this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        // We keep conditional chaining because an unknown Node could have an
+        // Identifier as property that might be deoptimized by default
+        this.variable?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return [expression, isPure || this.isPureFunction(path)];
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
+        }
+        return (this.scope.context.options.treeshake
+            .unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            !this.isPureFunction(EMPTY_PATH) &&
+            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return (this.variable !== null &&
+                    !this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            case INTERACTION_CALLED: {
+                return (!this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
+    }
+    isPossibleTDZ() {
+        // return cached value to avoid issues with the next tree-shaking pass
+        const cachedTdzAccess = this.isTDZAccess;
+        if (cachedTdzAccess !== null)
+            return cachedTdzAccess;
+        if (!(this.variable instanceof LocalVariable &&
+            this.variable.kind &&
+            tdzVariableKinds.has(this.variable.kind) &&
+            // We ignore modules that did not receive a treeshaking pass yet as that
+            // causes many false positives due to circular dependencies or disabled
+            // moduleSideEffects.
+            this.variable.module.hasTreeShakingPassStarted)) {
+            return (this.isTDZAccess = false);
+        }
+        let decl_id;
+        if (this.variable.declarations &&
+            this.variable.declarations.length === 1 &&
+            (decl_id = this.variable.declarations[0]) &&
+            this.start < decl_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            // a variable accessed before its declaration
+            // in the same function or at top level of module
+            return (this.isTDZAccess = true);
+        }
+        if (!this.variable.initReached) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
+        }
+        return (this.isTDZAccess = false);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable instanceof LocalVariable) {
+            // When accessing a variable from a module without side effects, this
+            // means we use an export of that module and therefore need to potentially
+            // include it in the bundle.
+            if (!this.variable.module.isExecuted) {
+                markModuleAndImpureDependenciesAsExecuted(this.variable.module);
+            }
+            this.variable.consolidateInitializers();
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.isVariableReference) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    disallowImportReassignment() {
+        return this.scope.context.error(parseAst_js.logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+    }
+    getVariableRespectingTDZ() {
+        if (this.isPossibleTDZ()) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return this.variable;
+    }
+    isPureFunction(path) {
+        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
+        for (const segment of path) {
+            if (currentPureFunction) {
+                if (currentPureFunction[PureFunctionKey]) {
+                    return true;
+                }
+                currentPureFunction = currentPureFunction[segment];
+            }
+            else {
+                return false;
+            }
+        }
+        return currentPureFunction?.[PureFunctionKey];
+    }
+}
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
+}
+
+class Identifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (!this.variable && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+            this.isVariableReference = true;
+        }
+    }
+    declare(kind, init) {
+        let variable;
+        const { treeshake } = this.scope.context.options;
+        switch (kind) {
+            case 'var': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
+            }
+            case 'function': {
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'let':
+            case 'const':
+            case 'using':
+            case 'await using':
+            case 'class': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'parameter': {
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            }
+            /* istanbul ignore next */
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+            }
+        }
+        return [(this.variable = variable)];
+    }
+    markDeclarationReached() {
+        this.variable.initReached = true;
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, `${this.name}: `);
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === parseAst_js.CallExpression &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+}
+
+function getSafeName(baseName, usedNames, forbiddenNames) {
+    let safeName = baseName;
+    let count = 1;
+    while (usedNames.has(safeName) || RESERVED_NAMES.has(safeName) || forbiddenNames?.has(safeName)) {
+        safeName = `${baseName}$${toBase64(count++)}`;
+    }
+    usedNames.add(safeName);
+    return safeName;
+}
+
+class Scope {
+    constructor() {
+        this.children = [];
+        this.variables = new Map();
+    }
+    /*
+    Redeclaration rules:
+    - var can redeclare var
+    - in function scopes, function and var can redeclare function and var
+    - var is hoisted across scopes, function remains in the scope it is declared
+    - var and function can redeclare function parameters, but parameters cannot redeclare parameters
+    - function cannot redeclare catch scope parameters
+    - var can redeclare catch scope parameters in a way
+        - if the parameter is an identifier and not a pattern
+        - then the variable is still declared in the hoisted outer scope, but the initializer is assigned to the parameter
+    - const, let, class, and function except in the cases above cannot redeclare anything
+     */
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if (kind === 'var' && existingKind === 'var') {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+        }
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
+    }
+    addHoistedVariable(name, variable) {
+        (this.hoistedVariables ||= new Map()).set(name, variable);
+    }
+    contains(name) {
+        return this.variables.has(name);
+    }
+    findVariable(_name) {
+        /* istanbul ignore next */
+        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
+    }
+}
+
+class ChildScope extends Scope {
+    constructor(parent, context) {
+        super();
+        this.parent = parent;
+        this.context = context;
+        this.accessedOutsideVariables = new Map();
+        parent.children.push(this);
+    }
+    addAccessedDynamicImport(importExpression) {
+        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedDynamicImport(importExpression);
+        }
+    }
+    addAccessedGlobals(globals, accessedGlobalsByScope) {
+        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
+        for (const name of globals) {
+            accessedGlobals.add(name);
+        }
+        accessedGlobalsByScope.set(this, accessedGlobals);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
+        }
+    }
+    addNamespaceMemberAccess(name, variable) {
+        this.accessedOutsideVariables.set(name, variable);
+        this.parent.addNamespaceMemberAccess(name, variable);
+    }
+    addReturnExpression(expression) {
+        if (this.parent instanceof ChildScope) {
+            this.parent.addReturnExpression(expression);
+        }
+    }
+    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
+        for (const variable of this.accessedOutsideVariables.values()) {
+            if (variable.included) {
+                usedNames.add(variable.getBaseVariableName());
+                if (format === 'system' && exportNamesByVariable.has(variable)) {
+                    usedNames.add('exports');
+                }
+            }
+        }
+        const accessedGlobals = accessedGlobalsByScope.get(this);
+        if (accessedGlobals) {
+            for (const name of accessedGlobals) {
+                usedNames.add(name);
+            }
+        }
+    }
+    contains(name) {
+        return this.variables.has(name) || this.parent.contains(name);
+    }
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        const usedNames = new Set();
+        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+        if (this.accessedDynamicImports) {
+            for (const importExpression of this.accessedDynamicImports) {
+                if (importExpression.inlineNamespace) {
+                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
+                }
+            }
+        }
+        for (const [name, variable] of this.variables) {
+            if (variable.included || variable.alwaysRendered) {
+                variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
+            }
+        }
+        for (const scope of this.children) {
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+        }
+    }
+    findLexicalBoundary() {
+        return this.parent.findLexicalBoundary();
+    }
+    findGlobal(name) {
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
+        }
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
+    }
+}
+
+function checkEffectForNodes(nodes, context) {
+    for (const node of nodes) {
+        if (node.hasEffects(context)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+class MethodBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.accessedValue = null;
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        if (interaction.type === INTERACTION_ASSIGNED && this.kind === 'set' && path.length === 0) {
+            return this.value.deoptimizeArgumentsOnInteractionAtPath({
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
+        }
+        this.getAccessedValue()[0].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    // As getter properties directly receive their values from fixed function
+    // expressions, there is no known situation where a getter is deoptimized.
+    deoptimizeCache() { }
+    deoptimizePath(path) {
+        this.getAccessedValue()[0].deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getAccessedValue()[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        return this.key.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.kind === 'get' && interaction.type === INTERACTION_ACCESSED && path.length === 0) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        // setters are only called for empty paths
+        if (this.kind === 'set' && interaction.type === INTERACTION_ASSIGNED) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        return this.getAccessedValue()[0].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() { }
+    getAccessedValue() {
+        if (this.accessedValue === null) {
+            if (this.kind === 'get') {
+                this.accessedValue = UNKNOWN_RETURN_EXPRESSION;
+                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
+            }
+            else {
+                return (this.accessedValue = [this.value, false]);
+            }
+        }
+        return this.accessedValue;
+    }
+}
+
+class MethodDefinition extends MethodBase {
+    hasEffects(context) {
+        return super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    applyDeoptimizations() { }
+}
+
+class BlockScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                if (existingVariable.kind === 'var' ||
+                    (kind === 'var' && existingVariable.kind === 'parameter')) {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+class StaticBlock extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            const bodyStartPos = findFirstOccurrenceOutsideComment(code.original.slice(this.start, this.end), '{') + 1;
+            renderStatementList(this.body, code, this.start + bodyStartPos, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+function isStaticBlock(statement) {
+    return statement.type === parseAst_js.StaticBlock;
+}
+
+class ObjectMember extends ExpressionEntity {
+    constructor(object, key) {
+        super();
+        this.object = object;
+        this.key = key;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.object.deoptimizePath([this.key, ...path]);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
+    }
+}
+
+class ClassNode extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new ChildScope(parentScope, parentScope.context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        this.getObjectEntity().deoptimizeAllProperties();
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.superClass?.hasEffects(context) || this.body.hasEffects(context);
+        this.id?.markDeclarationReached();
+        return initEffect || super.hasEffects(context) || checkEffectForNodes(this.decorators, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return interaction.type === INTERACTION_CALLED && path.length === 0
+            ? !interaction.withNew ||
+                (this.classConstructor === null
+                    ? this.superClass?.hasEffectsOnInteractionAtPath(path, interaction, context)
+                    : this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
+                false
+            : this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.superClass?.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively);
+        for (const decorator of this.decorators)
+            decorator.include(context, includeChildrenRecursively);
+        if (this.id) {
+            this.id.markDeclarationReached();
+            this.id.include();
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.id?.declare('class', this);
+        for (const method of this.body.body) {
+            if (method instanceof MethodDefinition && method.kind === 'constructor') {
+                this.classConstructor = method;
+                return;
+            }
+        }
+        this.classConstructor = null;
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const definition of this.body.body) {
+            if (!isStaticBlock(definition) &&
+                !(definition.static ||
+                    (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+                // Calls to methods are not tracked, ensure that the return value is deoptimized
+                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        const staticProperties = [];
+        const dynamicMethods = [];
+        for (const definition of this.body.body) {
+            if (isStaticBlock(definition))
+                continue;
+            const properties = definition.static ? staticProperties : dynamicMethods;
+            const definitionKind = definition.kind;
+            // Note that class fields do not end up on the prototype
+            if (properties === dynamicMethods && !definitionKind)
+                continue;
+            const kind = definitionKind === 'set' || definitionKind === 'get' ? definitionKind : 'init';
+            let key;
+            if (definition.computed) {
+                const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                if (typeof keyValue === 'symbol') {
+                    properties.push({ key: UnknownKey, kind, property: definition });
+                    continue;
+                }
+                else {
+                    key = String(keyValue);
+                }
+            }
+            else {
+                key =
+                    definition.key instanceof Identifier
+                        ? definition.key.name
+                        : String(definition.key.value);
+            }
+            properties.push({ key, kind, property: definition });
+        }
+        staticProperties.unshift({
+            key: 'prototype',
+            kind: 'init',
+            property: new ObjectEntity(dynamicMethods, this.superClass ? new ObjectMember(this.superClass, 'prototype') : OBJECT_PROTOTYPE)
+        });
+        return (this.objectEntity = new ObjectEntity(staticProperties, this.superClass || OBJECT_PROTOTYPE));
+    }
+}
+
+class ClassDeclaration extends ClassNode {
+    initialise() {
+        super.initialise();
+        if (this.id !== null) {
+            this.id.variable.isId = true;
+        }
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, format, snippets: { _, getPropertyAccess } } = options;
+        if (this.id) {
+            const { variable, name } = this.id;
+            if (format === 'system' && exportNamesByVariable.has(variable)) {
+                code.appendLeft(this.end, `${_}${getSystemExportStatement([variable], options)};`);
+            }
+            const renderedVariable = variable.getName(getPropertyAccess);
+            if (renderedVariable !== name) {
+                this.decorators.map(decorator => decorator.render(code, options));
+                this.superClass?.render(code, options);
+                this.body.render(code, {
+                    ...options,
+                    useOriginalName: (_variable) => _variable === variable
+                });
+                code.prependRight(this.start, `let ${renderedVariable}${_}=${_}`);
+                code.prependLeft(this.end, ';');
+                return;
+            }
+        }
+        super.render(code, options);
+    }
+    applyDeoptimizations() {
+        super.applyDeoptimizations();
+        const { id, scope } = this;
+        if (id) {
+            const { name, variable } = id;
+            for (const accessedVariable of scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+
+class ArgumentsVariable extends LocalVariable {
+    constructor(context) {
+        super('arguments', null, UNKNOWN_EXPRESSION, context, 'other');
+        this.deoptimizedArguments = [];
+    }
+    addArgumentToBeDeoptimized(argument) {
+        if (this.included) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.deoptimizedArguments.push(argument);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    include() {
+        super.include();
+        for (const argument of this.deoptimizedArguments) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.deoptimizedArguments.length = 0;
+    }
+}
+
+const MAX_TRACKED_INTERACTIONS = 20;
+const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
+const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
+const EMPTY_PATH_TRACKER = new PathTracker();
+const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
+class ParameterVariable extends LocalVariable {
+    constructor(name, declarator, context) {
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
+        this.deoptimizationInteractions = [];
+        this.deoptimizations = new PathTracker();
+        this.deoptimizedFields = new Set();
+        this.entitiesToBeDeoptimized = new Set();
+        this.expressionsUseTheKnownValue = [];
+        this.knownValue = null;
+        this.knownValueLiteral = UnknownValue;
+        this.frozenValue = null;
+    }
+    addEntityToBeDeoptimized(entity) {
+        if (entity === UNKNOWN_EXPRESSION) {
+            // As unknown expressions fully deoptimize all interactions, we can clear
+            // the interaction cache at this point provided we keep this optimization
+            // in mind when adding new interactions
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
+                for (const { interaction } of this.deoptimizationInteractions) {
+                    deoptimizeInteraction(interaction);
+                }
+                this.deoptimizationInteractions = NO_INTERACTIONS;
+            }
+        }
+        else if (this.deoptimizedFields.has(UnknownKey)) {
+            // This means that we already deoptimized all interactions and no longer
+            // track them
+            entity.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.entitiesToBeDeoptimized.has(entity)) {
+            this.entitiesToBeDeoptimized.add(entity);
+            for (const field of this.deoptimizedFields) {
+                entity.deoptimizePath([field]);
+            }
+            for (const { interaction, path } of this.deoptimizationInteractions) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+        }
+    }
+    markReassigned() {
+        if (this.isReassigned) {
+            return;
+        }
+        super.markReassigned();
+        for (const expression of this.expressionsUseTheKnownValue) {
+            expression.deoptimizeCache();
+        }
+        this.expressionsUseTheKnownValue = parseAst_js.EMPTY_ARRAY;
+    }
+    deoptimizeCache() {
+        this.markReassigned();
+    }
+    /**
+     * Update the known value of the parameter variable.
+     * Must be called for every function call, so it can track all the arguments,
+     * and deoptimizeCache itself to mark reassigned if the argument is changed.
+     * @param argument The argument of the function call
+     */
+    updateKnownValue(argument) {
+        if (this.isReassigned) {
+            return;
+        }
+        if (this.knownValue === null) {
+            this.knownValue = argument;
+            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return;
+        }
+        // the same literal or identifier, do nothing
+        if (this.knownValue === argument ||
+            (this.knownValue instanceof Identifier &&
+                argument instanceof Identifier &&
+                this.knownValue.variable === argument.variable)) {
+            return;
+        }
+        const oldValue = this.knownValueLiteral;
+        if (typeof oldValue === 'symbol') {
+            this.markReassigned();
+            return;
+        }
+        // add tracking for the new argument
+        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        if (newValue !== oldValue) {
+            this.markReassigned();
+        }
+    }
+    /**
+     * This function freezes the known value of the parameter variable,
+     * so the optimization starts with a certain ExpressionEntity.
+     * The optimization can be undone by calling `markReassigned`.
+     * @returns the frozen value
+     */
+    getKnownValue() {
+        if (this.frozenValue === null) {
+            this.frozenValue = this.knownValue || UNKNOWN_EXPRESSION;
+        }
+        return this.frozenValue;
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        const knownValue = this.getKnownValue();
+        this.expressionsUseTheKnownValue.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
+            return super.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        const knownValue = this.getKnownValue();
+        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        // For performance reasons, we fully deoptimize all deeper interactions
+        if (path.length >= 2 ||
+            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
+            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
+            (path.length === 1 &&
+                (this.deoptimizedFields.has(UnknownKey) ||
+                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
+            for (const entity of this.entitiesToBeDeoptimized) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.deoptimizationInteractions.push({
+                    interaction,
+                    path
+                });
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.markReassigned();
+            return;
+        }
+        if (this.deoptimizedFields.has(UnknownKey)) {
+            return;
+        }
+        const key = path[0];
+        if (this.deoptimizedFields.has(key)) {
+            return;
+        }
+        this.deoptimizedFields.add(key);
+        for (const entity of this.entitiesToBeDeoptimized) {
+            // We do not need a recursion tracker here as we already track whether
+            // this field is deoptimized
+            entity.deoptimizePath([key]);
+        }
+        if (key === UnknownKey) {
+            // save some memory
+            this.deoptimizationInteractions = NO_INTERACTIONS;
+            this.deoptimizations = EMPTY_PATH_TRACKER;
+            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
+            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        // We deoptimize everything that is called as that will trivially deoptimize
+        // the corresponding return expressions as well and avoid badly performing
+        // and complicated alternatives
+        if (path.length === 0) {
+            this.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.deoptimizedFields.has(path[0])) {
+            this.deoptimizePath([path[0]]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+}
+
+class ThisVariable extends ParameterVariable {
+    constructor(context) {
+        super('this', null, context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION).hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+}
+
+class CatchBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+        this.parent = parent;
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                const existingKind = existingVariable.kind;
+                if (existingKind === 'parameter' &&
+                    // If this is a destructured parameter, it is forbidden to redeclare
+                    existingVariable.declarations[0].parent.type === parseAst_js.CatchClause) {
+                    // If this is a var with the same name as the catch scope parameter,
+                    // the assignment actually goes to the parameter and the var is
+                    // hoisted without assignment. Locally, it is shadowed by the
+                    // parameter
+                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, kind);
+                    // To avoid the need to rewrite the declaration, we link the variable
+                    // names. If we ever implement a logic that splits initialization and
+                    // assignment for hoisted vars, the "renderLikeHoisted" logic can be
+                    // removed again.
+                    // We do not need to check whether there already is a linked
+                    // variable because then declaredVariable would be that linked
+                    // variable.
+                    existingVariable.renderLikeHoisted(declaredVariable);
+                    this.addHoistedVariable(name, declaredVariable);
+                    return declaredVariable;
+                }
+                if (existingKind === 'var') {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+            // We only add parameters to parameter scopes
+            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+class FunctionBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+    }
+    // There is stuff that is only allowed in function scopes, i.e. functions can
+    // be redeclared, functions and var can redeclare each other
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if ((kind === 'var' || kind === 'function') &&
+                (existingKind === 'var' || existingKind === 'function' || existingKind === 'parameter')) {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+        }
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
+    }
+}
+
+class ParameterScope extends ChildScope {
+    constructor(parent, isCatchScope) {
+        super(parent, parent.context);
+        this.parameters = [];
+        this.hasRest = false;
+        this.bodyScope = isCatchScope ? new CatchBodyScope(this) : new FunctionBodyScope(this);
+    }
+    /**
+     * Adds a parameter to this scope. Parameters must be added in the correct
+     * order, i.e. from left to right.
+     */
+    addParameterDeclaration(identifier) {
+        const { name, start } = identifier;
+        const existingParameter = this.variables.get(name);
+        if (existingParameter) {
+            return this.context.error(parseAst_js.logDuplicateArgumentNameError(name), start);
+        }
+        const variable = new ParameterVariable(name, identifier, this.context);
+        this.variables.set(name, variable);
+        // We also add it to the body scope to detect name conflicts with local
+        // variables. We still need the intermediate scope, though, as parameter
+        // defaults are NOT taken from the body scope but from the parameters or
+        // outside scope.
+        this.bodyScope.addHoistedVariable(name, variable);
+        return variable;
+    }
+    addParameterVariables(parameters, hasRest) {
+        this.parameters = parameters;
+        for (const parameterList of parameters) {
+            for (const parameter of parameterList) {
+                parameter.alwaysRendered = true;
+            }
+        }
+        this.hasRest = hasRest;
+    }
+    includeCallArguments(context, parameters) {
+        let calledFromTryStatement = false;
+        let argumentIncluded = false;
+        const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
+        for (const checkedArgument of parameters) {
+            if (checkedArgument instanceof SpreadElement) {
+                for (const argument of parameters) {
+                    argument.include(context, false);
+                }
+                break;
+            }
+        }
+        for (let index = parameters.length - 1; index >= 0; index--) {
+            const parameterVariables = this.parameters[index] || restParameter;
+            const argument = parameters[index];
+            if (parameterVariables) {
+                calledFromTryStatement = false;
+                if (parameterVariables.length === 0) {
+                    // handle empty destructuring
+                    argumentIncluded = true;
+                }
+                else {
+                    for (const variable of parameterVariables) {
+                        if (variable.included) {
+                            argumentIncluded = true;
+                        }
+                        if (variable.calledFromTryStatement) {
+                            calledFromTryStatement = true;
+                        }
+                    }
+                }
+            }
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
+                argumentIncluded = true;
+            }
+            if (argumentIncluded) {
+                argument.include(context, calledFromTryStatement);
+            }
+        }
+    }
+}
+
+class ReturnValueScope extends ParameterScope {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.returnExpressions = [];
+    }
+    addReturnExpression(expression) {
+        this.returnExpressions.push(expression);
+    }
+    getReturnExpression() {
+        if (this.returnExpression === null)
+            this.updateReturnExpression();
+        return this.returnExpression;
+    }
+    updateReturnExpression() {
+        if (this.returnExpressions.length === 1) {
+            this.returnExpression = this.returnExpressions[0];
+        }
+        else {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            for (const expression of this.returnExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
+}
+
+class FunctionScope extends ReturnValueScope {
+    constructor(parent) {
+        const { context } = parent;
+        super(parent, false);
+        this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
+        this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+    includeCallArguments(context, parameters) {
+        super.includeCallArguments(context, parameters);
+        if (this.argumentsVariable.included) {
+            for (const argument of parameters) {
+                if (!argument.included) {
+                    argument.include(context, false);
+                }
+            }
+        }
+    }
+}
+
+class ExpressionStatement extends NodeBase {
+    initialise() {
+        super.initialise();
+        if (this.directive &&
+            this.directive !== 'use strict' &&
+            this.parent.type === parseAst_js.Program) {
+            this.scope.context.log(parseAst_js.LOGLEVEL_WARN, 
+            // This is necessary, because either way (deleting or not) can lead to errors.
+            parseAst_js.logModuleLevelDirective(this.directive, this.scope.context.module.id), this.start);
+        }
+    }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
+    render(code, options) {
+        super.render(code, options);
+        if (code.original[this.end - 1] !== ';') {
+            code.appendLeft(this.end, ';');
+        }
+    }
+    shouldBeIncluded(context) {
+        if (this.directive && this.directive !== 'use strict')
+            return this.parent.type !== parseAst_js.Program;
+        return super.shouldBeIncluded(context);
+    }
+    applyDeoptimizations() { }
+}
+
+class BlockStatement extends NodeBase {
+    get deoptimizeBody() {
+        return isFlagSet(this.flags, 32768 /* Flag.deoptimizeBody */);
+    }
+    set deoptimizeBody(value) {
+        this.flags = setFlag(this.flags, 32768 /* Flag.deoptimizeBody */, value);
+    }
+    get directlyIncluded() {
+        return isFlagSet(this.flags, 16384 /* Flag.directlyIncluded */);
+    }
+    set directlyIncluded(value) {
+        this.flags = setFlag(this.flags, 16384 /* Flag.directlyIncluded */, value);
+    }
+    addImplicitReturnExpressionToScope() {
+        const lastStatement = this.body[this.body.length - 1];
+        if (!lastStatement || lastStatement.type !== parseAst_js.ReturnStatement) {
+            this.scope.addReturnExpression(UNKNOWN_EXPRESSION);
+        }
+    }
+    createScope(parentScope) {
+        this.scope = this.parent.preventChildBlockScope
+            ? parentScope
+            : new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.deoptimizeBody)
+            return true;
+        for (const node of this.body) {
+            if (context.brokenFlow)
+                break;
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!(this.deoptimizeBody && this.directlyIncluded)) {
+            this.included = true;
+            this.directlyIncluded = true;
+            if (this.deoptimizeBody)
+                includeChildrenRecursively = true;
+            for (const node of this.body) {
+                if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                    node.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        const firstBodyStatement = this.body[0];
+        this.deoptimizeBody =
+            firstBodyStatement instanceof ExpressionStatement &&
+                firstBodyStatement.directive === 'use asm';
+    }
+    render(code, options) {
+        if (this.body.length > 0) {
+            renderStatementList(this.body, code, this.start + 1, this.end - 1, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
+class RestElement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.argument.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.argument.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 ||
+            this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
+    markDeclarationReached() {
+        this.argument.markDeclarationReached();
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class FunctionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+        this.parameterVariableValuesDeoptimized = false;
+    }
+    get async() {
+        return isFlagSet(this.flags, 256 /* Flag.async */);
+    }
+    set async(value) {
+        this.flags = setFlag(this.flags, 256 /* Flag.async */, value);
+    }
+    get deoptimizedReturn() {
+        return isFlagSet(this.flags, 512 /* Flag.deoptimizedReturn */);
+    }
+    set deoptimizedReturn(value) {
+        this.flags = setFlag(this.flags, 512 /* Flag.deoptimizedReturn */, value);
+    }
+    get generator() {
+        return isFlagSet(this.flags, 4194304 /* Flag.generator */);
+    }
+    set generator(value) {
+        this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
+    }
+    updateParameterVariableValues(_arguments) {
+        for (let position = 0; position < this.params.length; position++) {
+            const parameter = this.params[position];
+            if (!(parameter instanceof Identifier)) {
+                continue;
+            }
+            const parameterVariable = parameter.variable;
+            const argument = _arguments[position + 1] ?? UNDEFINED_EXPRESSION;
+            parameterVariable.updateKnownValue(argument);
+        }
+    }
+    deoptimizeParameterVariableValues() {
+        for (const parameter of this.params) {
+            if (parameter instanceof Identifier) {
+                const parameterVariable = parameter.variable;
+                parameterVariable.markReassigned();
+            }
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_CALLED) {
+            const { parameters } = this.scope;
+            const { args } = interaction;
+            let hasRest = false;
+            for (let position = 0; position < args.length - 1; position++) {
+                const parameter = this.params[position];
+                // Only the "this" argument arg[0] can be null
+                const argument = args[position + 1];
+                if (argument instanceof SpreadElement) {
+                    this.deoptimizeParameterVariableValues();
+                }
+                if (hasRest || parameter instanceof RestElement) {
+                    hasRest = true;
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else if (parameter instanceof Identifier) {
+                    parameters[position][0].addEntityToBeDeoptimized(argument);
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+                else if (parameter) {
+                    argument.deoptimizePath(UNKNOWN_PATH);
+                }
+                else {
+                    this.addArgumentToBeDeoptimized(argument);
+                }
+            }
+            this.updateParameterVariableValues(args);
+        }
+        else {
+            this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+        if (path.length === 1 && path[0] === UnknownKey) {
+            // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
+            // which means the return expression and parameters need to be reassigned
+            this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+            for (const parameterList of this.scope.parameters) {
+                for (const parameter of parameterList) {
+                    parameter.deoptimizePath(UNKNOWN_PATH);
+                    parameter.markReassigned();
+                }
+            }
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (path.length > 0) {
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        if (this.async) {
+            if (!this.deoptimizedReturn) {
+                this.deoptimizedReturn = true;
+                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+                this.scope.context.requestTreeshakingPass();
+            }
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return [this.scope.getReturnExpression(), false];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length > 0 || interaction.type !== INTERACTION_CALLED) {
+            return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (this.async) {
+            const { propertyReadSideEffects } = this.scope.context.options
+                .treeshake;
+            const returnExpression = this.scope.getReturnExpression();
+            if (returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_CALL, context) ||
+                (propertyReadSideEffects &&
+                    (propertyReadSideEffects === 'always' ||
+                        returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_ACCESS, context)))) {
+                return true;
+            }
+        }
+        for (const parameter of this.params) {
+            if (parameter.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * If the function (expression or declaration) is only used as function calls
+     */
+    onlyFunctionCallUsed() {
+        let variable = null;
+        if (this.parent.type === parseAst_js.VariableDeclarator) {
+            variable = this.parent.id.variable ?? null;
+        }
+        if (this.parent.type === parseAst_js.ExportDefaultDeclaration) {
+            variable = this.parent.variable;
+        }
+        return variable?.getOnlyFunctionCallUsed() ?? false;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.parameterVariableValuesDeoptimized && !this.onlyFunctionCallUsed()) {
+            this.parameterVariableValuesDeoptimized = true;
+            this.deoptimizeParameterVariableValues();
+        }
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        const { brokenFlow } = context;
+        context.brokenFlow = false;
+        this.body.include(context, includeChildrenRecursively);
+        context.brokenFlow = brokenFlow;
+    }
+    includeCallArguments(context, parameters) {
+        this.scope.includeCallArguments(context, parameters);
+    }
+    initialise() {
+        super.initialise();
+        if (this.body instanceof BlockStatement) {
+            this.body.addImplicitReturnExpressionToScope();
+        }
+        else {
+            this.scope.addReturnExpression(this.body);
+        }
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationNoSideEffects = this.annotations.some(comment => comment.type === 'noSideEffects');
+        }
+    }
+    parseNode(esTreeNode) {
+        const { body, params } = esTreeNode;
+        const { scope } = this;
+        const { bodyScope, context } = scope;
+        // We need to ensure that parameters are declared before the body is parsed
+        // so that the scope already knows all parameters and can detect conflicts
+        // when parsing the body.
+        const parameters = (this.params = params.map((parameter) => new (context.getNodeConstructor(parameter.type))(this, scope).parseNode(parameter)));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        this.body = new (context.getNodeConstructor(body.type))(this, bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
+    }
+    addArgumentToBeDeoptimized(_argument) { }
+    applyDeoptimizations() { }
+}
+FunctionBase.prototype.preventChildBlockScope = true;
+
+class FunctionNode extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new FunctionScope(parentScope);
+        this.constructedEntity = new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE);
+        // This makes sure that all deoptimizations of "this" are applied to the
+        // constructed entity.
+        this.scope.thisVariable.addEntityToBeDeoptimized(this.constructedEntity);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        if (interaction.type === INTERACTION_CALLED && path.length === 0 && interaction.args[0]) {
+            // args[0] is the "this" argument
+            this.scope.thisVariable.addEntityToBeDeoptimized(interaction.args[0]);
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        return !!this.id?.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
+            return true;
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (interaction.type === INTERACTION_CALLED) {
+            const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
+            context.replacedVariableInits.set(this.scope.thisVariable, interaction.withNew ? this.constructedEntity : UNKNOWN_EXPRESSION);
+            const { brokenFlow, ignore, replacedVariableInits } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true,
+                this: interaction.withNew
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.brokenFlow = brokenFlow;
+            if (thisInit) {
+                replacedVariableInits.set(this.scope.thisVariable, thisInit);
+            }
+            else {
+                replacedVariableInits.delete(this.scope.thisVariable);
+            }
+            context.ignore = ignore;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        this.id?.include();
+        const hasArguments = this.scope.argumentsVariable.included;
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier) || hasArguments) {
+                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.id?.declare('function', this);
+    }
+    addArgumentToBeDeoptimized(argument) {
+        this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([
+            {
+                key: 'prototype',
+                kind: 'init',
+                property: new ObjectEntity([], OBJECT_PROTOTYPE)
+            }
+        ], OBJECT_PROTOTYPE));
+    }
+}
+
+class FunctionDeclaration extends FunctionNode {
+    initialise() {
+        super.initialise();
+        if (this.id !== null) {
+            this.id.variable.isId = true;
+        }
+    }
+    onlyFunctionCallUsed() {
+        // call super.onlyFunctionCallUsed for export default anonymous function
+        return this.id?.variable.getOnlyFunctionCallUsed() ?? super.onlyFunctionCallUsed();
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+}
+
+// The header ends at the first non-white-space after "default"
+function getDeclarationStart(code, start) {
+    return findNonWhiteSpace(code, findFirstOccurrenceOutsideComment(code, 'default', start) + 7);
+}
+function getFunctionIdInsertPosition(code, start) {
+    const declarationEnd = findFirstOccurrenceOutsideComment(code, 'function', start) + 'function'.length;
+    code = code.slice(declarationEnd, findFirstOccurrenceOutsideComment(code, '(', declarationEnd));
+    const generatorStarPos = findFirstOccurrenceOutsideComment(code, '*');
+    if (generatorStarPos === -1) {
+        return declarationEnd;
+    }
+    return declarationEnd + generatorStarPos + 1;
+}
+class ExportDefaultDeclaration extends NodeBase {
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        if (includeChildrenRecursively) {
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+    initialise() {
+        super.initialise();
+        const declaration = this.declaration;
+        this.declarationName =
+            (declaration.id && declaration.id.name) || this.declaration.name;
+        this.variable = this.scope.addExportDefaultDeclaration(this.declarationName || this.scope.context.getModuleName(), this, this.scope.context);
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        const declarationStart = getDeclarationStart(code.original, this.start);
+        if (this.declaration instanceof FunctionDeclaration) {
+            this.renderNamedDeclaration(code, declarationStart, this.declaration.id === null
+                ? getFunctionIdInsertPosition(code.original, declarationStart)
+                : null, options);
+        }
+        else if (this.declaration instanceof ClassDeclaration) {
+            this.renderNamedDeclaration(code, declarationStart, this.declaration.id === null
+                ? findFirstOccurrenceOutsideComment(code.original, 'class', start) + 'class'.length
+                : null, options);
+        }
+        else if (this.variable.getOriginalVariable() !== this.variable) {
+            // Remove altogether to prevent re-declaring the same variable
+            treeshakeNode(this, code, start, end);
+            return;
+        }
+        else if (this.variable.included) {
+            this.renderVariableDeclaration(code, declarationStart, options);
+        }
+        else {
+            code.remove(this.start, declarationStart);
+            this.declaration.render(code, options, {
+                renderedSurroundingElement: parseAst_js.ExpressionStatement
+            });
+            if (code.original[this.end - 1] !== ';') {
+                code.appendLeft(this.end, ';');
+            }
+            return;
+        }
+        this.declaration.render(code, options);
+    }
+    applyDeoptimizations() { }
+    renderNamedDeclaration(code, declarationStart, idInsertPosition, options) {
+        const { exportNamesByVariable, format, snippets: { getPropertyAccess } } = options;
+        const name = this.variable.getName(getPropertyAccess);
+        // Remove `export default`
+        code.remove(this.start, declarationStart);
+        if (idInsertPosition !== null) {
+            code.appendLeft(idInsertPosition, ` ${name}`);
+        }
+        if (format === 'system' &&
+            this.declaration instanceof ClassDeclaration &&
+            exportNamesByVariable.has(this.variable)) {
+            code.appendLeft(this.end, ` ${getSystemExportStatement([this.variable], options)};`);
+        }
+    }
+    renderVariableDeclaration(code, declarationStart, { format, exportNamesByVariable, snippets: { cnst, getPropertyAccess } }) {
+        const hasTrailingSemicolon = code.original.charCodeAt(this.end - 1) === 59; /*";"*/
+        const systemExportNames = format === 'system' && exportNamesByVariable.get(this.variable);
+        if (systemExportNames) {
+            code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = exports(${JSON.stringify(systemExportNames[0])}, `);
+            code.appendRight(hasTrailingSemicolon ? this.end - 1 : this.end, ')' + (hasTrailingSemicolon ? '' : ';'));
+        }
+        else {
+            code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = `);
+            if (!hasTrailingSemicolon) {
+                code.appendLeft(this.end, ';');
+            }
+        }
+    }
+}
+ExportDefaultDeclaration.prototype.needsBoundaries = true;
+
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+    if (!needsEscapeRegEx.test(id))
+        return id;
+    return id.replace(backSlashRegEx, '\\\\').replace(quoteNewlineRegEx, '\\$1');
+}
+
+const INTEROP_DEFAULT_VARIABLE = '_interopDefault';
+const INTEROP_DEFAULT_COMPAT_VARIABLE = '_interopDefaultCompat';
+const INTEROP_NAMESPACE_VARIABLE = '_interopNamespace';
+const INTEROP_NAMESPACE_COMPAT_VARIABLE = '_interopNamespaceCompat';
+const INTEROP_NAMESPACE_DEFAULT_VARIABLE = '_interopNamespaceDefault';
+const INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE = '_interopNamespaceDefaultOnly';
+const MERGE_NAMESPACES_VARIABLE = '_mergeNamespaces';
+const DOCUMENT_CURRENT_SCRIPT = '_documentCurrentScript';
+const defaultInteropHelpersByInteropType = {
+    auto: INTEROP_DEFAULT_VARIABLE,
+    compat: INTEROP_DEFAULT_COMPAT_VARIABLE,
+    default: null,
+    defaultOnly: null,
+    esModule: null
+};
+const isDefaultAProperty = (interopType, externalLiveBindings) => interopType === 'esModule' ||
+    (externalLiveBindings && (interopType === 'auto' || interopType === 'compat'));
+const namespaceInteropHelpersByInteropType = {
+    auto: INTEROP_NAMESPACE_VARIABLE,
+    compat: INTEROP_NAMESPACE_COMPAT_VARIABLE,
+    default: INTEROP_NAMESPACE_DEFAULT_VARIABLE,
+    defaultOnly: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE,
+    esModule: null
+};
+const canDefaultBeTakenFromNamespace = (interopType, externalLiveBindings) => interopType !== 'esModule' && isDefaultAProperty(interopType, externalLiveBindings);
+const getHelpersBlock = (additionalHelpers, accessedGlobals, indent, snippets, liveBindings, freeze, symbols) => {
+    const usedHelpers = new Set(additionalHelpers);
+    for (const variable of HELPER_NAMES) {
+        if (accessedGlobals.has(variable)) {
+            usedHelpers.add(variable);
+        }
+    }
+    return HELPER_NAMES.map(variable => usedHelpers.has(variable)
+        ? HELPER_GENERATORS[variable](indent, snippets, liveBindings, freeze, symbols, usedHelpers)
+        : '').join('');
+};
+const HELPER_GENERATORS = {
+    [DOCUMENT_CURRENT_SCRIPT](_t, { _, n }) {
+        return `var ${DOCUMENT_CURRENT_SCRIPT}${_}=${_}typeof document${_}!==${_}'undefined'${_}?${_}document.currentScript${_}:${_}null;${n}`;
+    },
+    [INTEROP_DEFAULT_COMPAT_VARIABLE](_t, snippets, liveBindings) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_DEFAULT_COMPAT_VARIABLE
+        });
+        return (`${left}${getIsCompatNamespace(snippets)}${_}?${_}` +
+            `${liveBindings ? getDefaultLiveBinding(snippets) : getDefaultStatic(snippets)}${right}${n}${n}`);
+    },
+    [INTEROP_DEFAULT_VARIABLE](_t, snippets, liveBindings) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_DEFAULT_VARIABLE
+        });
+        return (`${left}e${_}&&${_}e.__esModule${_}?${_}` +
+            `${liveBindings ? getDefaultLiveBinding(snippets) : getDefaultStatic(snippets)}${right}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_COMPAT_VARIABLE](t, snippets, liveBindings, freeze, symbols, usedHelpers) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        if (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)) {
+            const [left, right] = getDirectReturnFunction(['e'], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: INTEROP_NAMESPACE_COMPAT_VARIABLE
+            });
+            return `${left}${getIsCompatNamespace(snippets)}${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${right}${n}${n}`;
+        }
+        return (`function ${INTEROP_NAMESPACE_COMPAT_VARIABLE}(e)${_}{${n}` +
+            `${t}if${_}(${getIsCompatNamespace(snippets)})${_}return e;${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE](_t, snippets, _liveBindings, freeze, symbols) {
+        const { getDirectReturnFunction, getObject, n, _ } = snippets;
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE
+        });
+        return `${left}${getFrozen(freeze, getWithToStringTag(symbols, getObject([
+            [null, `__proto__:${_}null`],
+            ['default', 'e']
+        ], { lineBreakIndent: null }), snippets))}${right}${n}${n}`;
+    },
+    [INTEROP_NAMESPACE_DEFAULT_VARIABLE](t, snippets, liveBindings, freeze, symbols) {
+        const { _, n } = snippets;
+        return (`function ${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${_}{${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [INTEROP_NAMESPACE_VARIABLE](t, snippets, liveBindings, freeze, symbols, usedHelpers) {
+        const { _, getDirectReturnFunction, n } = snippets;
+        if (usedHelpers.has(INTEROP_NAMESPACE_DEFAULT_VARIABLE)) {
+            const [left, right] = getDirectReturnFunction(['e'], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: INTEROP_NAMESPACE_VARIABLE
+            });
+            return `${left}e${_}&&${_}e.__esModule${_}?${_}e${_}:${_}${INTEROP_NAMESPACE_DEFAULT_VARIABLE}(e)${right}${n}${n}`;
+        }
+        return (`function ${INTEROP_NAMESPACE_VARIABLE}(e)${_}{${n}` +
+            `${t}if${_}(e${_}&&${_}e.__esModule)${_}return e;${n}` +
+            createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) +
+            `}${n}${n}`);
+    },
+    [MERGE_NAMESPACES_VARIABLE](t, snippets, liveBindings, freeze, symbols) {
+        const { _, cnst, n } = snippets;
+        const useForEach = cnst === 'var' && liveBindings;
+        return (`function ${MERGE_NAMESPACES_VARIABLE}(n, m)${_}{${n}` +
+            `${t}${loopOverNamespaces(`{${n}` +
+                `${t}${t}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!(k in n))${_}{${n}` +
+                (liveBindings
+                    ? useForEach
+                        ? copyOwnPropertyLiveBinding
+                        : copyPropertyLiveBinding
+                    : copyPropertyStatic)(t, t + t + t + t, snippets) +
+                `${t}${t}${t}}${n}` +
+                `${t}${t}}`, useForEach, t, snippets)}${n}` +
+            `${t}return ${getFrozen(freeze, getWithToStringTag(symbols, 'n', snippets))};${n}` +
+            `}${n}${n}`);
+    }
+};
+const getDefaultLiveBinding = ({ _, getObject }) => `e${_}:${_}${getObject([['default', 'e']], { lineBreakIndent: null })}`;
+const getDefaultStatic = ({ _, getPropertyAccess }) => `e${getPropertyAccess('default')}${_}:${_}e`;
+const getIsCompatNamespace = ({ _ }) => `e${_}&&${_}typeof e${_}===${_}'object'${_}&&${_}'default'${_}in e`;
+const createNamespaceObject = (t, index, snippets, liveBindings, freeze, symbols) => {
+    const { _, cnst, getObject, getPropertyAccess, n, s } = snippets;
+    const copyProperty = `{${n}` +
+        (liveBindings ? copyNonDefaultOwnPropertyLiveBinding : copyPropertyStatic)(t, index + t + t, snippets) +
+        `${index}${t}}`;
+    return (`${index}${cnst} n${_}=${_}Object.create(null${symbols ? `,${_}{${_}[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}${_}}` : ''});${n}` +
+        `${index}if${_}(e)${_}{${n}` +
+        `${index}${t}${loopOverKeys(copyProperty, !liveBindings, snippets)}${n}` +
+        `${index}}${n}` +
+        `${index}n${getPropertyAccess('default')}${_}=${_}e;${n}` +
+        `${index}return ${getFrozen(freeze, 'n')}${s}${n}`);
+};
+const loopOverKeys = (body, allowVariableLoopVariable, { _, cnst, getFunctionIntro, s }) => cnst !== 'var' || allowVariableLoopVariable
+    ? `for${_}(${cnst} k in e)${_}${body}`
+    : `Object.keys(e).forEach(${getFunctionIntro(['k'], {
+        isAsync: false,
+        name: null
+    })}${body})${s}`;
+const loopOverNamespaces = (body, useForEach, t, { _, cnst, getDirectReturnFunction, getFunctionIntro, n }) => {
+    if (useForEach) {
+        const [left, right] = getDirectReturnFunction(['e'], {
+            functionReturn: false,
+            lineBreakIndent: { base: t, t },
+            name: null
+        });
+        return (`m.forEach(${left}` +
+            `e${_}&&${_}typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e)${_}&&${_}Object.keys(e).forEach(${getFunctionIntro(['k'], {
+                isAsync: false,
+                name: null
+            })}${body})${right});`);
+    }
+    return (`for${_}(var i${_}=${_}0;${_}i${_}<${_}m.length;${_}i++)${_}{${n}` +
+        `${t}${t}${cnst} e${_}=${_}m[i];${n}` +
+        `${t}${t}if${_}(typeof e${_}!==${_}'string'${_}&&${_}!Array.isArray(e))${_}{${_}for${_}(${cnst} k in e)${_}${body}${_}}${n}${t}}`);
+};
+const copyNonDefaultOwnPropertyLiveBinding = (t, index, snippets) => {
+    const { _, n } = snippets;
+    return (`${index}if${_}(k${_}!==${_}'default')${_}{${n}` +
+        copyOwnPropertyLiveBinding(t, index + t, snippets) +
+        `${index}}${n}`);
+};
+const copyOwnPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
+    const [left, right] = getDirectReturnFunction([], {
+        functionReturn: true,
+        lineBreakIndent: null,
+        name: null
+    });
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}enumerable:${_}true,${n}` +
+        `${index}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}});${n}`);
+};
+const copyPropertyLiveBinding = (t, index, { _, cnst, getDirectReturnFunction, n }) => {
+    const [left, right] = getDirectReturnFunction([], {
+        functionReturn: true,
+        lineBreakIndent: null,
+        name: null
+    });
+    return (`${index}${cnst} d${_}=${_}Object.getOwnPropertyDescriptor(e,${_}k);${n}` +
+        `${index}if${_}(d)${_}{${n}` +
+        `${index}${t}Object.defineProperty(n,${_}k,${_}d.get${_}?${_}d${_}:${_}{${n}` +
+        `${index}${t}${t}enumerable:${_}true,${n}` +
+        `${index}${t}${t}get:${_}${left}e[k]${right}${n}` +
+        `${index}${t}});${n}` +
+        `${index}}${n}`);
+};
+const copyPropertyStatic = (_t, index, { _, n }) => `${index}n[k]${_}=${_}e[k];${n}`;
+const getFrozen = (freeze, fragment) => freeze ? `Object.freeze(${fragment})` : fragment;
+const getWithToStringTag = (symbols, fragment, { _, getObject }) => symbols
+    ? `Object.defineProperty(${fragment},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`
+    : fragment;
+const HELPER_NAMES = Object.keys(HELPER_GENERATORS);
+function getToStringTagValue(getObject) {
+    return getObject([['value', "'Module'"]], {
+        lineBreakIndent: null
+    });
+}
+
+class Literal extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath() { }
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 ||
+            // unknown literals can also be null but do not start with an "n"
+            (this.value === null && this.scope.context.code.charCodeAt(this.start) !== 110) ||
+            typeof this.value === 'bigint' ||
+            // to support shims for regular expressions
+            this.scope.context.code.charCodeAt(this.start) === 47) {
+            return UnknownValue;
+        }
+        return this.value;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1)
+            return UNKNOWN_RETURN_EXPRESSION;
+        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return path.length > (this.value === null ? 0 : 1);
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                if (this.included &&
+                    this.value instanceof RegExp &&
+                    (this.value.global || this.value.sticky)) {
+                    return true;
+                }
+                return (path.length !== 1 ||
+                    hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.members = getLiteralMembersForValue(this.value);
+    }
+    parseNode(esTreeNode) {
+        this.value = esTreeNode.value;
+        this.regex = esTreeNode.regex;
+        return super.parseNode(esTreeNode);
+    }
+    render(code) {
+        if (typeof this.value === 'string') {
+            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
+        }
+    }
+}
+
+function getChainElementLiteralValueAtPath(element, object, path, recursionTracker, origin) {
+    if ('getLiteralValueAtPathAsChainElement' in object) {
+        const calleeValue = object.getLiteralValueAtPathAsChainElement(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin);
+        if (calleeValue === IS_SKIPPED_CHAIN || (element.optional && calleeValue == null)) {
+            return IS_SKIPPED_CHAIN;
+        }
+    }
+    else if (element.optional &&
+        object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, origin) == null) {
+        return IS_SKIPPED_CHAIN;
+    }
+    return element.getLiteralValueAtPath(path, recursionTracker, origin);
+}
+
+// To avoid infinite recursions
+const MAX_PATH_DEPTH = 7;
+function getResolvablePropertyKey(memberExpression) {
+    return memberExpression.computed
+        ? getResolvableComputedPropertyKey(memberExpression.property)
+        : memberExpression.property.name;
+}
+function getResolvableComputedPropertyKey(propertyKey) {
+    if (propertyKey instanceof Literal) {
+        return String(propertyKey.value);
+    }
+    return null;
+}
+function getPathIfNotComputed(memberExpression) {
+    const nextPathKey = memberExpression.propertyKey;
+    const object = memberExpression.object;
+    if (typeof nextPathKey === 'string') {
+        if (object instanceof Identifier) {
+            return [
+                { key: object.name, pos: object.start },
+                { key: nextPathKey, pos: memberExpression.property.start }
+            ];
+        }
+        if (object instanceof MemberExpression) {
+            const parentPath = getPathIfNotComputed(object);
+            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
+        }
+    }
+    return null;
+}
+function getStringFromPath(path) {
+    let pathString = path[0].key;
+    for (let index = 1; index < path.length; index++) {
+        pathString += '.' + path[index].key;
+    }
+    return pathString;
+}
+class MemberExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.expressionsToBeDeoptimized = [];
+    }
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    get assignmentDeoptimized() {
+        return isFlagSet(this.flags, 16 /* Flag.assignmentDeoptimized */);
+    }
+    set assignmentDeoptimized(value) {
+        this.flags = setFlag(this.flags, 16 /* Flag.assignmentDeoptimized */, value);
+    }
+    get bound() {
+        return isFlagSet(this.flags, 32 /* Flag.bound */);
+    }
+    set bound(value) {
+        this.flags = setFlag(this.flags, 32 /* Flag.bound */, value);
+    }
+    get isUndefined() {
+        return isFlagSet(this.flags, 64 /* Flag.isUndefined */);
+    }
+    set isUndefined(value) {
+        this.flags = setFlag(this.flags, 64 /* Flag.isUndefined */, value);
+    }
+    bind() {
+        this.bound = true;
+        const path = getPathIfNotComputed(this);
+        const baseVariable = path && this.scope.findVariable(path[0].key);
+        if (baseVariable?.isNamespace) {
+            const resolvedVariable = resolveNamespaceVariables(baseVariable, path.slice(1), this.scope.context);
+            if (!resolvedVariable) {
+                super.bind();
+            }
+            else if (resolvedVariable === 'undefined') {
+                this.isUndefined = true;
+            }
+            else {
+                this.variable = resolvedVariable;
+                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
+            }
+        }
+        else {
+            super.bind();
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.variable) {
+            this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+        else if (!this.isUndefined) {
+            if (path.length < MAX_PATH_DEPTH) {
+                this.object.deoptimizeArgumentsOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizeCache() {
+        const { expressionsToBeDeoptimized, object } = this;
+        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+        this.propertyKey = UnknownKey;
+        object.deoptimizePath(UNKNOWN_PATH);
+        for (const expression of expressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0)
+            this.disallowNamespaceReassignment();
+        if (this.variable) {
+            this.variable.deoptimizePath(path);
+        }
+        else if (!this.isUndefined && path.length < MAX_PATH_DEPTH) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizePath([
+                propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                ...path
+            ]);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+        }
+        return UnknownValue;
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return undefined;
+        }
+        return getChainElementLiteralValueAtPath(this, this.object, path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }
+        if (this.isUndefined) {
+            return [UNDEFINED_EXPRESSION, false];
+        }
+        if (this.propertyKey !== UnknownKey && path.length < MAX_PATH_DEPTH) {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            this.hasAccessEffect(context));
+    }
+    hasEffectsAsChainElement(context) {
+        if (this.variable || this.isUndefined)
+            return this.hasEffects(context);
+        const objectHasEffects = 'hasEffectsAsChainElement' in this.object
+            ? this.object.hasEffectsAsChainElement(context)
+            : this.object.hasEffects(context);
+        if (objectHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.object.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return objectHasEffects || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return objectHasEffects || this.property.hasEffects(context) || this.hasAccessEffect(context);
+    }
+    hasEffectsAsAssignmentTarget(context, checkAccess) {
+        if (checkAccess && !this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            (checkAccess && this.hasAccessEffect(context)) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.variable) {
+            return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        if (this.isUndefined) {
+            return true;
+        }
+        if (path.length < MAX_PATH_DEPTH) {
+            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
+        }
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.includeProperties(context, includeChildrenRecursively);
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        if (deoptimizeAccess) {
+            this.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.includeProperties(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.variable) {
+            this.variable.includeCallArguments(context, parameters);
+        }
+        else {
+            super.includeCallArguments(context, parameters);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.propertyKey = getResolvablePropertyKey(this);
+        this.accessInteraction = { args: [this.object], type: INTERACTION_ACCESSED };
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = parseAst_js.BLANK) {
+        if (this.variable || this.isUndefined) {
+            const { snippets: { getPropertyAccess } } = options;
+            let replacement = this.variable ? this.variable.getName(getPropertyAccess) : 'undefined';
+            if (renderedParentType && isCalleeOfRenderedParent)
+                replacement = '0, ' + replacement;
+            code.overwrite(this.start, this.end, replacement, {
+                contentOnly: true,
+                storeName: true
+            });
+        }
+        else {
+            if (renderedParentType && isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+            this.object.render(code, options, { renderedSurroundingElement });
+            this.property.render(code, options);
+        }
+    }
+    setAssignedValue(value) {
+        this.assignmentInteraction = {
+            args: [this.object, value],
+            type: INTERACTION_ASSIGNED
+        };
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.variable) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    applyAssignmentDeoptimization() {
+        this.assignmentDeoptimized = true;
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.isUndefined)) {
+            this.object.deoptimizeArgumentsOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    disallowNamespaceReassignment() {
+        if (this.object instanceof Identifier) {
+            const variable = this.scope.findVariable(this.object.name);
+            if (variable.isNamespace) {
+                if (this.variable) {
+                    this.scope.context.includeVariableInModule(this.variable);
+                }
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logIllegalImportReassignment(this.object.name, this.scope.context.module.id), this.start);
+            }
+        }
+    }
+    getPropertyKey() {
+        if (this.propertyKey === null) {
+            this.propertyKey = UnknownKey;
+            const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return (this.propertyKey =
+                value === SymbolToStringTag
+                    ? value
+                    : typeof value === 'symbol'
+                        ? UnknownKey
+                        : String(value));
+        }
+        return this.propertyKey;
+    }
+    hasAccessEffect(context) {
+        const { propertyReadSideEffects } = this.scope.context.options
+            .treeshake;
+        return (!(this.variable || this.isUndefined) &&
+            propertyReadSideEffects &&
+            (propertyReadSideEffects === 'always' ||
+                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
+    includeProperties(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
+    }
+}
+function resolveNamespaceVariables(baseVariable, path, astContext) {
+    if (path.length === 0)
+        return baseVariable;
+    if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
+        return null;
+    const exportName = path[0].key;
+    const variable = baseVariable.context.traceExport(exportName);
+    if (!variable) {
+        if (path.length === 1) {
+            const fileName = baseVariable.context.fileName;
+            astContext.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingExport(exportName, astContext.module.id, fileName), path[0].pos);
+            return 'undefined';
+        }
+        return null;
+    }
+    return resolveNamespaceVariables(variable, path.slice(1), astContext);
+}
+
+const FILE_PREFIX = 'ROLLUP_FILE_URL_';
+const IMPORT = 'import';
+class MetaProperty extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.metaProperty = null;
+        this.preliminaryChunkId = null;
+        this.referenceId = null;
+    }
+    getReferencedFileName(outputPluginDriver) {
+        const { meta: { name }, metaProperty } = this;
+        if (name === IMPORT && metaProperty?.startsWith(FILE_PREFIX)) {
+            return outputPluginDriver.getFileName(metaProperty.slice(FILE_PREFIX.length));
+        }
+        return null;
+    }
+    hasEffects() {
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            if (this.meta.name === IMPORT) {
+                this.scope.context.addImportMeta(this);
+                const parent = this.parent;
+                const metaProperty = (this.metaProperty =
+                    parent instanceof MemberExpression && typeof parent.propertyKey === 'string'
+                        ? parent.propertyKey
+                        : null);
+                if (metaProperty?.startsWith(FILE_PREFIX)) {
+                    this.referenceId = metaProperty.slice(FILE_PREFIX.length);
+                }
+            }
+        }
+    }
+    render(code, renderOptions) {
+        const { format, pluginDriver, snippets } = renderOptions;
+        const { scope: { context: { module } }, meta: { name }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
+        const { id: moduleId } = module;
+        if (name !== IMPORT)
+            return;
+        const chunkId = preliminaryChunkId;
+        if (referenceId) {
+            const fileName = pluginDriver.getFileName(referenceId);
+            const relativePath = parseAst_js.normalize(path.relative(path.dirname(chunkId), fileName));
+            const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
+                { chunkId, fileName, format, moduleId, referenceId, relativePath }
+            ]) || relativeUrlMechanisms[format](relativePath);
+            code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            return;
+        }
+        let replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
+            metaProperty,
+            { chunkId, format, moduleId }
+        ]);
+        if (!replacement) {
+            replacement = importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
+            renderOptions.accessedDocumentCurrentScript ||=
+                formatsMaybeAccessDocumentCurrentScript.includes(format) && replacement !== 'undefined';
+        }
+        if (typeof replacement === 'string') {
+            if (parent instanceof MemberExpression) {
+                code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
+            }
+            else {
+                code.overwrite(start, end, replacement, { contentOnly: true });
+            }
+        }
+    }
+    setResolution(format, accessedGlobalsByScope, preliminaryChunkId) {
+        this.preliminaryChunkId = preliminaryChunkId;
+        const accessedGlobals = (this.metaProperty?.startsWith(FILE_PREFIX) ? accessedFileUrlGlobals : accessedMetaUrlGlobals)[format];
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+}
+const formatsMaybeAccessDocumentCurrentScript = ['cjs', 'iife', 'umd'];
+const accessedMetaUrlGlobals = {
+    amd: ['document', 'module', 'URL'],
+    cjs: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    es: [],
+    iife: ['document', 'URL', DOCUMENT_CURRENT_SCRIPT],
+    system: ['module'],
+    umd: ['document', 'require', 'URL', DOCUMENT_CURRENT_SCRIPT]
+};
+const accessedFileUrlGlobals = {
+    amd: ['document', 'require', 'URL'],
+    cjs: ['document', 'require', 'URL'],
+    es: [],
+    iife: ['document', 'URL'],
+    system: ['module', 'URL'],
+    umd: ['document', 'require', 'URL']
+};
+const getResolveUrl = (path, URL = 'URL') => `new ${URL}(${path}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(`'${escapeId(relativePath)}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ''}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`);
+const getGenericImportMetaMechanism = (getUrl) => (property, { chunkId }) => {
+    const urlMechanism = getUrl(chunkId);
+    return property === null
+        ? `({ url: ${urlMechanism} })`
+        : property === 'url'
+            ? urlMechanism
+            : 'undefined';
+};
+const getFileUrlFromFullPath = (path) => `require('u' + 'rl').pathToFileURL(${path}).href`;
+const getFileUrlFromRelativePath = (path) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path)}'`);
+const getUrlFromDocument = (chunkId, umd = false) => `${umd ? `typeof document === 'undefined' ? location.href : ` : ''}(${DOCUMENT_CURRENT_SCRIPT} && ${DOCUMENT_CURRENT_SCRIPT}.tagName.toUpperCase() === 'SCRIPT' && ${DOCUMENT_CURRENT_SCRIPT}.src || new URL('${escapeId(chunkId)}', document.baseURI).href)`;
+const relativeUrlMechanisms = {
+    amd: relativePath => {
+        if (relativePath[0] !== '.')
+            relativePath = './' + relativePath;
+        return getResolveUrl(`require.toUrl('${escapeId(relativePath)}'), document.baseURI`);
+    },
+    cjs: relativePath => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath)})`,
+    es: relativePath => getResolveUrl(`'${escapeId(relativePath)}', import.meta.url`),
+    iife: relativePath => getRelativeUrlFromDocument(relativePath),
+    system: relativePath => getResolveUrl(`'${escapeId(relativePath)}', module.meta.url`),
+    umd: relativePath => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(relativePath)} : ${getRelativeUrlFromDocument(relativePath, true)})`
+};
+const importMetaMechanisms = {
+    amd: getGenericImportMetaMechanism(() => getResolveUrl(`module.uri, document.baseURI`)),
+    cjs: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId)})`),
+    iife: getGenericImportMetaMechanism(chunkId => getUrlFromDocument(chunkId)),
+    system: (property, { snippets: { getPropertyAccess } }) => property === null ? `module.meta` : `module.meta${getPropertyAccess(property)}`,
+    umd: getGenericImportMetaMechanism(chunkId => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromFullPath('__filename')} : ${getUrlFromDocument(chunkId, true)})`)
+};
+
+class UndefinedVariable extends Variable {
+    constructor() {
+        super('undefined');
+    }
+    getLiteralValueAtPath() {
+        return undefined;
+    }
+}
+
+class ExportDefaultVariable extends LocalVariable {
+    constructor(name, exportDefaultDeclaration, context) {
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, 'other');
+        this.hasId = false;
+        this.originalId = null;
+        this.originalVariable = null;
+        const declaration = exportDefaultDeclaration.declaration;
+        if ((declaration instanceof FunctionDeclaration || declaration instanceof ClassDeclaration) &&
+            declaration.id) {
+            this.hasId = true;
+            this.originalId = declaration.id;
+        }
+        else if (declaration instanceof Identifier) {
+            this.originalId = declaration;
+        }
+    }
+    addReference(identifier) {
+        if (!this.hasId) {
+            this.name = identifier.name;
+        }
+    }
+    addUsedPlace(usedPlace) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.addUsedPlace(usedPlace);
+        }
+        else {
+            original.addUsedPlace(usedPlace);
+        }
+    }
+    forbidName(name) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.forbidName(name);
+        }
+        else {
+            original.forbidName(name);
+        }
+    }
+    getAssignedVariableName() {
+        return (this.originalId && this.originalId.name) || null;
+    }
+    getBaseVariableName() {
+        const original = this.getOriginalVariable();
+        return original === this ? super.getBaseVariableName() : original.getBaseVariableName();
+    }
+    getDirectOriginalVariable() {
+        return this.originalId &&
+            (this.hasId ||
+                !(this.originalId.isPossibleTDZ() ||
+                    this.originalId.variable.isReassigned ||
+                    this.originalId.variable instanceof UndefinedVariable ||
+                    // this avoids a circular dependency
+                    'syntheticNamespace' in this.originalId.variable))
+            ? this.originalId.variable
+            : null;
+    }
+    getName(getPropertyAccess) {
+        const original = this.getOriginalVariable();
+        return original === this
+            ? super.getName(getPropertyAccess)
+            : original.getName(getPropertyAccess);
+    }
+    getOriginalVariable() {
+        if (this.originalVariable)
+            return this.originalVariable;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let original = this;
+        let currentVariable;
+        const checkedVariables = new Set();
+        do {
+            checkedVariables.add(original);
+            currentVariable = original;
+            original = currentVariable.getDirectOriginalVariable();
+        } while (original instanceof ExportDefaultVariable && !checkedVariables.has(original));
+        return (this.originalVariable = original || currentVariable);
+    }
+}
+
+class NamespaceVariable extends Variable {
+    constructor(context) {
+        super(context.getModuleName());
+        this.memberVariables = null;
+        this.mergedNamespaces = [];
+        this.referencedEarly = false;
+        this.references = [];
+        this.context = context;
+        this.module = context.module;
+    }
+    addReference(identifier) {
+        this.references.push(identifier);
+        this.name = identifier.name;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (path.length > 1 || (path.length === 1 && interaction.type === INTERACTION_CALLED)) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
+            }
+            else {
+                deoptimizeInteraction(interaction);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length > 1) {
+            const key = path[0];
+            if (typeof key === 'string') {
+                this.getMemberVariables()[key]?.deoptimizePath(path.slice(1));
+            }
+        }
+    }
+    getLiteralValueAtPath(path) {
+        if (path[0] === SymbolToStringTag) {
+            return 'Module';
+        }
+        return UnknownValue;
+    }
+    getMemberVariables() {
+        if (this.memberVariables) {
+            return this.memberVariables;
+        }
+        const memberVariables = Object.create(null);
+        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
+        for (const name of sortedExports) {
+            if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
+                const exportedVariable = this.context.traceExport(name);
+                if (exportedVariable) {
+                    memberVariables[name] = exportedVariable;
+                }
+            }
+        }
+        return (this.memberVariables = memberVariables);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (path.length === 0) {
+            // This can only be a call anyway
+            return true;
+        }
+        if (path.length === 1 && type !== INTERACTION_CALLED) {
+            return type === INTERACTION_ASSIGNED;
+        }
+        const key = path[0];
+        if (typeof key !== 'string') {
+            return true;
+        }
+        const memberVariable = this.getMemberVariables()[key];
+        return (!memberVariable ||
+            memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
+    }
+    include() {
+        super.include();
+        this.context.includeAllExports();
+    }
+    prepare(accessedGlobalsByScope) {
+        if (this.mergedNamespaces.length > 0) {
+            this.module.scope.addAccessedGlobals([MERGE_NAMESPACES_VARIABLE], accessedGlobalsByScope);
+        }
+    }
+    renderBlock(options) {
+        const { exportNamesByVariable, format, freeze, indent: t, symbols, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
+        const memberVariables = this.getMemberVariables();
+        const members = Object.entries(memberVariables)
+            .filter(([_, variable]) => variable.included)
+            .map(([name, variable]) => {
+            if (this.referencedEarly || variable.isReassigned || variable === this) {
+                return [
+                    null,
+                    `get ${stringifyObjectKeyIfNeeded(name)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
+                ];
+            }
+            return [name, variable.getName(getPropertyAccess)];
+        });
+        members.unshift([null, `__proto__:${_}null`]);
+        let output = getObject(members, { lineBreakIndent: { base: '', t } });
+        if (this.mergedNamespaces.length > 0) {
+            const assignmentArguments = this.mergedNamespaces.map(variable => variable.getName(getPropertyAccess));
+            output = `/*#__PURE__*/${MERGE_NAMESPACES_VARIABLE}(${output},${_}[${assignmentArguments.join(`,${_}`)}])`;
+        }
+        else {
+            // The helper to merge namespaces will also take care of freezing and toStringTag
+            if (symbols) {
+                output = `/*#__PURE__*/Object.defineProperty(${output},${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)})`;
+            }
+            if (freeze) {
+                output = `/*#__PURE__*/Object.freeze(${output})`;
+            }
+        }
+        const name = this.getName(getPropertyAccess);
+        output = `${cnst} ${name}${_}=${_}${output};`;
+        if (format === 'system' && exportNamesByVariable.has(this)) {
+            output += `${n}${getSystemExportStatement([this], options)};`;
+        }
+        return output;
+    }
+    renderFirst() {
+        return this.referencedEarly;
+    }
+    setMergedNamespaces(mergedNamespaces) {
+        this.mergedNamespaces = mergedNamespaces;
+        const moduleExecIndex = this.context.getModuleExecIndex();
+        for (const identifier of this.references) {
+            const { context } = identifier.scope;
+            if (context.getModuleExecIndex() <= moduleExecIndex) {
+                this.referencedEarly = true;
+                break;
+            }
+        }
+    }
+}
+NamespaceVariable.prototype.isNamespace = true;
+
+class SyntheticNamedExportVariable extends Variable {
+    constructor(context, name, syntheticNamespace) {
+        super(name);
+        this.baseVariable = null;
+        this.context = context;
+        this.module = context.module;
+        this.syntheticNamespace = syntheticNamespace;
+    }
+    getBaseVariable() {
+        if (this.baseVariable)
+            return this.baseVariable;
+        let baseVariable = this.syntheticNamespace;
+        while (baseVariable instanceof ExportDefaultVariable ||
+            baseVariable instanceof SyntheticNamedExportVariable) {
+            if (baseVariable instanceof ExportDefaultVariable) {
+                const original = baseVariable.getOriginalVariable();
+                if (original === baseVariable)
+                    break;
+                baseVariable = original;
+            }
+            if (baseVariable instanceof SyntheticNamedExportVariable) {
+                baseVariable = baseVariable.syntheticNamespace;
+            }
+        }
+        return (this.baseVariable = baseVariable);
+    }
+    getBaseVariableName() {
+        return this.syntheticNamespace.getBaseVariableName();
+    }
+    getName(getPropertyAccess) {
+        return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
+    }
+    include() {
+        super.include();
+        this.context.includeVariableInModule(this.syntheticNamespace);
+    }
+    setRenderNames(baseName, name) {
+        super.setRenderNames(baseName, name);
+    }
+}
+
+class ExternalChunk {
+    constructor(module, options, inputBase) {
+        this.options = options;
+        this.inputBase = inputBase;
+        this.defaultVariableName = '';
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.fileName = null;
+        this.importAttributes = null;
+        this.id = module.id;
+        this.moduleInfo = module.info;
+        this.renormalizeRenderPath = module.renormalizeRenderPath;
+        this.suggestedVariableName = module.suggestedVariableName;
+    }
+    getFileName() {
+        if (this.fileName) {
+            return this.fileName;
+        }
+        const { paths } = this.options;
+        return (this.fileName =
+            (typeof paths === 'function' ? paths(this.id) : paths[this.id]) ||
+                (this.renormalizeRenderPath ? parseAst_js.normalize(path.relative(this.inputBase, this.id)) : this.id));
+    }
+    getImportAttributes(snippets) {
+        return (this.importAttributes ||= formatAttributes(this.options.format === 'es' &&
+            this.options.externalImportAttributes &&
+            this.moduleInfo.attributes, snippets));
+    }
+    getImportPath(importer) {
+        return escapeId(this.renormalizeRenderPath
+            ? parseAst_js.getImportPath(importer, this.getFileName(), this.options.format === 'amd', false)
+            : this.getFileName());
+    }
+}
+function formatAttributes(attributes, { getObject }) {
+    if (!attributes) {
+        return null;
+    }
+    const assertionEntries = Object.entries(attributes).map(([key, value]) => [key, `'${value}'`]);
+    if (assertionEntries.length > 0) {
+        return getObject(assertionEntries, { lineBreakIndent: null });
+    }
+    return null;
+}
+
+function removeJsExtension(name) {
+    return name.endsWith('.js') ? name.slice(0, -3) : name;
+}
+
+function getCompleteAmdId(options, chunkId) {
+    if (options.autoId) {
+        return `${options.basePath ? options.basePath + '/' : ''}${removeJsExtension(chunkId)}`;
+    }
+    return options.id ?? '';
+}
+
+function getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, mechanism = 'return ') {
+    const { _, getDirectReturnFunction, getFunctionIntro, getPropertyAccess, n, s } = snippets;
+    if (!namedExportsMode) {
+        return `${n}${n}${mechanism}${getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess)};`;
+    }
+    let exportBlock = '';
+    if (namedExportsMode) {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported !== '*') {
+                    const importName = getReexportedImportName(name, specifier.imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (specifier.imported !== '*' && specifier.needsLiveBinding) {
+                        const [left, right] = getDirectReturnFunction([], {
+                            functionReturn: true,
+                            lineBreakIndent: null,
+                            name: null
+                        });
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}get:${_}${left}${importName}${right}${n}});`;
+                    }
+                    else if (specifier.reexported === '__proto__') {
+                        exportBlock +=
+                            `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                                `${t}enumerable:${_}true,${n}` +
+                                `${t}value:${_}${importName}${n}});`;
+                    }
+                    else {
+                        exportBlock += `exports${getPropertyAccess(specifier.reexported)}${_}=${_}${importName};`;
+                    }
+                }
+            }
+        }
+    }
+    for (const { exported, local } of exports) {
+        const lhs = `exports${getPropertyAccess(exported)}`;
+        const rhs = local;
+        if (lhs !== rhs) {
+            if (exportBlock)
+                exportBlock += n;
+            exportBlock +=
+                exported === '__proto__'
+                    ? `Object.defineProperty(exports,${_}"__proto__",${_}{${n}` +
+                        `${t}enumerable:${_}true,${n}` +
+                        `${t}value:${_}${rhs}${n}});`
+                    : `${lhs}${_}=${_}${rhs};`;
+        }
+    }
+    if (namedExportsMode) {
+        for (const { name, reexports } of dependencies) {
+            if (!reexports) {
+                continue;
+            }
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    if (exportBlock)
+                        exportBlock += n;
+                    if (!specifier.needsLiveBinding && reexportProtoFromExternal) {
+                        const protoString = "'__proto__'";
+                        exportBlock +=
+                            `Object.prototype.hasOwnProperty.call(${name},${_}${protoString})${_}&&${n}` +
+                                `${t}!Object.prototype.hasOwnProperty.call(exports,${_}${protoString})${_}&&${n}` +
+                                `${t}Object.defineProperty(exports,${_}${protoString},${_}{${n}` +
+                                `${t}${t}enumerable:${_}true,${n}` +
+                                `${t}${t}value:${_}${name}[${protoString}]${n}` +
+                                `${t}});${n}${n}`;
+                    }
+                    const copyPropertyIfNecessary = `{${n}${t}if${_}(k${_}!==${_}'default'${_}&&${_}!Object.prototype.hasOwnProperty.call(exports,${_}k))${_}${getDefineProperty(name, specifier.needsLiveBinding, t, snippets)}${s}${n}}`;
+                    exportBlock += `Object.keys(${name}).forEach(${getFunctionIntro(['k'], {
+                        isAsync: false,
+                        name: null
+                    })}${copyPropertyIfNecessary});`;
+                }
+            }
+        }
+    }
+    if (exportBlock) {
+        return `${n}${n}${exportBlock}`;
+    }
+    return '';
+}
+function getSingleDefaultExport(exports, dependencies, interop, externalLiveBindings, getPropertyAccess) {
+    if (exports.length > 0) {
+        return exports[0].local;
+    }
+    else {
+        for (const { defaultVariableName, importPath, isChunk, name, namedExportsMode: depNamedExportsMode, namespaceVariableName, reexports } of dependencies) {
+            if (reexports) {
+                return getReexportedImportName(name, reexports[0].imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, importPath, externalLiveBindings, getPropertyAccess);
+            }
+        }
+    }
+}
+function getReexportedImportName(moduleVariableName, imported, depNamedExportsMode, isChunk, defaultVariableName, namespaceVariableName, interop, moduleId, externalLiveBindings, getPropertyAccess) {
+    if (imported === 'default') {
+        if (!isChunk) {
+            const moduleInterop = interop(moduleId);
+            const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                ? defaultVariableName
+                : moduleVariableName;
+            return isDefaultAProperty(moduleInterop, externalLiveBindings)
+                ? `${variableName}${getPropertyAccess('default')}`
+                : variableName;
+        }
+        return depNamedExportsMode
+            ? `${moduleVariableName}${getPropertyAccess('default')}`
+            : moduleVariableName;
+    }
+    if (imported === '*') {
+        return (isChunk ? !depNamedExportsMode : namespaceInteropHelpersByInteropType[interop(moduleId)])
+            ? namespaceVariableName
+            : moduleVariableName;
+    }
+    return `${moduleVariableName}${getPropertyAccess(imported)}`;
+}
+function getEsModuleValue(getObject) {
+    return getObject([['value', 'true']], {
+        lineBreakIndent: null
+    });
+}
+function getNamespaceMarkers(hasNamedExports, addEsModule, addNamespaceToStringTag, { _, getObject }) {
+    if (hasNamedExports) {
+        if (addEsModule) {
+            if (addNamespaceToStringTag) {
+                return `Object.defineProperties(exports,${_}${getObject([
+                    ['__esModule', getEsModuleValue(getObject)],
+                    [null, `[Symbol.toStringTag]:${_}${getToStringTagValue(getObject)}`]
+                ], {
+                    lineBreakIndent: null
+                })});`;
+            }
+            return `Object.defineProperty(exports,${_}'__esModule',${_}${getEsModuleValue(getObject)});`;
+        }
+        if (addNamespaceToStringTag) {
+            return `Object.defineProperty(exports,${_}Symbol.toStringTag,${_}${getToStringTagValue(getObject)});`;
+        }
+    }
+    return '';
+}
+const getDefineProperty = (name, needsLiveBinding, t, { _, getDirectReturnFunction, n }) => {
+    if (needsLiveBinding) {
+        const [left, right] = getDirectReturnFunction([], {
+            functionReturn: true,
+            lineBreakIndent: null,
+            name: null
+        });
+        return (`Object.defineProperty(exports,${_}k,${_}{${n}` +
+            `${t}${t}enumerable:${_}true,${n}` +
+            `${t}${t}get:${_}${left}${name}[k]${right}${n}${t}})`);
+    }
+    return `exports[k]${_}=${_}${name}[k]`;
+};
+
+function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, indent, snippets) {
+    const { _, cnst, n } = snippets;
+    const neededInteropHelpers = new Set();
+    const interopStatements = [];
+    const addInteropStatement = (helperVariableName, helper, dependencyVariableName) => {
+        neededInteropHelpers.add(helper);
+        interopStatements.push(`${cnst} ${helperVariableName}${_}=${_}/*#__PURE__*/${helper}(${dependencyVariableName});`);
+    };
+    for (const { defaultVariableName, imports, importPath, isChunk, name, namedExportsMode, namespaceVariableName, reexports } of dependencies) {
+        if (isChunk) {
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                if (imported === '*' && reexported !== '*') {
+                    if (!namedExportsMode) {
+                        addInteropStatement(namespaceVariableName, INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE, name);
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            const moduleInterop = interop(importPath);
+            let hasDefault = false;
+            let hasNamespace = false;
+            for (const { imported, reexported } of [
+                ...(imports || []),
+                ...(reexports || [])
+            ]) {
+                let helper;
+                let variableName;
+                if (imported === 'default') {
+                    if (!hasDefault) {
+                        hasDefault = true;
+                        if (defaultVariableName !== namespaceVariableName) {
+                            variableName = defaultVariableName;
+                            helper = defaultInteropHelpersByInteropType[moduleInterop];
+                        }
+                    }
+                }
+                else if (imported === '*' && reexported !== '*' && !hasNamespace) {
+                    hasNamespace = true;
+                    helper = namespaceInteropHelpersByInteropType[moduleInterop];
+                    variableName = namespaceVariableName;
+                }
+                if (helper) {
+                    addInteropStatement(variableName, helper, name);
+                }
+            }
+        }
+    }
+    return `${getHelpersBlock(neededInteropHelpers, accessedGlobals, indent, snippets, externalLiveBindings, freeze, symbols)}${interopStatements.length > 0 ? `${interopStatements.join(n)}${n}${n}` : ''}`;
+}
+
+function addJsExtension(name) {
+    return name.endsWith('.js') ? name : name + '.js';
+}
+
+// AMD resolution will only respect the AMD baseUrl if the .js extension is omitted.
+// The assumption is that this makes sense for all relative ids:
+// https://requirejs.org/docs/api.html#jsfiles
+function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
+    if (id[0] !== '.') {
+        return id;
+    }
+    return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
+}
+
+const builtinModules = [
+	"assert",
+	"assert/strict",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"inspector/promises",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"readline/promises",
+	"repl",
+	"stream",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"util/types",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+];
+
+const nodeBuiltins = new Set(builtinModules);
+function warnOnBuiltins(log, dependencies) {
+    const externalBuiltins = dependencies
+        .map(({ importPath }) => importPath)
+        .filter(importPath => nodeBuiltins.has(importPath) || importPath.startsWith('node:'));
+    if (externalBuiltins.length === 0)
+        return;
+    log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNodeBuiltins(externalBuiltins));
+}
+
+function amd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, log, outro, snippets }, { amd, esModule, externalLiveBindings, freeze, generatedCode: { symbols }, interop, reexportProtoFromExternal, strict }) {
+    warnOnBuiltins(log, dependencies);
+    const deps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const parameters = dependencies.map(m => m.name);
+    const { n, getNonArrowFunctionIntro, _ } = snippets;
+    if (namedExportsMode && hasExports) {
+        parameters.unshift(`exports`);
+        deps.unshift(`'exports'`);
+    }
+    if (accessedGlobals.has('require')) {
+        parameters.unshift('require');
+        deps.unshift(`'require'`);
+    }
+    if (accessedGlobals.has('module')) {
+        parameters.unshift('module');
+        deps.unshift(`'module'`);
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const defineParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (deps.length > 0 ? `[${deps.join(`,${_}`)}],${_}` : ``);
+    const useStrict = strict ? `${_}'use strict';` : '';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        .prepend(`${amd.define}(${defineParameters}(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${useStrict}${n}${n}`)
+        .append(`${n}${n}}));`);
+}
+
+function cjs(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, isEntryFacade, isModuleFacade, namedExportsMode, outro, snippets }, { compact, esModule, externalLiveBindings, freeze, interop, generatedCode: { symbols }, reexportProtoFromExternal, strict }) {
+    const { _, n } = snippets;
+    const useStrict = strict ? `'use strict';${n}${n}` : '';
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, isEntryFacade && (esModule === true || (esModule === 'if-default-prop' && hasDefaultExport)), isModuleFacade && symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers += n + n;
+    }
+    const importBlock = getImportBlock$1(dependencies, snippets, compact);
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${useStrict}${intro}${namespaceMarkers}${importBlock}${interopBlock}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal, `module.exports${_}=${_}`);
+    magicString.append(`${exportBlock}${outro}`);
+}
+function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
+    let importBlock = '';
+    let definingVariable = false;
+    for (const { importPath, name, reexports, imports } of dependencies) {
+        if (!reexports && !imports) {
+            if (importBlock) {
+                importBlock += compact && !definingVariable ? ',' : `;${n}`;
+            }
+            definingVariable = false;
+            importBlock += `require('${importPath}')`;
+        }
+        else {
+            importBlock += compact && definingVariable ? ',' : `${importBlock ? `;${n}` : ''}${cnst} `;
+            definingVariable = true;
+            importBlock += `${name}${_}=${_}require('${importPath}')`;
+        }
+    }
+    if (importBlock) {
+        return `${importBlock};${n}${n}`;
+    }
+    return '';
+}
+
+function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols }, importAttributesKey }) {
+    const { n } = snippets;
+    const importBlock = getImportBlock(dependencies, importAttributesKey, snippets);
+    if (importBlock.length > 0)
+        intro += importBlock.join(n) + n + n;
+    intro += getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols);
+    if (intro)
+        magicString.prepend(intro);
+    const exportBlock = getExportBlock(exports, snippets);
+    if (exportBlock.length > 0)
+        magicString.append(n + n + exportBlock.join(n).trim());
+    if (outro)
+        magicString.append(outro);
+    magicString.trim();
+}
+function getImportBlock(dependencies, importAttributesKey, { _ }) {
+    const importBlock = [];
+    for (const { importPath, reexports, imports, name, attributes } of dependencies) {
+        const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
+        const pathWithAssertion = `'${importPath}'${assertion};`;
+        if (!reexports && !imports) {
+            importBlock.push(`import${_}${pathWithAssertion}`);
+            continue;
+        }
+        if (imports) {
+            let defaultImport = null;
+            let starImport = null;
+            const importedNames = [];
+            for (const specifier of imports) {
+                if (specifier.imported === 'default') {
+                    defaultImport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    starImport = specifier;
+                }
+                else {
+                    importedNames.push(specifier);
+                }
+            }
+            if (starImport) {
+                importBlock.push(`import${_}*${_}as ${starImport.local} from${_}${pathWithAssertion}`);
+            }
+            if (defaultImport && importedNames.length === 0) {
+                importBlock.push(`import ${defaultImport.local} from${_}${pathWithAssertion}`);
+            }
+            else if (importedNames.length > 0) {
+                importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ''}{${_}${importedNames
+                    .map(specifier => specifier.imported === specifier.local
+                    ? specifier.imported
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+        if (reexports) {
+            let starExport = null;
+            const namespaceReexports = [];
+            const namedReexports = [];
+            for (const specifier of reexports) {
+                if (specifier.reexported === '*') {
+                    starExport = specifier;
+                }
+                else if (specifier.imported === '*') {
+                    namespaceReexports.push(specifier);
+                }
+                else {
+                    namedReexports.push(specifier);
+                }
+            }
+            if (starExport) {
+                importBlock.push(`export${_}*${_}from${_}${pathWithAssertion}`);
+            }
+            if (namespaceReexports.length > 0) {
+                if (!imports ||
+                    !imports.some(specifier => specifier.imported === '*' && specifier.local === name)) {
+                    importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
+                }
+                for (const specifier of namespaceReexports) {
+                    importBlock.push(`export${_}{${_}${name === specifier.reexported
+                        ? name
+                        : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
+                }
+            }
+            if (namedReexports.length > 0) {
+                importBlock.push(`export${_}{${_}${namedReexports
+                    .map(specifier => specifier.imported === specifier.reexported
+                    ? stringifyIdentifierIfNeeded(specifier.imported)
+                    : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`)
+                    .join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            }
+        }
+    }
+    return importBlock;
+}
+function getExportBlock(exports, { _, cnst }) {
+    const exportBlock = [];
+    const exportDeclaration = [];
+    for (const specifier of exports) {
+        if (specifier.expression) {
+            exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
+        }
+        exportDeclaration.push(specifier.exported === specifier.local
+            ? specifier.local
+            : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
+    }
+    if (exportDeclaration.length > 0) {
+        exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
+    }
+    return exportBlock;
+}
+
+const keypath = (keypath, getPropertyAccess) => keypath.split('.').map(getPropertyAccess).join('');
+
+function setupNamespace(name, root, globals, { _, getPropertyAccess, s }, compact, log) {
+    const parts = name.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    parts.pop();
+    let propertyPath = root;
+    return (parts
+        .map(part => {
+        propertyPath += getPropertyAccess(part);
+        return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}${s}`;
+    })
+        .join(compact ? ',' : '\n') + (compact && parts.length > 0 ? ';' : '\n'));
+}
+function assignToDeepVariable(deepName, root, globals, assignment, { _, getPropertyAccess }, log) {
+    const parts = deepName.split('.');
+    // Check if the key exists in the object's prototype.
+    const isReserved = parts[0] in Object.prototype;
+    if (log && isReserved) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logReservedNamespace(parts[0]));
+    }
+    parts[0] =
+        (typeof globals === 'function'
+            ? globals(parts[0])
+            : isReserved
+                ? parts[0]
+                : globals[parts[0]]) || parts[0];
+    const last = parts.pop();
+    let propertyPath = root;
+    let deepAssignment = [
+        ...parts.map(part => {
+            propertyPath += getPropertyAccess(part);
+            return `${propertyPath}${_}=${_}${propertyPath}${_}||${_}{}`;
+        }),
+        `${propertyPath}${getPropertyAccess(last)}`
+    ].join(`,${_}`) + `${_}=${_}${assignment}`;
+    if (parts.length > 0) {
+        deepAssignment = `(${deepAssignment})`;
+    }
+    return deepAssignment;
+}
+
+function trimEmptyImports(dependencies) {
+    let index = dependencies.length;
+    while (index--) {
+        const { imports, reexports } = dependencies[index];
+        if (imports || reexports) {
+            return dependencies.slice(0, index + 1);
+        }
+    }
+    return [];
+}
+
+function iife(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, indent: t, intro, namedExportsMode, log, outro, snippets }, { compact, esModule, extend, freeze, externalLiveBindings, reexportProtoFromExternal, globals, interop, name, generatedCode: { symbols }, strict }) {
+    const { _, getNonArrowFunctionIntro, getPropertyAccess, n } = snippets;
+    const isNamespaced = name && name.includes('.');
+    const useVariableAssignment = !extend && !isNamespaced;
+    if (name && useVariableAssignment && !isLegal(name)) {
+        return parseAst_js.error(parseAst_js.logIllegalIdentifierAsName(name));
+    }
+    warnOnBuiltins(log, dependencies);
+    const external = trimEmptyImports(dependencies);
+    const deps = external.map(dep => dep.globalName || 'null');
+    const parameters = external.map(m => m.name);
+    if (hasExports && !name) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingNameOptionForIifeExport());
+    }
+    if (namedExportsMode && hasExports) {
+        if (extend) {
+            deps.unshift(`this${keypath(name, getPropertyAccess)}${_}=${_}this${keypath(name, getPropertyAccess)}${_}||${_}{}`);
+            parameters.unshift('exports');
+        }
+        else {
+            deps.unshift('{}');
+            parameters.unshift('exports');
+        }
+    }
+    const useStrict = strict ? `${t}'use strict';${n}` : '';
+    const interopBlock = getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets);
+    magicString.prepend(`${intro}${interopBlock}`);
+    let wrapperIntro = `(${getNonArrowFunctionIntro(parameters, {
+        isAsync: false,
+        name: null
+    })}{${n}${useStrict}${n}`;
+    if (hasExports) {
+        if (name && !(extend && namedExportsMode)) {
+            wrapperIntro =
+                (useVariableAssignment ? `var ${name}` : `this${keypath(name, getPropertyAccess)}`) +
+                    `${_}=${_}${wrapperIntro}`;
+        }
+        if (isNamespaced) {
+            wrapperIntro = setupNamespace(name, 'this', globals, snippets, compact, log) + wrapperIntro;
+        }
+    }
+    let wrapperOutro = `${n}${n}})(${deps.join(`,${_}`)});`;
+    if (hasExports && !extend && namedExportsMode) {
+        wrapperOutro = `${n}${n}${t}return exports;${wrapperOutro}`;
+    }
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .indent(t)
+        .prepend(wrapperIntro)
+        .append(wrapperOutro);
+}
+
+const MISSING_EXPORT_SHIM_VARIABLE = '_missingExportShim';
+
+function system(magicString, { accessedGlobals, dependencies, exports, hasExports, indent: t, intro, snippets, outro, usesTopLevelAwait }, { externalLiveBindings, freeze, name, generatedCode: { symbols }, strict, systemNullSetters }) {
+    const { _, getFunctionIntro, getNonArrowFunctionIntro, n, s } = snippets;
+    const { importBindings, setters, starExcludes } = analyzeDependencies(dependencies, exports, t, snippets);
+    const registeredName = name ? `'${name}',${_}` : '';
+    const wrapperParameters = accessedGlobals.has('module')
+        ? ['exports', 'module']
+        : hasExports
+            ? ['exports']
+            : [];
+    // factory function should be wrapped by parentheses to avoid lazy parsing,
+    // cf. https://v8.dev/blog/preparser#pife
+    let wrapperStart = `System.register(${registeredName}[` +
+        dependencies.map(({ importPath }) => `'${importPath}'`).join(`,${_}`) +
+        `],${_}(${getNonArrowFunctionIntro(wrapperParameters, {
+            isAsync: false,
+            name: null
+        })}{${n}${t}${strict ? "'use strict';" : ''}` +
+        getStarExcludesBlock(starExcludes, t, snippets) +
+        getImportBindingsBlock(importBindings, t, snippets) +
+        `${n}${t}return${_}{${setters.length > 0
+            ? `${n}${t}${t}setters:${_}[${setters
+                .map(setter => setter
+                ? `${getFunctionIntro(['module'], {
+                    isAsync: false,
+                    name: null
+                })}{${n}${t}${t}${t}${setter}${n}${t}${t}}`
+                : systemNullSetters
+                    ? `null`
+                    : `${getFunctionIntro([], { isAsync: false, name: null })}{}`)
+                .join(`,${_}`)}],`
+            : ''}${n}`;
+    wrapperStart += `${t}${t}execute:${_}(${getNonArrowFunctionIntro([], {
+        isAsync: usesTopLevelAwait,
+        name: null
+    })}{${n}${n}`;
+    const wrapperEnd = `${t}${t}})${n}${t}}${s}${n}}));`;
+    magicString
+        .prepend(intro +
+        getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols) +
+        getHoistedExportsBlock(exports, t, snippets))
+        .append(`${outro}${n}${n}` +
+        getSyntheticExportsBlock(exports, t, snippets) +
+        getMissingExportsBlock(exports, t, snippets))
+        .indent(`${t}${t}${t}`)
+        .append(wrapperEnd)
+        .prepend(wrapperStart);
+}
+function analyzeDependencies(dependencies, exports, t, { _, cnst, getObject, getPropertyAccess, n }) {
+    const importBindings = [];
+    const setters = [];
+    let starExcludes = null;
+    for (const { imports, reexports } of dependencies) {
+        const setter = [];
+        if (imports) {
+            for (const specifier of imports) {
+                importBindings.push(specifier.local);
+                if (specifier.imported === '*') {
+                    setter.push(`${specifier.local}${_}=${_}module;`);
+                }
+                else {
+                    setter.push(`${specifier.local}${_}=${_}module${getPropertyAccess(specifier.imported)};`);
+                }
+            }
+        }
+        if (reexports) {
+            const reexportedNames = [];
+            let hasStarReexport = false;
+            for (const { imported, reexported } of reexports) {
+                if (reexported === '*') {
+                    hasStarReexport = true;
+                }
+                else {
+                    reexportedNames.push([
+                        reexported,
+                        imported === '*' ? 'module' : `module${getPropertyAccess(imported)}`
+                    ]);
+                }
+            }
+            if (reexportedNames.length > 1 || hasStarReexport) {
+                if (hasStarReexport) {
+                    if (!starExcludes) {
+                        starExcludes = getStarExcludes({ dependencies, exports });
+                    }
+                    reexportedNames.unshift([null, `__proto__:${_}null`]);
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`${cnst} setter${_}=${_}${exportMapping};`, `for${_}(${cnst} name in module)${_}{`, `${t}if${_}(!_starExcludes[name])${_}setter[name]${_}=${_}module[name];`, '}', 'exports(setter);');
+                }
+                else {
+                    const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
+                    setter.push(`exports(${exportMapping});`);
+                }
+            }
+            else {
+                const [key, value] = reexportedNames[0];
+                setter.push(`exports(${JSON.stringify(key)},${_}${value});`);
+            }
+        }
+        setters.push(setter.join(`${n}${t}${t}${t}`));
+    }
+    return { importBindings, setters, starExcludes };
+}
+const getStarExcludes = ({ dependencies, exports }) => {
+    const starExcludes = new Set(exports.map(expt => expt.exported));
+    starExcludes.add('default');
+    for (const { reexports } of dependencies) {
+        if (reexports) {
+            for (const reexport of reexports) {
+                if (reexport.reexported !== '*')
+                    starExcludes.add(reexport.reexported);
+            }
+        }
+    }
+    return starExcludes;
+};
+const getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n }) => {
+    if (starExcludes) {
+        const fields = [...starExcludes].map(property => [
+            property,
+            '1'
+        ]);
+        fields.unshift([null, `__proto__:${_}null`]);
+        return `${n}${t}${cnst} _starExcludes${_}=${_}${getObject(fields, {
+            lineBreakIndent: { base: t, t }
+        })};`;
+    }
+    return '';
+};
+const getImportBindingsBlock = (importBindings, t, { _, n }) => (importBindings.length > 0 ? `${n}${t}var ${importBindings.join(`,${_}`)};` : '');
+const getHoistedExportsBlock = (exports, t, snippets) => getExportsBlock(exports.filter(expt => expt.hoisted).map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+function getExportsBlock(exports, t, { _, n }) {
+    if (exports.length === 0) {
+        return '';
+    }
+    if (exports.length === 1) {
+        return `exports(${JSON.stringify(exports[0].name)},${_}${exports[0].value});${n}${n}`;
+    }
+    return (`exports({${n}` +
+        exports
+            .map(({ name, value }) => `${t}${stringifyObjectKeyIfNeeded(name)}:${_}${value}`)
+            .join(`,${n}`) +
+        `${n}});${n}${n}`);
+}
+const getSyntheticExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.expression)
+    .map(expt => ({ name: expt.exported, value: expt.local })), t, snippets);
+const getMissingExportsBlock = (exports, t, snippets) => getExportsBlock(exports
+    .filter(expt => expt.local === MISSING_EXPORT_SHIM_VARIABLE)
+    .map(expt => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
+
+function globalProperty(name, globalVariable, getPropertyAccess) {
+    if (!name)
+        return 'null';
+    return `${globalVariable}${keypath(name, getPropertyAccess)}`;
+}
+function safeAccess(name, globalVariable, { _, getPropertyAccess }) {
+    let propertyPath = globalVariable;
+    return name
+        .split('.')
+        .map(part => (propertyPath += getPropertyAccess(part)))
+        .join(`${_}&&${_}`);
+}
+function umd(magicString, { accessedGlobals, dependencies, exports, hasDefaultExport, hasExports, id, indent: t, intro, namedExportsMode, log, outro, snippets }, { amd, compact, esModule, extend, externalLiveBindings, freeze, interop, name, generatedCode: { symbols }, globals, noConflict, reexportProtoFromExternal, strict }) {
+    const { _, cnst, getFunctionIntro, getNonArrowFunctionIntro, getPropertyAccess, n, s } = snippets;
+    const factoryVariable = compact ? 'f' : 'factory';
+    const globalVariable = compact ? 'g' : 'global';
+    if (hasExports && !name) {
+        return parseAst_js.error(parseAst_js.logMissingNameOptionForUmdExport());
+    }
+    warnOnBuiltins(log, dependencies);
+    const amdDeps = dependencies.map(m => `'${updateExtensionForRelativeAmdId(m.importPath, amd.forceJsExtensionForImports)}'`);
+    const cjsDeps = dependencies.map(m => `require('${m.importPath}')`);
+    const trimmedImports = trimEmptyImports(dependencies);
+    const globalDeps = trimmedImports.map(module => globalProperty(module.globalName, globalVariable, getPropertyAccess));
+    const factoryParameters = trimmedImports.map(m => m.name);
+    if (namedExportsMode && (hasExports || noConflict)) {
+        amdDeps.unshift(`'exports'`);
+        cjsDeps.unshift(`exports`);
+        globalDeps.unshift(assignToDeepVariable(name, globalVariable, globals, `${extend ? `${globalProperty(name, globalVariable, getPropertyAccess)}${_}||${_}` : ''}{}`, snippets, log));
+        factoryParameters.unshift('exports');
+    }
+    const completeAmdId = getCompleteAmdId(amd, id);
+    const amdParameters = (completeAmdId ? `'${completeAmdId}',${_}` : ``) +
+        (amdDeps.length > 0 ? `[${amdDeps.join(`,${_}`)}],${_}` : ``);
+    const define = amd.define;
+    const cjsExport = !namedExportsMode && hasExports ? `module.exports${_}=${_}` : ``;
+    const useStrict = strict ? `${_}'use strict';${n}` : ``;
+    let iifeExport;
+    if (noConflict) {
+        const noConflictExportsVariable = compact ? 'e' : 'exports';
+        let factory;
+        if (!namedExportsMode && hasExports) {
+            factory = `${cnst} ${noConflictExportsVariable}${_}=${_}${assignToDeepVariable(name, globalVariable, globals, `${factoryVariable}(${globalDeps.join(`,${_}`)})`, snippets, log)};`;
+        }
+        else {
+            const module = globalDeps.shift();
+            factory =
+                `${cnst} ${noConflictExportsVariable}${_}=${_}${module};${n}` +
+                    `${t}${t}${factoryVariable}(${[noConflictExportsVariable, ...globalDeps].join(`,${_}`)});`;
+        }
+        iifeExport =
+            `(${getFunctionIntro([], { isAsync: false, name: null })}{${n}` +
+                `${t}${t}${cnst} current${_}=${_}${safeAccess(name, globalVariable, snippets)};${n}` +
+                `${t}${t}${factory}${n}` +
+                `${t}${t}${noConflictExportsVariable}.noConflict${_}=${_}${getFunctionIntro([], {
+                    isAsync: false,
+                    name: null
+                })}{${_}` +
+                `${globalProperty(name, globalVariable, getPropertyAccess)}${_}=${_}current;${_}return ${noConflictExportsVariable}${s}${_}};${n}` +
+                `${t}})()`;
+    }
+    else {
+        iifeExport = `${factoryVariable}(${globalDeps.join(`,${_}`)})`;
+        if (!namedExportsMode && hasExports) {
+            iifeExport = assignToDeepVariable(name, globalVariable, globals, iifeExport, snippets, log);
+        }
+    }
+    const iifeNeedsGlobal = hasExports || (noConflict && namedExportsMode) || globalDeps.length > 0;
+    const wrapperParameters = [factoryVariable];
+    if (iifeNeedsGlobal) {
+        wrapperParameters.unshift(globalVariable);
+    }
+    const globalArgument = iifeNeedsGlobal ? `this,${_}` : '';
+    const iifeStart = iifeNeedsGlobal
+        ? `(${globalVariable}${_}=${_}typeof globalThis${_}!==${_}'undefined'${_}?${_}globalThis${_}:${_}${globalVariable}${_}||${_}self,${_}`
+        : '';
+    const iifeEnd = iifeNeedsGlobal ? ')' : '';
+    const cjsIntro = iifeNeedsGlobal
+        ? `${t}typeof exports${_}===${_}'object'${_}&&${_}typeof module${_}!==${_}'undefined'${_}?` +
+            `${_}${cjsExport}${factoryVariable}(${cjsDeps.join(`,${_}`)})${_}:${n}`
+        : '';
+    const wrapperIntro = `(${getNonArrowFunctionIntro(wrapperParameters, { isAsync: false, name: null })}{${n}` +
+        cjsIntro +
+        `${t}typeof ${define}${_}===${_}'function'${_}&&${_}${define}.amd${_}?${_}${define}(${amdParameters}${factoryVariable})${_}:${n}` +
+        `${t}${iifeStart}${iifeExport}${iifeEnd};${n}` +
+        // factory function should be wrapped by parentheses to avoid lazy parsing,
+        // cf. https://v8.dev/blog/preparser#pife
+        `})(${globalArgument}(${getNonArrowFunctionIntro(factoryParameters, {
+            isAsync: false,
+            name: null
+        })}{${useStrict}${n}`;
+    const wrapperOutro = n + n + '}));';
+    magicString.prepend(`${intro}${getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, t, snippets)}`);
+    const exportBlock = getExportBlock$1(exports, dependencies, namedExportsMode, interop, snippets, t, externalLiveBindings, reexportProtoFromExternal);
+    let namespaceMarkers = getNamespaceMarkers(namedExportsMode && hasExports, esModule === true || (esModule === 'if-default-prop' && hasDefaultExport), symbols, snippets);
+    if (namespaceMarkers) {
+        namespaceMarkers = n + n + namespaceMarkers;
+    }
+    magicString
+        .append(`${exportBlock}${namespaceMarkers}${outro}`)
+        .trim()
+        .indent(t)
+        .append(wrapperOutro)
+        .prepend(wrapperIntro);
+}
+
+const finalisers = { amd, cjs, es, iife, system, umd };
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var utils = {};
+
+var constants;
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+
+	const path = require$$0;
+	const WIN_SLASH = '\\\\/';
+	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+	/**
+	 * Posix glob regex
+	 */
+
+	const DOT_LITERAL = '\\.';
+	const PLUS_LITERAL = '\\+';
+	const QMARK_LITERAL = '\\?';
+	const SLASH_LITERAL = '\\/';
+	const ONE_CHAR = '(?=.)';
+	const QMARK = '[^/]';
+	const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+	const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+	const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+	const NO_DOT = `(?!${DOT_LITERAL})`;
+	const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+	const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+	const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+	const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+	const STAR = `${QMARK}*?`;
+
+	const POSIX_CHARS = {
+	  DOT_LITERAL,
+	  PLUS_LITERAL,
+	  QMARK_LITERAL,
+	  SLASH_LITERAL,
+	  ONE_CHAR,
+	  QMARK,
+	  END_ANCHOR,
+	  DOTS_SLASH,
+	  NO_DOT,
+	  NO_DOTS,
+	  NO_DOT_SLASH,
+	  NO_DOTS_SLASH,
+	  QMARK_NO_DOT,
+	  STAR,
+	  START_ANCHOR
+	};
+
+	/**
+	 * Windows glob regex
+	 */
+
+	const WINDOWS_CHARS = {
+	  ...POSIX_CHARS,
+
+	  SLASH_LITERAL: `[${WIN_SLASH}]`,
+	  QMARK: WIN_NO_SLASH,
+	  STAR: `${WIN_NO_SLASH}*?`,
+	  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+	  NO_DOT: `(?!${DOT_LITERAL})`,
+	  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+	  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+	  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+	  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+	  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+	};
+
+	/**
+	 * POSIX Bracket Regex
+	 */
+
+	const POSIX_REGEX_SOURCE = {
+	  alnum: 'a-zA-Z0-9',
+	  alpha: 'a-zA-Z',
+	  ascii: '\\x00-\\x7F',
+	  blank: ' \\t',
+	  cntrl: '\\x00-\\x1F\\x7F',
+	  digit: '0-9',
+	  graph: '\\x21-\\x7E',
+	  lower: 'a-z',
+	  print: '\\x20-\\x7E ',
+	  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+	  space: ' \\t\\r\\n\\v\\f',
+	  upper: 'A-Z',
+	  word: 'A-Za-z0-9_',
+	  xdigit: 'A-Fa-f0-9'
+	};
+
+	constants = {
+	  MAX_LENGTH: 1024 * 64,
+	  POSIX_REGEX_SOURCE,
+
+	  // regular expressions
+	  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+	  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+	  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+	  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+	  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+	  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+	  // Replace globs with equivalent patterns to reduce parsing time.
+	  REPLACEMENTS: {
+	    '***': '*',
+	    '**/**': '**',
+	    '**/**/**': '**'
+	  },
+
+	  // Digits
+	  CHAR_0: 48, /* 0 */
+	  CHAR_9: 57, /* 9 */
+
+	  // Alphabet chars.
+	  CHAR_UPPERCASE_A: 65, /* A */
+	  CHAR_LOWERCASE_A: 97, /* a */
+	  CHAR_UPPERCASE_Z: 90, /* Z */
+	  CHAR_LOWERCASE_Z: 122, /* z */
+
+	  CHAR_LEFT_PARENTHESES: 40, /* ( */
+	  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+	  CHAR_ASTERISK: 42, /* * */
+
+	  // Non-alphabetic chars.
+	  CHAR_AMPERSAND: 38, /* & */
+	  CHAR_AT: 64, /* @ */
+	  CHAR_BACKWARD_SLASH: 92, /* \ */
+	  CHAR_CARRIAGE_RETURN: 13, /* \r */
+	  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+	  CHAR_COLON: 58, /* : */
+	  CHAR_COMMA: 44, /* , */
+	  CHAR_DOT: 46, /* . */
+	  CHAR_DOUBLE_QUOTE: 34, /* " */
+	  CHAR_EQUAL: 61, /* = */
+	  CHAR_EXCLAMATION_MARK: 33, /* ! */
+	  CHAR_FORM_FEED: 12, /* \f */
+	  CHAR_FORWARD_SLASH: 47, /* / */
+	  CHAR_GRAVE_ACCENT: 96, /* ` */
+	  CHAR_HASH: 35, /* # */
+	  CHAR_HYPHEN_MINUS: 45, /* - */
+	  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+	  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+	  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+	  CHAR_LINE_FEED: 10, /* \n */
+	  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+	  CHAR_PERCENT: 37, /* % */
+	  CHAR_PLUS: 43, /* + */
+	  CHAR_QUESTION_MARK: 63, /* ? */
+	  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+	  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+	  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+	  CHAR_SEMICOLON: 59, /* ; */
+	  CHAR_SINGLE_QUOTE: 39, /* ' */
+	  CHAR_SPACE: 32, /*   */
+	  CHAR_TAB: 9, /* \t */
+	  CHAR_UNDERSCORE: 95, /* _ */
+	  CHAR_VERTICAL_LINE: 124, /* | */
+	  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+	  SEP: path.sep,
+
+	  /**
+	   * Create EXTGLOB_CHARS
+	   */
+
+	  extglobChars(chars) {
+	    return {
+	      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+	      '?': { type: 'qmark', open: '(?:', close: ')?' },
+	      '+': { type: 'plus', open: '(?:', close: ')+' },
+	      '*': { type: 'star', open: '(?:', close: ')*' },
+	      '@': { type: 'at', open: '(?:', close: ')' }
+	    };
+	  },
+
+	  /**
+	   * Create GLOB_CHARS
+	   */
+
+	  globChars(win32) {
+	    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+	  }
+	};
+	return constants;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+
+		const path = require$$0;
+		const win32 = process.platform === 'win32';
+		const {
+		  REGEX_BACKSLASH,
+		  REGEX_REMOVE_BACKSLASH,
+		  REGEX_SPECIAL_CHARS,
+		  REGEX_SPECIAL_CHARS_GLOBAL
+		} = /*@__PURE__*/ requireConstants();
+
+		exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+		exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+		exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+		exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+		exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+		exports.removeBackslashes = str => {
+		  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+		    return match === '\\' ? '' : match;
+		  });
+		};
+
+		exports.supportsLookbehinds = () => {
+		  const segs = process.version.slice(1).split('.').map(Number);
+		  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+		    return true;
+		  }
+		  return false;
+		};
+
+		exports.isWindows = options => {
+		  if (options && typeof options.windows === 'boolean') {
+		    return options.windows;
+		  }
+		  return win32 === true || path.sep === '\\';
+		};
+
+		exports.escapeLast = (input, char, lastIdx) => {
+		  const idx = input.lastIndexOf(char, lastIdx);
+		  if (idx === -1) return input;
+		  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+		  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+		};
+
+		exports.removePrefix = (input, state = {}) => {
+		  let output = input;
+		  if (output.startsWith('./')) {
+		    output = output.slice(2);
+		    state.prefix = './';
+		  }
+		  return output;
+		};
+
+		exports.wrapOutput = (input, state = {}, options = {}) => {
+		  const prepend = options.contains ? '' : '^';
+		  const append = options.contains ? '' : '$';
+
+		  let output = `${prepend}(?:${input})${append}`;
+		  if (state.negated === true) {
+		    output = `(?:^(?!${output}).*$)`;
+		  }
+		  return output;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var scan_1;
+var hasRequiredScan;
+
+function requireScan () {
+	if (hasRequiredScan) return scan_1;
+	hasRequiredScan = 1;
+
+	const utils = /*@__PURE__*/ requireUtils();
+	const {
+	  CHAR_ASTERISK,             /* * */
+	  CHAR_AT,                   /* @ */
+	  CHAR_BACKWARD_SLASH,       /* \ */
+	  CHAR_COMMA,                /* , */
+	  CHAR_DOT,                  /* . */
+	  CHAR_EXCLAMATION_MARK,     /* ! */
+	  CHAR_FORWARD_SLASH,        /* / */
+	  CHAR_LEFT_CURLY_BRACE,     /* { */
+	  CHAR_LEFT_PARENTHESES,     /* ( */
+	  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+	  CHAR_PLUS,                 /* + */
+	  CHAR_QUESTION_MARK,        /* ? */
+	  CHAR_RIGHT_CURLY_BRACE,    /* } */
+	  CHAR_RIGHT_PARENTHESES,    /* ) */
+	  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+	} = /*@__PURE__*/ requireConstants();
+
+	const isPathSeparator = code => {
+	  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+	};
+
+	const depth = token => {
+	  if (token.isPrefix !== true) {
+	    token.depth = token.isGlobstar ? Infinity : 1;
+	  }
+	};
+
+	/**
+	 * Quickly scans a glob pattern and returns an object with a handful of
+	 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+	 * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+	 * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+	 *
+	 * ```js
+	 * const pm = require('picomatch');
+	 * console.log(pm.scan('foo/bar/*.js'));
+	 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+	 * ```
+	 * @param {String} `str`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with tokens and regex source string.
+	 * @api public
+	 */
+
+	const scan = (input, options) => {
+	  const opts = options || {};
+
+	  const length = input.length - 1;
+	  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+	  const slashes = [];
+	  const tokens = [];
+	  const parts = [];
+
+	  let str = input;
+	  let index = -1;
+	  let start = 0;
+	  let lastIndex = 0;
+	  let isBrace = false;
+	  let isBracket = false;
+	  let isGlob = false;
+	  let isExtglob = false;
+	  let isGlobstar = false;
+	  let braceEscaped = false;
+	  let backslashes = false;
+	  let negated = false;
+	  let negatedExtglob = false;
+	  let finished = false;
+	  let braces = 0;
+	  let prev;
+	  let code;
+	  let token = { value: '', depth: 0, isGlob: false };
+
+	  const eos = () => index >= length;
+	  const peek = () => str.charCodeAt(index + 1);
+	  const advance = () => {
+	    prev = code;
+	    return str.charCodeAt(++index);
+	  };
+
+	  while (index < length) {
+	    code = advance();
+	    let next;
+
+	    if (code === CHAR_BACKWARD_SLASH) {
+	      backslashes = token.backslashes = true;
+	      code = advance();
+
+	      if (code === CHAR_LEFT_CURLY_BRACE) {
+	        braceEscaped = true;
+	      }
+	      continue;
+	    }
+
+	    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+	      braces++;
+
+	      while (eos() !== true && (code = advance())) {
+	        if (code === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (code === CHAR_LEFT_CURLY_BRACE) {
+	          braces++;
+	          continue;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (braceEscaped !== true && code === CHAR_COMMA) {
+	          isBrace = token.isBrace = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+
+	          if (scanToEnd === true) {
+	            continue;
+	          }
+
+	          break;
+	        }
+
+	        if (code === CHAR_RIGHT_CURLY_BRACE) {
+	          braces--;
+
+	          if (braces === 0) {
+	            braceEscaped = false;
+	            isBrace = token.isBrace = true;
+	            finished = true;
+	            break;
+	          }
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (code === CHAR_FORWARD_SLASH) {
+	      slashes.push(index);
+	      tokens.push(token);
+	      token = { value: '', depth: 0, isGlob: false };
+
+	      if (finished === true) continue;
+	      if (prev === CHAR_DOT && index === (start + 1)) {
+	        start += 2;
+	        continue;
+	      }
+
+	      lastIndex = index + 1;
+	      continue;
+	    }
+
+	    if (opts.noext !== true) {
+	      const isExtglobChar = code === CHAR_PLUS
+	        || code === CHAR_AT
+	        || code === CHAR_ASTERISK
+	        || code === CHAR_QUESTION_MARK
+	        || code === CHAR_EXCLAMATION_MARK;
+
+	      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+	        isGlob = token.isGlob = true;
+	        isExtglob = token.isExtglob = true;
+	        finished = true;
+	        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+	          negatedExtglob = true;
+	        }
+
+	        if (scanToEnd === true) {
+	          while (eos() !== true && (code = advance())) {
+	            if (code === CHAR_BACKWARD_SLASH) {
+	              backslashes = token.backslashes = true;
+	              code = advance();
+	              continue;
+	            }
+
+	            if (code === CHAR_RIGHT_PARENTHESES) {
+	              isGlob = token.isGlob = true;
+	              finished = true;
+	              break;
+	            }
+	          }
+	          continue;
+	        }
+	        break;
+	      }
+	    }
+
+	    if (code === CHAR_ASTERISK) {
+	      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_QUESTION_MARK) {
+	      isGlob = token.isGlob = true;
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+	      while (eos() !== true && (next = advance())) {
+	        if (next === CHAR_BACKWARD_SLASH) {
+	          backslashes = token.backslashes = true;
+	          advance();
+	          continue;
+	        }
+
+	        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+	          isBracket = token.isBracket = true;
+	          isGlob = token.isGlob = true;
+	          finished = true;
+	          break;
+	        }
+	      }
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+
+	    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+	      negated = token.negated = true;
+	      start++;
+	      continue;
+	    }
+
+	    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+	      isGlob = token.isGlob = true;
+
+	      if (scanToEnd === true) {
+	        while (eos() !== true && (code = advance())) {
+	          if (code === CHAR_LEFT_PARENTHESES) {
+	            backslashes = token.backslashes = true;
+	            code = advance();
+	            continue;
+	          }
+
+	          if (code === CHAR_RIGHT_PARENTHESES) {
+	            finished = true;
+	            break;
+	          }
+	        }
+	        continue;
+	      }
+	      break;
+	    }
+
+	    if (isGlob === true) {
+	      finished = true;
+
+	      if (scanToEnd === true) {
+	        continue;
+	      }
+
+	      break;
+	    }
+	  }
+
+	  if (opts.noext === true) {
+	    isExtglob = false;
+	    isGlob = false;
+	  }
+
+	  let base = str;
+	  let prefix = '';
+	  let glob = '';
+
+	  if (start > 0) {
+	    prefix = str.slice(0, start);
+	    str = str.slice(start);
+	    lastIndex -= start;
+	  }
+
+	  if (base && isGlob === true && lastIndex > 0) {
+	    base = str.slice(0, lastIndex);
+	    glob = str.slice(lastIndex);
+	  } else if (isGlob === true) {
+	    base = '';
+	    glob = str;
+	  } else {
+	    base = str;
+	  }
+
+	  if (base && base !== '' && base !== '/' && base !== str) {
+	    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+	      base = base.slice(0, -1);
+	    }
+	  }
+
+	  if (opts.unescape === true) {
+	    if (glob) glob = utils.removeBackslashes(glob);
+
+	    if (base && backslashes === true) {
+	      base = utils.removeBackslashes(base);
+	    }
+	  }
+
+	  const state = {
+	    prefix,
+	    input,
+	    start,
+	    base,
+	    glob,
+	    isBrace,
+	    isBracket,
+	    isGlob,
+	    isExtglob,
+	    isGlobstar,
+	    negated,
+	    negatedExtglob
+	  };
+
+	  if (opts.tokens === true) {
+	    state.maxDepth = 0;
+	    if (!isPathSeparator(code)) {
+	      tokens.push(token);
+	    }
+	    state.tokens = tokens;
+	  }
+
+	  if (opts.parts === true || opts.tokens === true) {
+	    let prevIndex;
+
+	    for (let idx = 0; idx < slashes.length; idx++) {
+	      const n = prevIndex ? prevIndex + 1 : start;
+	      const i = slashes[idx];
+	      const value = input.slice(n, i);
+	      if (opts.tokens) {
+	        if (idx === 0 && start !== 0) {
+	          tokens[idx].isPrefix = true;
+	          tokens[idx].value = prefix;
+	        } else {
+	          tokens[idx].value = value;
+	        }
+	        depth(tokens[idx]);
+	        state.maxDepth += tokens[idx].depth;
+	      }
+	      if (idx !== 0 || value !== '') {
+	        parts.push(value);
+	      }
+	      prevIndex = i;
+	    }
+
+	    if (prevIndex && prevIndex + 1 < input.length) {
+	      const value = input.slice(prevIndex + 1);
+	      parts.push(value);
+
+	      if (opts.tokens) {
+	        tokens[tokens.length - 1].value = value;
+	        depth(tokens[tokens.length - 1]);
+	        state.maxDepth += tokens[tokens.length - 1].depth;
+	      }
+	    }
+
+	    state.slashes = slashes;
+	    state.parts = parts;
+	  }
+
+	  return state;
+	};
+
+	scan_1 = scan;
+	return scan_1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+
+	const constants = /*@__PURE__*/ requireConstants();
+	const utils = /*@__PURE__*/ requireUtils();
+
+	/**
+	 * Constants
+	 */
+
+	const {
+	  MAX_LENGTH,
+	  POSIX_REGEX_SOURCE,
+	  REGEX_NON_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_BACKREF,
+	  REPLACEMENTS
+	} = constants;
+
+	/**
+	 * Helpers
+	 */
+
+	const expandRange = (args, options) => {
+	  if (typeof options.expandRange === 'function') {
+	    return options.expandRange(...args, options);
+	  }
+
+	  args.sort();
+	  const value = `[${args.join('-')}]`;
+
+	  return value;
+	};
+
+	/**
+	 * Create the message for a syntax error
+	 */
+
+	const syntaxError = (type, char) => {
+	  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+
+	/**
+	 * Parse the given input string.
+	 * @param {String} input
+	 * @param {Object} options
+	 * @return {Object}
+	 */
+
+	const parse = (input, options) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected a string');
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+	  let len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+	  const tokens = [bos];
+
+	  const capture = opts.capture ? '' : '?:';
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const PLATFORM_CHARS = constants.globChars(win32);
+	  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+
+	  const {
+	    DOT_LITERAL,
+	    PLUS_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOT_SLASH,
+	    NO_DOTS_SLASH,
+	    QMARK,
+	    QMARK_NO_DOT,
+	    STAR,
+	    START_ANCHOR
+	  } = PLATFORM_CHARS;
+
+	  const globstar = opts => {
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const nodot = opts.dot ? '' : NO_DOT;
+	  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+	  let star = opts.bash === true ? globstar(opts) : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  // minimatch options support
+	  if (typeof opts.noext === 'boolean') {
+	    opts.noextglob = opts.noext;
+	  }
+
+	  const state = {
+	    input,
+	    index: -1,
+	    start: 0,
+	    dot: opts.dot === true,
+	    consumed: '',
+	    output: '',
+	    prefix: '',
+	    backtrack: false,
+	    negated: false,
+	    brackets: 0,
+	    braces: 0,
+	    parens: 0,
+	    quotes: 0,
+	    globstar: false,
+	    tokens
+	  };
+
+	  input = utils.removePrefix(input, state);
+	  len = input.length;
+
+	  const extglobs = [];
+	  const braces = [];
+	  const stack = [];
+	  let prev = bos;
+	  let value;
+
+	  /**
+	   * Tokenizing helpers
+	   */
+
+	  const eos = () => state.index === len - 1;
+	  const peek = state.peek = (n = 1) => input[state.index + n];
+	  const advance = state.advance = () => input[++state.index] || '';
+	  const remaining = () => input.slice(state.index + 1);
+	  const consume = (value = '', num = 0) => {
+	    state.consumed += value;
+	    state.index += num;
+	  };
+
+	  const append = token => {
+	    state.output += token.output != null ? token.output : token.value;
+	    consume(token.value);
+	  };
+
+	  const negate = () => {
+	    let count = 1;
+
+	    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+	      advance();
+	      state.start++;
+	      count++;
+	    }
+
+	    if (count % 2 === 0) {
+	      return false;
+	    }
+
+	    state.negated = true;
+	    state.start++;
+	    return true;
+	  };
+
+	  const increment = type => {
+	    state[type]++;
+	    stack.push(type);
+	  };
+
+	  const decrement = type => {
+	    state[type]--;
+	    stack.pop();
+	  };
+
+	  /**
+	   * Push tokens onto the tokens array. This helper speeds up
+	   * tokenizing by 1) helping us avoid backtracking as much as possible,
+	   * and 2) helping us avoid creating extra tokens when consecutive
+	   * characters are plain text. This improves performance and simplifies
+	   * lookbehinds.
+	   */
+
+	  const push = tok => {
+	    if (prev.type === 'globstar') {
+	      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+	      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+	      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+	        state.output = state.output.slice(0, -prev.output.length);
+	        prev.type = 'star';
+	        prev.value = '*';
+	        prev.output = star;
+	        state.output += prev.output;
+	      }
+	    }
+
+	    if (extglobs.length && tok.type !== 'paren') {
+	      extglobs[extglobs.length - 1].inner += tok.value;
+	    }
+
+	    if (tok.value || tok.output) append(tok);
+	    if (prev && prev.type === 'text' && tok.type === 'text') {
+	      prev.value += tok.value;
+	      prev.output = (prev.output || '') + tok.value;
+	      return;
+	    }
+
+	    tok.prev = prev;
+	    tokens.push(tok);
+	    prev = tok;
+	  };
+
+	  const extglobOpen = (type, value) => {
+	    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+	    token.prev = prev;
+	    token.parens = state.parens;
+	    token.output = state.output;
+	    const output = (opts.capture ? '(' : '') + token.open;
+
+	    increment('parens');
+	    push({ type, value, output: state.output ? '' : ONE_CHAR });
+	    push({ type: 'paren', extglob: true, value: advance(), output });
+	    extglobs.push(token);
+	  };
+
+	  const extglobClose = token => {
+	    let output = token.close + (opts.capture ? ')' : '');
+	    let rest;
+
+	    if (token.type === 'negate') {
+	      let extglobStar = star;
+
+	      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+	        extglobStar = globstar(opts);
+	      }
+
+	      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+	        output = token.close = `)$))${extglobStar}`;
+	      }
+
+	      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+	        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+	        // In this case, we need to parse the string and use it in the output of the original pattern.
+	        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+	        //
+	        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+	        const expression = parse(rest, { ...options, fastpaths: false }).output;
+
+	        output = token.close = `)${expression})${extglobStar})`;
+	      }
+
+	      if (token.prev.type === 'bos') {
+	        state.negatedExtglob = true;
+	      }
+	    }
+
+	    push({ type: 'paren', extglob: true, value, output });
+	    decrement('parens');
+	  };
+
+	  /**
+	   * Fast paths
+	   */
+
+	  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+	    let backslashes = false;
+
+	    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+	      if (first === '\\') {
+	        backslashes = true;
+	        return m;
+	      }
+
+	      if (first === '?') {
+	        if (esc) {
+	          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        if (index === 0) {
+	          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+	        }
+	        return QMARK.repeat(chars.length);
+	      }
+
+	      if (first === '.') {
+	        return DOT_LITERAL.repeat(chars.length);
+	      }
+
+	      if (first === '*') {
+	        if (esc) {
+	          return esc + first + (rest ? star : '');
+	        }
+	        return star;
+	      }
+	      return esc ? m : `\\${m}`;
+	    });
+
+	    if (backslashes === true) {
+	      if (opts.unescape === true) {
+	        output = output.replace(/\\/g, '');
+	      } else {
+	        output = output.replace(/\\+/g, m => {
+	          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+	        });
+	      }
+	    }
+
+	    if (output === input && opts.contains === true) {
+	      state.output = input;
+	      return state;
+	    }
+
+	    state.output = utils.wrapOutput(output, state, options);
+	    return state;
+	  }
+
+	  /**
+	   * Tokenize input until we reach end-of-string
+	   */
+
+	  while (!eos()) {
+	    value = advance();
+
+	    if (value === '\u0000') {
+	      continue;
+	    }
+
+	    /**
+	     * Escaped characters
+	     */
+
+	    if (value === '\\') {
+	      const next = peek();
+
+	      if (next === '/' && opts.bash !== true) {
+	        continue;
+	      }
+
+	      if (next === '.' || next === ';') {
+	        continue;
+	      }
+
+	      if (!next) {
+	        value += '\\';
+	        push({ type: 'text', value });
+	        continue;
+	      }
+
+	      // collapse slashes to reduce potential for exploits
+	      const match = /^\\+/.exec(remaining());
+	      let slashes = 0;
+
+	      if (match && match[0].length > 2) {
+	        slashes = match[0].length;
+	        state.index += slashes;
+	        if (slashes % 2 !== 0) {
+	          value += '\\';
+	        }
+	      }
+
+	      if (opts.unescape === true) {
+	        value = advance();
+	      } else {
+	        value += advance();
+	      }
+
+	      if (state.brackets === 0) {
+	        push({ type: 'text', value });
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * If we're inside a regex character class, continue
+	     * until we reach the closing bracket.
+	     */
+
+	    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+	      if (opts.posix !== false && value === ':') {
+	        const inner = prev.value.slice(1);
+	        if (inner.includes('[')) {
+	          prev.posix = true;
+
+	          if (inner.includes(':')) {
+	            const idx = prev.value.lastIndexOf('[');
+	            const pre = prev.value.slice(0, idx);
+	            const rest = prev.value.slice(idx + 2);
+	            const posix = POSIX_REGEX_SOURCE[rest];
+	            if (posix) {
+	              prev.value = pre + posix;
+	              state.backtrack = true;
+	              advance();
+
+	              if (!bos.output && tokens.indexOf(prev) === 1) {
+	                bos.output = ONE_CHAR;
+	              }
+	              continue;
+	            }
+	          }
+	        }
+	      }
+
+	      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+	        value = `\\${value}`;
+	      }
+
+	      if (opts.posix === true && value === '!' && prev.value === '[') {
+	        value = '^';
+	      }
+
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * If we're inside a quoted string, continue
+	     * until we reach the closing double quote.
+	     */
+
+	    if (state.quotes === 1 && value !== '"') {
+	      value = utils.escapeRegex(value);
+	      prev.value += value;
+	      append({ value });
+	      continue;
+	    }
+
+	    /**
+	     * Double quotes
+	     */
+
+	    if (value === '"') {
+	      state.quotes = state.quotes === 1 ? 0 : 1;
+	      if (opts.keepQuotes === true) {
+	        push({ type: 'text', value });
+	      }
+	      continue;
+	    }
+
+	    /**
+	     * Parentheses
+	     */
+
+	    if (value === '(') {
+	      increment('parens');
+	      push({ type: 'paren', value });
+	      continue;
+	    }
+
+	    if (value === ')') {
+	      if (state.parens === 0 && opts.strictBrackets === true) {
+	        throw new SyntaxError(syntaxError('opening', '('));
+	      }
+
+	      const extglob = extglobs[extglobs.length - 1];
+	      if (extglob && state.parens === extglob.parens + 1) {
+	        extglobClose(extglobs.pop());
+	        continue;
+	      }
+
+	      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+	      decrement('parens');
+	      continue;
+	    }
+
+	    /**
+	     * Square brackets
+	     */
+
+	    if (value === '[') {
+	      if (opts.nobracket === true || !remaining().includes(']')) {
+	        if (opts.nobracket !== true && opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('closing', ']'));
+	        }
+
+	        value = `\\${value}`;
+	      } else {
+	        increment('brackets');
+	      }
+
+	      push({ type: 'bracket', value });
+	      continue;
+	    }
+
+	    if (value === ']') {
+	      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      if (state.brackets === 0) {
+	        if (opts.strictBrackets === true) {
+	          throw new SyntaxError(syntaxError('opening', '['));
+	        }
+
+	        push({ type: 'text', value, output: `\\${value}` });
+	        continue;
+	      }
+
+	      decrement('brackets');
+
+	      const prevValue = prev.value.slice(1);
+	      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+	        value = `/${value}`;
+	      }
+
+	      prev.value += value;
+	      append({ value });
+
+	      // when literal brackets are explicitly disabled
+	      // assume we should match with a regex character class
+	      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+	        continue;
+	      }
+
+	      const escaped = utils.escapeRegex(prev.value);
+	      state.output = state.output.slice(0, -prev.value.length);
+
+	      // when literal brackets are explicitly enabled
+	      // assume we should escape the brackets to match literal characters
+	      if (opts.literalBrackets === true) {
+	        state.output += escaped;
+	        prev.value = escaped;
+	        continue;
+	      }
+
+	      // when the user specifies nothing, try to match both
+	      prev.value = `(${capture}${escaped}|${prev.value})`;
+	      state.output += prev.value;
+	      continue;
+	    }
+
+	    /**
+	     * Braces
+	     */
+
+	    if (value === '{' && opts.nobrace !== true) {
+	      increment('braces');
+
+	      const open = {
+	        type: 'brace',
+	        value,
+	        output: '(',
+	        outputIndex: state.output.length,
+	        tokensIndex: state.tokens.length
+	      };
+
+	      braces.push(open);
+	      push(open);
+	      continue;
+	    }
+
+	    if (value === '}') {
+	      const brace = braces[braces.length - 1];
+
+	      if (opts.nobrace === true || !brace) {
+	        push({ type: 'text', value, output: value });
+	        continue;
+	      }
+
+	      let output = ')';
+
+	      if (brace.dots === true) {
+	        const arr = tokens.slice();
+	        const range = [];
+
+	        for (let i = arr.length - 1; i >= 0; i--) {
+	          tokens.pop();
+	          if (arr[i].type === 'brace') {
+	            break;
+	          }
+	          if (arr[i].type !== 'dots') {
+	            range.unshift(arr[i].value);
+	          }
+	        }
+
+	        output = expandRange(range, opts);
+	        state.backtrack = true;
+	      }
+
+	      if (brace.comma !== true && brace.dots !== true) {
+	        const out = state.output.slice(0, brace.outputIndex);
+	        const toks = state.tokens.slice(brace.tokensIndex);
+	        brace.value = brace.output = '\\{';
+	        value = output = '\\}';
+	        state.output = out;
+	        for (const t of toks) {
+	          state.output += (t.output || t.value);
+	        }
+	      }
+
+	      push({ type: 'brace', value, output });
+	      decrement('braces');
+	      braces.pop();
+	      continue;
+	    }
+
+	    /**
+	     * Pipes
+	     */
+
+	    if (value === '|') {
+	      if (extglobs.length > 0) {
+	        extglobs[extglobs.length - 1].conditions++;
+	      }
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Commas
+	     */
+
+	    if (value === ',') {
+	      let output = value;
+
+	      const brace = braces[braces.length - 1];
+	      if (brace && stack[stack.length - 1] === 'braces') {
+	        brace.comma = true;
+	        output = '|';
+	      }
+
+	      push({ type: 'comma', value, output });
+	      continue;
+	    }
+
+	    /**
+	     * Slashes
+	     */
+
+	    if (value === '/') {
+	      // if the beginning of the glob is "./", advance the start
+	      // to the current index, and don't add the "./" characters
+	      // to the state. This greatly simplifies lookbehinds when
+	      // checking for BOS characters like "!" and "." (not "./")
+	      if (prev.type === 'dot' && state.index === state.start + 1) {
+	        state.start = state.index + 1;
+	        state.consumed = '';
+	        state.output = '';
+	        tokens.pop();
+	        prev = bos; // reset "prev" to the first token
+	        continue;
+	      }
+
+	      push({ type: 'slash', value, output: SLASH_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Dots
+	     */
+
+	    if (value === '.') {
+	      if (state.braces > 0 && prev.type === 'dot') {
+	        if (prev.value === '.') prev.output = DOT_LITERAL;
+	        const brace = braces[braces.length - 1];
+	        prev.type = 'dots';
+	        prev.output += value;
+	        prev.value += value;
+	        brace.dots = true;
+	        continue;
+	      }
+
+	      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+	        push({ type: 'text', value, output: DOT_LITERAL });
+	        continue;
+	      }
+
+	      push({ type: 'dot', value, output: DOT_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Question marks
+	     */
+
+	    if (value === '?') {
+	      const isGroup = prev && prev.value === '(';
+	      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('qmark', value);
+	        continue;
+	      }
+
+	      if (prev && prev.type === 'paren') {
+	        const next = peek();
+	        let output = value;
+
+	        if (next === '<' && !utils.supportsLookbehinds()) {
+	          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+	        }
+
+	        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+	          output = `\\${value}`;
+	        }
+
+	        push({ type: 'text', value, output });
+	        continue;
+	      }
+
+	      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+	        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+	        continue;
+	      }
+
+	      push({ type: 'qmark', value, output: QMARK });
+	      continue;
+	    }
+
+	    /**
+	     * Exclamation
+	     */
+
+	    if (value === '!') {
+	      if (opts.noextglob !== true && peek() === '(') {
+	        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+	          extglobOpen('negate', value);
+	          continue;
+	        }
+	      }
+
+	      if (opts.nonegate !== true && state.index === 0) {
+	        negate();
+	        continue;
+	      }
+	    }
+
+	    /**
+	     * Plus
+	     */
+
+	    if (value === '+') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        extglobOpen('plus', value);
+	        continue;
+	      }
+
+	      if ((prev && prev.value === '(') || opts.regex === false) {
+	        push({ type: 'plus', value, output: PLUS_LITERAL });
+	        continue;
+	      }
+
+	      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+	        push({ type: 'plus', value });
+	        continue;
+	      }
+
+	      push({ type: 'plus', value: PLUS_LITERAL });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value === '@') {
+	      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+	        push({ type: 'at', extglob: true, value, output: '' });
+	        continue;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Plain text
+	     */
+
+	    if (value !== '*') {
+	      if (value === '$' || value === '^') {
+	        value = `\\${value}`;
+	      }
+
+	      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+	      if (match) {
+	        value += match[0];
+	        state.index += match[0].length;
+	      }
+
+	      push({ type: 'text', value });
+	      continue;
+	    }
+
+	    /**
+	     * Stars
+	     */
+
+	    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+	      prev.type = 'star';
+	      prev.star = true;
+	      prev.value += value;
+	      prev.output = star;
+	      state.backtrack = true;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    let rest = remaining();
+	    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+	      extglobOpen('star', value);
+	      continue;
+	    }
+
+	    if (prev.type === 'star') {
+	      if (opts.noglobstar === true) {
+	        consume(value);
+	        continue;
+	      }
+
+	      const prior = prev.prev;
+	      const before = prior.prev;
+	      const isStart = prior.type === 'slash' || prior.type === 'bos';
+	      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+	      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+	      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+	      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+	        push({ type: 'star', value, output: '' });
+	        continue;
+	      }
+
+	      // strip consecutive `/**/`
+	      while (rest.slice(0, 3) === '/**') {
+	        const after = input[state.index + 4];
+	        if (after && after !== '/') {
+	          break;
+	        }
+	        rest = rest.slice(3);
+	        consume('/**', 3);
+	      }
+
+	      if (prior.type === 'bos' && eos()) {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = globstar(opts);
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+	        prev.value += value;
+	        state.globstar = true;
+	        state.output += prior.output + prev.output;
+	        consume(value);
+	        continue;
+	      }
+
+	      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+	        const end = rest[1] !== void 0 ? '|$' : '';
+
+	        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+	        prior.output = `(?:${prior.output}`;
+
+	        prev.type = 'globstar';
+	        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+	        prev.value += value;
+
+	        state.output += prior.output + prev.output;
+	        state.globstar = true;
+
+	        consume(value + advance());
+
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      if (prior.type === 'bos' && rest[0] === '/') {
+	        prev.type = 'globstar';
+	        prev.value += value;
+	        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+	        state.output = prev.output;
+	        state.globstar = true;
+	        consume(value + advance());
+	        push({ type: 'slash', value: '/', output: '' });
+	        continue;
+	      }
+
+	      // remove single star from output
+	      state.output = state.output.slice(0, -prev.output.length);
+
+	      // reset previous token to globstar
+	      prev.type = 'globstar';
+	      prev.output = globstar(opts);
+	      prev.value += value;
+
+	      // reset output with globstar
+	      state.output += prev.output;
+	      state.globstar = true;
+	      consume(value);
+	      continue;
+	    }
+
+	    const token = { type: 'star', value, output: star };
+
+	    if (opts.bash === true) {
+	      token.output = '.*?';
+	      if (prev.type === 'bos' || prev.type === 'slash') {
+	        token.output = nodot + token.output;
+	      }
+	      push(token);
+	      continue;
+	    }
+
+	    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+	      token.output = value;
+	      push(token);
+	      continue;
+	    }
+
+	    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+	      if (prev.type === 'dot') {
+	        state.output += NO_DOT_SLASH;
+	        prev.output += NO_DOT_SLASH;
+
+	      } else if (opts.dot === true) {
+	        state.output += NO_DOTS_SLASH;
+	        prev.output += NO_DOTS_SLASH;
+
+	      } else {
+	        state.output += nodot;
+	        prev.output += nodot;
+	      }
+
+	      if (peek() !== '*') {
+	        state.output += ONE_CHAR;
+	        prev.output += ONE_CHAR;
+	      }
+	    }
+
+	    push(token);
+	  }
+
+	  while (state.brackets > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+	    state.output = utils.escapeLast(state.output, '[');
+	    decrement('brackets');
+	  }
+
+	  while (state.parens > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+	    state.output = utils.escapeLast(state.output, '(');
+	    decrement('parens');
+	  }
+
+	  while (state.braces > 0) {
+	    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+	    state.output = utils.escapeLast(state.output, '{');
+	    decrement('braces');
+	  }
+
+	  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+	    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+	  }
+
+	  // rebuild the output if we had to backtrack at any point
+	  if (state.backtrack === true) {
+	    state.output = '';
+
+	    for (const token of state.tokens) {
+	      state.output += token.output != null ? token.output : token.value;
+
+	      if (token.suffix) {
+	        state.output += token.suffix;
+	      }
+	    }
+	  }
+
+	  return state;
+	};
+
+	/**
+	 * Fast paths for creating regular expressions for common glob patterns.
+	 * This can significantly speed up processing and has very little downside
+	 * impact when none of the fast paths match.
+	 */
+
+	parse.fastpaths = (input, options) => {
+	  const opts = { ...options };
+	  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+	  const len = input.length;
+	  if (len > max) {
+	    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+	  }
+
+	  input = REPLACEMENTS[input] || input;
+	  const win32 = utils.isWindows(options);
+
+	  // create constants based on platform, for windows or posix
+	  const {
+	    DOT_LITERAL,
+	    SLASH_LITERAL,
+	    ONE_CHAR,
+	    DOTS_SLASH,
+	    NO_DOT,
+	    NO_DOTS,
+	    NO_DOTS_SLASH,
+	    STAR,
+	    START_ANCHOR
+	  } = constants.globChars(win32);
+
+	  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+	  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+	  const capture = opts.capture ? '' : '?:';
+	  const state = { negated: false, prefix: '' };
+	  let star = opts.bash === true ? '.*?' : STAR;
+
+	  if (opts.capture) {
+	    star = `(${star})`;
+	  }
+
+	  const globstar = opts => {
+	    if (opts.noglobstar === true) return star;
+	    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+	  };
+
+	  const create = str => {
+	    switch (str) {
+	      case '*':
+	        return `${nodot}${ONE_CHAR}${star}`;
+
+	      case '.*':
+	        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*.*':
+	        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '*/*':
+	        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+	      case '**':
+	        return nodot + globstar(opts);
+
+	      case '**/*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+	      case '**/*.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      case '**/.*':
+	        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+	      default: {
+	        const match = /^(.*?)\.(\w+)$/.exec(str);
+	        if (!match) return;
+
+	        const source = create(match[1]);
+	        if (!source) return;
+
+	        return source + DOT_LITERAL + match[2];
+	      }
+	    }
+	  };
+
+	  const output = utils.removePrefix(input, state);
+	  let source = create(output);
+
+	  if (source && opts.strictSlashes !== true) {
+	    source += `${SLASH_LITERAL}?`;
+	  }
+
+	  return source;
+	};
+
+	parse_1 = parse;
+	return parse_1;
+}
+
+var picomatch_1;
+var hasRequiredPicomatch$1;
+
+function requirePicomatch$1 () {
+	if (hasRequiredPicomatch$1) return picomatch_1;
+	hasRequiredPicomatch$1 = 1;
+
+	const path = require$$0;
+	const scan = /*@__PURE__*/ requireScan();
+	const parse = /*@__PURE__*/ requireParse();
+	const utils = /*@__PURE__*/ requireUtils();
+	const constants = /*@__PURE__*/ requireConstants();
+	const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+	/**
+	 * Creates a matcher function from one or more glob patterns. The
+	 * returned function takes a string to match as its first argument,
+	 * and returns true if the string is a match. The returned matcher
+	 * function also takes a boolean as the second argument that, when true,
+	 * returns an object with additional information.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch(glob[, options]);
+	 *
+	 * const isMatch = picomatch('*.!(*a)');
+	 * console.log(isMatch('a.a')); //=> false
+	 * console.log(isMatch('a.b')); //=> true
+	 * ```
+	 * @name picomatch
+	 * @param {String|Array} `globs` One or more glob patterns.
+	 * @param {Object=} `options`
+	 * @return {Function=} Returns a matcher function.
+	 * @api public
+	 */
+
+	const picomatch = (glob, options, returnState = false) => {
+	  if (Array.isArray(glob)) {
+	    const fns = glob.map(input => picomatch(input, options, returnState));
+	    const arrayMatcher = str => {
+	      for (const isMatch of fns) {
+	        const state = isMatch(str);
+	        if (state) return state;
+	      }
+	      return false;
+	    };
+	    return arrayMatcher;
+	  }
+
+	  const isState = isObject(glob) && glob.tokens && glob.input;
+
+	  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+	    throw new TypeError('Expected pattern to be a non-empty string');
+	  }
+
+	  const opts = options || {};
+	  const posix = utils.isWindows(options);
+	  const regex = isState
+	    ? picomatch.compileRe(glob, options)
+	    : picomatch.makeRe(glob, options, false, true);
+
+	  const state = regex.state;
+	  delete regex.state;
+
+	  let isIgnored = () => false;
+	  if (opts.ignore) {
+	    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+	    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+	  }
+
+	  const matcher = (input, returnObject = false) => {
+	    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+	    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+	    if (typeof opts.onResult === 'function') {
+	      opts.onResult(result);
+	    }
+
+	    if (isMatch === false) {
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (isIgnored(input)) {
+	      if (typeof opts.onIgnore === 'function') {
+	        opts.onIgnore(result);
+	      }
+	      result.isMatch = false;
+	      return returnObject ? result : false;
+	    }
+
+	    if (typeof opts.onMatch === 'function') {
+	      opts.onMatch(result);
+	    }
+	    return returnObject ? result : true;
+	  };
+
+	  if (returnState) {
+	    matcher.state = state;
+	  }
+
+	  return matcher;
+	};
+
+	/**
+	 * Test `input` with the given `regex`. This is used by the main
+	 * `picomatch()` function to test the input string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.test(input, regex[, options]);
+	 *
+	 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+	 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp} `regex`
+	 * @return {Object} Returns an object with matching info.
+	 * @api public
+	 */
+
+	picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+	  if (typeof input !== 'string') {
+	    throw new TypeError('Expected input to be a string');
+	  }
+
+	  if (input === '') {
+	    return { isMatch: false, output: '' };
+	  }
+
+	  const opts = options || {};
+	  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+	  let match = input === glob;
+	  let output = (match && format) ? format(input) : input;
+
+	  if (match === false) {
+	    output = format ? format(input) : input;
+	    match = output === glob;
+	  }
+
+	  if (match === false || opts.capture === true) {
+	    if (opts.matchBase === true || opts.basename === true) {
+	      match = picomatch.matchBase(input, regex, options, posix);
+	    } else {
+	      match = regex.exec(output);
+	    }
+	  }
+
+	  return { isMatch: Boolean(match), match, output };
+	};
+
+	/**
+	 * Match the basename of a filepath.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.matchBase(input, glob[, options]);
+	 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+	 * ```
+	 * @param {String} `input` String to test.
+	 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+	 * @return {Boolean}
+	 * @api public
+	 */
+
+	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+	  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+	  return regex.test(path.basename(input));
+	};
+
+	/**
+	 * Returns true if **any** of the given glob `patterns` match the specified `string`.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.isMatch(string, patterns[, options]);
+	 *
+	 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+	 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+	 * ```
+	 * @param {String|Array} str The string to test.
+	 * @param {String|Array} patterns One or more glob patterns to use for matching.
+	 * @param {Object} [options] See available [options](#options).
+	 * @return {Boolean} Returns true if any patterns match `str`
+	 * @api public
+	 */
+
+	picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+	/**
+	 * Parse a glob pattern to create the source string for a regular
+	 * expression.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const result = picomatch.parse(pattern[, options]);
+	 * ```
+	 * @param {String} `pattern`
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+	 * @api public
+	 */
+
+	picomatch.parse = (pattern, options) => {
+	  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+	  return parse(pattern, { ...options, fastpaths: false });
+	};
+
+	/**
+	 * Scan a glob pattern to separate the pattern into segments.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.scan(input[, options]);
+	 *
+	 * const result = picomatch.scan('!./foo/*.js');
+	 * console.log(result);
+	 * { prefix: '!./',
+	 *   input: '!./foo/*.js',
+	 *   start: 3,
+	 *   base: 'foo',
+	 *   glob: '*.js',
+	 *   isBrace: false,
+	 *   isBracket: false,
+	 *   isGlob: true,
+	 *   isExtglob: false,
+	 *   isGlobstar: false,
+	 *   negated: true }
+	 * ```
+	 * @param {String} `input` Glob pattern to scan.
+	 * @param {Object} `options`
+	 * @return {Object} Returns an object with
+	 * @api public
+	 */
+
+	picomatch.scan = (input, options) => scan(input, options);
+
+	/**
+	 * Compile a regular expression from the `state` object returned by the
+	 * [parse()](#parse) method.
+	 *
+	 * @param {Object} `state`
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+	 * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+	  if (returnOutput === true) {
+	    return state.output;
+	  }
+
+	  const opts = options || {};
+	  const prepend = opts.contains ? '' : '^';
+	  const append = opts.contains ? '' : '$';
+
+	  let source = `${prepend}(?:${state.output})${append}`;
+	  if (state && state.negated === true) {
+	    source = `^(?!${source}).*$`;
+	  }
+
+	  const regex = picomatch.toRegex(source, options);
+	  if (returnState === true) {
+	    regex.state = state;
+	  }
+
+	  return regex;
+	};
+
+	/**
+	 * Create a regular expression from a parsed glob pattern.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * const state = picomatch.parse('*.js');
+	 * // picomatch.compileRe(state[, options]);
+	 *
+	 * console.log(picomatch.compileRe(state));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `state` The object returned from the `.parse` method.
+	 * @param {Object} `options`
+	 * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+	 * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+	 * @return {RegExp} Returns a regex created from the given pattern.
+	 * @api public
+	 */
+
+	picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+	  if (!input || typeof input !== 'string') {
+	    throw new TypeError('Expected a non-empty string');
+	  }
+
+	  let parsed = { negated: false, fastpaths: true };
+
+	  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+	    parsed.output = parse.fastpaths(input, options);
+	  }
+
+	  if (!parsed.output) {
+	    parsed = parse(input, options);
+	  }
+
+	  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+	};
+
+	/**
+	 * Create a regular expression from the given regex source string.
+	 *
+	 * ```js
+	 * const picomatch = require('picomatch');
+	 * // picomatch.toRegex(source[, options]);
+	 *
+	 * const { output } = picomatch.parse('*.js');
+	 * console.log(picomatch.toRegex(output));
+	 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+	 * ```
+	 * @param {String} `source` Regular expression source string.
+	 * @param {Object} `options`
+	 * @return {RegExp}
+	 * @api public
+	 */
+
+	picomatch.toRegex = (source, options) => {
+	  try {
+	    const opts = options || {};
+	    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+	  } catch (err) {
+	    if (options && options.debug === true) throw err;
+	    return /$^/;
+	  }
+	};
+
+	/**
+	 * Picomatch constants.
+	 * @return {Object}
+	 */
+
+	picomatch.constants = constants;
+
+	/**
+	 * Expose "picomatch"
+	 */
+
+	picomatch_1 = picomatch;
+	return picomatch_1;
+}
+
+var picomatch;
+var hasRequiredPicomatch;
+
+function requirePicomatch () {
+	if (hasRequiredPicomatch) return picomatch;
+	hasRequiredPicomatch = 1;
+
+	picomatch = /*@__PURE__*/ requirePicomatch$1();
+	return picomatch;
+}
+
+var picomatchExports = /*@__PURE__*/ requirePicomatch();
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
+
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+const normalizePathRegExp = new RegExp(`\\${require$$0.win32.sep}`, 'g');
+const normalizePath = function normalizePath(filename) {
+    return filename.replace(normalizePathRegExp, require$$0.posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || require$$0.isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath(require$$0.resolve(resolutionBase || ''))
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return require$$0.posix.join(basePath, normalizePath(id));
+}
+const createFilter = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    if (!includeMatchers.length && !excludeMatchers.length)
+        return (id) => typeof id === 'string' && !id.includes('\0');
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (id.includes('\0'))
+            return false;
+        const pathId = normalizePath(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+
+class ArrayPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const element of this.elements) {
+            element?.addExportedVariables(variables, exportNamesByVariable);
+        }
+    }
+    declare(kind) {
+        const variables = [];
+        for (const element of this.elements) {
+            if (element !== null) {
+                variables.push(...element.declare(kind, UNKNOWN_EXPRESSION));
+            }
+        }
+        return variables;
+    }
+    // Patterns can only be deoptimized at the empty path at the moment
+    deoptimizePath() {
+        for (const element of this.elements) {
+            element?.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    // Patterns are only checked at the empty path at the moment
+    hasEffectsOnInteractionAtPath(_path, interaction, context) {
+        for (const element of this.elements) {
+            if (element?.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const element of this.elements) {
+            element?.markDeclarationReached();
+        }
+    }
+}
+
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    get expression() {
+        return isFlagSet(this.flags, 8388608 /* Flag.expression */);
+    }
+    set expression(value) {
+        this.flags = setFlag(this.flags, 8388608 /* Flag.expression */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, false);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context)) {
+            return true;
+        }
+        if (this.annotationNoSideEffects) {
+            return false;
+        }
+        if (interaction.type === INTERACTION_CALLED) {
+            const { ignore, brokenFlow } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true,
+                this: false
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.ignore = ignore;
+            context.brokenFlow = brokenFlow;
+        }
+        return false;
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this;
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    include(context, includeChildrenRecursively) {
+        super.include(context, includeChildrenRecursively);
+        for (const parameter of this.params) {
+            if (!(parameter instanceof Identifier)) {
+                parameter.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
+
+class ObjectPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        for (const property of this.properties) {
+            if (property.type === parseAst_js.Property) {
+                property.value.addExportedVariables(variables, exportNamesByVariable);
+            }
+            else {
+                property.argument.addExportedVariables(variables, exportNamesByVariable);
+            }
+        }
+    }
+    declare(kind, init) {
+        const variables = [];
+        for (const property of this.properties) {
+            variables.push(...property.declare(kind, init));
+        }
+        return variables;
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            for (const property of this.properties) {
+                property.deoptimizePath(path);
+            }
+        }
+    }
+    hasEffectsOnInteractionAtPath(
+    // At the moment, this is only triggered for assignment left-hand sides,
+    // where the path is empty
+    _path, interaction, context) {
+        for (const property of this.properties) {
+            if (property.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
+                return true;
+        }
+        return false;
+    }
+    markDeclarationReached() {
+        for (const property of this.properties) {
+            property.markDeclarationReached();
+        }
+    }
+}
+
+class AssignmentExpression extends NodeBase {
+    hasEffects(context) {
+        const { deoptimized, left, operator, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        // MemberExpressions do not access the property before assignments if the
+        // operator is '='.
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, operator !== '='));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, left, right, operator } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        if (includeChildrenRecursively ||
+            operator !== '=' ||
+            left.included ||
+            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
+            left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
+        }
+        right.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        if (this.left instanceof Identifier) {
+            const variable = this.scope.variables.get(this.left.name);
+            if (variable?.kind === 'const') {
+                this.scope.context.error(parseAst_js.logConstVariableReassignError(), this.left.start);
+            }
+        }
+        this.left.setAssignedValue(this.right);
+    }
+    render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        const { left, right, start, end, parent } = this;
+        if (left.included) {
+            left.render(code, options);
+            right.render(code, options);
+        }
+        else {
+            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', left.end) + 1);
+            code.remove(start, inclusionStart);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, right.start);
+            }
+            right.render(code, options, {
+                renderedParentType: renderedParentType || parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || parent.type
+            });
+        }
+        if (options.format === 'system') {
+            if (left instanceof Identifier) {
+                const variable = left.variable;
+                const exportNames = options.exportNamesByVariable.get(variable);
+                if (exportNames) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, start, end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== parseAst_js.ExpressionStatement, code, options);
+                    }
+                    return;
+                }
+            }
+            else {
+                const systemPatternExports = [];
+                left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
+                if (systemPatternExports.length > 0) {
+                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === parseAst_js.ExpressionStatement, code, options);
+                    return;
+                }
+            }
+        }
+        if (left.included &&
+            left instanceof ObjectPattern &&
+            (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
+                renderedSurroundingElement === parseAst_js.ArrowFunctionExpression)) {
+            code.appendRight(start, '(');
+            code.prependLeft(end, ')');
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class AssignmentPattern extends NodeBase {
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        return this.left.declare(kind, init);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.left.deoptimizePath(path);
+        }
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
+    }
+    markDeclarationReached() {
+        this.left.markDeclarationReached();
+    }
+    render(code, options, { isShorthandProperty } = parseAst_js.BLANK) {
+        this.left.render(code, options, { isShorthandProperty });
+        this.right.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class AwaitExpression extends NodeBase {
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            checkTopLevelAwait: if (!this.scope.context.usesTopLevelAwait) {
+                let parent = this.parent;
+                do {
+                    if (parent instanceof FunctionNode || parent instanceof ArrowFunctionExpression)
+                        break checkTopLevelAwait;
+                } while ((parent = parent.parent));
+                this.scope.context.usesTopLevelAwait = true;
+            }
+        }
+        this.argument.include(context, includeChildrenRecursively);
+    }
+}
+
+const binaryOperators = {
+    '!=': (left, right) => left != right,
+    '!==': (left, right) => left !== right,
+    '%': (left, right) => left % right,
+    '&': (left, right) => left & right,
+    '*': (left, right) => left * right,
+    // At the moment, "**" will be transpiled to Math.pow
+    '**': (left, right) => left ** right,
+    '+': (left, right) => left + right,
+    '-': (left, right) => left - right,
+    '/': (left, right) => left / right,
+    '<': (left, right) => left < right,
+    '<<': (left, right) => left << right,
+    '<=': (left, right) => left <= right,
+    '==': (left, right) => left == right,
+    '===': (left, right) => left === right,
+    '>': (left, right) => left > right,
+    '>=': (left, right) => left >= right,
+    '>>': (left, right) => left >> right,
+    '>>>': (left, right) => left >>> right,
+    '^': (left, right) => left ^ right,
+    '|': (left, right) => left | right
+    // We use the fallback for cases where we return something unknown
+    // in: () => UnknownValue,
+    // instanceof: () => UnknownValue,
+};
+class BinaryExpression extends NodeBase {
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length > 0)
+            return UnknownValue;
+        const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof leftValue === 'symbol')
+            return UnknownValue;
+        const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof rightValue === 'symbol')
+            return UnknownValue;
+        const operatorFunction = binaryOperators[this.operator];
+        if (!operatorFunction)
+            return UnknownValue;
+        return operatorFunction(leftValue, rightValue);
+    }
+    hasEffects(context) {
+        // support some implicit type coercion runtime errors
+        if (this.operator === '+' &&
+            this.parent instanceof ExpressionStatement &&
+            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '') {
+            return true;
+        }
+        return super.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
+    }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        this.left.render(code, options, { renderedSurroundingElement });
+        this.right.render(code, options);
+    }
+}
+
+class BreakStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.breaks)
+                return true;
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasBreak = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+
+function renderCallArguments(code, options, node) {
+    if (node.arguments.length > 0) {
+        if (node.arguments[node.arguments.length - 1].included) {
+            for (const argument of node.arguments) {
+                argument.render(code, options);
+            }
+        }
+        else {
+            let lastIncludedIndex = node.arguments.length - 2;
+            while (lastIncludedIndex >= 0 && !node.arguments[lastIncludedIndex].included) {
+                lastIncludedIndex--;
+            }
+            if (lastIncludedIndex >= 0) {
+                for (let index = 0; index <= lastIncludedIndex; index++) {
+                    node.arguments[index].render(code, options);
+                }
+                code.remove(findFirstOccurrenceOutsideComment(code.original, ',', node.arguments[lastIncludedIndex].end), node.end - 1);
+            }
+            else {
+                code.remove(findFirstOccurrenceOutsideComment(code.original, '(', node.callee.end) + 1, node.end - 1);
+            }
+        }
+    }
+}
+
+class CallExpressionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.deoptimizableDependentExpressions = [];
+        this.expressionsToBeDeoptimized = new Set();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        const { args } = interaction;
+        const [returnExpression, isPure] = this.getReturnExpression(recursionTracker);
+        if (isPure)
+            return;
+        const deoptimizedExpressions = args.filter(expression => !!expression && expression !== UNKNOWN_EXPRESSION);
+        if (deoptimizedExpressions.length === 0)
+            return;
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            for (const expression of deoptimizedExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        else {
+            recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+                for (const expression of deoptimizedExpressions) {
+                    this.expressionsToBeDeoptimized.add(expression);
+                }
+                returnExpression.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+            }, null);
+        }
+    }
+    deoptimizeCache() {
+        if (this.returnExpression?.[0] !== UNKNOWN_EXPRESSION) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            const { deoptimizableDependentExpressions, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_SET;
+            this.deoptimizableDependentExpressions = parseAst_js.EMPTY_ARRAY;
+            for (const expression of deoptimizableDependentExpressions) {
+                expression.deoptimizeCache();
+            }
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 ||
+            this.scope.context.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        const [returnExpression] = this.getReturnExpression();
+        if (returnExpression !== UNKNOWN_EXPRESSION) {
+            returnExpression.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const [returnExpression] = this.getReturnExpression(recursionTracker);
+        if (returnExpression === UNKNOWN_EXPRESSION) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const returnExpression = this.getReturnExpression(recursionTracker);
+        if (returnExpression[0] === UNKNOWN_EXPRESSION) {
+            return returnExpression;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
+            this.deoptimizableDependentExpressions.push(origin);
+            const [expression, isPure] = returnExpression[0].getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+            return [expression, isPure || returnExpression[1]];
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (type === INTERACTION_CALLED) {
+            const { args, withNew } = interaction;
+            if ((withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, args, this)) {
+                return false;
+            }
+        }
+        else if ((type === INTERACTION_ASSIGNED
+            ? context.assigned
+            : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
+            return false;
+        }
+        const [returnExpression, isPure] = this.getReturnExpression();
+        return ((type === INTERACTION_ASSIGNED || !isPure) &&
+            returnExpression.hasEffectsOnInteractionAtPath(path, interaction, context));
+    }
+}
+
+class CallExpression extends CallExpressionBase {
+    get optional() {
+        return isFlagSet(this.flags, 128 /* Flag.optional */);
+    }
+    set optional(value) {
+        this.flags = setFlag(this.flags, 128 /* Flag.optional */, value);
+    }
+    bind() {
+        super.bind();
+        if (this.callee instanceof Identifier) {
+            const variable = this.scope.findVariable(this.callee.name);
+            if (variable.isNamespace) {
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCannotCallNamespace(this.callee.name), this.start);
+            }
+            if (this.callee.name === 'eval') {
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logEval(this.scope.context.module.id), this.start);
+            }
+        }
+        this.interaction = {
+            args: [
+                this.callee instanceof MemberExpression && !this.callee.variable
+                    ? this.callee.object
+                    : null,
+                ...this.arguments
+            ],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
+    }
+    getLiteralValueAtPathAsChainElement(path, recursionTracker, origin) {
+        return getChainElementLiteralValueAtPath(this, this.callee, path, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        if (this.annotationPure) {
+            return false;
+        }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    hasEffectsAsChainElement(context) {
+        const calleeHasEffects = 'hasEffectsAsChainElement' in this.callee
+            ? this.callee.hasEffectsAsChainElement(context)
+            : this.callee.hasEffects(context);
+        if (calleeHasEffects === IS_SKIPPED_CHAIN)
+            return IS_SKIPPED_CHAIN;
+        if (this.optional &&
+            this.callee.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) == null) {
+            return (!this.annotationPure && calleeHasEffects) || IS_SKIPPED_CHAIN;
+        }
+        // We only apply deoptimizations lazily once we know we are not skipping
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (!this.annotationPure &&
+            (calleeHasEffects ||
+                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context)));
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+            if (includeChildrenRecursively === INCLUDE_PARAMETERS &&
+                this.callee instanceof Identifier &&
+                this.callee.variable) {
+                this.callee.variable.markCalledFromTryStatement();
+            }
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
+    initialise() {
+        super.initialise();
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        this.callee.render(code, options, {
+            isCalleeOfRenderedParent: true,
+            renderedSurroundingElement
+        });
+        renderCallArguments(code, options, this);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
+}
+
+class CatchClause extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ParameterScope(parentScope, true);
+    }
+    parseNode(esTreeNode) {
+        const { body, param, type } = esTreeNode;
+        this.type = type;
+        if (param) {
+            this.param = new (this.scope.context.getNodeConstructor(param.type))(this, this.scope).parseNode(param);
+            this.param.declare('parameter', UNKNOWN_EXPRESSION);
+        }
+        this.body = new BlockStatement(this, this.scope.bodyScope).parseNode(body);
+        return super.parseNode(esTreeNode);
+    }
+}
+CatchClause.prototype.preventChildBlockScope = true;
+
+class ChainExpression extends NodeBase {
+    // deoptimizations are not relevant as we are not caching values
+    deoptimizeCache() { }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const literalValue = this.expression.getLiteralValueAtPathAsChainElement(path, recursionTracker, origin);
+        return literalValue === IS_SKIPPED_CHAIN ? undefined : literalValue;
+    }
+    hasEffects(context) {
+        return this.expression.hasEffectsAsChainElement(context) === true;
+    }
+    removeAnnotations(code) {
+        this.expression.removeAnnotations(code);
+    }
+    applyDeoptimizations() { }
+}
+
+class ClassBodyScope extends ChildScope {
+    constructor(parent, classNode) {
+        const { context } = parent;
+        super(parent, context);
+        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, 'other')));
+        this.instanceScope = new ChildScope(this, context);
+        this.instanceScope.variables.set('this', new ThisVariable(context));
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+}
+
+class ClassBody extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new ClassBodyScope(parentScope, this.parent);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.scope.context.includeVariableInModule(this.scope.thisVariable);
+        for (const definition of this.body) {
+            definition.include(context, includeChildrenRecursively);
+        }
+    }
+    parseNode(esTreeNode) {
+        const body = (this.body = []);
+        for (const definition of esTreeNode.body) {
+            body.push(new (this.scope.context.getNodeConstructor(definition.type))(this, definition.static ? this.scope : this.scope.instanceScope).parseNode(definition));
+        }
+        return super.parseNode(esTreeNode);
+    }
+    applyDeoptimizations() { }
+}
+
+class ClassExpression extends ClassNode {
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+
+class MultiExpression extends ExpressionEntity {
+    constructor(expressions) {
+        super();
+        this.expressions = expressions;
+    }
+    deoptimizePath(path) {
+        for (const expression of this.expressions) {
+            expression.deoptimizePath(path);
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return [
+            new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0])),
+            false
+        ];
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        for (const expression of this.expressions) {
+            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
+                return true;
+        }
+        return false;
+    }
+}
+
+class ConditionalExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.expressionsToBeDeoptimized = [];
+        this.usedBranch = null;
+    }
+    get isBranchResolutionAnalysed() {
+        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
+    set isBranchResolutionAnalysed(value) {
+        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.consequent.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        if (this.usedBranch !== null) {
+            const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+    }
+    deoptimizePath(path) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
+        }
+        else {
+            this.consequent.deoptimizePath(path);
+            this.alternate.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return this.consequent.hasEffects(context) || this.alternate.hasEffects(context);
+        }
+        return usedBranch.hasEffects(context);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return (this.consequent.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.alternate.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const usedBranch = this.getUsedBranch();
+        if (includeChildrenRecursively || this.test.shouldBeIncluded(context) || usedBranch === null) {
+            this.test.include(context, includeChildrenRecursively);
+            this.consequent.include(context, includeChildrenRecursively);
+            this.alternate.include(context, includeChildrenRecursively);
+        }
+        else {
+            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
+    includeCallArguments(context, parameters) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.includeCallArguments(context, parameters);
+        }
+        else {
+            this.consequent.includeCallArguments(context, parameters);
+            this.alternate.includeCallArguments(context, parameters);
+        }
+    }
+    removeAnnotations(code) {
+        this.test.removeAnnotations(code);
+    }
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        const usedBranch = this.getUsedBranch();
+        if (this.test.included) {
+            this.test.render(code, options, { renderedSurroundingElement });
+            this.consequent.render(code, options);
+            this.alternate.render(code, options);
+        }
+        else {
+            const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
+            const inclusionStart = findNonWhiteSpace(code.original, (this.consequent.included
+                ? findFirstOccurrenceOutsideComment(code.original, '?', this.test.end)
+                : colonPos) + 1);
+            if (preventASI) {
+                removeLineBreaks(code, inclusionStart, usedBranch.start);
+            }
+            code.remove(this.start, inclusionStart);
+            if (this.consequent.included) {
+                code.remove(colonPos, this.end);
+            }
+            this.test.removeAnnotations(code);
+            usedBranch.render(code, options, {
+                isCalleeOfRenderedParent,
+                preventASI: true,
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            });
+        }
+    }
+    getUsedBranch() {
+        if (this.isBranchResolutionAnalysed) {
+            return this.usedBranch;
+        }
+        this.isBranchResolutionAnalysed = true;
+        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        return typeof testValue === 'symbol'
+            ? null
+            : (this.usedBranch = testValue ? this.consequent : this.alternate);
+    }
+}
+
+class ContinueStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.label) {
+            if (!context.ignore.labels.has(this.label.name))
+                return true;
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            if (!context.ignore.continues)
+                return true;
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context) {
+        this.included = true;
+        if (this.label) {
+            this.label.include();
+            context.includedLabels.add(this.label.name);
+        }
+        else {
+            context.hasContinue = true;
+        }
+        context.brokenFlow = true;
+    }
+}
+
+class DebuggerStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+}
+
+class Decorator extends NodeBase {
+    hasEffects(context) {
+        return (this.expression.hasEffects(context) ||
+            this.expression.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context));
+    }
+}
+
+function hasLoopBodyEffects(context, body) {
+    const { brokenFlow, hasBreak, hasContinue, ignore } = context;
+    const { breaks, continues } = ignore;
+    ignore.breaks = true;
+    ignore.continues = true;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    if (body.hasEffects(context))
+        return true;
+    ignore.breaks = breaks;
+    ignore.continues = continues;
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+    return false;
+}
+function includeLoopBody(context, body, includeChildrenRecursively) {
+    const { brokenFlow, hasBreak, hasContinue } = context;
+    context.hasBreak = false;
+    context.hasContinue = false;
+    body.include(context, includeChildrenRecursively, { asSingleStatement: true });
+    context.hasBreak = hasBreak;
+    context.hasContinue = hasContinue;
+    context.brokenFlow = brokenFlow;
+}
+
+class DoWhileStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
+
+class EmptyStatement extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+}
+
+class ExportAllDeclaration extends NodeBase {
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ExportAllDeclaration.prototype.needsBoundaries = true;
+
+class ExportNamedDeclaration extends NodeBase {
+    bind() {
+        // Do not bind specifiers
+        this.declaration?.bind();
+    }
+    hasEffects(context) {
+        return !!this.declaration?.hasEffects(context);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addExport(this);
+    }
+    removeAnnotations(code) {
+        this.declaration?.removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions) {
+        const { start, end } = nodeRenderOptions;
+        if (this.declaration === null) {
+            code.remove(start, end);
+        }
+        else {
+            code.remove(this.start, this.declaration.start);
+            this.declaration.render(code, options, { end, start });
+        }
+    }
+    applyDeoptimizations() { }
+}
+ExportNamedDeclaration.prototype.needsBoundaries = true;
+
+class ExportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class ForInStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, body);
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "in" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 110 /* n */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ForOfStatement extends NodeBase {
+    get await() {
+        return isFlagSet(this.flags, 131072 /* Flag.await */);
+    }
+    set await(value) {
+        this.flags = setFlag(this.flags, 131072 /* Flag.await */, value);
+    }
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        // Placeholder until proper Symbol.Iterator support
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
+        includeLoopBody(context, body, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        this.left.render(code, options, NO_SEMICOLON);
+        this.right.render(code, options, NO_SEMICOLON);
+        // handle no space between "of" and the right side
+        if (code.original.charCodeAt(this.right.start - 1) === 102 /* f */) {
+            code.prependLeft(this.right.start, ' ');
+        }
+        this.body.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ForStatement extends NodeBase {
+    createScope(parentScope) {
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.init?.hasEffects(context) ||
+            this.test?.hasEffects(context) ||
+            this.update?.hasEffects(context)) {
+            return true;
+        }
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.init?.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        this.test?.include(context, includeChildrenRecursively);
+        this.update?.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+    render(code, options) {
+        this.init?.render(code, options, NO_SEMICOLON);
+        this.test?.render(code, options, NO_SEMICOLON);
+        this.update?.render(code, options, NO_SEMICOLON);
+        this.body.render(code, options);
+    }
+}
+
+class FunctionExpression extends FunctionNode {
+    createScope(parentScope) {
+        super.createScope((this.idScope = new ChildScope(parentScope, parentScope.context)));
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.id !== null) {
+            this.id = new Identifier(this, this.idScope).parseNode(esTreeNode.id);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    onlyFunctionCallUsed() {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this &&
+            (this.id === null || this.id.variable.getOnlyFunctionCallUsed());
+        return isIIFE || super.onlyFunctionCallUsed();
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+}
+
+class TrackingScope extends BlockScope {
+    constructor() {
+        super(...arguments);
+        this.hoistedDeclarations = [];
+    }
+    addDeclaration(identifier, context, init, kind) {
+        this.hoistedDeclarations.push(identifier);
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+const unset = Symbol('unset');
+class IfStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.testValue = unset;
+    }
+    deoptimizeCache() {
+        this.testValue = UnknownValue;
+    }
+    hasEffects(context) {
+        if (this.test.hasEffects(context)) {
+            return true;
+        }
+        const testValue = this.getTestValue();
+        if (typeof testValue === 'symbol') {
+            const { brokenFlow } = context;
+            if (this.consequent.hasEffects(context))
+                return true;
+            const consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+            if (this.alternate === null)
+                return false;
+            if (this.alternate.hasEffects(context))
+                return true;
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+            return false;
+        }
+        return testValue ? this.consequent.hasEffects(context) : !!this.alternate?.hasEffects(context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        if (includeChildrenRecursively) {
+            this.includeRecursively(includeChildrenRecursively, context);
+        }
+        else {
+            const testValue = this.getTestValue();
+            if (typeof testValue === 'symbol') {
+                this.includeUnknownTest(context);
+            }
+            else {
+                this.includeKnownTest(context, testValue);
+            }
+        }
+    }
+    parseNode(esTreeNode) {
+        this.consequent = new (this.scope.context.getNodeConstructor(esTreeNode.consequent.type))(this, (this.consequentScope = new TrackingScope(this.scope))).parseNode(esTreeNode.consequent);
+        if (esTreeNode.alternate) {
+            this.alternate = new (this.scope.context.getNodeConstructor(esTreeNode.alternate.type))(this, (this.alternateScope = new TrackingScope(this.scope))).parseNode(esTreeNode.alternate);
+        }
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { getPropertyAccess } } = options;
+        // Note that unknown test values are always included
+        const testValue = this.getTestValue();
+        const hoistedDeclarations = [];
+        const includesIfElse = this.test.included;
+        const noTreeshake = !this.scope.context.options.treeshake;
+        if (includesIfElse) {
+            this.test.render(code, options);
+        }
+        else {
+            code.remove(this.start, this.consequent.start);
+        }
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
+            this.consequent.render(code, options);
+        }
+        else {
+            code.overwrite(this.consequent.start, this.consequent.end, includesIfElse ? ';' : '');
+            hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
+        }
+        if (this.alternate) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
+                if (includesIfElse) {
+                    if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
+                        code.prependLeft(this.alternate.start, ' ');
+                    }
+                }
+                else {
+                    code.remove(this.consequent.end, this.alternate.start);
+                }
+                this.alternate.render(code, options);
+            }
+            else {
+                if (includesIfElse && this.shouldKeepAlternateBranch()) {
+                    code.overwrite(this.alternate.start, this.end, ';');
+                }
+                else {
+                    code.remove(this.consequent.end, this.end);
+                }
+                hoistedDeclarations.push(...this.alternateScope.hoistedDeclarations);
+            }
+        }
+        this.renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess);
+    }
+    applyDeoptimizations() { }
+    getTestValue() {
+        if (this.testValue === unset) {
+            return (this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        }
+        return this.testValue;
+    }
+    includeKnownTest(context, testValue) {
+        if (this.test.shouldBeIncluded(context)) {
+            this.test.include(context, false);
+        }
+        if (testValue && this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+        }
+        if (!testValue && this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+        }
+    }
+    includeRecursively(includeChildrenRecursively, context) {
+        this.test.include(context, includeChildrenRecursively);
+        this.consequent.include(context, includeChildrenRecursively);
+        this.alternate?.include(context, includeChildrenRecursively);
+    }
+    includeUnknownTest(context) {
+        this.test.include(context, false);
+        const { brokenFlow } = context;
+        let consequentBrokenFlow = false;
+        if (this.consequent.shouldBeIncluded(context)) {
+            this.consequent.include(context, false, { asSingleStatement: true });
+            consequentBrokenFlow = context.brokenFlow;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.alternate?.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
+            context.brokenFlow = context.brokenFlow && consequentBrokenFlow;
+        }
+    }
+    renderHoistedDeclarations(hoistedDeclarations, code, getPropertyAccess) {
+        const hoistedVariables = [
+            ...new Set(hoistedDeclarations.map(identifier => {
+                const variable = identifier.variable;
+                return variable.included ? variable.getName(getPropertyAccess) : '';
+            }))
+        ]
+            .filter(Boolean)
+            .join(', ');
+        if (hoistedVariables) {
+            const parentType = this.parent.type;
+            const needsBraces = parentType !== parseAst_js.Program && parentType !== parseAst_js.BlockStatement;
+            code.prependRight(this.start, `${needsBraces ? '{ ' : ''}var ${hoistedVariables}; `);
+            if (needsBraces) {
+                code.appendLeft(this.end, ` }`);
+            }
+        }
+    }
+    shouldKeepAlternateBranch() {
+        let currentParent = this.parent;
+        do {
+            if (currentParent instanceof IfStatement && currentParent.alternate) {
+                return true;
+            }
+            if (currentParent instanceof BlockStatement) {
+                return false;
+            }
+            currentParent = currentParent.parent;
+        } while (currentParent);
+        return false;
+    }
+}
+
+class ImportAttribute extends NodeBase {
+}
+
+class ImportDeclaration extends NodeBase {
+    // Do not bind specifiers or attributes
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addImport(this);
+    }
+    render(code, _options, nodeRenderOptions) {
+        code.remove(nodeRenderOptions.start, nodeRenderOptions.end);
+    }
+    applyDeoptimizations() { }
+}
+ImportDeclaration.prototype.needsBoundaries = true;
+
+class ImportDefaultSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+function isReassignedExportsMember(variable, exportNamesByVariable) {
+    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
+}
+
+class VariableDeclarator extends NodeBase {
+    declareDeclarator(kind, isUsingDeclaration) {
+        this.isUsingDeclaration = isUsingDeclaration;
+        this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        this.id.deoptimizePath(path);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.init?.hasEffects(context);
+        this.id.markDeclarationReached();
+        return initEffect || this.id.hasEffects(context) || this.isUsingDeclaration;
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, id, init } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        init?.include(context, includeChildrenRecursively);
+        id.markDeclarationReached();
+        if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
+            id.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.init?.removeAnnotations(code);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
+        const { end, id, init, start } = this;
+        const renderId = id.included || this.isUsingDeclaration;
+        if (renderId) {
+            id.render(code, options);
+        }
+        else {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
+            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
+        }
+        if (init) {
+            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+                const renderedVariable = id.variable.getName(getPropertyAccess);
+                if (renderedVariable !== id.name) {
+                    code.appendLeft(init.start + 5, ` ${id.name}`);
+                }
+            }
+            init.render(code, options, renderId ? parseAst_js.BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
+        }
+        else if (id instanceof Identifier &&
+            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
+            code.appendLeft(end, `${_}=${_}void 0`);
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { id, init } = this;
+        if (init && id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+            const { name, variable } = id;
+            for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+
+class ImportExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.inlineNamespace = null;
+        this.attributes = null;
+        this.mechanism = null;
+        this.namespaceExportName = undefined;
+        this.resolution = null;
+        this.resolutionString = null;
+    }
+    // Do not bind attributes
+    bind() {
+        this.source.bind();
+    }
+    /**
+     * Get imported variables for deterministic usage, valid cases are:
+     *
+     * - `const { foo } = await import('bar')`.
+     * - `(await import('bar')).foo`
+     * - `import('bar').then(({ foo }) => {})`
+     *
+     * Returns empty array if it's side-effect only import.
+     * Returns undefined if it's not fully deterministic.
+     */
+    getDeterministicImportedNames() {
+        const parent1 = this.parent;
+        // Side-effect only: import('bar')
+        if (parent1 instanceof ExpressionStatement) {
+            return parseAst_js.EMPTY_ARRAY;
+        }
+        if (parent1 instanceof AwaitExpression) {
+            const parent2 = parent1.parent;
+            // Side-effect only: await import('bar')
+            if (parent2 instanceof ExpressionStatement) {
+                return parseAst_js.EMPTY_ARRAY;
+            }
+            // Case 1: const { foo } = await import('bar')
+            if (parent2 instanceof VariableDeclarator) {
+                const declaration = parent2.id;
+                return declaration instanceof ObjectPattern
+                    ? getDeterministicObjectDestructure(declaration)
+                    : undefined;
+            }
+            // Case 2: (await import('bar')).foo
+            if (parent2 instanceof MemberExpression) {
+                const id = parent2.property;
+                if (!parent2.computed && id instanceof Identifier) {
+                    return [id.name];
+                }
+            }
+            return;
+        }
+        // Case 3: import('bar').then(({ foo }) => {})
+        if (parent1 instanceof MemberExpression) {
+            const callExpression = parent1.parent;
+            const property = parent1.property;
+            if (!(callExpression instanceof CallExpression) || !(property instanceof Identifier)) {
+                return;
+            }
+            const memberName = property.name;
+            // side-effect only, when only chaining .catch or .finally
+            if (callExpression.parent instanceof ExpressionStatement &&
+                ['catch', 'finally'].includes(memberName)) {
+                return parseAst_js.EMPTY_ARRAY;
+            }
+            if (memberName !== 'then')
+                return;
+            // Side-effect only: import('bar').then()
+            if (callExpression.arguments.length === 0) {
+                return parseAst_js.EMPTY_ARRAY;
+            }
+            const argument = callExpression.arguments[0];
+            if (callExpression.arguments.length !== 1 ||
+                !(argument instanceof ArrowFunctionExpression || argument instanceof FunctionExpression)) {
+                return;
+            }
+            // Side-effect only: import('bar').then(() => {})
+            if (argument.params.length === 0) {
+                return parseAst_js.EMPTY_ARRAY;
+            }
+            const declaration = argument.params[0];
+            if (argument.params.length === 1 && declaration instanceof ObjectPattern) {
+                return getDeterministicObjectDestructure(declaration);
+            }
+            return;
+        }
+    }
+    hasEffects() {
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeDynamicImport(this);
+            this.scope.addAccessedDynamicImport(this);
+        }
+        this.source.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        super.initialise();
+        this.scope.context.addDynamicImport(this);
+    }
+    parseNode(esTreeNode) {
+        this.sourceAstNode = esTreeNode.source;
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        const { snippets: { _, getDirectReturnFunction, getObject, getPropertyAccess } } = options;
+        if (this.inlineNamespace) {
+            const [left, right] = getDirectReturnFunction([], {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: null
+            });
+            code.overwrite(this.start, this.end, `Promise.resolve().then(${left}${this.inlineNamespace.getName(getPropertyAccess)}${right})`);
+            return;
+        }
+        if (this.mechanism) {
+            code.overwrite(this.start, findFirstOccurrenceOutsideComment(code.original, '(', this.start + 6) + 1, this.mechanism.left);
+            code.overwrite(this.end - 1, this.end, this.mechanism.right);
+        }
+        if (this.resolutionString) {
+            code.overwrite(this.source.start, this.source.end, this.resolutionString);
+            if (this.namespaceExportName) {
+                const [left, right] = getDirectReturnFunction(['n'], {
+                    functionReturn: true,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                code.prependLeft(this.end, `.then(${left}n.${this.namespaceExportName}${right})`);
+            }
+        }
+        else {
+            this.source.render(code, options);
+        }
+        if (this.attributes !== true) {
+            if (this.options) {
+                code.overwrite(this.source.end, this.end - 1, '', { contentOnly: true });
+            }
+            if (this.attributes) {
+                code.appendLeft(this.end - 1, `,${_}${getObject([['assert', this.attributes]], {
+                    lineBreakIndent: null
+                })}`);
+            }
+        }
+    }
+    setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName, attributes) {
+        const { format } = options;
+        this.inlineNamespace = null;
+        this.resolution = resolution;
+        this.resolutionString = resolutionString;
+        this.namespaceExportName = namespaceExportName;
+        this.attributes = attributes;
+        const accessedGlobals = [...(accessedImportGlobals[format] || [])];
+        let helper;
+        ({ helper, mechanism: this.mechanism } = this.getDynamicImportMechanismAndHelper(resolution, exportMode, options, snippets, pluginDriver));
+        if (helper) {
+            accessedGlobals.push(helper);
+        }
+        if (accessedGlobals.length > 0) {
+            this.scope.addAccessedGlobals(accessedGlobals, accessedGlobalsByScope);
+        }
+    }
+    setInternalResolution(inlineNamespace) {
+        this.inlineNamespace = inlineNamespace;
+    }
+    applyDeoptimizations() { }
+    getDynamicImportMechanismAndHelper(resolution, exportMode, { compact, dynamicImportInCjs, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver) {
+        const mechanism = pluginDriver.hookFirstSync('renderDynamicImport', [
+            {
+                customResolution: typeof this.resolution === 'string' ? this.resolution : null,
+                format,
+                moduleId: this.scope.context.module.id,
+                targetModuleId: this.resolution && typeof this.resolution !== 'string' ? this.resolution.id : null
+            }
+        ]);
+        if (mechanism) {
+            return { helper: null, mechanism };
+        }
+        const hasDynamicTarget = !this.resolution || typeof this.resolution === 'string';
+        switch (format) {
+            case 'cjs': {
+                if (dynamicImportInCjs &&
+                    (!resolution || typeof resolution === 'string' || resolution instanceof ExternalModule)) {
+                    return { helper: null, mechanism: null };
+                }
+                const helper = getInteropHelper(resolution, exportMode, interop);
+                let left = `require(`;
+                let right = `)`;
+                if (helper) {
+                    left = `/*#__PURE__*/${helper}(${left}`;
+                    right += ')';
+                }
+                const [functionLeft, functionRight] = getDirectReturnFunction([], {
+                    functionReturn: true,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                left = `Promise.resolve().then(${functionLeft}${left}`;
+                right += `${functionRight})`;
+                if (!arrowFunctions && hasDynamicTarget) {
+                    left = getDirectReturnIifeLeft(['t'], `${left}t${right}`, {
+                        needsArrowReturnParens: false,
+                        needsWrappedFunction: true
+                    });
+                    right = ')';
+                }
+                return {
+                    helper,
+                    mechanism: { left, right }
+                };
+            }
+            case 'amd': {
+                const resolve = compact ? 'c' : 'resolve';
+                const reject = compact ? 'e' : 'reject';
+                const helper = getInteropHelper(resolution, exportMode, interop);
+                const [resolveLeft, resolveRight] = getDirectReturnFunction(['m'], {
+                    functionReturn: false,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                const resolveNamespace = helper
+                    ? `${resolveLeft}${resolve}(/*#__PURE__*/${helper}(m))${resolveRight}`
+                    : resolve;
+                const [handlerLeft, handlerRight] = getDirectReturnFunction([resolve, reject], {
+                    functionReturn: false,
+                    lineBreakIndent: null,
+                    name: null
+                });
+                let left = `new Promise(${handlerLeft}require([`;
+                let right = `],${_}${resolveNamespace},${_}${reject})${handlerRight})`;
+                if (!arrowFunctions && hasDynamicTarget) {
+                    left = getDirectReturnIifeLeft(['t'], `${left}t${right}`, {
+                        needsArrowReturnParens: false,
+                        needsWrappedFunction: true
+                    });
+                    right = ')';
+                }
+                return {
+                    helper,
+                    mechanism: { left, right }
+                };
+            }
+            case 'system': {
+                return {
+                    helper: null,
+                    mechanism: {
+                        left: 'module.import(',
+                        right: ')'
+                    }
+                };
+            }
+        }
+        return { helper: null, mechanism: null };
+    }
+}
+function getInteropHelper(resolution, exportMode, interop) {
+    return exportMode === 'external'
+        ? namespaceInteropHelpersByInteropType[interop(resolution instanceof ExternalModule ? resolution.id : null)]
+        : exportMode === 'default'
+            ? INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE
+            : null;
+}
+const accessedImportGlobals = {
+    amd: ['require'],
+    cjs: ['require'],
+    system: ['module']
+};
+function getDeterministicObjectDestructure(objectPattern) {
+    const variables = [];
+    for (const property of objectPattern.properties) {
+        if (property.type === 'RestElement' || property.computed || property.key.type !== 'Identifier')
+            return;
+        variables.push(property.key.name);
+    }
+    return variables;
+}
+
+class ImportNamespaceSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class ImportSpecifier extends NodeBase {
+    applyDeoptimizations() { }
+}
+
+class JSXIdentifier extends IdentifierBase {
+    constructor() {
+        super(...arguments);
+        this.isNativeElement = false;
+    }
+    bind() {
+        const type = this.getType();
+        if (type === 0 /* IdentifierType.Reference */) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+        }
+        else if (type === 1 /* IdentifierType.NativeElementName */) {
+            this.isNativeElement = true;
+        }
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+            }
+        }
+        else if (this.isNativeElement &&
+            this.scope.context.options.jsx.mode !== 'preserve') {
+            code.update(this.start, this.end, JSON.stringify(this.name));
+        }
+    }
+    getType() {
+        switch (this.parent.type) {
+            case 'JSXOpeningElement':
+            case 'JSXClosingElement': {
+                return this.name.startsWith(this.name.charAt(0).toUpperCase())
+                    ? 0 /* IdentifierType.Reference */
+                    : 1 /* IdentifierType.NativeElementName */;
+            }
+            case 'JSXMemberExpression': {
+                return this.parent.object === this
+                    ? 0 /* IdentifierType.Reference */
+                    : 2 /* IdentifierType.Other */;
+            }
+            case 'JSXAttribute':
+            case 'JSXNamespacedName': {
+                return 2 /* IdentifierType.Other */;
+            }
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Unexpected parent node type for JSXIdentifier: ${this.parent.type}`);
+            }
+        }
+    }
+}
+
+class JSXAttribute extends NodeBase {
+    render(code, options, { jsxMode } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (['classic', 'automatic'].includes(jsxMode)) {
+            const { name, value } = this;
+            const key = name instanceof JSXIdentifier ? name.name : `${name.namespace.name}:${name.name.name}`;
+            if (!(jsxMode === 'automatic' && key === 'key')) {
+                const safeKey = stringifyObjectKeyIfNeeded(key);
+                if (key !== safeKey) {
+                    code.overwrite(name.start, name.end, safeKey, { contentOnly: true });
+                }
+                if (value) {
+                    code.overwrite(name.end, value.start, ': ', { contentOnly: true });
+                }
+                else {
+                    code.appendLeft(name.end, ': true');
+                }
+            }
+        }
+    }
+}
+
+class JSXClosingBase extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, ')', { contentOnly: true });
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+
+class JSXClosingElement extends JSXClosingBase {
+}
+
+class JSXClosingFragment extends JSXClosingBase {
+}
+
+class JSXSpreadAttribute extends NodeBase {
+    render(code, options) {
+        this.argument.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.argument.start, '', { contentOnly: true });
+            code.overwrite(this.argument.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXEmptyExpression extends NodeBase {
+}
+
+class JSXExpressionContainer extends NodeBase {
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.remove(this.start, this.expression.start);
+            code.remove(this.expression.end, this.end);
+        }
+        this.expression.render(code, options);
+    }
+}
+
+function getRenderedJsxChildren(children) {
+    let renderedChildren = 0;
+    for (const child of children) {
+        if (!(child instanceof JSXExpressionContainer && child.expression instanceof JSXEmptyExpression)) {
+            renderedChildren++;
+        }
+    }
+    return renderedChildren;
+}
+
+function getAndIncludeFactoryVariable(factory, preserve, importSource, node) {
+    const [baseName, nestedName] = factory.split('.');
+    let factoryVariable;
+    if (importSource) {
+        factoryVariable = node.scope.context.getImportedJsxFactoryVariable(nestedName ? 'default' : baseName, node.start, importSource);
+        if (preserve) {
+            // This pretends we are accessing an included global variable of the same name
+            const globalVariable = node.scope.findGlobal(baseName);
+            globalVariable.include();
+            // This excludes this variable from renaming
+            factoryVariable.globalName = baseName;
+        }
+    }
+    else {
+        factoryVariable = node.scope.findGlobal(baseName);
+    }
+    node.scope.context.includeVariableInModule(factoryVariable);
+    if (factoryVariable instanceof LocalVariable) {
+        factoryVariable.consolidateInitializers();
+        factoryVariable.addUsedPlace(node);
+        node.scope.context.requestTreeshakingPass();
+    }
+    return factoryVariable;
+}
+
+class JSXElementBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.factoryVariable = null;
+        this.factory = null;
+    }
+    initialise() {
+        super.initialise();
+        const { importSource } = (this.jsxMode = this.getRenderingMode());
+        if (importSource) {
+            this.scope.context.addImportSource(importSource);
+        }
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const { factory, importSource, mode } = this.jsxMode;
+            if (factory) {
+                this.factory = factory;
+                this.factoryVariable = getAndIncludeFactoryVariable(factory, mode === 'preserve', importSource, this);
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    applyDeoptimizations() { }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            return {
+                factory: getRenderedJsxChildren(this.children) > 1 ? 'jsxs' : 'jsx',
+                importSource: jsx.jsxImportSource,
+                mode
+            };
+        }
+        return { factory, importSource, mode };
+    }
+    renderChildren(code, options, openingEnd) {
+        const { children } = this;
+        let hasMultipleChildren = false;
+        let childrenEnd = openingEnd;
+        let firstChild = null;
+        for (const child of children) {
+            if (child instanceof JSXExpressionContainer &&
+                child.expression instanceof JSXEmptyExpression) {
+                code.remove(childrenEnd, child.end);
+            }
+            else {
+                code.appendLeft(childrenEnd, ', ');
+                child.render(code, options);
+                if (firstChild) {
+                    hasMultipleChildren = true;
+                }
+                else {
+                    firstChild = child;
+                }
+            }
+            childrenEnd = child.end;
+        }
+        return { childrenEnd, firstChild, hasMultipleChildren };
+    }
+}
+
+class JSXElement extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    getRenderingMode() {
+        const jsx = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx;
+        if (mode === 'automatic') {
+            // In the case there is a key after a spread attribute, we fall back to
+            // classic mode, see https://github.com/facebook/react/issues/20031#issuecomment-710346866
+            // for reasoning.
+            let hasSpread = false;
+            for (const attribute of this.openingElement.attributes) {
+                if (attribute instanceof JSXSpreadAttribute) {
+                    hasSpread = true;
+                }
+                else if (hasSpread && attribute.name.name === 'key') {
+                    return { factory, importSource, mode: 'classic' };
+                }
+            }
+        }
+        return super.getRenderingMode();
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factory, factoryVariable, openingElement: { end: openingEnd, selfClosing } } = this;
+        const [, ...nestedName] = factory.split('.');
+        const { firstAttribute, hasAttributes, hasSpread, inObject, previousEnd } = this.renderAttributes(code, options, [factoryVariable.getName(getPropertyAccess, useOriginalName), ...nestedName].join('.'), false);
+        this.wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, 'null', previousEnd);
+        this.renderChildren(code, options, openingEnd);
+        if (selfClosing) {
+            code.appendLeft(end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingElement, end, factoryVariable, openingElement: { end: openindEnd, selfClosing } } = this;
+        let { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd } = this.renderAttributes(code, options, factoryVariable.getName(getPropertyAccess, useOriginalName), true);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openindEnd);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `children: ${hasMultipleChildren ? '[' : ''}`);
+            if (!inObject) {
+                code.prependRight(firstChild.start, '{ ');
+                inObject = true;
+            }
+            previousEnd = closingElement.start;
+            if (hasMultipleChildren) {
+                code.appendLeft(previousEnd, ']');
+            }
+        }
+        this.wrapAttributes(code, inObject, hasAttributes || !!firstChild, hasSpread, firstAttribute || firstChild, '{}', childrenEnd);
+        if (keyAttribute) {
+            const { value } = keyAttribute;
+            // This will appear to the left of the moved code...
+            code.appendLeft(childrenEnd, ', ');
+            if (value) {
+                code.move(value.start, value.end, childrenEnd);
+            }
+            else {
+                code.appendLeft(childrenEnd, 'true');
+            }
+        }
+        if (selfClosing) {
+            // Moving the key attribute will also move the parenthesis to the right position
+            code.appendLeft(keyAttribute?.value?.end || end, ')');
+        }
+        else {
+            closingElement.render(code, options);
+        }
+    }
+    renderAttributes(code, options, factoryName, extractKeyAttribute) {
+        const { jsxMode: { mode }, openingElement } = this;
+        const { attributes, end: openingEnd, start: openingStart, name: { start: nameStart, end: nameEnd } } = openingElement;
+        code.update(openingStart, nameStart, `/*#__PURE__*/${factoryName}(`);
+        openingElement.render(code, options, { jsxMode: mode });
+        let keyAttribute = null;
+        let hasSpread = false;
+        let inObject = false;
+        let previousEnd = nameEnd;
+        let hasAttributes = false;
+        let firstAttribute = null;
+        for (const attribute of attributes) {
+            if (attribute instanceof JSXAttribute) {
+                if (extractKeyAttribute && attribute.name.name === 'key') {
+                    keyAttribute = attribute;
+                    code.remove(previousEnd, attribute.value?.start || attribute.end);
+                    continue;
+                }
+                code.appendLeft(previousEnd, ',');
+                if (!inObject) {
+                    code.prependRight(attribute.start, '{ ');
+                    inObject = true;
+                }
+                hasAttributes = true;
+            }
+            else {
+                if (inObject) {
+                    if (hasAttributes) {
+                        code.appendLeft(previousEnd, ' ');
+                    }
+                    code.appendLeft(previousEnd, '},');
+                    inObject = false;
+                }
+                else {
+                    code.appendLeft(previousEnd, ',');
+                }
+                hasSpread = true;
+            }
+            previousEnd = attribute.end;
+            if (!firstAttribute) {
+                firstAttribute = attribute;
+            }
+        }
+        code.remove(attributes.at(-1)?.end || previousEnd, openingEnd);
+        return { firstAttribute, hasAttributes, hasSpread, inObject, keyAttribute, previousEnd };
+    }
+    wrapAttributes(code, inObject, hasAttributes, hasSpread, firstAttribute, missingAttributesFallback, attributesEnd) {
+        if (inObject) {
+            code.appendLeft(attributesEnd, ' }');
+        }
+        if (hasSpread) {
+            if (hasAttributes) {
+                const { start } = firstAttribute;
+                if (firstAttribute instanceof JSXSpreadAttribute) {
+                    code.prependRight(start, '{}, ');
+                }
+                code.prependRight(start, 'Object.assign(');
+                code.appendLeft(attributesEnd, ')');
+            }
+        }
+        else if (!hasAttributes) {
+            code.appendLeft(attributesEnd, `, ${missingAttributesFallback}`);
+        }
+    }
+}
+
+class JSXFragment extends JSXElementBase {
+    render(code, options) {
+        switch (this.jsxMode.mode) {
+            case 'classic': {
+                this.renderClassicMode(code, options);
+                break;
+            }
+            case 'automatic': {
+                this.renderAutomaticMode(code, options);
+                break;
+            }
+            default: {
+                super.render(code, options);
+            }
+        }
+    }
+    renderClassicMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factory, factoryVariable, openingFragment, start } = this;
+        const [, ...nestedName] = factory.split('.');
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${[
+            factoryVariable.getName(getPropertyAccess, useOriginalName),
+            ...nestedName
+        ].join('.')}(`);
+        code.appendLeft(openingFragment.end, ', null');
+        this.renderChildren(code, options, openingFragment.end);
+        closingFragment.render(code, options);
+    }
+    renderAutomaticMode(code, options) {
+        const { snippets: { getPropertyAccess }, useOriginalName } = options;
+        const { closingFragment, factoryVariable, openingFragment, start } = this;
+        openingFragment.render(code, options);
+        code.prependRight(start, `/*#__PURE__*/${factoryVariable.getName(getPropertyAccess, useOriginalName)}(`);
+        const { firstChild, hasMultipleChildren, childrenEnd } = this.renderChildren(code, options, openingFragment.end);
+        if (firstChild) {
+            code.prependRight(firstChild.start, `{ children: ${hasMultipleChildren ? '[' : ''}`);
+            if (hasMultipleChildren) {
+                code.appendLeft(closingFragment.start, ']');
+            }
+            code.appendLeft(childrenEnd, ' }');
+        }
+        else {
+            code.appendLeft(openingFragment.end, ', {}');
+        }
+        closingFragment.render(code, options);
+    }
+}
+
+class JSXMemberExpression extends NodeBase {
+}
+
+class JSXNamespacedName extends NodeBase {
+}
+
+class JSXOpeningElement extends NodeBase {
+    render(code, options, { jsxMode = this.scope.context.options.jsx.mode } = {}) {
+        this.name.render(code, options);
+        for (const attribute of this.attributes) {
+            attribute.render(code, options, { jsxMode });
+        }
+    }
+}
+
+class JSXOpeningFragment extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.fragment = null;
+        this.fragmentVariable = null;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            const jsx = this.scope.context.options.jsx;
+            if (jsx.mode === 'automatic') {
+                this.fragment = 'Fragment';
+                this.fragmentVariable = getAndIncludeFactoryVariable('Fragment', false, jsx.jsxImportSource, this);
+            }
+            else {
+                const { fragment, importSource, mode } = jsx;
+                if (fragment != null) {
+                    this.fragment = fragment;
+                    this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === 'preserve', importSource, this);
+                }
+            }
+        }
+        super.include(context, includeChildrenRecursively);
+    }
+    render(code, options) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            const { snippets: { getPropertyAccess }, useOriginalName } = options;
+            const [, ...nestedFragment] = this.fragment.split('.');
+            const fragment = [
+                this.fragmentVariable.getName(getPropertyAccess, useOriginalName),
+                ...nestedFragment
+            ].join('.');
+            code.update(this.start, this.end, fragment);
+        }
+    }
+}
+
+class JSXSpreadChild extends NodeBase {
+    render(code, options) {
+        super.render(code, options);
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.expression.start, '...', { contentOnly: true });
+            code.overwrite(this.expression.end, this.end, '', { contentOnly: true });
+        }
+    }
+}
+
+class JSXText extends NodeBase {
+    render(code) {
+        const { mode } = this.scope.context.options.jsx;
+        if (mode !== 'preserve') {
+            code.overwrite(this.start, this.end, JSON.stringify(this.value), {
+                contentOnly: true
+            });
+        }
+    }
+}
+
+class LabeledStatement extends NodeBase {
+    hasEffects(context) {
+        const { brokenFlow, includedLabels } = context;
+        context.ignore.labels.add(this.label.name);
+        context.includedLabels = new Set();
+        let bodyHasEffects = false;
+        if (this.body.hasEffects(context)) {
+            bodyHasEffects = true;
+        }
+        else {
+            context.ignore.labels.delete(this.label.name);
+            if (context.includedLabels.has(this.label.name)) {
+                context.includedLabels.delete(this.label.name);
+                context.brokenFlow = brokenFlow;
+            }
+        }
+        context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
+        return bodyHasEffects;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const { brokenFlow, includedLabels } = context;
+        context.includedLabels = new Set();
+        this.body.include(context, includeChildrenRecursively);
+        if (includeChildrenRecursively || context.includedLabels.has(this.label.name)) {
+            this.label.include();
+            context.includedLabels.delete(this.label.name);
+            context.brokenFlow = brokenFlow;
+        }
+        context.includedLabels = new Set([...includedLabels, ...context.includedLabels]);
+    }
+    render(code, options) {
+        if (this.label.included) {
+            this.label.render(code, options);
+        }
+        else {
+            code.remove(this.start, findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1));
+        }
+        this.body.render(code, options);
+    }
+}
+
+class LogicalExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        // We collect deoptimization information if usedBranch !== null
+        this.expressionsToBeDeoptimized = [];
+        this.usedBranch = null;
+    }
+    //private isBranchResolutionAnalysed = false;
+    get isBranchResolutionAnalysed() {
+        return isFlagSet(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */);
+    }
+    set isBranchResolutionAnalysed(value) {
+        this.flags = setFlag(this.flags, 65536 /* Flag.isBranchResolutionAnalysed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.left.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        this.right.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        if (this.usedBranch) {
+            const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { scope: { context }, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            // Request another pass because we need to ensure "include" runs again if
+            // it is rendered
+            context.requestTreeshakingPass();
+        }
+    }
+    deoptimizePath(path) {
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch) {
+            usedBranch.deoptimizePath(path);
+        }
+        else {
+            this.left.deoptimizePath(path);
+            this.right.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch)
+            return [
+                new MultiExpression([
+                    this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0],
+                    this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)[0]
+                ]),
+                false
+            ];
+        this.expressionsToBeDeoptimized.push(origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        if (this.left.hasEffects(context)) {
+            return true;
+        }
+        if (this.getUsedBranch() !== this.left) {
+            return this.right.hasEffects(context);
+        }
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const usedBranch = this.getUsedBranch();
+        if (!usedBranch) {
+            return (this.left.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.right.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const usedBranch = this.getUsedBranch();
+        if (includeChildrenRecursively ||
+            (usedBranch === this.right && this.left.shouldBeIncluded(context)) ||
+            !usedBranch) {
+            this.left.include(context, includeChildrenRecursively);
+            this.right.include(context, includeChildrenRecursively);
+        }
+        else {
+            usedBranch.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.left.removeAnnotations(code);
+    }
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = parseAst_js.BLANK) {
+        if (!this.left.included || !this.right.included) {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
+            if (this.right.included) {
+                const removePos = findNonWhiteSpace(code.original, operatorPos + 2);
+                code.remove(this.start, removePos);
+                if (preventASI) {
+                    removeLineBreaks(code, removePos, this.right.start);
+                }
+                this.left.removeAnnotations(code);
+            }
+            else {
+                code.remove(findLastWhiteSpaceReverse(code.original, this.left.end, operatorPos), this.end);
+            }
+            this.getUsedBranch().render(code, options, {
+                isCalleeOfRenderedParent,
+                preventASI,
+                renderedParentType: renderedParentType || this.parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            });
+        }
+        else {
+            this.left.render(code, options, {
+                preventASI,
+                renderedSurroundingElement
+            });
+            this.right.render(code, options);
+        }
+    }
+    getUsedBranch() {
+        if (!this.isBranchResolutionAnalysed) {
+            this.isBranchResolutionAnalysed = true;
+            const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            if (typeof leftValue === 'symbol') {
+                return null;
+            }
+            else {
+                this.usedBranch =
+                    (this.operator === '||' && leftValue) ||
+                        (this.operator === '&&' && !leftValue) ||
+                        (this.operator === '??' && leftValue != null)
+                        ? this.left
+                        : this.right;
+            }
+        }
+        return this.usedBranch;
+    }
+}
+
+class NewExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        if (this.annotationPure) {
+            return false;
+        }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 0 || type !== INTERACTION_ACCESSED;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.callee.include(context, false);
+        }
+        this.callee.includeCallArguments(context, this.arguments);
+    }
+    initialise() {
+        super.initialise();
+        this.interaction = {
+            args: [null, ...this.arguments],
+            type: INTERACTION_CALLED,
+            withNew: true
+        };
+        if (this.annotations &&
+            this.scope.context.options.treeshake.annotations) {
+            this.annotationPure = this.annotations.some(comment => comment.type === 'pure');
+        }
+    }
+    render(code, options) {
+        this.callee.render(code, options);
+        renderCallArguments(code, options, this);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.callee.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+class ObjectExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizeCache() {
+        this.getObjectEntity().deoptimizeAllProperties();
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    render(code, options, { renderedSurroundingElement } = parseAst_js.BLANK) {
+        super.render(code, options);
+        if (renderedSurroundingElement === parseAst_js.ExpressionStatement ||
+            renderedSurroundingElement === parseAst_js.ArrowFunctionExpression) {
+            code.appendRight(this.start, '(');
+            code.prependLeft(this.end, ')');
+        }
+    }
+    applyDeoptimizations() { }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        let prototype = OBJECT_PROTOTYPE;
+        const properties = [];
+        for (const property of this.properties) {
+            if (property instanceof SpreadElement) {
+                properties.push({ key: UnknownKey, kind: 'init', property });
+                continue;
+            }
+            let key;
+            if (property.computed) {
+                const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                if (typeof keyValue === 'symbol') {
+                    properties.push({ key: UnknownKey, kind: property.kind, property });
+                    continue;
+                }
+                else {
+                    key = String(keyValue);
+                }
+            }
+            else {
+                key =
+                    property.key instanceof Identifier
+                        ? property.key.name
+                        : String(property.key.value);
+                if (key === '__proto__' && property.kind === 'init') {
+                    prototype =
+                        property.value instanceof Literal && property.value.value === null
+                            ? null
+                            : property.value;
+                    continue;
+                }
+            }
+            properties.push({ key, kind: property.kind, property });
+        }
+        return (this.objectEntity = new ObjectEntity(properties, prototype));
+    }
+}
+
+class PanicError extends NodeBase {
+    initialise() {
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = parseAst_js.getRollupError(parseAst_js.logParseError(this.message));
+        const moduleParseError = parseAst_js.logModuleParseError(parseError, id);
+        return parseAst_js.error(moduleParseError);
+    }
+}
+
+class ParseError extends NodeBase {
+    initialise() {
+        const pos = this.start;
+        const id = this.scope.context.module.id;
+        // This simulates the current nested error structure. We could also just
+        // replace it with a flat error.
+        const parseError = parseAst_js.getRollupError(parseAst_js.logParseError(this.message, pos));
+        const moduleParseError = parseAst_js.logModuleParseError(parseError, id);
+        this.scope.context.error(moduleParseError, pos);
+    }
+}
+
+class PrivateIdentifier extends NodeBase {
+}
+
+class Program extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.hasCachedEffect = null;
+        this.hasLoggedEffect = false;
+    }
+    hasCachedEffects() {
+        if (!this.included) {
+            return false;
+        }
+        return this.hasCachedEffect === null
+            ? (this.hasCachedEffect = this.hasEffects(createHasEffectsContext()))
+            : this.hasCachedEffect;
+    }
+    hasEffects(context) {
+        for (const node of this.body) {
+            if (node.hasEffects(context)) {
+                if (this.scope.context.options.experimentalLogSideEffects && !this.hasLoggedEffect) {
+                    this.hasLoggedEffect = true;
+                    const { code, log, module } = this.scope.context;
+                    log(parseAst_js.LOGLEVEL_INFO, parseAst_js.logFirstSideEffect(code, module.id, parseAst_js.locate(code, node.start, { offsetLine: 1 })), node.start);
+                }
+                return (this.hasCachedEffect = true);
+            }
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        for (const node of this.body) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context)) {
+                node.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        if (this.invalidAnnotations)
+            for (const { start, end, type } of this.invalidAnnotations) {
+                this.scope.context.magicString.remove(start, end);
+                if (type === 'pure' || type === 'noSideEffects') {
+                    this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidAnnotation(this.scope.context.code.slice(start, end), this.scope.context.module.id, type), start);
+                }
+            }
+    }
+    render(code, options) {
+        let start = this.start;
+        if (code.original.startsWith('#!')) {
+            start = Math.min(code.original.indexOf('\n') + 1, this.end);
+            code.remove(0, start);
+        }
+        if (this.body.length > 0) {
+            // Keep all consecutive lines that start with a comment
+            while (code.original[start] === '/' && /[*/]/.test(code.original[start + 1])) {
+                const firstLineBreak = findFirstLineBreakOutsideComment(code.original.slice(start, this.body[0].start));
+                if (firstLineBreak[0] === -1) {
+                    break;
+                }
+                start += firstLineBreak[1];
+            }
+            renderStatementList(this.body, code, start, this.end, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+    applyDeoptimizations() { }
+}
+
+class Property extends MethodBase {
+    constructor() {
+        super(...arguments);
+        this.declarationInit = null;
+    }
+    //declare method: boolean;
+    get method() {
+        return isFlagSet(this.flags, 262144 /* Flag.method */);
+    }
+    set method(value) {
+        this.flags = setFlag(this.flags, 262144 /* Flag.method */, value);
+    }
+    //declare shorthand: boolean;
+    get shorthand() {
+        return isFlagSet(this.flags, 524288 /* Flag.shorthand */);
+    }
+    set shorthand(value) {
+        this.flags = setFlag(this.flags, 524288 /* Flag.shorthand */, value);
+    }
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.value.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const propertyReadSideEffects = this.scope.context.options.treeshake.propertyReadSideEffects;
+        return ((this.parent.type === 'ObjectPattern' && propertyReadSideEffects === 'always') ||
+            this.key.hasEffects(context) ||
+            this.value.hasEffects(context));
+    }
+    markDeclarationReached() {
+        this.value.markDeclarationReached();
+    }
+    render(code, options) {
+        if (!this.shorthand) {
+            this.key.render(code, options);
+        }
+        this.value.render(code, options, { isShorthandProperty: this.shorthand });
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class PropertyDefinition extends NodeBase {
+    get computed() {
+        return isFlagSet(this.flags, 1024 /* Flag.computed */);
+    }
+    set computed(value) {
+        this.flags = setFlag(this.flags, 1024 /* Flag.computed */, value);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.value?.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.value?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.value
+            ? this.value.getLiteralValueAtPath(path, recursionTracker, origin)
+            : UnknownValue;
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.value
+            ? this.value.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
+            : UNKNOWN_RETURN_EXPRESSION;
+    }
+    hasEffects(context) {
+        return (this.key.hasEffects(context) ||
+            (this.static && !!this.value?.hasEffects(context)) ||
+            checkEffectForNodes(this.decorators, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return !this.value || this.value.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    applyDeoptimizations() { }
+}
+
+class ReturnStatement extends NodeBase {
+    hasEffects(context) {
+        if (!context.ignore.returnYield || this.argument?.hasEffects(context))
+            return true;
+        context.brokenFlow = true;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.argument?.include(context, includeChildrenRecursively);
+        context.brokenFlow = true;
+    }
+    initialise() {
+        super.initialise();
+        this.scope.addReturnExpression(this.argument || UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        if (this.argument) {
+            this.argument.render(code, options, { preventASI: true });
+            if (this.argument.start === this.start + 6 /* 'return'.length */) {
+                code.prependLeft(this.start + 6, ' ');
+            }
+        }
+    }
+}
+
+class SequenceExpression extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.expressions[this.expressions.length - 1].deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.expressions[this.expressions.length - 1].deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.expressions[this.expressions.length - 1].getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    hasEffects(context) {
+        for (const expression of this.expressions) {
+            if (expression.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.expressions[this.expressions.length - 1].hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const lastExpression = this.expressions[this.expressions.length - 1];
+        for (const expression of this.expressions) {
+            if (includeChildrenRecursively ||
+                (expression === lastExpression && !(this.parent instanceof ExpressionStatement)) ||
+                expression.shouldBeIncluded(context))
+                expression.include(context, includeChildrenRecursively);
+        }
+    }
+    removeAnnotations(code) {
+        this.expressions[0].removeAnnotations(code);
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = parseAst_js.BLANK) {
+        let includedNodes = 0;
+        let lastSeparatorPos = null;
+        const lastNode = this.expressions[this.expressions.length - 1];
+        for (const { node, separator, start, end } of getCommaSeparatedNodesWithBoundaries(this.expressions, code, this.start, this.end)) {
+            if (!node.included) {
+                treeshakeNode(node, code, start, end);
+                continue;
+            }
+            includedNodes++;
+            lastSeparatorPos = separator;
+            if (includedNodes === 1 && preventASI) {
+                removeLineBreaks(code, start, node.start);
+            }
+            if (includedNodes === 1) {
+                const parentType = renderedParentType || this.parent.type;
+                node.render(code, options, {
+                    isCalleeOfRenderedParent: isCalleeOfRenderedParent && node === lastNode,
+                    renderedParentType: parentType,
+                    renderedSurroundingElement: parentType
+                });
+            }
+            else {
+                node.render(code, options);
+            }
+        }
+        if (lastSeparatorPos) {
+            code.remove(lastSeparatorPos, this.end);
+        }
+    }
+}
+
+class Super extends NodeBase {
+    bind() {
+        this.variable = this.scope.findVariable('this');
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.variable.deoptimizePath(path);
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+}
+
+class SwitchCase extends NodeBase {
+    hasEffects(context) {
+        if (this.test?.hasEffects(context))
+            return true;
+        for (const node of this.consequent) {
+            if (context.brokenFlow)
+                break;
+            if (node.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test?.include(context, includeChildrenRecursively);
+        for (const node of this.consequent) {
+            if (includeChildrenRecursively || node.shouldBeIncluded(context))
+                node.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options, nodeRenderOptions) {
+        if (this.consequent.length > 0) {
+            if (this.test) {
+                this.test.render(code, options);
+            }
+            const testEnd = this.test
+                ? this.test.end
+                : findFirstOccurrenceOutsideComment(code.original, 'default', this.start) + 7;
+            const consequentStart = findFirstOccurrenceOutsideComment(code.original, ':', testEnd) + 1;
+            renderStatementList(this.consequent, code, consequentStart, nodeRenderOptions.end, options);
+        }
+        else {
+            super.render(code, options);
+        }
+    }
+}
+SwitchCase.prototype.needsBoundaries = true;
+
+class SwitchStatement extends NodeBase {
+    createScope(parentScope) {
+        this.parentScope = parentScope;
+        this.scope = new BlockScope(parentScope);
+    }
+    hasEffects(context) {
+        if (this.discriminant.hasEffects(context))
+            return true;
+        const { brokenFlow, hasBreak, ignore } = context;
+        const { breaks } = ignore;
+        ignore.breaks = true;
+        context.hasBreak = false;
+        let onlyHasBrokenFlow = true;
+        for (const switchCase of this.cases) {
+            if (switchCase.hasEffects(context))
+                return true;
+            onlyHasBrokenFlow &&= context.brokenFlow && !context.hasBreak;
+            context.hasBreak = false;
+            context.brokenFlow = brokenFlow;
+        }
+        if (this.defaultCase !== null) {
+            context.brokenFlow = onlyHasBrokenFlow;
+        }
+        ignore.breaks = breaks;
+        context.hasBreak = hasBreak;
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.discriminant.include(context, includeChildrenRecursively);
+        const { brokenFlow, hasBreak } = context;
+        context.hasBreak = false;
+        let onlyHasBrokenFlow = true;
+        let isCaseIncluded = includeChildrenRecursively ||
+            (this.defaultCase !== null && this.defaultCase < this.cases.length - 1);
+        for (let caseIndex = this.cases.length - 1; caseIndex >= 0; caseIndex--) {
+            const switchCase = this.cases[caseIndex];
+            if (switchCase.included) {
+                isCaseIncluded = true;
+            }
+            if (!isCaseIncluded) {
+                const hasEffectsContext = createHasEffectsContext();
+                hasEffectsContext.ignore.breaks = true;
+                isCaseIncluded = switchCase.hasEffects(hasEffectsContext);
+            }
+            if (isCaseIncluded) {
+                switchCase.include(context, includeChildrenRecursively);
+                onlyHasBrokenFlow &&= context.brokenFlow && !context.hasBreak;
+                context.hasBreak = false;
+                context.brokenFlow = brokenFlow;
+            }
+            else {
+                onlyHasBrokenFlow = brokenFlow;
+            }
+        }
+        if (isCaseIncluded && this.defaultCase !== null) {
+            context.brokenFlow = onlyHasBrokenFlow;
+        }
+        context.hasBreak = hasBreak;
+    }
+    initialise() {
+        super.initialise();
+        for (let caseIndex = 0; caseIndex < this.cases.length; caseIndex++) {
+            if (this.cases[caseIndex].test === null) {
+                this.defaultCase = caseIndex;
+                return;
+            }
+        }
+        this.defaultCase = null;
+    }
+    parseNode(esTreeNode) {
+        this.discriminant = new (this.scope.context.getNodeConstructor(esTreeNode.discriminant.type))(this, this.parentScope).parseNode(esTreeNode.discriminant);
+        return super.parseNode(esTreeNode);
+    }
+    render(code, options) {
+        this.discriminant.render(code, options);
+        if (this.cases.length > 0) {
+            renderStatementList(this.cases, code, this.cases[0].start, this.end - 1, options);
+        }
+    }
+}
+
+class TaggedTemplateExpression extends CallExpressionBase {
+    bind() {
+        super.bind();
+        if (this.tag.type === parseAst_js.Identifier) {
+            const name = this.tag.name;
+            const variable = this.scope.findVariable(name);
+            if (variable.isNamespace) {
+                this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCannotCallNamespace(name), this.start);
+            }
+        }
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.quasi.expressions) {
+            if (argument.hasEffects(context))
+                return true;
+        }
+        return (this.tag.hasEffects(context) ||
+            this.tag.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (includeChildrenRecursively) {
+            super.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.included = true;
+            this.tag.include(context, includeChildrenRecursively);
+            this.quasi.include(context, includeChildrenRecursively);
+        }
+        this.tag.includeCallArguments(context, this.args);
+        const [returnExpression] = this.getReturnExpression();
+        if (!returnExpression.included) {
+            returnExpression.include(context, false);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.args = [UNKNOWN_EXPRESSION, ...this.quasi.expressions];
+        this.interaction = {
+            args: [
+                this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
+                ...this.args
+            ],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
+    }
+    render(code, options) {
+        this.tag.render(code, options, { isCalleeOfRenderedParent: true });
+        this.quasi.render(code, options);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.tag.deoptimizeArgumentsOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
+        this.scope.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_RETURN_EXPRESSION;
+            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
+}
+
+class TemplateElement extends NodeBase {
+    get tail() {
+        return isFlagSet(this.flags, 1048576 /* Flag.tail */);
+    }
+    set tail(value) {
+        this.flags = setFlag(this.flags, 1048576 /* Flag.tail */, value);
+    }
+    // Do not try to bind value
+    bind() { }
+    hasEffects() {
+        return false;
+    }
+    include() {
+        this.included = true;
+    }
+    parseNode(esTreeNode) {
+        this.value = esTreeNode.value;
+        return super.parseNode(esTreeNode);
+    }
+    render() { }
+}
+
+class TemplateLiteral extends NodeBase {
+    deoptimizeArgumentsOnInteractionAtPath() { }
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 || this.quasis.length !== 1) {
+            return UnknownValue;
+        }
+        return this.quasis[0].value.cooked;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
+        }
+        return true;
+    }
+    render(code, options) {
+        code.indentExclusionRanges.push([this.start, this.end]);
+        super.render(code, options);
+    }
+}
+
+class ModuleScope extends ChildScope {
+    constructor(parent, context) {
+        super(parent, context);
+        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, 'other'));
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (this.context.module.importDescriptions.has(identifier.name)) {
+            context.error(parseAst_js.logRedeclarationError(identifier.name), identifier.start);
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+    addExportDefaultDeclaration(name, exportDefaultDeclaration, context) {
+        const variable = new ExportDefaultVariable(name, exportDefaultDeclaration, context);
+        this.variables.set('default', variable);
+        return variable;
+    }
+    addNamespaceMemberAccess() { }
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        // all module level variables are already deconflicted when deconflicting the chunk
+        for (const scope of this.children)
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+    findLexicalBoundary() {
+        return this;
+    }
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
+        }
+        const variable = this.context.traceVariable(name) || this.parent.findVariable(name);
+        if (variable instanceof GlobalVariable) {
+            this.accessedOutsideVariables.set(name, variable);
+        }
+        return variable;
+    }
+}
+
+class ThisExpression extends NodeBase {
+    bind() {
+        this.variable = this.scope.findVariable('this');
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        this.variable.deoptimizePath(path);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length === 0) {
+            return interaction.type !== INTERACTION_ACCESSED;
+        }
+        return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    include() {
+        if (!this.included) {
+            this.included = true;
+            this.scope.context.includeVariableInModule(this.variable);
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.alias =
+            this.scope.findLexicalBoundary() instanceof ModuleScope
+                ? this.scope.context.moduleContext
+                : null;
+        if (this.alias === 'undefined') {
+            this.scope.context.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logThisIsUndefined(), this.start);
+        }
+    }
+    render(code) {
+        if (this.alias !== null) {
+            code.overwrite(this.start, this.end, this.alias, {
+                contentOnly: false,
+                storeName: true
+            });
+        }
+    }
+}
+
+class ThrowStatement extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.argument.include(context, includeChildrenRecursively);
+        context.brokenFlow = true;
+    }
+    render(code, options) {
+        this.argument.render(code, options, { preventASI: true });
+        if (this.argument.start === this.start + 5 /* 'throw'.length */) {
+            code.prependLeft(this.start + 5, ' ');
+        }
+    }
+}
+
+class TryStatement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.directlyIncluded = false;
+        this.includedLabelsAfterBlock = null;
+    }
+    hasEffects(context) {
+        return ((this.scope.context.options.treeshake.tryCatchDeoptimization
+            ? this.block.body.length > 0
+            : this.block.hasEffects(context)) || !!this.finalizer?.hasEffects(context));
+    }
+    include(context, includeChildrenRecursively) {
+        const tryCatchDeoptimization = this.scope.context.options.treeshake?.tryCatchDeoptimization;
+        const { brokenFlow, includedLabels } = context;
+        if (!this.directlyIncluded || !tryCatchDeoptimization) {
+            this.included = true;
+            this.directlyIncluded = true;
+            this.block.include(context, tryCatchDeoptimization ? INCLUDE_PARAMETERS : includeChildrenRecursively);
+            if (includedLabels.size > 0) {
+                this.includedLabelsAfterBlock = [...includedLabels];
+            }
+            context.brokenFlow = brokenFlow;
+        }
+        else if (this.includedLabelsAfterBlock) {
+            for (const label of this.includedLabelsAfterBlock) {
+                includedLabels.add(label);
+            }
+        }
+        if (this.handler !== null) {
+            this.handler.include(context, includeChildrenRecursively);
+            context.brokenFlow = brokenFlow;
+        }
+        this.finalizer?.include(context, includeChildrenRecursively);
+    }
+}
+
+const unaryOperators = {
+    '!': value => !value,
+    '+': value => +value,
+    '-': value => -value,
+    delete: () => UnknownValue,
+    typeof: value => typeof value,
+    void: () => undefined,
+    '~': value => ~value
+};
+class UnaryExpression extends NodeBase {
+    get prefix() {
+        return isFlagSet(this.flags, 2097152 /* Flag.prefix */);
+    }
+    set prefix(value) {
+        this.flags = setFlag(this.flags, 2097152 /* Flag.prefix */, value);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (path.length > 0)
+            return UnknownValue;
+        const argumentValue = this.argument.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
+        if (typeof argumentValue === 'symbol')
+            return UnknownValue;
+        return unaryOperators[this.operator](argumentValue);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.operator === 'typeof' && this.argument instanceof Identifier)
+            return false;
+        return (this.argument.hasEffects(context) ||
+            (this.operator === 'delete' &&
+                this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)));
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.operator === 'void' ? 0 : 1);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.operator === 'delete') {
+            this.argument.deoptimizePath(EMPTY_PATH);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+}
+
+class UpdateExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return this.argument.hasEffectsAsAssignmentTarget(context, true);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
+    }
+    initialise() {
+        super.initialise();
+        this.argument.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, format, snippets: { _ } } = options;
+        this.argument.render(code, options);
+        if (format === 'system') {
+            const variable = this.argument.variable;
+            const exportNames = exportNamesByVariable.get(variable);
+            if (exportNames) {
+                if (this.prefix) {
+                    if (exportNames.length === 1) {
+                        renderSystemExportExpression(variable, this.start, this.end, code, options);
+                    }
+                    else {
+                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== parseAst_js.ExpressionStatement, code, options);
+                    }
+                }
+                else {
+                    const operator = this.operator[0];
+                    renderSystemExportSequenceBeforeExpression(variable, this.start, this.end, this.parent.type !== parseAst_js.ExpressionStatement, code, options, `${_}${operator}${_}1`);
+                }
+            }
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.argument.deoptimizePath(EMPTY_PATH);
+        if (this.argument instanceof Identifier) {
+            const variable = this.scope.findVariable(this.argument.name);
+            variable.markReassigned();
+        }
+        this.scope.context.requestTreeshakingPass();
+    }
+}
+
+function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
+    for (const declarator of declarations) {
+        if (!declarator.id.included)
+            return false;
+        if (declarator.id.type === parseAst_js.Identifier) {
+            if (exportNamesByVariable.has(declarator.id.variable))
+                return false;
+        }
+        else {
+            const exportedVariables = [];
+            declarator.id.addExportedVariables(exportedVariables, exportNamesByVariable);
+            if (exportedVariables.length > 0)
+                return false;
+        }
+    }
+    return true;
+}
+class VariableDeclaration extends NodeBase {
+    deoptimizePath() {
+        for (const declarator of this.declarations) {
+            declarator.deoptimizePath(EMPTY_PATH);
+        }
+    }
+    hasEffectsOnInteractionAtPath() {
+        return false;
+    }
+    include(context, includeChildrenRecursively, { asSingleStatement } = parseAst_js.BLANK) {
+        this.included = true;
+        for (const declarator of this.declarations) {
+            if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
+                declarator.include(context, includeChildrenRecursively);
+            const { id, init } = declarator;
+            if (asSingleStatement) {
+                id.include(context, includeChildrenRecursively);
+            }
+            if (init &&
+                id.included &&
+                !init.included &&
+                (id instanceof ObjectPattern || id instanceof ArrayPattern)) {
+                init.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    initialise() {
+        super.initialise();
+        this.isUsingDeclaration = this.kind === 'await using' || this.kind === 'using';
+        for (const declarator of this.declarations) {
+            declarator.declareDeclarator(this.kind, this.isUsingDeclaration);
+        }
+    }
+    removeAnnotations(code) {
+        this.declarations[0].removeAnnotations(code);
+    }
+    render(code, options, nodeRenderOptions = parseAst_js.BLANK) {
+        if (this.isUsingDeclaration ||
+            areAllDeclarationsIncludedAndNotExported(this.declarations, options.exportNamesByVariable)) {
+            for (const declarator of this.declarations) {
+                declarator.render(code, options);
+            }
+            if (!nodeRenderOptions.isNoStatement &&
+                code.original.charCodeAt(this.end - 1) !== 59 /*";"*/) {
+                code.appendLeft(this.end, ';');
+            }
+        }
+        else {
+            this.renderReplacedDeclarations(code, options);
+        }
+    }
+    applyDeoptimizations() { }
+    renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, systemPatternExports, options) {
+        if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
+            code.remove(this.end - 1, this.end);
+        }
+        separatorString += ';';
+        if (lastSeparatorPos === null) {
+            code.appendLeft(renderedContentEnd, separatorString);
+        }
+        else {
+            if (code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/ &&
+                (code.original.charCodeAt(this.end) === 10 /*"\n"*/ ||
+                    code.original.charCodeAt(this.end) === 13) /*"\r"*/) {
+                actualContentEnd--;
+                if (code.original.charCodeAt(actualContentEnd) === 13 /*"\r"*/) {
+                    actualContentEnd--;
+                }
+            }
+            if (actualContentEnd === lastSeparatorPos + 1) {
+                code.overwrite(lastSeparatorPos, renderedContentEnd, separatorString);
+            }
+            else {
+                code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
+                code.remove(actualContentEnd, renderedContentEnd);
+            }
+        }
+        if (systemPatternExports.length > 0) {
+            code.appendLeft(renderedContentEnd, ` ${getSystemExportStatement(systemPatternExports, options)};`);
+        }
+    }
+    renderReplacedDeclarations(code, options) {
+        const separatedNodes = getCommaSeparatedNodesWithBoundaries(this.declarations, code, this.start + this.kind.length, this.end - (code.original.charCodeAt(this.end - 1) === 59 /*";"*/ ? 1 : 0));
+        let actualContentEnd, renderedContentEnd;
+        renderedContentEnd = findNonWhiteSpace(code.original, this.start + this.kind.length);
+        let lastSeparatorPos = renderedContentEnd - 1;
+        code.remove(this.start, lastSeparatorPos);
+        let isInDeclaration = false;
+        let hasRenderedContent = false;
+        let separatorString = '', leadingString, nextSeparatorString;
+        const aggregatedSystemExports = [];
+        const singleSystemExport = gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports);
+        for (const { node, start, separator, contentEnd, end } of separatedNodes) {
+            if (!node.included) {
+                code.remove(start, end);
+                node.removeAnnotations(code);
+                continue;
+            }
+            node.render(code, options);
+            leadingString = '';
+            nextSeparatorString = '';
+            if (!node.id.included ||
+                (node.id instanceof Identifier &&
+                    isReassignedExportsMember(node.id.variable, options.exportNamesByVariable))) {
+                if (hasRenderedContent) {
+                    separatorString += ';';
+                }
+                isInDeclaration = false;
+            }
+            else {
+                if (singleSystemExport && singleSystemExport === node.id.variable) {
+                    const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', node.id.end);
+                    renderSystemExportExpression(singleSystemExport, findNonWhiteSpace(code.original, operatorPos + 1), separator === null ? contentEnd : separator, code, options);
+                }
+                if (isInDeclaration) {
+                    separatorString += ',';
+                }
+                else {
+                    if (hasRenderedContent) {
+                        separatorString += ';';
+                    }
+                    leadingString += `${this.kind} `;
+                    isInDeclaration = true;
+                }
+            }
+            if (renderedContentEnd === lastSeparatorPos + 1) {
+                code.overwrite(lastSeparatorPos, renderedContentEnd, separatorString + leadingString);
+            }
+            else {
+                code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
+                code.appendLeft(renderedContentEnd, leadingString);
+            }
+            actualContentEnd = contentEnd;
+            renderedContentEnd = end;
+            hasRenderedContent = true;
+            lastSeparatorPos = separator;
+            separatorString = nextSeparatorString;
+        }
+        this.renderDeclarationEnd(code, separatorString, lastSeparatorPos, actualContentEnd, renderedContentEnd, aggregatedSystemExports, options);
+    }
+}
+function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregatedSystemExports) {
+    let singleSystemExport = null;
+    if (options.format === 'system') {
+        for (const { node } of separatedNodes) {
+            if (node.id instanceof Identifier &&
+                node.init &&
+                aggregatedSystemExports.length === 0 &&
+                options.exportNamesByVariable.get(node.id.variable)?.length === 1) {
+                singleSystemExport = node.id.variable;
+                aggregatedSystemExports.push(singleSystemExport);
+            }
+            else {
+                node.id.addExportedVariables(aggregatedSystemExports, options.exportNamesByVariable);
+            }
+        }
+        if (aggregatedSystemExports.length > 1) {
+            singleSystemExport = null;
+        }
+        else if (singleSystemExport) {
+            aggregatedSystemExports.length = 0;
+        }
+    }
+    return singleSystemExport;
+}
+
+class WhileStatement extends NodeBase {
+    hasEffects(context) {
+        if (this.test.hasEffects(context))
+            return true;
+        return hasLoopBodyEffects(context, this.body);
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        this.test.include(context, includeChildrenRecursively);
+        includeLoopBody(context, this.body, includeChildrenRecursively);
+    }
+}
+
+class YieldExpression extends NodeBase {
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        return !(context.ignore.returnYield && !this.argument?.hasEffects(context));
+    }
+    render(code, options) {
+        if (this.argument) {
+            this.argument.render(code, options, { preventASI: true });
+            if (this.argument.start === this.start + 5 /* 'yield'.length */) {
+                code.prependLeft(this.start + 5, ' ');
+            }
+        }
+    }
+}
+
+// This file is generated by scripts/generate-buffer-parsers.js.
+// Do not edit this file directly.
+function convertProgram(buffer, parent, parentScope) {
+    return convertNode(parent, parentScope, 0, parseAst_js.getAstBuffer(buffer));
+}
+const nodeTypeStrings = [
+    'PanicError',
+    'ParseError',
+    'ArrayExpression',
+    'ArrayPattern',
+    'ArrowFunctionExpression',
+    'AssignmentExpression',
+    'AssignmentPattern',
+    'AwaitExpression',
+    'BinaryExpression',
+    'BlockStatement',
+    'BreakStatement',
+    'CallExpression',
+    'CatchClause',
+    'ChainExpression',
+    'ClassBody',
+    'ClassDeclaration',
+    'ClassExpression',
+    'ConditionalExpression',
+    'ContinueStatement',
+    'DebuggerStatement',
+    'Decorator',
+    'ExpressionStatement',
+    'DoWhileStatement',
+    'EmptyStatement',
+    'ExportAllDeclaration',
+    'ExportDefaultDeclaration',
+    'ExportNamedDeclaration',
+    'ExportSpecifier',
+    'ExpressionStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'ForStatement',
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'Identifier',
+    'IfStatement',
+    'ImportAttribute',
+    'ImportDeclaration',
+    'ImportDefaultSpecifier',
+    'ImportExpression',
+    'ImportNamespaceSpecifier',
+    'ImportSpecifier',
+    'JSXAttribute',
+    'JSXClosingElement',
+    'JSXClosingFragment',
+    'JSXElement',
+    'JSXEmptyExpression',
+    'JSXExpressionContainer',
+    'JSXFragment',
+    'JSXIdentifier',
+    'JSXMemberExpression',
+    'JSXNamespacedName',
+    'JSXOpeningElement',
+    'JSXOpeningFragment',
+    'JSXSpreadAttribute',
+    'JSXSpreadChild',
+    'JSXText',
+    'LabeledStatement',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'Literal',
+    'LogicalExpression',
+    'MemberExpression',
+    'MetaProperty',
+    'MethodDefinition',
+    'NewExpression',
+    'ObjectExpression',
+    'ObjectPattern',
+    'PrivateIdentifier',
+    'Program',
+    'Property',
+    'PropertyDefinition',
+    'RestElement',
+    'ReturnStatement',
+    'SequenceExpression',
+    'SpreadElement',
+    'StaticBlock',
+    'Super',
+    'SwitchCase',
+    'SwitchStatement',
+    'TaggedTemplateExpression',
+    'TemplateElement',
+    'TemplateLiteral',
+    'ThisExpression',
+    'ThrowStatement',
+    'TryStatement',
+    'UnaryExpression',
+    'UpdateExpression',
+    'VariableDeclaration',
+    'VariableDeclarator',
+    'WhileStatement',
+    'YieldExpression'
+];
+const nodeConstructors$1 = [
+    PanicError,
+    ParseError,
+    ArrayExpression,
+    ArrayPattern,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    AssignmentPattern,
+    AwaitExpression,
+    BinaryExpression,
+    BlockStatement,
+    BreakStatement,
+    CallExpression,
+    CatchClause,
+    ChainExpression,
+    ClassBody,
+    ClassDeclaration,
+    ClassExpression,
+    ConditionalExpression,
+    ContinueStatement,
+    DebuggerStatement,
+    Decorator,
+    ExpressionStatement,
+    DoWhileStatement,
+    EmptyStatement,
+    ExportAllDeclaration,
+    ExportDefaultDeclaration,
+    ExportNamedDeclaration,
+    ExportSpecifier,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    FunctionExpression,
+    Identifier,
+    IfStatement,
+    ImportAttribute,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    ImportExpression,
+    ImportNamespaceSpecifier,
+    ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
+    LabeledStatement,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    MetaProperty,
+    MethodDefinition,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
+    RestElement,
+    ReturnStatement,
+    SequenceExpression,
+    SpreadElement,
+    StaticBlock,
+    Super,
+    SwitchCase,
+    SwitchStatement,
+    TaggedTemplateExpression,
+    TemplateElement,
+    TemplateLiteral,
+    ThisExpression,
+    ThrowStatement,
+    TryStatement,
+    UnaryExpression,
+    UpdateExpression,
+    VariableDeclaration,
+    VariableDeclarator,
+    WhileStatement,
+    YieldExpression
+];
+const bufferParsers = [
+    function panicError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
+    },
+    function parseError(node, position, buffer) {
+        node.message = buffer.convertString(buffer[position]);
+    },
+    function arrayExpression(node, position, buffer) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function arrayPattern(node, position, buffer) {
+        const { scope } = node;
+        node.elements = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function arrowFunctionExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.expression = (flags & 2) === 2;
+        node.generator = (flags & 4) === 4;
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 2], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 3], buffer);
+    },
+    function assignmentExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function assignmentPattern(node, position, buffer) {
+        const { scope } = node;
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function awaitExpression(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function binaryExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function blockStatement(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function breakStatement(node, position, buffer) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
+    },
+    function callExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.optional = (flags & 1) === 1;
+        node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 2], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 3], buffer);
+    },
+    function catchClause(node, position, buffer) {
+        const { scope } = node;
+        const parameterPosition = buffer[position];
+        const parameter = (node.param =
+            parameterPosition === 0 ? null : convertNode(node, scope, parameterPosition, buffer));
+        parameter?.declare('parameter', UNKNOWN_EXPRESSION);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 1], buffer);
+    },
+    function chainExpression(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function classBody(node, position, buffer) {
+        const { scope } = node;
+        const bodyPosition = buffer[position];
+        const body = (node.body = []);
+        if (bodyPosition) {
+            const length = buffer[bodyPosition];
+            for (let index = 0; index < length; index++) {
+                const nodePosition = buffer[bodyPosition + 1 + index];
+                body.push(convertNode(node, (buffer[nodePosition + 3] & 1) === 0 ? scope.instanceScope : scope, nodePosition, buffer));
+            }
+        }
+    },
+    function classDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
+        node.id =
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
+        node.superClass =
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function classExpression(node, position, buffer) {
+        const { scope } = node;
+        node.decorators = convertNodeList(node, scope, buffer[position], buffer);
+        const idPosition = buffer[position + 1];
+        node.id = idPosition === 0 ? null : convertNode(node, scope, idPosition, buffer);
+        const superClassPosition = buffer[position + 2];
+        node.superClass =
+            superClassPosition === 0 ? null : convertNode(node, scope, superClassPosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function conditionalExpression(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, scope, buffer[position + 1], buffer);
+        node.alternate = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function continueStatement(node, position, buffer) {
+        const { scope } = node;
+        const labelPosition = buffer[position];
+        node.label = labelPosition === 0 ? null : convertNode(node, scope, labelPosition, buffer);
+    },
+    function debuggerStatement() { },
+    function decorator(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function directive(node, position, buffer) {
+        const { scope } = node;
+        node.directive = buffer.convertString(buffer[position]);
+        node.expression = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function doWhileStatement(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNode(node, scope, buffer[position], buffer);
+        node.test = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function emptyStatement() { },
+    function exportAllDeclaration(node, position, buffer) {
+        const { scope } = node;
+        const exportedPosition = buffer[position];
+        node.exported =
+            exportedPosition === 0 ? null : convertNode(node, scope, exportedPosition, buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function exportDefaultDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.declaration = convertNode(node, scope, buffer[position], buffer);
+    },
+    function exportNamedDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
+        const sourcePosition = buffer[position + 1];
+        node.source = sourcePosition === 0 ? null : convertNode(node, scope, sourcePosition, buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+        const declarationPosition = buffer[position + 3];
+        node.declaration =
+            declarationPosition === 0 ? null : convertNode(node, scope, declarationPosition, buffer);
+    },
+    function exportSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+        const exportedPosition = buffer[position + 1];
+        node.exported =
+            exportedPosition === 0 ? node.local : convertNode(node, scope, exportedPosition, buffer);
+    },
+    function expressionStatement(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function forInStatement(node, position, buffer) {
+        const { scope } = node;
+        node.left = convertNode(node, scope, buffer[position], buffer);
+        node.right = convertNode(node, scope, buffer[position + 1], buffer);
+        node.body = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function forOfStatement(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.await = (flags & 1) === 1;
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function forStatement(node, position, buffer) {
+        const { scope } = node;
+        const initPosition = buffer[position];
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
+        const testPosition = buffer[position + 1];
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
+        const updatePosition = buffer[position + 2];
+        node.update = updatePosition === 0 ? null : convertNode(node, scope, updatePosition, buffer);
+        node.body = convertNode(node, scope, buffer[position + 3], buffer);
+    },
+    function functionDeclaration(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
+        node.id =
+            idPosition === 0 ? null : convertNode(node, scope.parent, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
+    },
+    function functionExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.async = (flags & 1) === 1;
+        node.generator = (flags & 2) === 2;
+        const annotations = (node.annotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer));
+        node.annotationNoSideEffects = annotations.some(comment => comment.type === 'noSideEffects');
+        const idPosition = buffer[position + 2];
+        node.id = idPosition === 0 ? null : convertNode(node, node.idScope, idPosition, buffer);
+        const parameters = (node.params = convertNodeList(node, scope, buffer[position + 3], buffer));
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        node.body = convertNode(node, scope.bodyScope, buffer[position + 4], buffer);
+    },
+    function identifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function ifStatement(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.consequent = convertNode(node, (node.consequentScope = new TrackingScope(scope)), buffer[position + 1], buffer);
+        const alternatePosition = buffer[position + 2];
+        node.alternate =
+            alternatePosition === 0
+                ? null
+                : convertNode(node, (node.alternateScope = new TrackingScope(scope)), alternatePosition, buffer);
+    },
+    function importAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.key = convertNode(node, scope, buffer[position], buffer);
+        node.value = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function importDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.specifiers = convertNodeList(node, scope, buffer[position], buffer);
+        node.source = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function importDefaultSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+    },
+    function importExpression(node, position, buffer) {
+        const { scope } = node;
+        node.source = convertNode(node, scope, buffer[position], buffer);
+        node.sourceAstNode = parseAst_js.convertNode(buffer[position], buffer);
+        const optionsPosition = buffer[position + 1];
+        node.options = optionsPosition === 0 ? null : convertNode(node, scope, optionsPosition, buffer);
+    },
+    function importNamespaceSpecifier(node, position, buffer) {
+        const { scope } = node;
+        node.local = convertNode(node, scope, buffer[position], buffer);
+    },
+    function importSpecifier(node, position, buffer) {
+        const { scope } = node;
+        const importedPosition = buffer[position];
+        node.local = convertNode(node, scope, buffer[position + 1], buffer);
+        node.imported =
+            importedPosition === 0 ? node.local : convertNode(node, scope, importedPosition, buffer);
+    },
+    function jsxAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+        const valuePosition = buffer[position + 1];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
+    },
+    function jsxClosingElement(node, position, buffer) {
+        const { scope } = node;
+        node.name = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxClosingFragment() { },
+    function jsxElement(node, position, buffer) {
+        const { scope } = node;
+        node.openingElement = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        const closingElementPosition = buffer[position + 2];
+        node.closingElement =
+            closingElementPosition === 0
+                ? null
+                : convertNode(node, scope, closingElementPosition, buffer);
+    },
+    function jsxEmptyExpression() { },
+    function jsxExpressionContainer(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxFragment(node, position, buffer) {
+        const { scope } = node;
+        node.openingFragment = convertNode(node, scope, buffer[position], buffer);
+        node.children = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.closingFragment = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function jsxMemberExpression(node, position, buffer) {
+        const { scope } = node;
+        node.object = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxNamespacedName(node, position, buffer) {
+        const { scope } = node;
+        node.namespace = convertNode(node, scope, buffer[position], buffer);
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function jsxOpeningElement(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.selfClosing = (flags & 1) === 1;
+        node.name = convertNode(node, scope, buffer[position + 1], buffer);
+        node.attributes = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function jsxOpeningFragment(node) {
+        node.attributes = [];
+        node.selfClosing = false;
+    },
+    function jsxSpreadAttribute(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxSpreadChild(node, position, buffer) {
+        const { scope } = node;
+        node.expression = convertNode(node, scope, buffer[position], buffer);
+    },
+    function jsxText(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
+        node.raw = buffer.convertString(buffer[position + 1]);
+    },
+    function labeledStatement(node, position, buffer) {
+        const { scope } = node;
+        node.label = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function literalBigInt(node, position, buffer) {
+        const bigint = (node.bigint = buffer.convertString(buffer[position]));
+        node.raw = buffer.convertString(buffer[position + 1]);
+        node.value = BigInt(bigint);
+    },
+    function literalBoolean(node, position, buffer) {
+        const flags = buffer[position];
+        const value = (node.value = (flags & 1) === 1);
+        node.raw = value ? 'true' : 'false';
+    },
+    function literalNull(node) {
+        node.value = null;
+    },
+    function literalNumber(node, position, buffer) {
+        const rawPosition = buffer[position];
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
+        node.value = new DataView(buffer.buffer).getFloat64((position + 1) << 2, true);
+    },
+    function literalRegExp(node, position, buffer) {
+        const flags = buffer.convertString(buffer[position]);
+        const pattern = buffer.convertString(buffer[position + 1]);
+        node.raw = `/${pattern}/${flags}`;
+        node.regex = { flags, pattern };
+        node.value = new RegExp(pattern, flags);
+    },
+    function literalString(node, position, buffer) {
+        node.value = buffer.convertString(buffer[position]);
+        const rawPosition = buffer[position + 1];
+        node.raw = rawPosition === 0 ? undefined : buffer.convertString(rawPosition);
+    },
+    function logicalExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
+        node.left = convertNode(node, scope, buffer[position + 1], buffer);
+        node.right = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function memberExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.computed = (flags & 1) === 1;
+        node.optional = (flags & 2) === 2;
+        node.object = convertNode(node, scope, buffer[position + 1], buffer);
+        node.property = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function metaProperty(node, position, buffer) {
+        const { scope } = node;
+        node.meta = convertNode(node, scope, buffer[position], buffer);
+        node.property = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function methodDefinition(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        node.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        node.value = convertNode(node, scope, buffer[position + 3], buffer);
+        node.kind = parseAst_js.FIXED_STRINGS[buffer[position + 4]];
+    },
+    function newExpression(node, position, buffer) {
+        const { scope } = node;
+        node.annotations = parseAst_js.convertAnnotations(buffer[position], buffer);
+        node.callee = convertNode(node, scope, buffer[position + 1], buffer);
+        node.arguments = convertNodeList(node, scope, buffer[position + 2], buffer);
+    },
+    function objectExpression(node, position, buffer) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function objectPattern(node, position, buffer) {
+        const { scope } = node;
+        node.properties = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function privateIdentifier(node, position, buffer) {
+        node.name = buffer.convertString(buffer[position]);
+    },
+    function program(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+        node.invalidAnnotations = parseAst_js.convertAnnotations(buffer[position + 1], buffer);
+    },
+    function property(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.method = (flags & 1) === 1;
+        node.shorthand = (flags & 2) === 2;
+        node.computed = (flags & 4) === 4;
+        const keyPosition = buffer[position + 1];
+        node.value = convertNode(node, scope, buffer[position + 2], buffer);
+        node.kind = parseAst_js.FIXED_STRINGS[buffer[position + 3]];
+        node.key = keyPosition === 0 ? node.value : convertNode(node, scope, keyPosition, buffer);
+    },
+    function propertyDefinition(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.static = (flags & 1) === 1;
+        node.computed = (flags & 2) === 2;
+        node.decorators = convertNodeList(node, scope, buffer[position + 1], buffer);
+        node.key = convertNode(node, scope, buffer[position + 2], buffer);
+        const valuePosition = buffer[position + 3];
+        node.value = valuePosition === 0 ? null : convertNode(node, scope, valuePosition, buffer);
+    },
+    function restElement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function returnStatement(node, position, buffer) {
+        const { scope } = node;
+        const argumentPosition = buffer[position];
+        node.argument =
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
+    },
+    function sequenceExpression(node, position, buffer) {
+        const { scope } = node;
+        node.expressions = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function spreadElement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function staticBlock(node, position, buffer) {
+        const { scope } = node;
+        node.body = convertNodeList(node, scope, buffer[position], buffer);
+    },
+    function superElement() { },
+    function switchCase(node, position, buffer) {
+        const { scope } = node;
+        const testPosition = buffer[position];
+        node.test = testPosition === 0 ? null : convertNode(node, scope, testPosition, buffer);
+        node.consequent = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function switchStatement(node, position, buffer) {
+        const { scope } = node;
+        node.discriminant = convertNode(node, node.parentScope, buffer[position], buffer);
+        node.cases = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function taggedTemplateExpression(node, position, buffer) {
+        const { scope } = node;
+        node.tag = convertNode(node, scope, buffer[position], buffer);
+        node.quasi = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function templateElement(node, position, buffer) {
+        const flags = buffer[position];
+        node.tail = (flags & 1) === 1;
+        const cookedPosition = buffer[position + 1];
+        const cooked = cookedPosition === 0 ? undefined : buffer.convertString(cookedPosition);
+        const raw = buffer.convertString(buffer[position + 2]);
+        node.value = { cooked, raw };
+    },
+    function templateLiteral(node, position, buffer) {
+        const { scope } = node;
+        node.quasis = convertNodeList(node, scope, buffer[position], buffer);
+        node.expressions = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function thisExpression() { },
+    function throwStatement(node, position, buffer) {
+        const { scope } = node;
+        node.argument = convertNode(node, scope, buffer[position], buffer);
+    },
+    function tryStatement(node, position, buffer) {
+        const { scope } = node;
+        node.block = convertNode(node, scope, buffer[position], buffer);
+        const handlerPosition = buffer[position + 1];
+        node.handler = handlerPosition === 0 ? null : convertNode(node, scope, handlerPosition, buffer);
+        const finalizerPosition = buffer[position + 2];
+        node.finalizer =
+            finalizerPosition === 0 ? null : convertNode(node, scope, finalizerPosition, buffer);
+    },
+    function unaryExpression(node, position, buffer) {
+        const { scope } = node;
+        node.operator = parseAst_js.FIXED_STRINGS[buffer[position]];
+        node.argument = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function updateExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.prefix = (flags & 1) === 1;
+        node.operator = parseAst_js.FIXED_STRINGS[buffer[position + 1]];
+        node.argument = convertNode(node, scope, buffer[position + 2], buffer);
+    },
+    function variableDeclaration(node, position, buffer) {
+        const { scope } = node;
+        node.kind = parseAst_js.FIXED_STRINGS[buffer[position]];
+        node.declarations = convertNodeList(node, scope, buffer[position + 1], buffer);
+    },
+    function variableDeclarator(node, position, buffer) {
+        const { scope } = node;
+        node.id = convertNode(node, scope, buffer[position], buffer);
+        const initPosition = buffer[position + 1];
+        node.init = initPosition === 0 ? null : convertNode(node, scope, initPosition, buffer);
+    },
+    function whileStatement(node, position, buffer) {
+        const { scope } = node;
+        node.test = convertNode(node, scope, buffer[position], buffer);
+        node.body = convertNode(node, scope, buffer[position + 1], buffer);
+    },
+    function yieldExpression(node, position, buffer) {
+        const { scope } = node;
+        const flags = buffer[position];
+        node.delegate = (flags & 1) === 1;
+        const argumentPosition = buffer[position + 1];
+        node.argument =
+            argumentPosition === 0 ? null : convertNode(node, scope, argumentPosition, buffer);
+    }
+];
+function convertNode(parent, parentScope, position, buffer) {
+    const nodeType = buffer[position];
+    const NodeConstructor = nodeConstructors$1[nodeType];
+    /* istanbul ignore if: This should never be executed but is a safeguard against faulty buffers */
+    if (!NodeConstructor) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+    const node = new NodeConstructor(parent, parentScope);
+    node.type = nodeTypeStrings[nodeType];
+    node.start = buffer[position + 1];
+    node.end = buffer[position + 2];
+    bufferParsers[nodeType](node, position + 3, buffer);
+    node.initialise();
+    return node;
+}
+function convertNodeList(parent, parentScope, position, buffer) {
+    if (position === 0)
+        return parseAst_js.EMPTY_ARRAY;
+    const length = buffer[position++];
+    const list = [];
+    for (let index = 0; index < length; index++) {
+        const nodePosition = buffer[position++];
+        list.push(nodePosition ? convertNode(parent, parentScope, nodePosition, buffer) : null);
+    }
+    return list;
+}
+
+class UnknownNode extends NodeBase {
+    hasEffects() {
+        return true;
+    }
+    include(context) {
+        super.include(context, true);
+    }
+}
+
+// This file is generated by scripts/generate-node-index.js.
+// Do not edit this file directly.
+const nodeConstructors = {
+    ArrayExpression,
+    ArrayPattern,
+    ArrowFunctionExpression,
+    AssignmentExpression,
+    AssignmentPattern,
+    AwaitExpression,
+    BinaryExpression,
+    BlockStatement,
+    BreakStatement,
+    CallExpression,
+    CatchClause,
+    ChainExpression,
+    ClassBody,
+    ClassDeclaration,
+    ClassExpression,
+    ConditionalExpression,
+    ContinueStatement,
+    DebuggerStatement,
+    Decorator,
+    DoWhileStatement,
+    EmptyStatement,
+    ExportAllDeclaration,
+    ExportDefaultDeclaration,
+    ExportNamedDeclaration,
+    ExportSpecifier,
+    ExpressionStatement,
+    ForInStatement,
+    ForOfStatement,
+    ForStatement,
+    FunctionDeclaration,
+    FunctionExpression,
+    Identifier,
+    IfStatement,
+    ImportAttribute,
+    ImportDeclaration,
+    ImportDefaultSpecifier,
+    ImportExpression,
+    ImportNamespaceSpecifier,
+    ImportSpecifier,
+    JSXAttribute,
+    JSXClosingElement,
+    JSXClosingFragment,
+    JSXElement,
+    JSXEmptyExpression,
+    JSXExpressionContainer,
+    JSXFragment,
+    JSXIdentifier,
+    JSXMemberExpression,
+    JSXNamespacedName,
+    JSXOpeningElement,
+    JSXOpeningFragment,
+    JSXSpreadAttribute,
+    JSXSpreadChild,
+    JSXText,
+    LabeledStatement,
+    Literal,
+    LogicalExpression,
+    MemberExpression,
+    MetaProperty,
+    MethodDefinition,
+    NewExpression,
+    ObjectExpression,
+    ObjectPattern,
+    PanicError,
+    ParseError,
+    PrivateIdentifier,
+    Program,
+    Property,
+    PropertyDefinition,
+    RestElement,
+    ReturnStatement,
+    SequenceExpression,
+    SpreadElement,
+    StaticBlock,
+    Super,
+    SwitchCase,
+    SwitchStatement,
+    TaggedTemplateExpression,
+    TemplateElement,
+    TemplateLiteral,
+    ThisExpression,
+    ThrowStatement,
+    TryStatement,
+    UnaryExpression,
+    UnknownNode,
+    UpdateExpression,
+    VariableDeclaration,
+    VariableDeclarator,
+    WhileStatement,
+    YieldExpression
+};
+
+class ExportShimVariable extends Variable {
+    constructor(module) {
+        super(MISSING_EXPORT_SHIM_VARIABLE);
+        this.module = module;
+    }
+    include() {
+        super.include();
+        this.module.needsExportShim = true;
+    }
+}
+
+const sourceMapCache = new WeakMap();
+/**
+ * This clears the decoded array and falls back to the encoded string form.
+ * Sourcemap mappings arrays can be very large and holding on to them for longer
+ * than is necessary leads to poor heap utilization.
+ */
+function resetCacheToEncoded(cache) {
+    if (cache.encodedMappings === undefined && cache.decodedMappings) {
+        cache.encodedMappings = encode(cache.decodedMappings);
+    }
+    cache.decodedMappings = undefined;
+}
+function resetSourcemapCache(map, sourcemapChain) {
+    if (map) {
+        const cache = sourceMapCache.get(map);
+        if (cache) {
+            resetCacheToEncoded(cache);
+        }
+    }
+    if (!sourcemapChain) {
+        return;
+    }
+    for (const map of sourcemapChain) {
+        if (map.missing)
+            continue;
+        resetSourcemapCache(map);
+    }
+}
+function decodedSourcemap(map) {
+    if (!map)
+        return null;
+    if (typeof map === 'string') {
+        map = JSON.parse(map);
+    }
+    if (!map.mappings) {
+        return {
+            mappings: [],
+            names: [],
+            sources: [],
+            version: 3
+        };
+    }
+    const originalMappings = map.mappings;
+    const isAlreadyDecoded = Array.isArray(originalMappings);
+    const cache = {
+        decodedMappings: isAlreadyDecoded ? originalMappings : undefined,
+        encodedMappings: isAlreadyDecoded ? undefined : originalMappings
+    };
+    const decodedMap = {
+        ...map,
+        // By moving mappings behind an accessor, we can avoid unneeded computation for cases
+        // where the mappings field is never actually accessed. This appears to greatly reduce
+        // the overhead of sourcemap decoding in terms of both compute time and memory usage.
+        get mappings() {
+            if (cache.decodedMappings) {
+                return cache.decodedMappings;
+            }
+            // If decodedMappings doesn't exist then encodedMappings should.
+            // The only scenario where cache.encodedMappings should be undefined is if the map
+            // this was constructed from was already decoded, or if mappings was set to a new
+            // decoded string. In either case, this line shouldn't get hit.
+            cache.decodedMappings = cache.encodedMappings ? decode(cache.encodedMappings) : [];
+            cache.encodedMappings = undefined;
+            return cache.decodedMappings;
+        }
+    };
+    sourceMapCache.set(decodedMap, cache);
+    return decodedMap;
+}
+
+function getId(m) {
+    return m.id;
+}
+
+function getOriginalLocation(sourcemapChain, location) {
+    const filteredSourcemapChain = sourcemapChain.filter((sourcemap) => !sourcemap.missing);
+    traceSourcemap: while (filteredSourcemapChain.length > 0) {
+        const sourcemap = filteredSourcemapChain.pop();
+        const line = sourcemap.mappings[location.line - 1];
+        if (line) {
+            const filteredLine = line.filter((segment) => segment.length > 1);
+            const lastSegment = filteredLine[filteredLine.length - 1];
+            for (const segment of filteredLine) {
+                if (segment[0] >= location.column || segment === lastSegment) {
+                    location = {
+                        column: segment[3],
+                        line: segment[2] + 1
+                    };
+                    continue traceSourcemap;
+                }
+            }
+        }
+        throw new Error("Can't resolve original location of error.");
+    }
+    return location;
+}
+
+const ATTRIBUTE_KEYWORDS = new Set(['assert', 'with']);
+function getAttributesFromImportExpression(node) {
+    const { scope: { context }, options, start } = node;
+    if (!(options instanceof ObjectExpression)) {
+        if (options) {
+            context.module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logImportAttributeIsInvalid(context.module.id), start);
+        }
+        return parseAst_js.EMPTY_OBJECT;
+    }
+    const assertProperty = options.properties.find((property) => ATTRIBUTE_KEYWORDS.has(getPropertyKey(property)))?.value;
+    if (!assertProperty) {
+        return parseAst_js.EMPTY_OBJECT;
+    }
+    if (!(assertProperty instanceof ObjectExpression)) {
+        context.module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logImportOptionsAreInvalid(context.module.id), start);
+        return parseAst_js.EMPTY_OBJECT;
+    }
+    const assertFields = assertProperty.properties
+        .map(property => {
+        const key = getPropertyKey(property);
+        if (typeof key === 'string' &&
+            typeof property.value.value === 'string') {
+            return [key, property.value.value];
+        }
+        context.module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logImportAttributeIsInvalid(context.module.id), property.start);
+        return null;
+    })
+        .filter((property) => !!property);
+    if (assertFields.length > 0) {
+        return Object.fromEntries(assertFields);
+    }
+    return parseAst_js.EMPTY_OBJECT;
+}
+const getPropertyKey = (property) => {
+    const key = property.key;
+    return (key &&
+        !property.computed &&
+        (key.name || key.value));
+};
+function getAttributesFromImportExportDeclaration(attributes) {
+    return attributes?.length
+        ? Object.fromEntries(attributes.map(assertion => [getPropertyKey(assertion), assertion.value.value]))
+        : parseAst_js.EMPTY_OBJECT;
+}
+function doAttributesDiffer(assertionA, assertionB) {
+    const keysA = Object.keys(assertionA);
+    return (keysA.length !== Object.keys(assertionB).length ||
+        keysA.some(key => assertionA[key] !== assertionB[key]));
+}
+
+let timers = new Map();
+function getPersistedLabel(label, level) {
+    switch (level) {
+        case 1: {
+            return `# ${label}`;
+        }
+        case 2: {
+            return `## ${label}`;
+        }
+        case 3: {
+            return label;
+        }
+        default: {
+            return `- ${label}`;
+        }
+    }
+}
+function timeStartImpl(label, level = 3) {
+    label = getPersistedLabel(label, level);
+    const startMemory = process$1.memoryUsage().heapUsed;
+    const startTime = node_perf_hooks.performance.now();
+    const timer = timers.get(label);
+    if (timer === undefined) {
+        timers.set(label, {
+            memory: 0,
+            startMemory,
+            startTime,
+            time: 0,
+            totalMemory: 0
+        });
+    }
+    else {
+        timer.startMemory = startMemory;
+        timer.startTime = startTime;
+    }
+}
+function timeEndImpl(label, level = 3) {
+    label = getPersistedLabel(label, level);
+    const timer = timers.get(label);
+    if (timer !== undefined) {
+        const currentMemory = process$1.memoryUsage().heapUsed;
+        timer.memory += currentMemory - timer.startMemory;
+        timer.time += node_perf_hooks.performance.now() - timer.startTime;
+        timer.totalMemory = Math.max(timer.totalMemory, currentMemory);
+    }
+}
+function getTimings() {
+    const newTimings = {};
+    for (const [label, { memory, time, totalMemory }] of timers) {
+        newTimings[label] = [time, memory, totalMemory];
+    }
+    return newTimings;
+}
+let timeStart = doNothing;
+let timeEnd = doNothing;
+const TIMED_PLUGIN_HOOKS = [
+    'augmentChunkHash',
+    'buildEnd',
+    'buildStart',
+    'generateBundle',
+    'load',
+    'moduleParsed',
+    'options',
+    'outputOptions',
+    'renderChunk',
+    'renderDynamicImport',
+    'renderStart',
+    'resolveDynamicImport',
+    'resolveFileUrl',
+    'resolveId',
+    'resolveImportMeta',
+    'shouldTransformCachedModule',
+    'transform',
+    'writeBundle'
+];
+function getPluginWithTimers(plugin, index) {
+    if (plugin._hasTimer)
+        return plugin;
+    plugin._hasTimer = true;
+    for (const hook of TIMED_PLUGIN_HOOKS) {
+        if (hook in plugin) {
+            let timerLabel = `plugin ${index}`;
+            if (plugin.name) {
+                timerLabel += ` (${plugin.name})`;
+            }
+            timerLabel += ` - ${hook}`;
+            const handler = function (...parameters) {
+                timeStart(timerLabel, 4);
+                const result = hookFunction.apply(this, parameters);
+                timeEnd(timerLabel, 4);
+                return result;
+            };
+            let hookFunction;
+            if (typeof plugin[hook].handler === 'function') {
+                hookFunction = plugin[hook].handler;
+                plugin[hook].handler = handler;
+            }
+            else {
+                hookFunction = plugin[hook];
+                plugin[hook] = handler;
+            }
+        }
+    }
+    return plugin;
+}
+function initialiseTimers(inputOptions) {
+    if (inputOptions.perf) {
+        timers = new Map();
+        timeStart = timeStartImpl;
+        timeEnd = timeEndImpl;
+        inputOptions.plugins = inputOptions.plugins.map(getPluginWithTimers);
+    }
+    else {
+        timeStart = doNothing;
+        timeEnd = doNothing;
+    }
+}
+
+const MISSING_EXPORT_SHIM_DESCRIPTION = {
+    identifier: null,
+    localName: MISSING_EXPORT_SHIM_VARIABLE
+};
+function getVariableForExportNameRecursive(target, name, importerForSideEffects, isExportAllSearch, searchedNamesAndModules = new Map()) {
+    const searchedModules = searchedNamesAndModules.get(name);
+    if (searchedModules) {
+        if (searchedModules.has(target)) {
+            return isExportAllSearch ? [null] : parseAst_js.error(parseAst_js.logCircularReexport(name, target.id));
+        }
+        searchedModules.add(target);
+    }
+    else {
+        searchedNamesAndModules.set(name, new Set([target]));
+    }
+    return target.getVariableForExportName(name, {
+        importerForSideEffects,
+        isExportAllSearch,
+        searchedNamesAndModules
+    });
+}
+function getAndExtendSideEffectModules(variable, module) {
+    const sideEffectModules = getOrCreate(module.sideEffectDependenciesByVariable, variable, (getNewSet));
+    let currentVariable = variable;
+    const referencedVariables = new Set([currentVariable]);
+    while (true) {
+        const importingModule = currentVariable.module;
+        currentVariable =
+            currentVariable instanceof ExportDefaultVariable
+                ? currentVariable.getDirectOriginalVariable()
+                : currentVariable instanceof SyntheticNamedExportVariable
+                    ? currentVariable.syntheticNamespace
+                    : null;
+        if (!currentVariable || referencedVariables.has(currentVariable)) {
+            break;
+        }
+        referencedVariables.add(currentVariable);
+        sideEffectModules.add(importingModule);
+        const originalSideEffects = importingModule.sideEffectDependenciesByVariable.get(currentVariable);
+        if (originalSideEffects) {
+            for (const module of originalSideEffects) {
+                sideEffectModules.add(module);
+            }
+        }
+    }
+    return sideEffectModules;
+}
+class Module {
+    constructor(graph, id, options, isEntry, moduleSideEffects, syntheticNamedExports, meta, attributes) {
+        this.graph = graph;
+        this.id = id;
+        this.options = options;
+        this.alternativeReexportModules = new Map();
+        this.chunkFileNames = new Set();
+        this.chunkNames = [];
+        this.cycles = new Set();
+        this.dependencies = new Set();
+        this.dynamicDependencies = new Set();
+        this.dynamicImporters = [];
+        this.dynamicImports = [];
+        this.execIndex = Infinity;
+        this.hasTreeShakingPassStarted = false;
+        this.implicitlyLoadedAfter = new Set();
+        this.implicitlyLoadedBefore = new Set();
+        this.importDescriptions = new Map();
+        this.importMetas = [];
+        this.importedFromNotTreeshaken = false;
+        this.importers = [];
+        this.includedDynamicImporters = [];
+        this.includedImports = new Set();
+        this.isExecuted = false;
+        this.isUserDefinedEntryPoint = false;
+        this.needsExportShim = false;
+        this.sideEffectDependenciesByVariable = new Map();
+        this.sourcesWithAttributes = new Map();
+        this.allExportNames = null;
+        this.ast = null;
+        this.exportAllModules = [];
+        this.exportAllSources = new Set();
+        this.exportNamesByVariable = null;
+        this.exportShimVariable = new ExportShimVariable(this);
+        this.exports = new Map();
+        this.namespaceReexportsByName = new Map();
+        this.reexportDescriptions = new Map();
+        this.relevantDependencies = null;
+        this.syntheticExports = new Map();
+        this.syntheticNamespace = null;
+        this.transformDependencies = [];
+        this.transitiveReexports = null;
+        this.excludeFromSourcemap = /\0/.test(id);
+        this.context = options.moduleContext(id);
+        this.preserveSignature = this.options.preserveEntrySignatures;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const module = this;
+        const { dynamicImports, dynamicImporters, exportAllSources, exports, implicitlyLoadedAfter, implicitlyLoadedBefore, importers, reexportDescriptions, sourcesWithAttributes } = this;
+        this.info = {
+            ast: null,
+            attributes,
+            code: null,
+            get dynamicallyImportedIdResolutions() {
+                return dynamicImports
+                    .map(({ argument }) => typeof argument === 'string' && module.resolvedIds[argument])
+                    .filter(Boolean);
+            },
+            get dynamicallyImportedIds() {
+                // We cannot use this.dynamicDependencies because this is needed before
+                // dynamicDependencies are populated
+                return dynamicImports.map(({ id }) => id).filter((id) => id != null);
+            },
+            get dynamicImporters() {
+                return dynamicImporters.sort();
+            },
+            get exportedBindings() {
+                const exportBindings = { '.': [...exports.keys()] };
+                for (const [name, { source }] of reexportDescriptions) {
+                    (exportBindings[source] ??= []).push(name);
+                }
+                for (const source of exportAllSources) {
+                    (exportBindings[source] ??= []).push('*');
+                }
+                return exportBindings;
+            },
+            get exports() {
+                return [
+                    ...exports.keys(),
+                    ...reexportDescriptions.keys(),
+                    ...[...exportAllSources].map(() => '*')
+                ];
+            },
+            get hasDefaultExport() {
+                // This information is only valid after parsing
+                if (!module.ast) {
+                    return null;
+                }
+                return module.exports.has('default') || reexportDescriptions.has('default');
+            },
+            id,
+            get implicitlyLoadedAfterOneOf() {
+                return Array.from(implicitlyLoadedAfter, getId).sort();
+            },
+            get implicitlyLoadedBefore() {
+                return Array.from(implicitlyLoadedBefore, getId).sort();
+            },
+            get importedIdResolutions() {
+                return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]).filter(Boolean);
+            },
+            get importedIds() {
+                // We cannot use this.dependencies because this is needed before
+                // dependencies are populated
+                return Array.from(sourcesWithAttributes.keys(), source => module.resolvedIds[source]?.id).filter(Boolean);
+            },
+            get importers() {
+                return importers.sort();
+            },
+            isEntry,
+            isExternal: false,
+            get isIncluded() {
+                if (graph.phase !== BuildPhase.GENERATE) {
+                    return null;
+                }
+                return module.isIncluded();
+            },
+            meta: { ...meta },
+            moduleSideEffects,
+            syntheticNamedExports
+        };
+    }
+    basename() {
+        const base = path.basename(this.id);
+        const extension = path.extname(this.id);
+        return makeLegal(extension ? base.slice(0, -extension.length) : base);
+    }
+    bindReferences() {
+        this.ast.bind();
+    }
+    cacheInfoGetters() {
+        cacheObjectGetters(this.info, [
+            'dynamicallyImportedIdResolutions',
+            'dynamicallyImportedIds',
+            'dynamicImporters',
+            'exportedBindings',
+            'exports',
+            'hasDefaultExport',
+            'implicitlyLoadedAfterOneOf',
+            'implicitlyLoadedBefore',
+            'importedIdResolutions',
+            'importedIds',
+            'importers'
+        ]);
+    }
+    error(properties, pos) {
+        if (pos !== undefined) {
+            this.addLocationToLogProps(properties, pos);
+        }
+        return parseAst_js.error(properties);
+    }
+    // sum up the length of all ast nodes that are included
+    estimateSize() {
+        let size = 0;
+        for (const node of this.ast.body) {
+            if (node.included) {
+                size += node.end - node.start;
+            }
+        }
+        return size;
+    }
+    getAllExportNames() {
+        if (this.allExportNames) {
+            return this.allExportNames;
+        }
+        this.allExportNames = new Set([...this.exports.keys(), ...this.reexportDescriptions.keys()]);
+        for (const module of this.exportAllModules) {
+            if (module instanceof ExternalModule) {
+                this.allExportNames.add(`*${module.id}`);
+                continue;
+            }
+            for (const name of module.getAllExportNames()) {
+                if (name !== 'default')
+                    this.allExportNames.add(name);
+            }
+        }
+        // We do not count the synthetic namespace as a regular export to hide it
+        // from entry signatures and namespace objects
+        if (typeof this.info.syntheticNamedExports === 'string') {
+            this.allExportNames.delete(this.info.syntheticNamedExports);
+        }
+        return this.allExportNames;
+    }
+    getDependenciesToBeIncluded() {
+        if (this.relevantDependencies)
+            return this.relevantDependencies;
+        this.relevantDependencies = new Set();
+        const necessaryDependencies = new Set();
+        const alwaysCheckedDependencies = new Set();
+        const dependencyVariables = new Set(this.includedImports);
+        if (this.info.isEntry ||
+            this.includedDynamicImporters.length > 0 ||
+            this.namespace.included ||
+            this.implicitlyLoadedAfter.size > 0) {
+            for (const exportName of [...this.getReexports(), ...this.getExports()]) {
+                const [exportedVariable] = this.getVariableForExportName(exportName);
+                if (exportedVariable?.included) {
+                    dependencyVariables.add(exportedVariable);
+                }
+            }
+        }
+        for (let variable of dependencyVariables) {
+            const sideEffectDependencies = this.sideEffectDependenciesByVariable.get(variable);
+            if (sideEffectDependencies) {
+                for (const module of sideEffectDependencies) {
+                    alwaysCheckedDependencies.add(module);
+                }
+            }
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            else if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            necessaryDependencies.add(variable.module);
+        }
+        if (!this.options.treeshake || this.info.moduleSideEffects === 'no-treeshake') {
+            for (const dependency of this.dependencies) {
+                this.relevantDependencies.add(dependency);
+            }
+        }
+        else {
+            this.addRelevantSideEffectDependencies(this.relevantDependencies, necessaryDependencies, alwaysCheckedDependencies);
+        }
+        for (const dependency of necessaryDependencies) {
+            this.relevantDependencies.add(dependency);
+        }
+        return this.relevantDependencies;
+    }
+    getExportNamesByVariable() {
+        if (this.exportNamesByVariable) {
+            return this.exportNamesByVariable;
+        }
+        const exportNamesByVariable = new Map();
+        for (const exportName of this.getAllExportNames()) {
+            let [tracedVariable] = this.getVariableForExportName(exportName);
+            if (tracedVariable instanceof ExportDefaultVariable) {
+                tracedVariable = tracedVariable.getOriginalVariable();
+            }
+            if (!tracedVariable ||
+                !(tracedVariable.included || tracedVariable instanceof ExternalVariable)) {
+                continue;
+            }
+            const existingExportNames = exportNamesByVariable.get(tracedVariable);
+            if (existingExportNames) {
+                existingExportNames.push(exportName);
+            }
+            else {
+                exportNamesByVariable.set(tracedVariable, [exportName]);
+            }
+        }
+        return (this.exportNamesByVariable = exportNamesByVariable);
+    }
+    getExports() {
+        return [...this.exports.keys()];
+    }
+    getReexports() {
+        if (this.transitiveReexports) {
+            return this.transitiveReexports;
+        }
+        // to avoid infinite recursion when using circular `export * from X`
+        this.transitiveReexports = [];
+        const reexports = new Set(this.reexportDescriptions.keys());
+        for (const module of this.exportAllModules) {
+            if (module instanceof ExternalModule) {
+                reexports.add(`*${module.id}`);
+            }
+            else {
+                for (const name of [...module.getReexports(), ...module.getExports()]) {
+                    if (name !== 'default')
+                        reexports.add(name);
+                }
+            }
+        }
+        return (this.transitiveReexports = [...reexports]);
+    }
+    getRenderedExports() {
+        // only direct exports are counted here, not reexports at all
+        const renderedExports = [];
+        const removedExports = [];
+        for (const exportName of this.exports.keys()) {
+            const [variable] = this.getVariableForExportName(exportName);
+            (variable?.included ? renderedExports : removedExports).push(exportName);
+        }
+        return { removedExports, renderedExports };
+    }
+    getSyntheticNamespace() {
+        if (this.syntheticNamespace === null) {
+            this.syntheticNamespace = undefined;
+            [this.syntheticNamespace] = this.getVariableForExportName(typeof this.info.syntheticNamedExports === 'string'
+                ? this.info.syntheticNamedExports
+                : 'default', { onlyExplicit: true });
+        }
+        if (!this.syntheticNamespace) {
+            return parseAst_js.error(parseAst_js.logSyntheticNamedExportsNeedNamespaceExport(this.id, this.info.syntheticNamedExports));
+        }
+        return this.syntheticNamespace;
+    }
+    getVariableForExportName(name, { importerForSideEffects, isExportAllSearch, onlyExplicit, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
+        if (name[0] === '*') {
+            if (name.length === 1) {
+                // export * from './other'
+                return [this.namespace];
+            }
+            // export * from 'external'
+            const module = this.graph.modulesById.get(name.slice(1));
+            return module.getVariableForExportName('*');
+        }
+        // export { foo } from './other'
+        const reexportDeclaration = this.reexportDescriptions.get(name);
+        if (reexportDeclaration) {
+            const [variable] = getVariableForExportNameRecursive(reexportDeclaration.module, reexportDeclaration.localName, importerForSideEffects, false, searchedNamesAndModules);
+            if (!variable) {
+                return this.error(parseAst_js.logMissingExport(reexportDeclaration.localName, this.id, reexportDeclaration.module.id), reexportDeclaration.start);
+            }
+            if (importerForSideEffects) {
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+                if (this.info.moduleSideEffects) {
+                    getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
+                }
+            }
+            return [variable];
+        }
+        const exportDeclaration = this.exports.get(name);
+        if (exportDeclaration) {
+            if (exportDeclaration === MISSING_EXPORT_SHIM_DESCRIPTION) {
+                return [this.exportShimVariable];
+            }
+            const name = exportDeclaration.localName;
+            const variable = this.traceVariable(name, {
+                importerForSideEffects,
+                searchedNamesAndModules
+            });
+            if (importerForSideEffects) {
+                setAlternativeExporterIfCyclic(variable, importerForSideEffects, this);
+                getOrCreate(importerForSideEffects.sideEffectDependenciesByVariable, variable, (getNewSet)).add(this);
+            }
+            return [variable];
+        }
+        if (onlyExplicit) {
+            return [null];
+        }
+        if (name !== 'default') {
+            const foundNamespaceReexport = this.namespaceReexportsByName.get(name) ??
+                this.getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules);
+            this.namespaceReexportsByName.set(name, foundNamespaceReexport);
+            if (foundNamespaceReexport[0]) {
+                return foundNamespaceReexport;
+            }
+        }
+        if (this.info.syntheticNamedExports) {
+            return [
+                getOrCreate(this.syntheticExports, name, () => new SyntheticNamedExportVariable(this.astContext, name, this.getSyntheticNamespace()))
+            ];
+        }
+        // we don't want to create shims when we are just
+        // probing export * modules for exports
+        if (!isExportAllSearch && this.options.shimMissingExports) {
+            this.shimMissingExport(name);
+            return [this.exportShimVariable];
+        }
+        return [null];
+    }
+    hasEffects() {
+        return this.info.moduleSideEffects === 'no-treeshake' || this.ast.hasCachedEffects();
+    }
+    include() {
+        const context = createInclusionContext();
+        if (this.ast.shouldBeIncluded(context))
+            this.ast.include(context, false);
+    }
+    includeAllExports(includeNamespaceMembers) {
+        if (!this.isExecuted) {
+            markModuleAndImpureDependenciesAsExecuted(this);
+            this.graph.needsTreeshakingPass = true;
+        }
+        for (const exportName of this.exports.keys()) {
+            if (includeNamespaceMembers || exportName !== this.info.syntheticNamedExports) {
+                const variable = this.getVariableForExportName(exportName)[0];
+                if (!variable) {
+                    return parseAst_js.error(parseAst_js.logMissingEntryExport(exportName, this.id));
+                }
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+            }
+        }
+        for (const name of this.getReexports()) {
+            const [variable] = this.getVariableForExportName(name);
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+                if (variable instanceof ExternalVariable) {
+                    variable.module.reexported = true;
+                }
+            }
+        }
+        if (includeNamespaceMembers) {
+            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
+    includeAllInBundle() {
+        this.ast.include(createInclusionContext(), true);
+        this.includeAllExports(false);
+    }
+    includeExportsByNames(names) {
+        if (!this.isExecuted) {
+            markModuleAndImpureDependenciesAsExecuted(this);
+            this.graph.needsTreeshakingPass = true;
+        }
+        let includeNamespaceMembers = false;
+        for (const name of names) {
+            const variable = this.getVariableForExportName(name)[0];
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+            }
+            if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
+                includeNamespaceMembers = true;
+            }
+        }
+        if (includeNamespaceMembers) {
+            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
+    isIncluded() {
+        // Modules where this.ast is missing have been loaded via this.load and are
+        // not yet fully processed, hence they cannot be included.
+        return (this.ast &&
+            (this.ast.included ||
+                this.namespace.included ||
+                this.importedFromNotTreeshaken ||
+                this.exportShimVariable.included));
+    }
+    linkImports() {
+        this.addModulesToImportDescriptions(this.importDescriptions);
+        this.addModulesToImportDescriptions(this.reexportDescriptions);
+        const externalExportAllModules = [];
+        for (const source of this.exportAllSources) {
+            const module = this.graph.modulesById.get(this.resolvedIds[source].id);
+            if (module instanceof ExternalModule) {
+                externalExportAllModules.push(module);
+                continue;
+            }
+            this.exportAllModules.push(module);
+        }
+        this.exportAllModules.push(...externalExportAllModules);
+    }
+    log(level, properties, pos) {
+        this.addLocationToLogProps(properties, pos);
+        this.options.onLog(level, properties);
+    }
+    render(options) {
+        const source = this.magicString.clone();
+        this.ast.render(source, options);
+        source.trim();
+        const { usesTopLevelAwait } = this.astContext;
+        if (usesTopLevelAwait && options.format !== 'es' && options.format !== 'system') {
+            return parseAst_js.error(parseAst_js.logInvalidFormatForTopLevelAwait(this.id, options.format));
+        }
+        return { source, usesTopLevelAwait };
+    }
+    async setSource({ ast, code, customTransformCache, originalCode, originalSourcemap, resolvedIds, sourcemapChain, transformDependencies, transformFiles, ...moduleOptions }) {
+        timeStart('generate ast', 3);
+        if (code.startsWith('#!')) {
+            const shebangEndPosition = code.indexOf('\n');
+            this.shebang = code.slice(2, shebangEndPosition);
+        }
+        this.info.code = code;
+        this.originalCode = originalCode;
+        // We need to call decodedSourcemap on the input in case they were hydrated from json in the cache and don't
+        // have the lazy evaluation cache configured. Right now this isn't enforced by the type system because the
+        // RollupCache stores `ExistingDecodedSourcemap` instead of `ExistingRawSourcemap`
+        this.originalSourcemap = decodedSourcemap(originalSourcemap);
+        this.sourcemapChain = sourcemapChain.map(mapOrMissing => mapOrMissing.missing ? mapOrMissing : decodedSourcemap(mapOrMissing));
+        // If coming from cache and this value is already fully decoded, we want to re-encode here to save memory.
+        resetSourcemapCache(this.originalSourcemap, this.sourcemapChain);
+        if (transformFiles) {
+            this.transformFiles = transformFiles;
+        }
+        this.transformDependencies = transformDependencies;
+        this.customTransformCache = customTransformCache;
+        this.updateOptions(moduleOptions);
+        this.resolvedIds = resolvedIds ?? Object.create(null);
+        // By default, `id` is the file name. Custom resolvers and loaders
+        // can change that, but it makes sense to use it for the source file name
+        const fileName = this.id;
+        this.magicString = new MagicString(code, {
+            filename: (this.excludeFromSourcemap ? null : fileName), // don't include plugin helpers in sourcemap
+            indentExclusionRanges: []
+        });
+        this.astContext = {
+            addDynamicImport: this.addDynamicImport.bind(this),
+            addExport: this.addExport.bind(this),
+            addImport: this.addImport.bind(this),
+            addImportMeta: this.addImportMeta.bind(this),
+            addImportSource: this.addImportSource.bind(this),
+            code, // Only needed for debugging
+            deoptimizationTracker: this.graph.deoptimizationTracker,
+            error: this.error.bind(this),
+            fileName, // Needed for warnings
+            getExports: this.getExports.bind(this),
+            getImportedJsxFactoryVariable: this.getImportedJsxFactoryVariable.bind(this),
+            getModuleExecIndex: () => this.execIndex,
+            getModuleName: this.basename.bind(this),
+            getNodeConstructor: (name) => nodeConstructors[name] || nodeConstructors.UnknownNode,
+            getReexports: this.getReexports.bind(this),
+            importDescriptions: this.importDescriptions,
+            includeAllExports: () => this.includeAllExports(true),
+            includeDynamicImport: this.includeDynamicImport.bind(this),
+            includeVariableInModule: this.includeVariableInModule.bind(this),
+            log: this.log.bind(this),
+            magicString: this.magicString,
+            manualPureFunctions: this.graph.pureFunctions,
+            module: this,
+            moduleContext: this.context,
+            options: this.options,
+            requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
+            traceExport: (name) => this.getVariableForExportName(name)[0],
+            traceVariable: this.traceVariable.bind(this),
+            usesTopLevelAwait: false
+        };
+        this.scope = new ModuleScope(this.graph.scope, this.astContext);
+        this.namespace = new NamespaceVariable(this.astContext);
+        const programParent = { context: this.astContext, type: 'Module' };
+        if (ast) {
+            this.ast = new nodeConstructors[ast.type](programParent, this.scope).parseNode(ast);
+            this.info.ast = ast;
+        }
+        else {
+            // Measuring asynchronous code does not provide reasonable results
+            timeEnd('generate ast', 3);
+            const astBuffer = await native_js.parseAsync(code, false, this.options.jsx !== false);
+            timeStart('generate ast', 3);
+            this.ast = convertProgram(astBuffer, programParent, this.scope);
+            // Make lazy and apply LRU cache to not hog the memory
+            Object.defineProperty(this.info, 'ast', {
+                get: () => {
+                    if (this.graph.astLru.has(fileName)) {
+                        return this.graph.astLru.get(fileName);
+                    }
+                    else {
+                        const parsedAst = this.tryParse();
+                        // If the cache is not disabled, we need to keep the AST in memory
+                        // until the end when the cache is generated
+                        if (this.options.cache !== false) {
+                            Object.defineProperty(this.info, 'ast', {
+                                value: parsedAst
+                            });
+                            return parsedAst;
+                        }
+                        // Otherwise, we keep it in a small LRU cache to not hog too much
+                        // memory but allow the same AST to be requested several times.
+                        this.graph.astLru.set(fileName, parsedAst);
+                        return parsedAst;
+                    }
+                }
+            });
+        }
+        timeEnd('generate ast', 3);
+    }
+    toJSON() {
+        return {
+            ast: this.info.ast,
+            attributes: this.info.attributes,
+            code: this.info.code,
+            customTransformCache: this.customTransformCache,
+            dependencies: Array.from(this.dependencies, getId),
+            id: this.id,
+            meta: this.info.meta,
+            moduleSideEffects: this.info.moduleSideEffects,
+            originalCode: this.originalCode,
+            originalSourcemap: this.originalSourcemap,
+            resolvedIds: this.resolvedIds,
+            sourcemapChain: this.sourcemapChain,
+            syntheticNamedExports: this.info.syntheticNamedExports,
+            transformDependencies: this.transformDependencies,
+            transformFiles: this.transformFiles
+        };
+    }
+    traceVariable(name, { importerForSideEffects, isExportAllSearch, searchedNamesAndModules } = parseAst_js.EMPTY_OBJECT) {
+        const localVariable = this.scope.variables.get(name);
+        if (localVariable) {
+            return localVariable;
+        }
+        const importDescription = this.importDescriptions.get(name);
+        if (importDescription) {
+            const otherModule = importDescription.module;
+            if (otherModule instanceof Module && importDescription.name === '*') {
+                return otherModule.namespace;
+            }
+            const [declaration] = getVariableForExportNameRecursive(otherModule, importDescription.name, importerForSideEffects || this, isExportAllSearch, searchedNamesAndModules);
+            if (!declaration) {
+                return this.error(parseAst_js.logMissingExport(importDescription.name, this.id, otherModule.id), importDescription.start);
+            }
+            return declaration;
+        }
+        return null;
+    }
+    updateOptions({ meta, moduleSideEffects, syntheticNamedExports }) {
+        if (moduleSideEffects != null) {
+            this.info.moduleSideEffects = moduleSideEffects;
+        }
+        if (syntheticNamedExports != null) {
+            this.info.syntheticNamedExports = syntheticNamedExports;
+        }
+        if (meta != null) {
+            Object.assign(this.info.meta, meta);
+        }
+    }
+    addDynamicImport(node) {
+        let argument = node.sourceAstNode;
+        if (argument.type === parseAst_js.TemplateLiteral) {
+            if (argument.quasis.length === 1 &&
+                typeof argument.quasis[0].value.cooked === 'string') {
+                argument = argument.quasis[0].value.cooked;
+            }
+        }
+        else if (argument.type === parseAst_js.Literal &&
+            typeof argument.value === 'string') {
+            argument = argument.value;
+        }
+        this.dynamicImports.push({ argument, id: null, node, resolution: null });
+    }
+    assertUniqueExportName(name, nodeStart) {
+        if (this.exports.has(name) || this.reexportDescriptions.has(name)) {
+            this.error(parseAst_js.logDuplicateExportError(name), nodeStart);
+        }
+    }
+    addExport(node) {
+        if (node instanceof ExportDefaultDeclaration) {
+            // export default foo;
+            this.assertUniqueExportName('default', node.start);
+            this.exports.set('default', {
+                identifier: node.variable.getAssignedVariableName(),
+                localName: 'default'
+            });
+        }
+        else if (node instanceof ExportAllDeclaration) {
+            const source = node.source.value;
+            this.addSource(source, node);
+            if (node.exported) {
+                // export * as name from './other'
+                const name = node.exported instanceof Literal ? node.exported.value : node.exported.name;
+                this.assertUniqueExportName(name, node.exported.start);
+                this.reexportDescriptions.set(name, {
+                    localName: '*',
+                    module: null, // filled in later,
+                    source,
+                    start: node.start
+                });
+            }
+            else {
+                // export * from './other'
+                this.exportAllSources.add(source);
+            }
+        }
+        else if (node.source instanceof Literal) {
+            // export { name } from './other'
+            const source = node.source.value;
+            this.addSource(source, node);
+            for (const { exported, local, start } of node.specifiers) {
+                const name = exported instanceof Literal ? exported.value : exported.name;
+                this.assertUniqueExportName(name, start);
+                this.reexportDescriptions.set(name, {
+                    localName: local instanceof Literal ? local.value : local.name,
+                    module: null, // filled in later,
+                    source,
+                    start
+                });
+            }
+        }
+        else if (node.declaration) {
+            const declaration = node.declaration;
+            if (declaration instanceof VariableDeclaration) {
+                // export var { foo, bar } = ...
+                // export var foo = 1, bar = 2;
+                for (const declarator of declaration.declarations) {
+                    for (const localName of extractAssignedNames(declarator.id)) {
+                        this.assertUniqueExportName(localName, declarator.id.start);
+                        this.exports.set(localName, { identifier: null, localName });
+                    }
+                }
+            }
+            else {
+                // export function foo () {}
+                const localName = declaration.id.name;
+                this.assertUniqueExportName(localName, declaration.id.start);
+                this.exports.set(localName, { identifier: null, localName });
+            }
+        }
+        else {
+            // export { foo, bar, baz }
+            for (const { local, exported } of node.specifiers) {
+                // except for reexports, local must be an Identifier
+                const localName = local.name;
+                const exportedName = exported instanceof Identifier ? exported.name : exported.value;
+                this.assertUniqueExportName(exportedName, exported.start);
+                this.exports.set(exportedName, { identifier: null, localName });
+            }
+        }
+    }
+    addImport(node) {
+        const source = node.source.value;
+        this.addSource(source, node);
+        for (const specifier of node.specifiers) {
+            const localName = specifier.local.name;
+            if (this.scope.variables.has(localName) || this.importDescriptions.has(localName)) {
+                this.error(parseAst_js.logRedeclarationError(localName), specifier.local.start);
+            }
+            const name = specifier instanceof ImportDefaultSpecifier
+                ? 'default'
+                : specifier instanceof ImportNamespaceSpecifier
+                    ? '*'
+                    : specifier.imported instanceof Identifier
+                        ? specifier.imported.name
+                        : specifier.imported.value;
+            this.importDescriptions.set(localName, {
+                module: null, // filled in later
+                name,
+                source,
+                start: specifier.start
+            });
+        }
+    }
+    addImportSource(importSource) {
+        if (importSource && !this.sourcesWithAttributes.has(importSource)) {
+            this.sourcesWithAttributes.set(importSource, parseAst_js.EMPTY_OBJECT);
+        }
+    }
+    addImportMeta(node) {
+        this.importMetas.push(node);
+    }
+    addLocationToLogProps(properties, pos) {
+        properties.id = this.id;
+        properties.pos = pos;
+        let code = this.info.code;
+        const location = parseAst_js.locate(code, pos, { offsetLine: 1 });
+        if (location) {
+            let { column, line } = location;
+            try {
+                ({ column, line } = getOriginalLocation(this.sourcemapChain, { column, line }));
+                code = this.originalCode;
+            }
+            catch (error_) {
+                this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidSourcemapForError(error_, this.id, column, line, pos));
+            }
+            parseAst_js.augmentCodeLocation(properties, { column, line }, code, this.id);
+        }
+    }
+    addModulesToImportDescriptions(importDescription) {
+        for (const specifier of importDescription.values()) {
+            const { id } = this.resolvedIds[specifier.source];
+            specifier.module = this.graph.modulesById.get(id);
+        }
+    }
+    addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies) {
+        const handledDependencies = new Set();
+        const addSideEffectDependencies = (possibleDependencies) => {
+            for (const dependency of possibleDependencies) {
+                if (handledDependencies.has(dependency)) {
+                    continue;
+                }
+                handledDependencies.add(dependency);
+                if (necessaryDependencies.has(dependency)) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                if (!(dependency.info.moduleSideEffects || alwaysCheckedDependencies.has(dependency))) {
+                    continue;
+                }
+                if (dependency instanceof ExternalModule || dependency.hasEffects()) {
+                    relevantDependencies.add(dependency);
+                    continue;
+                }
+                addSideEffectDependencies(dependency.dependencies);
+            }
+        };
+        addSideEffectDependencies(this.dependencies);
+        addSideEffectDependencies(alwaysCheckedDependencies);
+    }
+    addSource(source, declaration) {
+        const parsedAttributes = getAttributesFromImportExportDeclaration(declaration.attributes);
+        const existingAttributes = this.sourcesWithAttributes.get(source);
+        if (existingAttributes) {
+            if (doAttributesDiffer(existingAttributes, parsedAttributes)) {
+                this.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInconsistentImportAttributes(existingAttributes, parsedAttributes, source, this.id), declaration.start);
+            }
+        }
+        else {
+            this.sourcesWithAttributes.set(source, parsedAttributes);
+        }
+    }
+    getImportedJsxFactoryVariable(baseName, nodeStart, importSource) {
+        const { id } = this.resolvedIds[importSource];
+        const module = this.graph.modulesById.get(id);
+        const [variable] = module.getVariableForExportName(baseName);
+        if (!variable) {
+            return this.error(parseAst_js.logMissingJsxExport(baseName, id, this.id), nodeStart);
+        }
+        return variable;
+    }
+    getVariableFromNamespaceReexports(name, importerForSideEffects, searchedNamesAndModules) {
+        let foundSyntheticDeclaration = null;
+        const foundInternalDeclarations = new Map();
+        const foundExternalDeclarations = new Set();
+        for (const module of this.exportAllModules) {
+            // Synthetic namespaces should not hide "regular" exports of the same name
+            if (module.info.syntheticNamedExports === name) {
+                continue;
+            }
+            const [variable, indirectExternal] = getVariableForExportNameRecursive(module, name, importerForSideEffects, true, 
+            // We are creating a copy to handle the case where the same binding is
+            // imported through different namespace reexports gracefully
+            copyNameToModulesMap(searchedNamesAndModules));
+            if (module instanceof ExternalModule || indirectExternal) {
+                foundExternalDeclarations.add(variable);
+            }
+            else if (variable instanceof SyntheticNamedExportVariable) {
+                if (!foundSyntheticDeclaration) {
+                    foundSyntheticDeclaration = variable;
+                }
+            }
+            else if (variable) {
+                foundInternalDeclarations.set(variable, module);
+            }
+        }
+        if (foundInternalDeclarations.size > 0) {
+            const foundDeclarationList = [...foundInternalDeclarations];
+            const usedDeclaration = foundDeclarationList[0][0];
+            if (foundDeclarationList.length === 1) {
+                return [usedDeclaration];
+            }
+            this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logNamespaceConflict(name, this.id, foundDeclarationList.map(([, module]) => module.id)));
+            // TODO we are pretending it was not found while it should behave like "undefined"
+            return [null];
+        }
+        if (foundExternalDeclarations.size > 0) {
+            const foundDeclarationList = [...foundExternalDeclarations];
+            const usedDeclaration = foundDeclarationList[0];
+            if (foundDeclarationList.length > 1) {
+                this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logAmbiguousExternalNamespaces(name, this.id, usedDeclaration.module.id, foundDeclarationList.map(declaration => declaration.module.id)));
+            }
+            return [usedDeclaration, true];
+        }
+        if (foundSyntheticDeclaration) {
+            return [foundSyntheticDeclaration];
+        }
+        return [null];
+    }
+    includeAndGetAdditionalMergedNamespaces() {
+        const externalNamespaces = new Set();
+        const syntheticNamespaces = new Set();
+        for (const module of [this, ...this.exportAllModules]) {
+            if (module instanceof ExternalModule) {
+                const [externalVariable] = module.getVariableForExportName('*');
+                externalVariable.include();
+                this.includedImports.add(externalVariable);
+                externalNamespaces.add(externalVariable);
+            }
+            else if (module.info.syntheticNamedExports) {
+                const syntheticNamespace = module.getSyntheticNamespace();
+                syntheticNamespace.include();
+                this.includedImports.add(syntheticNamespace);
+                syntheticNamespaces.add(syntheticNamespace);
+            }
+        }
+        return [...syntheticNamespaces, ...externalNamespaces];
+    }
+    includeDynamicImport(node) {
+        const resolution = this.dynamicImports.find(dynamicImport => dynamicImport.node === node).resolution;
+        if (resolution instanceof Module) {
+            resolution.includedDynamicImporters.push(this);
+            const importedNames = this.options.treeshake
+                ? node.getDeterministicImportedNames()
+                : undefined;
+            if (importedNames) {
+                resolution.includeExportsByNames(importedNames);
+            }
+            else {
+                resolution.includeAllExports(true);
+            }
+        }
+    }
+    includeVariable(variable) {
+        const variableModule = variable.module;
+        if (variable.included) {
+            if (variableModule instanceof Module && variableModule !== this) {
+                getAndExtendSideEffectModules(variable, this);
+            }
+        }
+        else {
+            variable.include();
+            this.graph.needsTreeshakingPass = true;
+            if (variableModule instanceof Module) {
+                if (!variableModule.isExecuted) {
+                    markModuleAndImpureDependenciesAsExecuted(variableModule);
+                }
+                if (variableModule !== this) {
+                    const sideEffectModules = getAndExtendSideEffectModules(variable, this);
+                    for (const module of sideEffectModules) {
+                        if (!module.isExecuted) {
+                            markModuleAndImpureDependenciesAsExecuted(module);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    includeVariableInModule(variable) {
+        this.includeVariable(variable);
+        const variableModule = variable.module;
+        if (variableModule && variableModule !== this) {
+            this.includedImports.add(variable);
+        }
+    }
+    shimMissingExport(name) {
+        this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logShimmedExport(this.id, name));
+        this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
+    }
+    tryParse() {
+        try {
+            return parseAst_js.parseAst(this.info.code, { jsx: this.options.jsx !== false });
+        }
+        catch (error_) {
+            return this.error(parseAst_js.logModuleParseError(error_, this.id), error_.pos);
+        }
+    }
+}
+// if there is a cyclic import in the reexport chain, we should not
+// import from the original module but from the cyclic module to not
+// mess up execution order.
+function setAlternativeExporterIfCyclic(variable, importer, reexporter) {
+    if (variable.module instanceof Module && variable.module !== reexporter) {
+        const exporterCycles = variable.module.cycles;
+        if (exporterCycles.size > 0) {
+            const importerCycles = reexporter.cycles;
+            for (const cycleSymbol of importerCycles) {
+                if (exporterCycles.has(cycleSymbol)) {
+                    importer.alternativeReexportModules.set(variable, reexporter);
+                    break;
+                }
+            }
+        }
+    }
+}
+const copyNameToModulesMap = (searchedNamesAndModules) => searchedNamesAndModules &&
+    new Map(Array.from(searchedNamesAndModules, ([name, modules]) => [name, new Set(modules)]));
+
+const concatSeparator = (out, next) => (next ? `${out}\n${next}` : out);
+const concatDblSeparator = (out, next) => (next ? `${out}\n\n${next}` : out);
+async function createAddons(options, outputPluginDriver, chunk) {
+    try {
+        let [banner, footer, intro, outro] = await Promise.all([
+            outputPluginDriver.hookReduceValue('banner', options.banner(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('footer', options.footer(chunk), [chunk], concatSeparator),
+            outputPluginDriver.hookReduceValue('intro', options.intro(chunk), [chunk], concatDblSeparator),
+            outputPluginDriver.hookReduceValue('outro', options.outro(chunk), [chunk], concatDblSeparator)
+        ]);
+        if (intro)
+            intro += '\n\n';
+        if (outro)
+            outro = `\n\n${outro}`;
+        if (banner)
+            banner += '\n';
+        if (footer)
+            footer = '\n' + footer;
+        return { banner, footer, intro, outro };
+    }
+    catch (error_) {
+        return parseAst_js.error(parseAst_js.logAddonNotGenerated(error_.message, error_.hook, error_.plugin));
+    }
+}
+
+const DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT = {
+    amd: deconflictImportsOther,
+    cjs: deconflictImportsOther,
+    es: deconflictImportsEsmOrSystem,
+    iife: deconflictImportsOther,
+    system: deconflictImportsEsmOrSystem,
+    umd: deconflictImportsOther
+};
+function deconflictChunk(modules, dependenciesToBeDeconflicted, imports, usedNames, format, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports, exportNamesByVariable, accessedGlobalsByScope, includedNamespaces) {
+    const reversedModules = [...modules].reverse();
+    for (const module of reversedModules) {
+        module.scope.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+    deconflictTopLevelVariables(usedNames, reversedModules, includedNamespaces);
+    DECONFLICT_IMPORTED_VARIABLES_BY_FORMAT[format](usedNames, imports, dependenciesToBeDeconflicted, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports);
+    for (const module of reversedModules) {
+        module.scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
+    }
+}
+function deconflictImportsEsmOrSystem(usedNames, imports, dependenciesToBeDeconflicted, _interop, preserveModules, _externalLiveBindings, chunkByModule, externalChunkByModule, syntheticExports) {
+    // This is needed for namespace reexports
+    for (const dependency of dependenciesToBeDeconflicted.dependencies) {
+        if (preserveModules || dependency instanceof ExternalChunk) {
+            dependency.variableName = getSafeName(dependency.suggestedVariableName, usedNames, null);
+        }
+    }
+    for (const variable of imports) {
+        const module = variable.module;
+        const name = variable.name;
+        if (variable.isNamespace && (preserveModules || module instanceof ExternalModule)) {
+            variable.setRenderNames(null, (module instanceof ExternalModule
+                ? externalChunkByModule.get(module)
+                : chunkByModule.get(module)).variableName);
+        }
+        else if (module instanceof ExternalModule && name === 'default') {
+            variable.setRenderNames(null, getSafeName([...module.exportedVariables].some(([exportedVariable, exportedName]) => exportedName === '*' && exportedVariable.included)
+                ? module.suggestedVariableName + '__default'
+                : module.suggestedVariableName, usedNames, variable.forbiddenNames));
+        }
+        else {
+            variable.setRenderNames(null, getSafeName(makeLegal(name), usedNames, variable.forbiddenNames));
+        }
+    }
+    for (const variable of syntheticExports) {
+        variable.setRenderNames(null, getSafeName(variable.name, usedNames, variable.forbiddenNames));
+    }
+}
+function deconflictImportsOther(usedNames, imports, { deconflictedDefault, deconflictedNamespace, dependencies }, interop, preserveModules, externalLiveBindings, chunkByModule, externalChunkByModule) {
+    for (const chunk of dependencies) {
+        chunk.variableName = getSafeName(chunk.suggestedVariableName, usedNames, null);
+    }
+    for (const chunk of deconflictedNamespace) {
+        chunk.namespaceVariableName = getSafeName(`${chunk.suggestedVariableName}__namespace`, usedNames, null);
+    }
+    for (const externalModule of deconflictedDefault) {
+        externalModule.defaultVariableName =
+            deconflictedNamespace.has(externalModule) &&
+                canDefaultBeTakenFromNamespace(interop(externalModule.id), externalLiveBindings)
+                ? externalModule.namespaceVariableName
+                : getSafeName(`${externalModule.suggestedVariableName}__default`, usedNames, null);
+    }
+    for (const variable of imports) {
+        const module = variable.module;
+        if (module instanceof ExternalModule) {
+            const chunk = externalChunkByModule.get(module);
+            const name = variable.name;
+            if (name === 'default') {
+                const moduleInterop = interop(module.id);
+                const variableName = defaultInteropHelpersByInteropType[moduleInterop]
+                    ? chunk.defaultVariableName
+                    : chunk.variableName;
+                if (isDefaultAProperty(moduleInterop, externalLiveBindings)) {
+                    variable.setRenderNames(variableName, 'default');
+                }
+                else {
+                    variable.setRenderNames(null, variableName);
+                }
+            }
+            else if (name === '*') {
+                variable.setRenderNames(null, namespaceInteropHelpersByInteropType[interop(module.id)]
+                    ? chunk.namespaceVariableName
+                    : chunk.variableName);
+            }
+            else {
+                // if the second parameter is `null`, it uses its "name" for the property name
+                variable.setRenderNames(chunk.variableName, null);
+            }
+        }
+        else {
+            const chunk = chunkByModule.get(module);
+            if (preserveModules && variable.isNamespace) {
+                variable.setRenderNames(null, chunk.exportMode === 'default' ? chunk.namespaceVariableName : chunk.variableName);
+            }
+            else if (chunk.exportMode === 'default') {
+                variable.setRenderNames(null, chunk.variableName);
+            }
+            else {
+                variable.setRenderNames(chunk.variableName, chunk.getVariableExportName(variable));
+            }
+        }
+    }
+}
+function deconflictTopLevelVariables(usedNames, modules, includedNamespaces) {
+    for (const module of modules) {
+        for (const variable of module.scope.variables.values()) {
+            if (variable.included &&
+                // this will only happen for exports in some formats
+                !(variable.renderBaseName ||
+                    (variable instanceof ExportDefaultVariable && variable.getOriginalVariable() !== variable))) {
+                variable.setRenderNames(null, getSafeName(variable.name, usedNames, variable.forbiddenNames));
+            }
+        }
+        if (includedNamespaces.has(module)) {
+            const namespace = module.namespace;
+            namespace.setRenderNames(null, getSafeName(namespace.name, usedNames, namespace.forbiddenNames));
+        }
+    }
+}
+
+function assignExportsToMangledNames(exports, exportsByName, exportNamesByVariable) {
+    let nameIndex = 0;
+    for (const variable of exports) {
+        let [exportName] = variable.name;
+        if (exportsByName.has(exportName)) {
+            do {
+                exportName = toBase64(++nameIndex);
+                // skip past leading number identifiers
+                if (exportName.charCodeAt(0) === 49 /* '1' */) {
+                    nameIndex += 9 * 64 ** (exportName.length - 1);
+                    exportName = toBase64(nameIndex);
+                }
+            } while (RESERVED_NAMES.has(exportName) || exportsByName.has(exportName));
+        }
+        exportsByName.set(exportName, variable);
+        exportNamesByVariable.set(variable, [exportName]);
+    }
+}
+function assignExportsToNames(exports, exportsByName, exportNamesByVariable) {
+    for (const variable of exports) {
+        let nameIndex = 0;
+        let exportName = variable.name;
+        while (exportsByName.has(exportName)) {
+            exportName = variable.name + '$' + ++nameIndex;
+        }
+        exportsByName.set(exportName, variable);
+        exportNamesByVariable.set(variable, [exportName]);
+    }
+}
+
+function getExportMode(chunk, { exports: exportMode, name, format }, facadeModuleId, log) {
+    const exportKeys = chunk.getExportNames();
+    if (exportMode === 'default') {
+        if (exportKeys.length !== 1 || exportKeys[0] !== 'default') {
+            return parseAst_js.error(parseAst_js.logIncompatibleExportOptionValue('default', exportKeys, facadeModuleId));
+        }
+    }
+    else if (exportMode === 'none' && exportKeys.length > 0) {
+        return parseAst_js.error(parseAst_js.logIncompatibleExportOptionValue('none', exportKeys, facadeModuleId));
+    }
+    if (exportMode === 'auto') {
+        if (exportKeys.length === 0) {
+            exportMode = 'none';
+        }
+        else if (exportKeys.length === 1 && exportKeys[0] === 'default') {
+            exportMode = 'default';
+        }
+        else {
+            if (format !== 'es' && format !== 'system' && exportKeys.includes('default')) {
+                log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMixedExport(facadeModuleId, name));
+            }
+            exportMode = 'named';
+        }
+    }
+    return exportMode;
+}
+
+function guessIndentString(code) {
+    const lines = code.split('\n');
+    const tabbed = lines.filter(line => /^\t+/.test(line));
+    const spaced = lines.filter(line => /^ {2,}/.test(line));
+    if (tabbed.length === 0 && spaced.length === 0) {
+        return null;
+    }
+    // More lines tabbed than spaced? Assume tabs, and
+    // default to tabs in the case of a tie (or nothing
+    // to go on)
+    if (tabbed.length >= spaced.length) {
+        return '\t';
+    }
+    // Otherwise, we need to guess the multiple
+    const min = spaced.reduce((previous, current) => {
+        const numberSpaces = /^ +/.exec(current)[0].length;
+        return Math.min(numberSpaces, previous);
+    }, Infinity);
+    return ' '.repeat(min);
+}
+function getIndentString(modules, options) {
+    if (options.indent !== true)
+        return options.indent;
+    for (const module of modules) {
+        const indent = guessIndentString(module.originalCode);
+        if (indent !== null)
+            return indent;
+    }
+    return '\t';
+}
+
+function getStaticDependencies(chunk, orderedModules, chunkByModule, externalChunkByModule) {
+    const staticDependencyBlocks = [];
+    const handledDependencies = new Set();
+    for (let modulePos = orderedModules.length - 1; modulePos >= 0; modulePos--) {
+        const module = orderedModules[modulePos];
+        if (!handledDependencies.has(module)) {
+            const staticDependencies = [];
+            addStaticDependencies(module, staticDependencies, handledDependencies, chunk, chunkByModule, externalChunkByModule);
+            staticDependencyBlocks.unshift(staticDependencies);
+        }
+    }
+    const dependencies = new Set();
+    for (const block of staticDependencyBlocks) {
+        for (const dependency of block) {
+            dependencies.add(dependency);
+        }
+    }
+    return dependencies;
+}
+function addStaticDependencies(module, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule) {
+    const dependencies = module.getDependenciesToBeIncluded();
+    for (const dependency of dependencies) {
+        if (dependency instanceof ExternalModule) {
+            staticDependencies.push(externalChunkByModule.get(dependency));
+            continue;
+        }
+        const dependencyChunk = chunkByModule.get(dependency);
+        if (dependencyChunk !== chunk) {
+            staticDependencies.push(dependencyChunk);
+            continue;
+        }
+        if (!handledModules.has(dependency)) {
+            handledModules.add(dependency);
+            addStaticDependencies(dependency, staticDependencies, handledModules, chunk, chunkByModule, externalChunkByModule);
+        }
+    }
+}
+
+const NON_ASSET_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+]);
+function getGlobalName(chunk, globals, hasExports, log) {
+    const globalName = typeof globals === 'function' ? globals(chunk.id) : globals[chunk.id];
+    if (globalName) {
+        return globalName;
+    }
+    if (hasExports) {
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingGlobalName(chunk.id, chunk.variableName));
+        return chunk.variableName;
+    }
+}
+class Chunk {
+    constructor(orderedModules, inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, manualChunkAlias, getPlaceholder, bundle, inputBase, snippets) {
+        this.orderedModules = orderedModules;
+        this.inputOptions = inputOptions;
+        this.outputOptions = outputOptions;
+        this.unsetOptions = unsetOptions;
+        this.pluginDriver = pluginDriver;
+        this.modulesById = modulesById;
+        this.chunkByModule = chunkByModule;
+        this.externalChunkByModule = externalChunkByModule;
+        this.facadeChunkByModule = facadeChunkByModule;
+        this.includedNamespaces = includedNamespaces;
+        this.manualChunkAlias = manualChunkAlias;
+        this.getPlaceholder = getPlaceholder;
+        this.bundle = bundle;
+        this.inputBase = inputBase;
+        this.snippets = snippets;
+        this.entryModules = [];
+        this.exportMode = 'named';
+        this.facadeModule = null;
+        this.namespaceVariableName = '';
+        this.variableName = '';
+        this.accessedGlobalsByScope = new Map();
+        this.dependencies = new Set();
+        this.dynamicEntryModules = [];
+        this.dynamicName = null;
+        this.exportNamesByVariable = new Map();
+        this.exports = new Set();
+        this.exportsByName = new Map();
+        this.fileName = null;
+        this.implicitEntryModules = [];
+        this.implicitlyLoadedBefore = new Set();
+        this.imports = new Set();
+        this.includedDynamicImports = null;
+        this.includedReexportsByModule = new Map();
+        // This may be updated in the constructor
+        this.isEmpty = true;
+        this.name = null;
+        this.needsExportsShim = false;
+        this.preRenderedChunkInfo = null;
+        this.preliminaryFileName = null;
+        this.preliminarySourcemapFileName = null;
+        this.renderedChunkInfo = null;
+        this.renderedDependencies = null;
+        this.renderedModules = Object.create(null);
+        this.sortedExportNames = null;
+        this.strictFacade = false;
+        this.execIndex = orderedModules.length > 0 ? orderedModules[0].execIndex : Infinity;
+        const chunkModules = new Set(orderedModules);
+        for (const module of orderedModules) {
+            chunkByModule.set(module, this);
+            if (module.namespace.included && !outputOptions.preserveModules) {
+                includedNamespaces.add(module);
+            }
+            if (this.isEmpty && module.isIncluded()) {
+                this.isEmpty = false;
+            }
+            if (module.info.isEntry || outputOptions.preserveModules) {
+                this.entryModules.push(module);
+            }
+            for (const importer of module.includedDynamicImporters) {
+                if (!chunkModules.has(importer)) {
+                    this.dynamicEntryModules.push(module);
+                    // Modules with synthetic exports need an artificial namespace for dynamic imports
+                    if (module.info.syntheticNamedExports) {
+                        includedNamespaces.add(module);
+                        this.exports.add(module.namespace);
+                    }
+                }
+            }
+            if (module.implicitlyLoadedAfter.size > 0) {
+                this.implicitEntryModules.push(module);
+            }
+        }
+        this.suggestedVariableName = makeLegal(this.generateVariableName());
+    }
+    static generateFacade(inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, facadedModule, facadeName, getPlaceholder, bundle, inputBase, snippets) {
+        const chunk = new Chunk([], inputOptions, outputOptions, unsetOptions, pluginDriver, modulesById, chunkByModule, externalChunkByModule, facadeChunkByModule, includedNamespaces, null, getPlaceholder, bundle, inputBase, snippets);
+        chunk.assignFacadeName(facadeName, facadedModule);
+        if (!facadeChunkByModule.has(facadedModule)) {
+            facadeChunkByModule.set(facadedModule, chunk);
+        }
+        for (const dependency of facadedModule.getDependenciesToBeIncluded()) {
+            chunk.dependencies.add(dependency instanceof Module
+                ? chunkByModule.get(dependency)
+                : externalChunkByModule.get(dependency));
+        }
+        if (!chunk.dependencies.has(chunkByModule.get(facadedModule)) &&
+            facadedModule.info.moduleSideEffects &&
+            facadedModule.hasEffects()) {
+            chunk.dependencies.add(chunkByModule.get(facadedModule));
+        }
+        chunk.ensureReexportsAreAvailableForModule(facadedModule);
+        chunk.facadeModule = facadedModule;
+        chunk.strictFacade = true;
+        return chunk;
+    }
+    canModuleBeFacade(module, exposedVariables) {
+        const moduleExportNamesByVariable = module.getExportNamesByVariable();
+        // All exports of this chunk need to be exposed by the candidate module
+        for (const exposedVariable of this.exports) {
+            if (!moduleExportNamesByVariable.has(exposedVariable)) {
+                return false;
+            }
+        }
+        // Additionally, we need to expose namespaces of dynamic entries that are not the facade module and exports from other entry modules
+        for (const exposedVariable of exposedVariables) {
+            if (!(exposedVariable.module === module ||
+                moduleExportNamesByVariable.has(exposedVariable) ||
+                (exposedVariable instanceof SyntheticNamedExportVariable &&
+                    moduleExportNamesByVariable.has(exposedVariable.getBaseVariable())))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    finalizeChunk(code, map, sourcemapFileName, hashesByPlaceholder) {
+        const renderedChunkInfo = this.getRenderedChunkInfo();
+        const finalize = (code) => replacePlaceholders(code, hashesByPlaceholder);
+        const preliminaryFileName = renderedChunkInfo.fileName;
+        const fileName = (this.fileName = finalize(preliminaryFileName));
+        return {
+            ...renderedChunkInfo,
+            code,
+            dynamicImports: renderedChunkInfo.dynamicImports.map(finalize),
+            fileName,
+            implicitlyLoadedBefore: renderedChunkInfo.implicitlyLoadedBefore.map(finalize),
+            importedBindings: Object.fromEntries(Object.entries(renderedChunkInfo.importedBindings).map(([fileName, bindings]) => [
+                finalize(fileName),
+                bindings
+            ])),
+            imports: renderedChunkInfo.imports.map(finalize),
+            map,
+            preliminaryFileName,
+            referencedFiles: renderedChunkInfo.referencedFiles.map(finalize),
+            sourcemapFileName
+        };
+    }
+    generateExports() {
+        this.sortedExportNames = null;
+        const remainingExports = new Set(this.exports);
+        if (this.facadeModule !== null &&
+            (this.facadeModule.preserveSignature !== false || this.strictFacade)) {
+            const exportNamesByVariable = this.facadeModule.getExportNamesByVariable();
+            for (const [variable, exportNames] of exportNamesByVariable) {
+                this.exportNamesByVariable.set(variable, [...exportNames]);
+                for (const exportName of exportNames) {
+                    this.exportsByName.set(exportName, variable);
+                }
+                remainingExports.delete(variable);
+            }
+        }
+        if (this.outputOptions.minifyInternalExports) {
+            assignExportsToMangledNames(remainingExports, this.exportsByName, this.exportNamesByVariable);
+        }
+        else {
+            assignExportsToNames(remainingExports, this.exportsByName, this.exportNamesByVariable);
+        }
+        if (this.outputOptions.preserveModules || (this.facadeModule && this.facadeModule.info.isEntry))
+            this.exportMode = getExportMode(this, this.outputOptions, this.facadeModule.id, this.inputOptions.onLog);
+    }
+    generateFacades() {
+        const facades = [];
+        const entryModules = new Set([...this.entryModules, ...this.implicitEntryModules]);
+        const exposedVariables = new Set(this.dynamicEntryModules.map(({ namespace }) => namespace));
+        for (const module of entryModules) {
+            if (module.preserveSignature) {
+                for (const exportedVariable of module.getExportNamesByVariable().keys()) {
+                    // We need to expose all entry exports from this chunk
+                    if (this.chunkByModule.get(exportedVariable.module) === this) {
+                        exposedVariables.add(exportedVariable);
+                    }
+                }
+            }
+        }
+        for (const module of entryModules) {
+            const requiredFacades = Array.from(new Set(module.chunkNames.filter(({ isUserDefined }) => isUserDefined).map(({ name }) => name)), 
+            // mapping must run after Set 'name' dedupe
+            name => ({
+                name
+            }));
+            if (requiredFacades.length === 0 && module.isUserDefinedEntryPoint) {
+                requiredFacades.push({});
+            }
+            requiredFacades.push(...Array.from(module.chunkFileNames, fileName => ({ fileName })));
+            if (requiredFacades.length === 0) {
+                requiredFacades.push({});
+            }
+            if (!this.facadeModule) {
+                const needsStrictFacade = !this.outputOptions.preserveModules &&
+                    (module.preserveSignature === 'strict' ||
+                        (module.preserveSignature === 'exports-only' &&
+                            module.getExportNamesByVariable().size > 0));
+                if (!needsStrictFacade || this.canModuleBeFacade(module, exposedVariables)) {
+                    this.facadeModule = module;
+                    this.facadeChunkByModule.set(module, this);
+                    if (module.preserveSignature) {
+                        this.strictFacade = needsStrictFacade;
+                    }
+                    this.assignFacadeName(requiredFacades.shift(), module, this.outputOptions.preserveModules);
+                }
+            }
+            for (const facadeName of requiredFacades) {
+                facades.push(Chunk.generateFacade(this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.modulesById, this.chunkByModule, this.externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, module, facadeName, this.getPlaceholder, this.bundle, this.inputBase, this.snippets));
+            }
+        }
+        for (const module of this.dynamicEntryModules) {
+            if (module.info.syntheticNamedExports)
+                continue;
+            if (!this.facadeModule && this.canModuleBeFacade(module, exposedVariables)) {
+                this.facadeModule = module;
+                this.facadeChunkByModule.set(module, this);
+                this.strictFacade = true;
+                this.dynamicName = getChunkNameFromModule(module);
+            }
+            else if (this.facadeModule === module &&
+                !this.strictFacade &&
+                this.canModuleBeFacade(module, exposedVariables)) {
+                this.strictFacade = true;
+            }
+            else if (!this.facadeChunkByModule.get(module)?.strictFacade) {
+                this.includedNamespaces.add(module);
+                this.exports.add(module.namespace);
+            }
+        }
+        if (!this.outputOptions.preserveModules) {
+            this.addNecessaryImportsForFacades();
+        }
+        return facades;
+    }
+    getChunkName() {
+        return (this.name ??= this.outputOptions.sanitizeFileName(this.getFallbackChunkName()));
+    }
+    getExportNames() {
+        return (this.sortedExportNames ??= [...this.exportsByName.keys()].sort());
+    }
+    getFileName() {
+        return this.fileName || this.getPreliminaryFileName().fileName;
+    }
+    getImportPath(importer) {
+        return escapeId(parseAst_js.getImportPath(importer, this.getFileName(), this.outputOptions.format === 'amd' && !this.outputOptions.amd.forceJsExtensionForImports, true));
+    }
+    getPreliminaryFileName() {
+        if (this.preliminaryFileName) {
+            return this.preliminaryFileName;
+        }
+        let fileName;
+        let hashPlaceholder = null;
+        const { chunkFileNames, entryFileNames, file, format, preserveModules } = this.outputOptions;
+        if (file) {
+            fileName = path.basename(file);
+        }
+        else if (this.fileName === null) {
+            const [pattern, patternName] = preserveModules || this.facadeModule?.isUserDefinedEntryPoint
+                ? [entryFileNames, 'output.entryFileNames']
+                : [chunkFileNames, 'output.chunkFileNames'];
+            fileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
+                format: () => format,
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
+                name: () => this.getChunkName()
+            });
+            if (!hashPlaceholder) {
+                fileName = makeUnique(fileName, this.bundle);
+            }
+        }
+        else {
+            fileName = this.fileName;
+        }
+        if (!hashPlaceholder) {
+            this.bundle[fileName] = FILE_PLACEHOLDER;
+        }
+        // Caching is essential to not conflict with the file name reservation above
+        return (this.preliminaryFileName = { fileName, hashPlaceholder });
+    }
+    getPreliminarySourcemapFileName() {
+        if (this.preliminarySourcemapFileName) {
+            return this.preliminarySourcemapFileName;
+        }
+        let sourcemapFileName = null;
+        let hashPlaceholder = null;
+        const { sourcemapFileNames, format } = this.outputOptions;
+        if (sourcemapFileNames) {
+            const [pattern, patternName] = [sourcemapFileNames, 'output.sourcemapFileNames'];
+            sourcemapFileName = renderNamePattern(typeof pattern === 'function' ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
+                chunkhash: () => this.getPreliminaryFileName().hashPlaceholder || '',
+                format: () => format,
+                hash: size => hashPlaceholder ||
+                    (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
+                name: () => this.getChunkName()
+            });
+            if (!hashPlaceholder) {
+                sourcemapFileName = makeUnique(sourcemapFileName, this.bundle);
+            }
+        }
+        else {
+            return null;
+        }
+        return (this.preliminarySourcemapFileName = { fileName: sourcemapFileName, hashPlaceholder });
+    }
+    getRenderedChunkInfo() {
+        if (this.renderedChunkInfo) {
+            return this.renderedChunkInfo;
+        }
+        return (this.renderedChunkInfo = {
+            ...this.getPreRenderedChunkInfo(),
+            dynamicImports: this.getDynamicDependencies().map(resolveFileName),
+            fileName: this.getFileName(),
+            implicitlyLoadedBefore: Array.from(this.implicitlyLoadedBefore, resolveFileName),
+            importedBindings: getImportedBindingsPerDependency(this.getRenderedDependencies(), resolveFileName),
+            imports: Array.from(this.dependencies, resolveFileName),
+            modules: this.renderedModules,
+            referencedFiles: this.getReferencedFiles()
+        });
+    }
+    getVariableExportName(variable) {
+        if (this.outputOptions.preserveModules && variable instanceof NamespaceVariable) {
+            return '*';
+        }
+        return this.exportNamesByVariable.get(variable)[0];
+    }
+    link() {
+        this.dependencies = getStaticDependencies(this, this.orderedModules, this.chunkByModule, this.externalChunkByModule);
+        for (const module of this.orderedModules) {
+            this.addImplicitlyLoadedBeforeFromModule(module);
+            this.setUpChunkImportsAndExportsForModule(module);
+        }
+    }
+    async render() {
+        const { dependencies, exportMode, facadeModule, inputOptions: { onLog }, outputOptions, pluginDriver, snippets } = this;
+        const { format, hoistTransitiveImports, preserveModules } = outputOptions;
+        // for static and dynamic entry points, add transitive dependencies to this
+        // chunk's dependencies to avoid loading latency
+        if (hoistTransitiveImports && !preserveModules && facadeModule !== null) {
+            for (const dep of dependencies) {
+                if (dep instanceof Chunk)
+                    this.inlineChunkDependencies(dep);
+            }
+        }
+        const preliminaryFileName = this.getPreliminaryFileName();
+        const preliminarySourcemapFileName = this.getPreliminarySourcemapFileName();
+        const { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait } = this.renderModules(preliminaryFileName.fileName);
+        const renderedDependencies = [...this.getRenderedDependencies().values()];
+        const renderedExports = exportMode === 'none' ? [] : this.getChunkExportDeclarations(format);
+        let hasExports = renderedExports.length > 0;
+        let hasDefaultExport = false;
+        for (const renderedDependency of renderedDependencies) {
+            const { reexports } = renderedDependency;
+            if (reexports?.length) {
+                hasExports = true;
+                if (!hasDefaultExport && reexports.some(reexport => reexport.reexported === 'default')) {
+                    hasDefaultExport = true;
+                }
+                if (format === 'es') {
+                    renderedDependency.reexports = reexports.filter(({ reexported }) => !renderedExports.find(({ exported }) => exported === reexported));
+                }
+            }
+        }
+        if (!hasDefaultExport) {
+            for (const { exported } of renderedExports) {
+                if (exported === 'default') {
+                    hasDefaultExport = true;
+                    break;
+                }
+            }
+        }
+        const { intro, outro, banner, footer } = await createAddons(outputOptions, pluginDriver, this.getRenderedChunkInfo());
+        finalisers[format](renderedSource, {
+            accessedGlobals,
+            dependencies: renderedDependencies,
+            exports: renderedExports,
+            hasDefaultExport,
+            hasExports,
+            id: preliminaryFileName.fileName,
+            indent,
+            intro,
+            isEntryFacade: preserveModules || (facadeModule !== null && facadeModule.info.isEntry),
+            isModuleFacade: facadeModule !== null,
+            log: onLog,
+            namedExportsMode: exportMode !== 'default',
+            outro,
+            snippets,
+            usesTopLevelAwait
+        }, outputOptions);
+        if (banner)
+            magicString.prepend(banner);
+        if (format === 'es' || format === 'cjs') {
+            const shebang = facadeModule !== null && facadeModule.info.isEntry && facadeModule.shebang;
+            if (shebang) {
+                magicString.prepend(`#!${shebang}\n`);
+            }
+        }
+        if (footer)
+            magicString.append(footer);
+        return {
+            chunk: this,
+            magicString,
+            preliminaryFileName,
+            preliminarySourcemapFileName,
+            usedModules
+        };
+    }
+    addImplicitlyLoadedBeforeFromModule(baseModule) {
+        const { chunkByModule, implicitlyLoadedBefore } = this;
+        for (const module of baseModule.implicitlyLoadedBefore) {
+            const chunk = chunkByModule.get(module);
+            if (chunk && chunk !== this) {
+                implicitlyLoadedBefore.add(chunk);
+            }
+        }
+    }
+    addNecessaryImportsForFacades() {
+        for (const [module, variables] of this.includedReexportsByModule) {
+            if (this.includedNamespaces.has(module)) {
+                for (const variable of variables) {
+                    this.imports.add(variable);
+                }
+            }
+        }
+    }
+    assignFacadeName({ fileName, name }, facadedModule, preservePath) {
+        if (fileName) {
+            this.fileName = fileName;
+        }
+        else {
+            this.name = this.outputOptions.sanitizeFileName(name ||
+                (preservePath
+                    ? this.getPreserveModulesChunkNameFromModule(facadedModule)
+                    : getChunkNameFromModule(facadedModule)));
+        }
+    }
+    checkCircularDependencyImport(variable, importingModule) {
+        const variableModule = variable.module;
+        if (variableModule instanceof Module) {
+            const exportChunk = this.chunkByModule.get(variableModule);
+            let alternativeReexportModule;
+            do {
+                alternativeReexportModule = importingModule.alternativeReexportModules.get(variable);
+                if (alternativeReexportModule) {
+                    const exportingChunk = this.chunkByModule.get(alternativeReexportModule);
+                    if (exportingChunk !== exportChunk) {
+                        this.inputOptions.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCyclicCrossChunkReexport(
+                        // Namespaces do not have an export name
+                        variableModule.getExportNamesByVariable().get(variable)?.[0] || '*', variableModule.id, alternativeReexportModule.id, importingModule.id, this.outputOptions.preserveModules));
+                    }
+                    importingModule = alternativeReexportModule;
+                }
+            } while (alternativeReexportModule);
+        }
+    }
+    ensureReexportsAreAvailableForModule(module) {
+        const includedReexports = [];
+        const map = module.getExportNamesByVariable();
+        for (const exportedVariable of map.keys()) {
+            const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
+            const importedVariable = isSynthetic ? exportedVariable.getBaseVariable() : exportedVariable;
+            this.checkCircularDependencyImport(importedVariable, module);
+            // When preserving modules, we do not create namespace objects but directly
+            // use the actual namespaces, which would be broken by this logic.
+            if (!(importedVariable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+                const exportingModule = importedVariable.module;
+                if (exportingModule instanceof Module) {
+                    const chunk = this.chunkByModule.get(exportingModule);
+                    if (chunk && chunk !== this) {
+                        chunk.exports.add(importedVariable);
+                        includedReexports.push(importedVariable);
+                        if (isSynthetic) {
+                            this.imports.add(importedVariable);
+                        }
+                    }
+                }
+            }
+        }
+        if (includedReexports.length > 0) {
+            this.includedReexportsByModule.set(module, includedReexports);
+        }
+    }
+    generateVariableName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
+        }
+        const moduleForNaming = this.entryModules[0] ||
+            this.implicitEntryModules[0] ||
+            this.dynamicEntryModules[0] ||
+            this.orderedModules[this.orderedModules.length - 1];
+        if (moduleForNaming) {
+            return getChunkNameFromModule(moduleForNaming);
+        }
+        return 'chunk';
+    }
+    getChunkExportDeclarations(format) {
+        const exports = [];
+        for (const exportName of this.getExportNames()) {
+            if (exportName[0] === '*')
+                continue;
+            const variable = this.exportsByName.get(exportName);
+            if (!(variable instanceof SyntheticNamedExportVariable)) {
+                const module = variable.module;
+                if (module) {
+                    const chunk = this.chunkByModule.get(module);
+                    if (chunk !== this) {
+                        if (!chunk || format !== 'es') {
+                            continue;
+                        }
+                        const chunkDep = this.renderedDependencies.get(chunk);
+                        if (!chunkDep) {
+                            continue;
+                        }
+                        const { imports, reexports } = chunkDep;
+                        const importedByReexported = reexports?.find(({ reexported }) => reexported === exportName);
+                        const isImported = imports?.find(({ imported }) => imported === importedByReexported?.imported);
+                        if (!isImported) {
+                            continue;
+                        }
+                    }
+                }
+            }
+            let expression = null;
+            let hoisted = false;
+            let local = variable.getName(this.snippets.getPropertyAccess);
+            if (variable instanceof LocalVariable) {
+                for (const declaration of variable.declarations) {
+                    if (declaration.parent instanceof FunctionDeclaration ||
+                        (declaration instanceof ExportDefaultDeclaration &&
+                            declaration.declaration instanceof FunctionDeclaration)) {
+                        hoisted = true;
+                        break;
+                    }
+                }
+            }
+            else if (variable instanceof SyntheticNamedExportVariable) {
+                expression = local;
+                if (format === 'es') {
+                    local = variable.renderName;
+                }
+            }
+            exports.push({
+                exported: exportName,
+                expression,
+                hoisted,
+                local
+            });
+        }
+        return exports;
+    }
+    getDependenciesToBeDeconflicted(addNonNamespacesAndInteropHelpers, addDependenciesWithoutBindings, interop) {
+        const dependencies = new Set();
+        const deconflictedDefault = new Set();
+        const deconflictedNamespace = new Set();
+        for (const variable of [...this.exportNamesByVariable.keys(), ...this.imports]) {
+            if (addNonNamespacesAndInteropHelpers || variable.isNamespace) {
+                const module = variable.module;
+                if (module instanceof ExternalModule) {
+                    const chunk = this.externalChunkByModule.get(module);
+                    dependencies.add(chunk);
+                    if (addNonNamespacesAndInteropHelpers) {
+                        if (variable.name === 'default') {
+                            if (defaultInteropHelpersByInteropType[interop(module.id)]) {
+                                deconflictedDefault.add(chunk);
+                            }
+                        }
+                        else if (variable.isNamespace &&
+                            namespaceInteropHelpersByInteropType[interop(module.id)] &&
+                            (this.imports.has(variable) ||
+                                !this.exportNamesByVariable.get(variable)?.every(name => name.startsWith('*')))) {
+                            // We only need to deconflict it if the namespace is actually
+                            // created as a variable, i.e. because it is used internally or
+                            // because it is reexported as an object
+                            deconflictedNamespace.add(chunk);
+                        }
+                    }
+                }
+                else {
+                    const chunk = this.chunkByModule.get(module);
+                    if (chunk !== this) {
+                        dependencies.add(chunk);
+                        if (addNonNamespacesAndInteropHelpers &&
+                            chunk.exportMode === 'default' &&
+                            variable.isNamespace) {
+                            deconflictedNamespace.add(chunk);
+                        }
+                    }
+                }
+            }
+        }
+        if (addDependenciesWithoutBindings) {
+            for (const dependency of this.dependencies) {
+                dependencies.add(dependency);
+            }
+        }
+        return { deconflictedDefault, deconflictedNamespace, dependencies };
+    }
+    getDynamicDependencies() {
+        return this.getIncludedDynamicImports()
+            .map(resolvedDynamicImport => resolvedDynamicImport.facadeChunk ||
+            resolvedDynamicImport.chunk ||
+            resolvedDynamicImport.externalChunk ||
+            resolvedDynamicImport.resolution)
+            .filter((resolution) => resolution !== this &&
+            (resolution instanceof Chunk || resolution instanceof ExternalChunk));
+    }
+    getDynamicImportStringAndAttributes(resolution, fileName) {
+        if (resolution instanceof ExternalModule) {
+            const chunk = this.externalChunkByModule.get(resolution);
+            return [`'${chunk.getImportPath(fileName)}'`, chunk.getImportAttributes(this.snippets)];
+        }
+        return [
+            resolution || '',
+            (this.outputOptions.format === 'es' && this.outputOptions.externalImportAttributes) || null
+        ];
+    }
+    getFallbackChunkName() {
+        if (this.manualChunkAlias) {
+            return this.manualChunkAlias;
+        }
+        if (this.dynamicName) {
+            return this.dynamicName;
+        }
+        if (this.fileName) {
+            return parseAst_js.getAliasName(this.fileName);
+        }
+        return parseAst_js.getAliasName(this.orderedModules[this.orderedModules.length - 1].id);
+    }
+    getImportSpecifiers() {
+        const { interop } = this.outputOptions;
+        const importsByDependency = new Map();
+        for (const variable of this.imports) {
+            const module = variable.module;
+            let dependency;
+            let imported;
+            if (module instanceof ExternalModule) {
+                dependency = this.externalChunkByModule.get(module);
+                imported = variable.name;
+                if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
+                    return parseAst_js.error(parseAst_js.logUnexpectedNamedImport(module.id, imported, false));
+                }
+            }
+            else {
+                dependency = this.chunkByModule.get(module);
+                imported = dependency.getVariableExportName(variable);
+            }
+            getOrCreate(importsByDependency, dependency, getNewArray).push({
+                imported,
+                local: variable.getName(this.snippets.getPropertyAccess)
+            });
+        }
+        return importsByDependency;
+    }
+    getIncludedDynamicImports() {
+        if (this.includedDynamicImports) {
+            return this.includedDynamicImports;
+        }
+        const includedDynamicImports = [];
+        for (const module of this.orderedModules) {
+            for (const { node, resolution } of module.dynamicImports) {
+                if (!node.included) {
+                    continue;
+                }
+                includedDynamicImports.push(resolution instanceof Module
+                    ? {
+                        chunk: this.chunkByModule.get(resolution),
+                        externalChunk: null,
+                        facadeChunk: this.facadeChunkByModule.get(resolution),
+                        node,
+                        resolution
+                    }
+                    : resolution instanceof ExternalModule
+                        ? {
+                            chunk: null,
+                            externalChunk: this.externalChunkByModule.get(resolution),
+                            facadeChunk: null,
+                            node,
+                            resolution
+                        }
+                        : { chunk: null, externalChunk: null, facadeChunk: null, node, resolution });
+            }
+        }
+        return (this.includedDynamicImports = includedDynamicImports);
+    }
+    getPreRenderedChunkInfo() {
+        if (this.preRenderedChunkInfo) {
+            return this.preRenderedChunkInfo;
+        }
+        const { dynamicEntryModules, facadeModule, implicitEntryModules, orderedModules } = this;
+        return (this.preRenderedChunkInfo = {
+            exports: this.getExportNames(),
+            facadeModuleId: facadeModule && facadeModule.id,
+            isDynamicEntry: dynamicEntryModules.length > 0,
+            isEntry: !!facadeModule?.info.isEntry,
+            isImplicitEntry: implicitEntryModules.length > 0,
+            moduleIds: orderedModules.map(({ id }) => id),
+            name: this.getChunkName(),
+            type: 'chunk'
+        });
+    }
+    getPreserveModulesChunkNameFromModule(module) {
+        const predefinedChunkName = getPredefinedChunkNameFromModule(module);
+        if (predefinedChunkName)
+            return predefinedChunkName;
+        const { preserveModulesRoot, sanitizeFileName } = this.outputOptions;
+        const sanitizedId = sanitizeFileName(parseAst_js.normalize(module.id.split(QUERY_HASH_REGEX, 1)[0]));
+        const extensionName = path.extname(sanitizedId);
+        const idWithoutExtension = NON_ASSET_EXTENSIONS.has(extensionName)
+            ? sanitizedId.slice(0, -extensionName.length)
+            : sanitizedId;
+        if (parseAst_js.isAbsolute(idWithoutExtension)) {
+            if (preserveModulesRoot && path.resolve(idWithoutExtension).startsWith(preserveModulesRoot)) {
+                return idWithoutExtension.slice(preserveModulesRoot.length).replace(/^[/\\]/, '');
+            }
+            else {
+                // handle edge case in Windows
+                if (this.inputBase === '/' && !idWithoutExtension.startsWith('/')) {
+                    return parseAst_js.relative(this.inputBase, idWithoutExtension.replace(/^[a-zA-Z]:[/\\]/, '/'));
+                }
+                return parseAst_js.relative(this.inputBase, idWithoutExtension);
+            }
+        }
+        else {
+            return (this.outputOptions.virtualDirname.replace(/\/$/, '') + '/' + path.basename(idWithoutExtension));
+        }
+    }
+    getReexportSpecifiers() {
+        const { externalLiveBindings, interop } = this.outputOptions;
+        const reexportSpecifiers = new Map();
+        for (let exportName of this.getExportNames()) {
+            let dependency;
+            let imported;
+            let needsLiveBinding = false;
+            if (exportName[0] === '*') {
+                const id = exportName.slice(1);
+                if (interop(id) === 'defaultOnly') {
+                    this.inputOptions.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnexpectedNamespaceReexport(id));
+                }
+                needsLiveBinding = externalLiveBindings;
+                dependency = this.externalChunkByModule.get(this.modulesById.get(id));
+                imported = exportName = '*';
+            }
+            else {
+                const variable = this.exportsByName.get(exportName);
+                if (variable instanceof SyntheticNamedExportVariable)
+                    continue;
+                const module = variable.module;
+                if (module instanceof Module) {
+                    dependency = this.chunkByModule.get(module);
+                    if (dependency === this)
+                        continue;
+                    imported = dependency.getVariableExportName(variable);
+                    needsLiveBinding = variable.isReassigned;
+                }
+                else {
+                    dependency = this.externalChunkByModule.get(module);
+                    imported = variable.name;
+                    if (imported !== 'default' && imported !== '*' && interop(module.id) === 'defaultOnly') {
+                        return parseAst_js.error(parseAst_js.logUnexpectedNamedImport(module.id, imported, true));
+                    }
+                    needsLiveBinding =
+                        externalLiveBindings &&
+                            (imported !== 'default' || isDefaultAProperty(interop(module.id), true));
+                }
+            }
+            getOrCreate(reexportSpecifiers, dependency, getNewArray).push({
+                imported,
+                needsLiveBinding,
+                reexported: exportName
+            });
+        }
+        return reexportSpecifiers;
+    }
+    getReferencedFiles() {
+        const referencedFiles = new Set();
+        for (const module of this.orderedModules) {
+            for (const meta of module.importMetas) {
+                const fileName = meta.getReferencedFileName(this.pluginDriver);
+                if (fileName) {
+                    referencedFiles.add(fileName);
+                }
+            }
+        }
+        return [...referencedFiles];
+    }
+    getRenderedDependencies() {
+        if (this.renderedDependencies) {
+            return this.renderedDependencies;
+        }
+        const importSpecifiers = this.getImportSpecifiers();
+        const reexportSpecifiers = this.getReexportSpecifiers();
+        const renderedDependencies = new Map();
+        const fileName = this.getFileName();
+        for (const dependency of this.dependencies) {
+            const imports = importSpecifiers.get(dependency) || null;
+            const reexports = reexportSpecifiers.get(dependency) || null;
+            const namedExportsMode = dependency instanceof ExternalChunk || dependency.exportMode !== 'default';
+            const importPath = dependency.getImportPath(fileName);
+            renderedDependencies.set(dependency, {
+                attributes: dependency instanceof ExternalChunk
+                    ? dependency.getImportAttributes(this.snippets)
+                    : null,
+                defaultVariableName: dependency.defaultVariableName,
+                globalName: dependency instanceof ExternalChunk &&
+                    (this.outputOptions.format === 'umd' || this.outputOptions.format === 'iife') &&
+                    getGlobalName(dependency, this.outputOptions.globals, (imports || reexports) !== null, this.inputOptions.onLog),
+                importPath,
+                imports,
+                isChunk: dependency instanceof Chunk,
+                name: dependency.variableName,
+                namedExportsMode,
+                namespaceVariableName: dependency.namespaceVariableName,
+                reexports
+            });
+        }
+        return (this.renderedDependencies = renderedDependencies);
+    }
+    inlineChunkDependencies(chunk) {
+        for (const dep of chunk.dependencies) {
+            if (this.dependencies.has(dep))
+                continue;
+            this.dependencies.add(dep);
+            if (dep instanceof Chunk) {
+                this.inlineChunkDependencies(dep);
+            }
+        }
+    }
+    // This method changes properties on the AST before rendering and must not be async
+    renderModules(fileName) {
+        const { accessedGlobalsByScope, dependencies, exportNamesByVariable, includedNamespaces, inputOptions: { onLog }, isEmpty, orderedModules, outputOptions, pluginDriver, renderedModules, snippets } = this;
+        const { compact, format, freeze, generatedCode: { symbols } } = outputOptions;
+        const { _, cnst, n } = snippets;
+        this.setDynamicImportResolutions(fileName);
+        this.setImportMetaResolutions(fileName);
+        this.setIdentifierRenderResolutions();
+        const magicString = new Bundle$1({ separator: `${n}${n}` });
+        const indent = getIndentString(orderedModules, outputOptions);
+        const usedModules = [];
+        let hoistedSource = '';
+        const accessedGlobals = new Set();
+        const renderedModuleSources = new Map();
+        const renderOptions = {
+            accessedDocumentCurrentScript: false,
+            exportNamesByVariable,
+            format,
+            freeze,
+            indent,
+            pluginDriver,
+            snippets,
+            symbols,
+            useOriginalName: null
+        };
+        let usesTopLevelAwait = false;
+        for (const module of orderedModules) {
+            let renderedLength = 0;
+            let source;
+            if (module.isIncluded() || includedNamespaces.has(module)) {
+                const rendered = module.render(renderOptions);
+                if (!renderOptions.accessedDocumentCurrentScript &&
+                    formatsMaybeAccessDocumentCurrentScript.includes(format)) {
+                    this.accessedGlobalsByScope.get(module.scope)?.delete(DOCUMENT_CURRENT_SCRIPT);
+                }
+                renderOptions.accessedDocumentCurrentScript = false;
+                ({ source } = rendered);
+                usesTopLevelAwait ||= rendered.usesTopLevelAwait;
+                renderedLength = source.length();
+                if (renderedLength) {
+                    if (compact && source.lastLine().includes('//'))
+                        source.append('\n');
+                    renderedModuleSources.set(module, source);
+                    magicString.addSource(source);
+                    usedModules.push(module);
+                }
+                const namespace = module.namespace;
+                if (includedNamespaces.has(module)) {
+                    const rendered = namespace.renderBlock(renderOptions);
+                    if (namespace.renderFirst())
+                        hoistedSource += n + rendered;
+                    else
+                        magicString.addSource(new MagicString(rendered));
+                }
+                const accessedGlobalVariables = accessedGlobalsByScope.get(module.scope);
+                if (accessedGlobalVariables) {
+                    for (const name of accessedGlobalVariables) {
+                        accessedGlobals.add(name);
+                    }
+                }
+            }
+            const { renderedExports, removedExports } = module.getRenderedExports();
+            renderedModules[module.id] = {
+                get code() {
+                    return source?.toString() ?? null;
+                },
+                originalLength: module.originalCode.length,
+                removedExports,
+                renderedExports,
+                renderedLength
+            };
+        }
+        if (hoistedSource)
+            magicString.prepend(hoistedSource + n + n);
+        if (this.needsExportsShim) {
+            magicString.prepend(`${n}${cnst} ${MISSING_EXPORT_SHIM_VARIABLE}${_}=${_}void 0;${n}${n}`);
+        }
+        const renderedSource = compact ? magicString : magicString.trim();
+        if (isEmpty && this.getExportNames().length === 0 && dependencies.size === 0) {
+            onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logEmptyChunk(this.getChunkName()));
+        }
+        return { accessedGlobals, indent, magicString, renderedSource, usedModules, usesTopLevelAwait };
+    }
+    setDynamicImportResolutions(fileName) {
+        const { accessedGlobalsByScope, outputOptions, pluginDriver, snippets } = this;
+        for (const resolvedDynamicImport of this.getIncludedDynamicImports()) {
+            if (resolvedDynamicImport.chunk) {
+                const { chunk, facadeChunk, node, resolution } = resolvedDynamicImport;
+                if (chunk === this) {
+                    node.setInternalResolution(resolution.namespace);
+                }
+                else {
+                    node.setExternalResolution((facadeChunk || chunk).exportMode, resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, `'${(facadeChunk || chunk).getImportPath(fileName)}'`, !facadeChunk?.strictFacade && chunk.exportNamesByVariable.get(resolution.namespace)[0], null);
+                }
+            }
+            else {
+                const { node, resolution } = resolvedDynamicImport;
+                const [resolutionString, attributes] = this.getDynamicImportStringAndAttributes(resolution, fileName);
+                node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, attributes);
+            }
+        }
+    }
+    setIdentifierRenderResolutions() {
+        const { format, generatedCode: { symbols }, interop, preserveModules, externalLiveBindings } = this.outputOptions;
+        const syntheticExports = new Set();
+        for (const exportName of this.getExportNames()) {
+            const exportVariable = this.exportsByName.get(exportName);
+            if (format !== 'es' &&
+                format !== 'system' &&
+                exportVariable.isReassigned &&
+                !exportVariable.isId) {
+                exportVariable.setRenderNames('exports', exportName);
+            }
+            else if (exportVariable instanceof SyntheticNamedExportVariable) {
+                syntheticExports.add(exportVariable);
+            }
+            else {
+                exportVariable.setRenderNames(null, null);
+            }
+        }
+        for (const module of this.orderedModules) {
+            if (module.needsExportShim) {
+                this.needsExportsShim = true;
+                break;
+            }
+        }
+        const usedNames = new Set(['Object', 'Promise']);
+        if (this.needsExportsShim) {
+            usedNames.add(MISSING_EXPORT_SHIM_VARIABLE);
+        }
+        if (symbols) {
+            usedNames.add('Symbol');
+        }
+        switch (format) {
+            case 'system': {
+                usedNames.add('module').add('exports');
+                break;
+            }
+            case 'es': {
+                break;
+            }
+            case 'cjs': {
+                usedNames.add('module').add('require').add('__filename').add('__dirname');
+            }
+            // fallthrough
+            default: {
+                usedNames.add('exports');
+                for (const helper of HELPER_NAMES) {
+                    usedNames.add(helper);
+                }
+            }
+        }
+        deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, preserveModules, externalLiveBindings, this.chunkByModule, this.externalChunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
+    }
+    setImportMetaResolutions(fileName) {
+        const { accessedGlobalsByScope, includedNamespaces, orderedModules, outputOptions: { format } } = this;
+        for (const module of orderedModules) {
+            for (const importMeta of module.importMetas) {
+                importMeta.setResolution(format, accessedGlobalsByScope, fileName);
+            }
+            if (includedNamespaces.has(module)) {
+                module.namespace.prepare(accessedGlobalsByScope);
+            }
+        }
+    }
+    setUpChunkImportsAndExportsForModule(module) {
+        const moduleImports = new Set(module.includedImports);
+        // when we are not preserving modules, we need to make all namespace variables available for
+        // rendering the namespace object
+        if (!this.outputOptions.preserveModules && this.includedNamespaces.has(module)) {
+            const memberVariables = module.namespace.getMemberVariables();
+            for (const variable of Object.values(memberVariables)) {
+                if (variable.included) {
+                    moduleImports.add(variable);
+                }
+            }
+        }
+        for (let variable of moduleImports) {
+            if (variable instanceof ExportDefaultVariable) {
+                variable = variable.getOriginalVariable();
+            }
+            if (variable instanceof SyntheticNamedExportVariable) {
+                variable = variable.getBaseVariable();
+            }
+            const chunk = this.chunkByModule.get(variable.module);
+            if (chunk !== this) {
+                this.imports.add(variable);
+                if (variable.module instanceof Module) {
+                    this.checkCircularDependencyImport(variable, module);
+                    // When preserving modules, we do not create namespace objects but directly
+                    // use the actual namespaces, which would be broken by this logic.
+                    if (!(variable instanceof NamespaceVariable && this.outputOptions.preserveModules)) {
+                        chunk.exports.add(variable);
+                    }
+                }
+            }
+        }
+        if (this.includedNamespaces.has(module) ||
+            (module.info.isEntry && module.preserveSignature !== false) ||
+            module.includedDynamicImporters.some(importer => this.chunkByModule.get(importer) !== this)) {
+            this.ensureReexportsAreAvailableForModule(module);
+        }
+        for (const { node, resolution } of module.dynamicImports) {
+            if (node.included &&
+                resolution instanceof Module &&
+                this.chunkByModule.get(resolution) === this &&
+                !this.includedNamespaces.has(resolution)) {
+                this.includedNamespaces.add(resolution);
+                this.ensureReexportsAreAvailableForModule(resolution);
+            }
+        }
+    }
+}
+function getChunkNameFromModule(module) {
+    return getPredefinedChunkNameFromModule(module) ?? parseAst_js.getAliasName(module.id);
+}
+function getPredefinedChunkNameFromModule(module) {
+    return (module.chunkNames.find(({ isUserDefined }) => isUserDefined)?.name ?? module.chunkNames[0]?.name);
+}
+function getImportedBindingsPerDependency(renderedDependencies, resolveFileName) {
+    const importedBindingsPerDependency = {};
+    for (const [dependency, declaration] of renderedDependencies) {
+        const specifiers = new Set();
+        if (declaration.imports) {
+            for (const { imported } of declaration.imports) {
+                specifiers.add(imported);
+            }
+        }
+        if (declaration.reexports) {
+            for (const { imported } of declaration.reexports) {
+                specifiers.add(imported);
+            }
+        }
+        importedBindingsPerDependency[resolveFileName(dependency)] = [...specifiers];
+    }
+    return importedBindingsPerDependency;
+}
+const QUERY_HASH_REGEX = /[#?]/;
+const resolveFileName = (dependency) => dependency.getFileName();
+
+/**
+ * Concatenate a number of iterables to a new iterable without fully evaluating
+ * their iterators. Useful when e.g. working with large sets or lists and when
+ * there is a chance that the iterators will not be fully exhausted.
+ */
+function* concatLazy(iterables) {
+    for (const iterable of iterables) {
+        yield* iterable;
+    }
+}
+
+/**
+ * At its core, the algorithm first starts from each static or dynamic entry
+ * point and then assigns that entry point to all modules than can be reached
+ * via static imports. We call this the *dependent entry points* of that
+ * module.
+ *
+ * Then we group all modules with the same dependent entry points into chunks
+ * as those modules will always be loaded together.
+ *
+ * One non-trivial optimization we can apply is that dynamic entries are
+ * different from static entries in so far as when a dynamic import occurs,
+ * some modules are already in memory. If some of these modules are also
+ * dependencies of the dynamic entry, then it does not make sense to create a
+ * separate chunk for them. Instead, the dynamic import target can load them
+ * from the importing chunk.
+ *
+ * With regard to chunking, if B is implicitly loaded after A, then this can be
+ * handled the same way as if there was a dynamic import A => B.
+ *
+ * Example:
+ * Assume A -> B (A imports B), A => C (A dynamically imports C) and C -> B.
+ * Then the initial algorithm would assign A into the A chunk, C into the C
+ * chunk and B into the AC chunk, i.e. the chunk with the dependent entry
+ * points A and C.
+ * However we know that C can only be loaded from A, so A and its dependency B
+ * must already be in memory when C is loaded. So it is enough to create only
+ * two chunks A containing [AB] and C containing [C].
+ *
+ * So we do not assign the dynamic entry C as dependent entry point to modules
+ * that are already loaded.
+ *
+ * In a more complex example, let us assume that we have entry points X and Y.
+ * Further, let us assume
+ * X -> A, X -> B, X -> C,
+ * Y -> A, Y -> B,
+ * A => D,
+ * D -> B, D -> C
+ * So without dynamic import optimization, the dependent entry points are
+ * A: XY, B: DXY, C: DX, D: D, X: X, Y: Y, so we would for now create six
+ * chunks.
+ *
+ * Now D is loaded only after A is loaded. But A is loaded if either X is
+ * loaded or Y is loaded. So the modules that are already in memory when D is
+ * loaded are the intersection of all modules that X depends on with all
+ * modules that Y depends on, which in this case are the modules A and B.
+ * We could also say they are all modules that have both X and Y as dependent
+ * entry points.
+ *
+ * So we can remove D as dependent entry point from A and B, which means they
+ * both now have only XY as dependent entry points and can be merged into the
+ * same chunk.
+ *
+ * Now let us extend this to the most general case where we have several
+ * dynamic importers for one dynamic entry point.
+ *
+ * In the most general form, it works like this:
+ * For each dynamic entry point, we have a number of dynamic importers, which
+ * are the modules importing it. Using the previous ideas, we can determine
+ * the modules already in memory for each dynamic importer by looking for all
+ * modules that have all the dependent entry points of the dynamic importer as
+ * dependent entry points.
+ * So the modules that are guaranteed to be in memory when the dynamic entry
+ * point is loaded are the intersection of the modules already in memory for
+ * each dynamic importer.
+ *
+ * Assuming that A => D and B => D and A has dependent entry points XY and B
+ * has dependent entry points YZ, then the modules guaranteed to be in memory
+ * are all modules that have at least XYZ as dependent entry points.
+ * We call XYZ the *dynamically dependent entry points* of D.
+ *
+ * Now there is one last case to consider: If one of the dynamically dependent
+ * entries is itself a dynamic entry, then any module is in memory that either
+ * is a dependency of that dynamic entry or again has the dynamic dependent
+ * entries of that dynamic entry as dependent entry points.
+ *
+ * A naive algorithm for this proved to be costly as it contained an O(n^3)
+ * complexity with regard to dynamic entries that blew up for very large
+ * projects.
+ *
+ * If we have an efficient way to do Set operations, an alternative approach
+ * would be to instead collect already loaded modules per dynamic entry. And as
+ * all chunks from the initial grouping would behave the same, we can instead
+ * collect already loaded chunks for a performance improvement.
+ *
+ * To do that efficiently, need
+ * - a Map of dynamic imports per dynamic entry, which contains all dynamic
+ *   imports that can be triggered by a dynamic entry
+ * - a Map of static dependencies per entry
+ * - a Map of already loaded chunks per entry that we initially populate with
+ *   empty Sets for static entries and Sets containing all entries for dynamic
+ *   entries
+ *
+ * For efficient operations, we assign each entry a numerical index and
+ * represent Sets of Chunks as BigInt values where each chunk corresponds to a
+ * bit index. Then the last two maps can be represented as arrays of BigInt
+ * values.
+ *
+ * Then we iterate through each dynamic entry. We set the already loaded modules
+ * to the intersection of the previously already loaded modules with the union
+ * of the already loaded modules of that chunk with its static dependencies.
+ *
+ * If the already loaded modules changed, then we use the Map of dynamic imports
+ * per dynamic entry to marks all dynamic entry dependencies as "dirty" and put
+ * them back into the iteration. As an additional optimization, we note for
+ * each dynamic entry which dynamic dependent entries have changed and only
+ * intersect those entries again on subsequent interations.
+ *
+ * Then we remove the dynamic entries from the list of dependent entries for
+ * those chunks that are already loaded for that dynamic entry and create
+ * another round of chunks.
+ */
+function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log) {
+    const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
+    const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
+    // Each chunk is identified by its position in this array
+    const chunkAtoms = getChunksWithSameDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
+    const staticDependencyAtomsByEntry = getStaticDependencyAtomsByEntry(allEntries, chunkAtoms);
+    // Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+    // If we no longer want this, we should make a copy here.
+    const alreadyLoadedAtomsByEntry = getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+    // This mutates the dependentEntries in chunkAtoms
+    removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry);
+    const { chunks, sideEffectAtoms, sizeByAtom } = getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize);
+    chunkDefinitions.push(...getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log).map(({ modules }) => ({
+        alias: null,
+        modules
+    })));
+    return chunkDefinitions;
+}
+function getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry) {
+    const chunkDefinitions = [];
+    const modulesInManualChunks = new Set(manualChunkAliasByEntry.keys());
+    const manualChunkModulesByAlias = Object.create(null);
+    for (const [entry, alias] of manualChunkAliasByEntry) {
+        addStaticDependenciesToManualChunk(entry, (manualChunkModulesByAlias[alias] ||= []), modulesInManualChunks);
+    }
+    for (const [alias, modules] of Object.entries(manualChunkModulesByAlias)) {
+        chunkDefinitions.push({ alias, modules });
+    }
+    return { chunkDefinitions, modulesInManualChunks };
+}
+function addStaticDependenciesToManualChunk(entry, manualChunkModules, modulesInManualChunks) {
+    const modulesToHandle = new Set([entry]);
+    for (const module of modulesToHandle) {
+        modulesInManualChunks.add(module);
+        manualChunkModules.push(module);
+        for (const dependency of module.dependencies) {
+            if (!(dependency instanceof ExternalModule || modulesInManualChunks.has(dependency))) {
+                modulesToHandle.add(dependency);
+            }
+        }
+    }
+}
+function analyzeModuleGraph(entries) {
+    const dynamicEntryModules = new Set();
+    const dependentEntriesByModule = new Map();
+    const dynamicImportModulesByEntry = [];
+    const allEntriesSet = new Set(entries);
+    let entryIndex = 0;
+    for (const currentEntry of allEntriesSet) {
+        const dynamicImportsForCurrentEntry = new Set();
+        dynamicImportModulesByEntry.push(dynamicImportsForCurrentEntry);
+        const modulesToHandle = new Set([currentEntry]);
+        for (const module of modulesToHandle) {
+            getOrCreate(dependentEntriesByModule, module, (getNewSet)).add(entryIndex);
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (!(dependency instanceof ExternalModule)) {
+                    modulesToHandle.add(dependency);
+                }
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module &&
+                    resolution.includedDynamicImporters.length > 0 &&
+                    !allEntriesSet.has(resolution)) {
+                    dynamicEntryModules.add(resolution);
+                    allEntriesSet.add(resolution);
+                    dynamicImportsForCurrentEntry.add(resolution);
+                }
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                if (!allEntriesSet.has(dependency)) {
+                    dynamicEntryModules.add(dependency);
+                    allEntriesSet.add(dependency);
+                }
+            }
+        }
+        entryIndex++;
+    }
+    const allEntries = [...allEntriesSet];
+    const { dynamicEntries, dynamicImportsByEntry } = getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry);
+    return {
+        allEntries,
+        dependentEntriesByModule,
+        dynamicallyDependentEntriesByDynamicEntry: getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries),
+        dynamicImportsByEntry
+    };
+}
+function getDynamicEntries(allEntries, dynamicEntryModules, dynamicImportModulesByEntry) {
+    const entryIndexByModule = new Map();
+    const dynamicEntries = new Set();
+    for (const [entryIndex, entry] of allEntries.entries()) {
+        entryIndexByModule.set(entry, entryIndex);
+        if (dynamicEntryModules.has(entry)) {
+            dynamicEntries.add(entryIndex);
+        }
+    }
+    const dynamicImportsByEntry = [];
+    for (const dynamicImportModules of dynamicImportModulesByEntry) {
+        const dynamicImports = new Set();
+        for (const dynamicEntry of dynamicImportModules) {
+            dynamicImports.add(entryIndexByModule.get(dynamicEntry));
+        }
+        dynamicImportsByEntry.push(dynamicImports);
+    }
+    return { dynamicEntries, dynamicImportsByEntry };
+}
+function getDynamicallyDependentEntriesByDynamicEntry(dependentEntriesByModule, dynamicEntries, allEntries) {
+    const dynamicallyDependentEntriesByDynamicEntry = new Map();
+    for (const dynamicEntryIndex of dynamicEntries) {
+        const dynamicallyDependentEntries = getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicEntryIndex, (getNewSet));
+        const dynamicEntry = allEntries[dynamicEntryIndex];
+        for (const importer of concatLazy([
+            dynamicEntry.includedDynamicImporters,
+            dynamicEntry.implicitlyLoadedAfter
+        ])) {
+            for (const entry of dependentEntriesByModule.get(importer)) {
+                dynamicallyDependentEntries.add(entry);
+            }
+        }
+    }
+    return dynamicallyDependentEntriesByDynamicEntry;
+}
+function getChunksWithSameDependentEntries(modulesWithDependentEntries) {
+    const chunkModules = Object.create(null);
+    for (const { dependentEntries, modules } of modulesWithDependentEntries) {
+        let chunkSignature = 0n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+        }
+        (chunkModules[String(chunkSignature)] ||= {
+            dependentEntries: new Set(dependentEntries),
+            modules: []
+        }).modules.push(...modules);
+    }
+    return Object.values(chunkModules);
+}
+function* getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks) {
+    for (const [module, dependentEntries] of dependentEntriesByModule) {
+        if (!modulesInManualChunks.has(module)) {
+            yield { dependentEntries, modules: [module] };
+        }
+    }
+}
+function getStaticDependencyAtomsByEntry(allEntries, chunkAtoms) {
+    // The indices correspond to the indices in allEntries. The atoms correspond
+    // to bits in the bigint values where chunk 0 is the lowest bit.
+    const staticDependencyAtomsByEntry = allEntries.map(() => 0n);
+    // This toggles the bits for each atom that is a dependency of an entry
+    let atomMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
+        for (const entryIndex of dependentEntries) {
+            staticDependencyAtomsByEntry[entryIndex] |= atomMask;
+        }
+        atomMask <<= 1n;
+    }
+    return staticDependencyAtomsByEntry;
+}
+// Warning: This will consume dynamicallyDependentEntriesByDynamicEntry.
+function getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+    // Dynamic entries have all atoms as already loaded initially because we then
+    // intersect with the static dependency atoms of all dynamic importers.
+    // Static entries cannot have already loaded atoms.
+    const alreadyLoadedAtomsByEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+    for (const [dynamicEntryIndex, dynamicallyDependentEntries] of dynamicallyDependentEntriesByDynamicEntry) {
+        // We delete here so that they can be added again if necessary to be handled
+        // again by the loop
+        dynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const knownLoadedAtoms = alreadyLoadedAtomsByEntry[dynamicEntryIndex];
+        let updatedLoadedAtoms = knownLoadedAtoms;
+        for (const entryIndex of dynamicallyDependentEntries) {
+            updatedLoadedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        // If the knownLoadedAtoms changed, all dependent dynamic entries need to be
+        // updated again
+        if (updatedLoadedAtoms !== knownLoadedAtoms) {
+            alreadyLoadedAtomsByEntry[dynamicEntryIndex] = updatedLoadedAtoms;
+            for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
+                // If this adds an entry that was deleted before, it will be handled
+                // again. This is the reason why we delete every entry from this map
+                // that we processed.
+                getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicImport, (getNewSet)).add(dynamicEntryIndex);
+            }
+        }
+    }
+    return alreadyLoadedAtomsByEntry;
+}
+/**
+ * This removes all unnecessary dynamic entries from the dependentEntries in its
+ * first argument if a chunk is already loaded without that entry.
+ */
+function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry) {
+    // Remove entries from dependent entries if a chunk is already loaded without
+    // that entry.
+    let chunkMask = 1n;
+    for (const { dependentEntries } of chunkAtoms) {
+        for (const entryIndex of dependentEntries) {
+            if ((alreadyLoadedAtomsByEntry[entryIndex] & chunkMask) === chunkMask) {
+                dependentEntries.delete(entryIndex);
+            }
+        }
+        chunkMask <<= 1n;
+    }
+}
+function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
+    const chunksBySignature = Object.create(null);
+    const chunkByModule = new Map();
+    const sizeByAtom = [];
+    let sideEffectAtoms = 0n;
+    let atomMask = 1n;
+    for (const { dependentEntries, modules } of chunkAtoms) {
+        let chunkSignature = 0n;
+        let correlatedAtoms = -1n;
+        for (const entryIndex of dependentEntries) {
+            chunkSignature |= 1n << BigInt(entryIndex);
+            // Correlated atoms are the atoms that are guaranteed to be loaded as
+            // well when a given atom is loaded. It is the intersection of the already
+            // loaded modules of each chunk merged with its static dependencies.
+            correlatedAtoms &=
+                staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        const chunk = (chunksBySignature[String(chunkSignature)] ||= {
+            containedAtoms: 0n,
+            correlatedAtoms,
+            dependencies: new Set(),
+            dependentChunks: new Set(),
+            dependentEntries: new Set(dependentEntries),
+            modules: [],
+            pure: true,
+            size: 0
+        });
+        let atomSize = 0;
+        let pure = true;
+        for (const module of modules) {
+            chunkByModule.set(module, chunk);
+            // Unfortunately, we cannot take tree-shaking into account here because
+            // rendering did not happen yet, but we can detect empty modules
+            if (module.isIncluded()) {
+                pure &&= !module.hasEffects();
+                // we use a trivial size for the default minChunkSize to improve
+                // performance
+                atomSize += minChunkSize > 1 ? module.estimateSize() : 1;
+            }
+        }
+        if (!pure) {
+            sideEffectAtoms |= atomMask;
+        }
+        sizeByAtom.push(atomSize);
+        chunk.containedAtoms |= atomMask;
+        chunk.modules.push(...modules);
+        chunk.pure &&= pure;
+        chunk.size += atomSize;
+        atomMask <<= 1n;
+    }
+    const chunks = Object.values(chunksBySignature);
+    sideEffectAtoms |= addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, atomMask);
+    return { chunks, sideEffectAtoms, sizeByAtom };
+}
+function addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, nextAvailableAtomMask) {
+    const signatureByExternalModule = new Map();
+    let externalSideEffectAtoms = 0n;
+    for (const chunk of chunks) {
+        const { dependencies, modules } = chunk;
+        for (const module of modules) {
+            for (const dependency of module.getDependenciesToBeIncluded()) {
+                if (dependency instanceof ExternalModule) {
+                    if (dependency.info.moduleSideEffects) {
+                        const signature = getOrCreate(signatureByExternalModule, dependency, () => {
+                            const signature = nextAvailableAtomMask;
+                            nextAvailableAtomMask <<= 1n;
+                            externalSideEffectAtoms |= signature;
+                            return signature;
+                        });
+                        chunk.containedAtoms |= signature;
+                        chunk.correlatedAtoms |= signature;
+                    }
+                }
+                else {
+                    const dependencyChunk = chunkByModule.get(dependency);
+                    if (dependencyChunk && dependencyChunk !== chunk) {
+                        dependencies.add(dependencyChunk);
+                        dependencyChunk.dependentChunks.add(chunk);
+                    }
+                }
+            }
+        }
+    }
+    return externalSideEffectAtoms;
+}
+/**
+ * This function tries to get rid of small chunks by merging them with other
+ * chunks.
+ *
+ * We can only merge chunks safely if after the merge, loading any entry point
+ * in any allowed order will not trigger side effects that should not have been
+ * triggered. While side effects are usually things like global function calls,
+ * global variable mutations or potentially thrown errors, details do not
+ * matter here, and we just discern chunks without side effects (pure chunks)
+ * from other chunks.
+ *
+ * As a first step, we assign each pre-generated chunk with side effects a
+ * label. I.e. we have side effect "A" if the non-pure chunk "A" is loaded.
+ *
+ * Now to determine the side effects of loading a chunk, one also has to take
+ * the side effects of its dependencies into account. So if A depends on B
+ * (A -> B) and both have side effects, loading A triggers effects AB.
+ *
+ * Now from the previous step we know that each chunk is uniquely determine by
+ * the entry points that depend on it and cause it to load, which we will call
+ * its dependent entry points.
+ *
+ * E.g. if X -> A and Y -> A, then the dependent entry points of A are XY.
+ * Starting from that idea, we can determine a set of chunks—and thus a set
+ * of side effects—that must have been triggered if a certain chunk has been
+ * loaded. Basically, it is the intersection of all chunks loaded by the
+ * dependent entry points of a given chunk. We call the corresponding side
+ * effects the correlated side effects of that chunk.
+ *
+ * Example:
+ * X -> ABC, Y -> ADE, A-> F, B -> D
+ * Then taking dependencies into account, X -> ABCDF, Y -> ADEF
+ * The intersection is ADF. So we know that when A is loaded, D and F must also
+ * be in memory even though neither D nor A is a dependency of the other.
+ * If all have side effects, we call ADF the correlated side effects of A. The
+ * correlated side effects need to remain constant when merging chunks.
+ *
+ * In contrast, we have the dependency side effects of A, which represents
+ * the side effects we trigger if we directly load A. In this example, the
+ * dependency side effects are AF.
+ * For entry chunks, dependency and correlated side effects are the same.
+ *
+ * With these concepts, merging chunks is allowed if the correlated side
+ * effects of each entry do not change. Thus, we are allowed to merge two
+ * chunks if
+ *
+ * a) the dependency side effects of each chunk are a subset of the correlated
+ *    side effects of the other chunk, so no additional side effects are
+ *    triggered for any entry, or
+ * b) The dependent entry points of chunk A are a subset of the dependent entry
+ *    points of chunk B while the dependency side effects of A are a subset of
+ *    the correlated side effects of B. Because in that scenario, whenever A is
+ *    loaded, B is loaded as well. But there are cases when B is loaded where A
+ *    is not loaded. So if we merge the chunks, all dependency side effects of
+ *    A will be added to the correlated side effects of B, and as the latter is
+ *    not allowed to change, the former need to be a subset of the latter.
+ *
+ * Another consideration when merging small chunks into other chunks is to
+ * avoid
+ * that too much additional code is loaded. This is achieved when the dependent
+ * entries of the small chunk are a subset of the dependent entries of the
+ * other
+ * chunk. Because then when the small chunk is loaded, the other chunk was
+ * loaded/in memory anyway, so at most when the other chunk is loaded, the
+ * additional size of the small chunk is loaded unnecessarily.
+ *
+ * So the algorithm performs merges in two passes:
+ *
+ * 1. First we try to merge small chunks A only into other chunks B if the
+ *    dependent entries of A are a subset of the dependent entries of B and the
+ *    dependency side effects of A are a subset of the correlated side effects
+ *    of B.
+ * 2. Only then for all remaining small chunks, we look for arbitrary merges
+ *    following the rule (a), starting with the smallest chunks to look for
+ *    possible merge targets.
+ */
+function getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log) {
+    timeStart('optimize chunks', 3);
+    const chunkPartition = getPartitionedChunks(chunks, minChunkSize);
+    if (!chunkPartition) {
+        timeEnd('optimize chunks', 3);
+        return chunks; // the actual modules
+    }
+    if (minChunkSize > 1) {
+        log('info', parseAst_js.logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, 'Initially'));
+    }
+    mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
+    if (minChunkSize > 1) {
+        log('info', parseAst_js.logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, 'After merging chunks'));
+    }
+    timeEnd('optimize chunks', 3);
+    return [...chunkPartition.small, ...chunkPartition.big];
+}
+function getPartitionedChunks(chunks, minChunkSize) {
+    const smallChunks = [];
+    const bigChunks = [];
+    for (const chunk of chunks) {
+        (chunk.size < minChunkSize ? smallChunks : bigChunks).push(chunk);
+    }
+    if (smallChunks.length === 0) {
+        return null;
+    }
+    smallChunks.sort(compareChunkSize);
+    bigChunks.sort(compareChunkSize);
+    return {
+        big: new Set(bigChunks),
+        small: new Set(smallChunks)
+    };
+}
+function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+    return sizeA - sizeB;
+}
+function mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom) {
+    const { small } = chunkPartition;
+    for (const mergedChunk of small) {
+        const bestTargetChunk = findBestMergeTarget(mergedChunk, chunkPartition, sideEffectAtoms, sizeByAtom, 
+        // In the default case, we do not accept size increases
+        minChunkSize <= 1 ? 1 : Infinity);
+        if (bestTargetChunk) {
+            const { containedAtoms, correlatedAtoms, modules, pure, size } = mergedChunk;
+            small.delete(mergedChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).delete(bestTargetChunk);
+            bestTargetChunk.modules.push(...modules);
+            bestTargetChunk.size += size;
+            bestTargetChunk.pure &&= pure;
+            const { dependencies, dependentChunks, dependentEntries } = bestTargetChunk;
+            bestTargetChunk.correlatedAtoms &= correlatedAtoms;
+            bestTargetChunk.containedAtoms |= containedAtoms;
+            for (const entry of mergedChunk.dependentEntries) {
+                dependentEntries.add(entry);
+            }
+            for (const dependency of mergedChunk.dependencies) {
+                dependencies.add(dependency);
+                dependency.dependentChunks.delete(mergedChunk);
+                dependency.dependentChunks.add(bestTargetChunk);
+            }
+            for (const dependentChunk of mergedChunk.dependentChunks) {
+                dependentChunks.add(dependentChunk);
+                dependentChunk.dependencies.delete(mergedChunk);
+                dependentChunk.dependencies.add(bestTargetChunk);
+            }
+            dependencies.delete(bestTargetChunk);
+            dependentChunks.delete(bestTargetChunk);
+            getChunksInPartition(bestTargetChunk, minChunkSize, chunkPartition).add(bestTargetChunk);
+        }
+    }
+}
+function findBestMergeTarget(mergedChunk, { big, small }, sideEffectAtoms, sizeByAtom, smallestAdditionalSize) {
+    let bestTargetChunk = null;
+    // In the default case, we do not accept size increases
+    for (const targetChunk of concatLazy([small, big])) {
+        if (mergedChunk === targetChunk)
+            continue;
+        const additionalSizeAfterMerge = getAdditionalSizeAfterMerge(mergedChunk, targetChunk, smallestAdditionalSize, sideEffectAtoms, sizeByAtom);
+        if (additionalSizeAfterMerge < smallestAdditionalSize) {
+            bestTargetChunk = targetChunk;
+            if (additionalSizeAfterMerge === 0)
+                break;
+            smallestAdditionalSize = additionalSizeAfterMerge;
+        }
+    }
+    return bestTargetChunk;
+}
+/**
+ * Determine the additional unused code size that would be added by merging the
+ * two chunks. This is not an exact measurement but rather an upper bound. If
+ * the merge produces cycles or adds non-correlated side effects, `Infinity`
+ * is returned.
+ * Merging will not produce cycles if none of the direct non-merged
+ * dependencies of a chunk have the other chunk as a transitive dependency.
+ */
+function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, 
+// The maximum additional unused code size allowed to be added by the merge,
+// taking dependencies into account, needs to be below this number
+currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
+    return firstSize < currentAdditionalSize
+        ? firstSize +
+            getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom)
+        : Infinity;
+}
+function getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(dependentChunk, dependencyChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
+    const { correlatedAtoms } = dependencyChunk;
+    let dependencyAtoms = dependentChunk.containedAtoms;
+    const dependentContainedSideEffects = dependencyAtoms & sideEffectAtoms;
+    if ((correlatedAtoms & dependentContainedSideEffects) !== dependentContainedSideEffects) {
+        return Infinity;
+    }
+    const chunksToCheck = new Set(dependentChunk.dependencies);
+    for (const { dependencies, containedAtoms } of chunksToCheck) {
+        dependencyAtoms |= containedAtoms;
+        const containedSideEffects = containedAtoms & sideEffectAtoms;
+        if ((correlatedAtoms & containedSideEffects) !== containedSideEffects) {
+            return Infinity;
+        }
+        for (const dependency of dependencies) {
+            if (dependency === dependencyChunk) {
+                return Infinity;
+            }
+            chunksToCheck.add(dependency);
+        }
+    }
+    return getAtomsSizeIfBelowLimit(dependencyAtoms & ~correlatedAtoms, currentAdditionalSize, sizeByAtom);
+}
+function getAtomsSizeIfBelowLimit(atoms, currentAdditionalSize, sizeByAtom) {
+    let size = 0;
+    let atomIndex = 0;
+    let atomSignature = 1n;
+    const { length } = sizeByAtom;
+    for (; atomIndex < length; atomIndex++) {
+        if ((atoms & atomSignature) === atomSignature) {
+            size += sizeByAtom[atomIndex];
+        }
+        atomSignature <<= 1n;
+        if (size >= currentAdditionalSize) {
+            return Infinity;
+        }
+    }
+    return size;
+}
+function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+    return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+}
+
+// ported from https://github.com/substack/node-commondir
+function commondir(files) {
+    if (files.length === 0)
+        return '/';
+    if (files.length === 1)
+        return path.dirname(files[0]);
+    const commonSegments = files.slice(1).reduce((commonSegments, file) => {
+        const pathSegments = file.split(/\/+|\\+/);
+        let index;
+        for (index = 0; commonSegments[index] === pathSegments[index] &&
+            index < Math.min(commonSegments.length, pathSegments.length); index++)
+            ;
+        return commonSegments.slice(0, index);
+    }, files[0].split(/\/+|\\+/));
+    // Windows correctly handles paths with forward-slashes
+    return commonSegments.length > 1 ? commonSegments.join('/') : '/';
+}
+
+const compareExecIndex = (unitA, unitB) => unitA.execIndex > unitB.execIndex ? 1 : -1;
+function sortByExecutionOrder(units) {
+    units.sort(compareExecIndex);
+}
+// This process is currently faulty in so far as it only takes the first entry
+// module into account and assumes that dynamic imports are imported in a
+// certain order.
+// A better algorithm would follow every possible execution path and mark which
+// modules are executed before or after which other modules. THen the chunking
+// would need to take care that in each chunk, all modules are always executed
+// in the same sequence.
+function analyseModuleExecution(entryModules) {
+    let nextExecIndex = 0;
+    const cyclePaths = [];
+    const analysedModules = new Set();
+    const dynamicImports = new Set();
+    const parents = new Map();
+    const orderedModules = [];
+    const analyseModule = (module) => {
+        if (module instanceof Module) {
+            for (const dependency of module.dependencies) {
+                if (parents.has(dependency)) {
+                    if (!analysedModules.has(dependency)) {
+                        cyclePaths.push(getCyclePath(dependency, module, parents));
+                    }
+                    continue;
+                }
+                parents.set(dependency, module);
+                analyseModule(dependency);
+            }
+            for (const dependency of module.implicitlyLoadedBefore) {
+                dynamicImports.add(dependency);
+            }
+            for (const { resolution } of module.dynamicImports) {
+                if (resolution instanceof Module) {
+                    dynamicImports.add(resolution);
+                }
+            }
+            orderedModules.push(module);
+        }
+        module.execIndex = nextExecIndex++;
+        analysedModules.add(module);
+    };
+    for (const currentEntry of entryModules) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
+        }
+    }
+    for (const currentEntry of dynamicImports) {
+        if (!parents.has(currentEntry)) {
+            parents.set(currentEntry, null);
+            analyseModule(currentEntry);
+        }
+    }
+    return { cyclePaths, orderedModules };
+}
+function getCyclePath(module, parent, parents) {
+    const cycleSymbol = Symbol(module.id);
+    const path = [module.id];
+    let nextModule = parent;
+    module.cycles.add(cycleSymbol);
+    while (nextModule !== module) {
+        nextModule.cycles.add(cycleSymbol);
+        path.push(nextModule.id);
+        nextModule = parents.get(nextModule);
+    }
+    path.push(path[0]);
+    path.reverse();
+    return path;
+}
+
+function getGenerateCodeSnippets({ compact, generatedCode: { arrowFunctions, constBindings, objectShorthand, reservedNamesAsProps } }) {
+    const { _, n, s } = compact ? { _: '', n: '', s: '' } : { _: ' ', n: '\n', s: ';' };
+    const cnst = constBindings ? 'const' : 'var';
+    const getNonArrowFunctionIntro = (parameters, { isAsync, name }) => `${isAsync ? `async ` : ''}function${name ? ` ${name}` : ''}${_}(${parameters.join(`,${_}`)})${_}`;
+    const getFunctionIntro = arrowFunctions
+        ? (parameters, { isAsync, name }) => {
+            const singleParameter = parameters.length === 1;
+            const asyncString = isAsync ? `async${singleParameter ? ' ' : _}` : '';
+            return `${name ? `${cnst} ${name}${_}=${_}` : ''}${asyncString}${singleParameter ? parameters[0] : `(${parameters.join(`,${_}`)})`}${_}=>${_}`;
+        }
+        : getNonArrowFunctionIntro;
+    const getDirectReturnFunction = (parameters, { functionReturn, lineBreakIndent, name }) => [
+        `${getFunctionIntro(parameters, {
+            isAsync: false,
+            name
+        })}${arrowFunctions
+            ? lineBreakIndent
+                ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}`
+                : ''
+            : `{${lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _}${functionReturn ? 'return ' : ''}`}`,
+        arrowFunctions
+            ? `${name ? ';' : ''}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : ''}`
+            : `${s}${lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`
+    ];
+    const isValidPropertyName = reservedNamesAsProps
+        ? (name) => VALID_IDENTIFIER_REGEXP.test(name)
+        : (name) => !RESERVED_NAMES.has(name) && VALID_IDENTIFIER_REGEXP.test(name);
+    return {
+        _,
+        cnst,
+        getDirectReturnFunction,
+        getDirectReturnIifeLeft: (parameters, returned, { needsArrowReturnParens, needsWrappedFunction }) => {
+            const [left, right] = getDirectReturnFunction(parameters, {
+                functionReturn: true,
+                lineBreakIndent: null,
+                name: null
+            });
+            return `${wrapIfNeeded(`${left}${wrapIfNeeded(returned, arrowFunctions && needsArrowReturnParens)}${right}`, arrowFunctions || needsWrappedFunction)}(`;
+        },
+        getFunctionIntro,
+        getNonArrowFunctionIntro,
+        getObject(fields, { lineBreakIndent }) {
+            const prefix = lineBreakIndent ? `${n}${lineBreakIndent.base}${lineBreakIndent.t}` : _;
+            return `{${fields
+                .map(([key, value]) => {
+                if (key === null)
+                    return `${prefix}${value}`;
+                const keyInObject = stringifyObjectKeyIfNeeded(key);
+                return key === value && objectShorthand && key === keyInObject
+                    ? prefix + key
+                    : `${prefix}${keyInObject}:${_}${value}`;
+            })
+                .join(`,`)}${fields.length === 0 ? '' : lineBreakIndent ? `${n}${lineBreakIndent.base}` : _}}`;
+        },
+        getPropertyAccess: (name) => isValidPropertyName(name) ? `.${name}` : `[${JSON.stringify(name)}]`,
+        n,
+        s
+    };
+}
+const wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
+
+class Source {
+    constructor(filename, content) {
+        this.isOriginal = true;
+        this.filename = filename;
+        this.content = content;
+    }
+    traceSegment(line, column, name) {
+        return { column, line, name, source: this };
+    }
+}
+class Link {
+    constructor(map, sources) {
+        this.sources = sources;
+        this.names = map.names;
+        this.mappings = map.mappings;
+    }
+    traceMappings() {
+        const sources = [];
+        const sourceIndexMap = new Map();
+        const sourcesContent = [];
+        const names = [];
+        const nameIndexMap = new Map();
+        const mappings = [];
+        for (const line of this.mappings) {
+            const tracedLine = [];
+            for (const segment of line) {
+                if (segment.length === 1)
+                    continue;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    continue;
+                const traced = source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : '');
+                if (traced) {
+                    const { column, line, name, source: { content, filename } } = traced;
+                    let sourceIndex = sourceIndexMap.get(filename);
+                    if (sourceIndex === undefined) {
+                        sourceIndex = sources.length;
+                        sources.push(filename);
+                        sourceIndexMap.set(filename, sourceIndex);
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (sourcesContent[sourceIndex] == null) {
+                        sourcesContent[sourceIndex] = content;
+                    }
+                    else if (content != null && sourcesContent[sourceIndex] !== content) {
+                        return parseAst_js.error(parseAst_js.logConflictingSourcemapSources(filename));
+                    }
+                    const tracedSegment = [segment[0], sourceIndex, line, column];
+                    if (name) {
+                        let nameIndex = nameIndexMap.get(name);
+                        if (nameIndex === undefined) {
+                            nameIndex = names.length;
+                            names.push(name);
+                            nameIndexMap.set(name, nameIndex);
+                        }
+                        tracedSegment[4] = nameIndex;
+                    }
+                    tracedLine.push(tracedSegment);
+                }
+            }
+            mappings.push(tracedLine);
+        }
+        return { mappings, names, sources, sourcesContent };
+    }
+    traceSegment(line, column, name) {
+        const segments = this.mappings[line];
+        if (!segments)
+            return null;
+        // binary search through segments for the given column
+        let searchStart = 0;
+        let searchEnd = segments.length - 1;
+        while (searchStart <= searchEnd) {
+            const m = (searchStart + searchEnd) >> 1;
+            const segment = segments[m];
+            // If a sourcemap does not have sufficient resolution to contain a
+            // necessary mapping, e.g. because it only contains line information, we
+            // use the best approximation we could find
+            if (segment[0] === column || searchStart === searchEnd) {
+                if (segment.length == 1)
+                    return null;
+                const source = this.sources[segment[1]];
+                if (!source)
+                    return null;
+                return source.traceSegment(segment[2], segment[3], segment.length === 5 ? this.names[segment[4]] : name);
+            }
+            if (segment[0] > column) {
+                searchEnd = m - 1;
+            }
+            else {
+                searchStart = m + 1;
+            }
+        }
+        return null;
+    }
+}
+function getLinkMap(log) {
+    return function linkMap(source, map) {
+        if (!map.missing) {
+            return new Link(map, [source]);
+        }
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logSourcemapBroken(map.plugin));
+        return new Link({
+            mappings: [],
+            names: []
+        }, [source]);
+    };
+}
+function getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, linkMap) {
+    let source;
+    if (originalSourcemap) {
+        const sources = originalSourcemap.sources;
+        const sourcesContent = originalSourcemap.sourcesContent || [];
+        const directory = path.dirname(id) || '.';
+        const sourceRoot = originalSourcemap.sourceRoot || '.';
+        const baseSources = sources.map((source, index) => new Source(path.resolve(directory, sourceRoot, source), sourcesContent[index]));
+        source = new Link(originalSourcemap, baseSources);
+    }
+    else {
+        source = new Source(id, originalCode);
+    }
+    return sourcemapChain.reduce(linkMap, source);
+}
+function collapseSourcemaps(file, map, modules, bundleSourcemapChain, excludeContent, log) {
+    const linkMap = getLinkMap(log);
+    const moduleSources = modules
+        .filter(module => !module.excludeFromSourcemap)
+        .map(module => getCollapsedSourcemap(module.id, module.originalCode, module.originalSourcemap, module.sourcemapChain, linkMap));
+    const link = new Link(map, moduleSources);
+    const source = bundleSourcemapChain.reduce(linkMap, link);
+    let { sources, sourcesContent, names, mappings } = source.traceMappings();
+    if (file) {
+        const directory = path.dirname(file);
+        sources = sources.map((source) => path.relative(directory, source));
+        file = path.basename(file);
+    }
+    sourcesContent = (excludeContent ? null : sourcesContent);
+    for (const module of modules) {
+        resetSourcemapCache(module.originalSourcemap, module.sourcemapChain);
+    }
+    return new SourceMap({ file, mappings, names, sources, sourcesContent });
+}
+function collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log) {
+    if (sourcemapChain.length === 0) {
+        return originalSourcemap;
+    }
+    const source = getCollapsedSourcemap(id, originalCode, originalSourcemap, sourcemapChain, getLinkMap(log));
+    const map = source.traceMappings();
+    return decodedSourcemap({ version: 3, ...map });
+}
+
+// this looks ridiculous, but it prevents sourcemap tooling from mistaking
+// this for an actual sourceMappingURL
+let SOURCEMAPPING_URL = 'sourceMa';
+SOURCEMAPPING_URL += 'ppingURL';
+
+async function renderChunks(chunks, bundle, pluginDriver, outputOptions, log) {
+    timeStart('render chunks', 2);
+    reserveEntryChunksInBundle(chunks);
+    const renderedChunks = await Promise.all(chunks.map(chunk => chunk.render()));
+    timeEnd('render chunks', 2);
+    timeStart('transform chunks', 2);
+    const getHash = hasherByType[outputOptions.hashCharacters];
+    const chunkGraph = getChunkGraph(chunks);
+    const { hashDependenciesByPlaceholder, initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, placeholders, renderedChunksByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
+    const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash);
+    addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
+    timeEnd('transform chunks', 2);
+}
+function reserveEntryChunksInBundle(chunks) {
+    for (const chunk of chunks) {
+        if (chunk.facadeModule && chunk.facadeModule.isUserDefinedEntryPoint) {
+            // reserves name in bundle as side effect if it does not contain a hash
+            chunk.getPreliminaryFileName();
+        }
+    }
+}
+function getChunkGraph(chunks) {
+    return Object.fromEntries(chunks.map(chunk => {
+        const renderedChunkInfo = chunk.getRenderedChunkInfo();
+        return [renderedChunkInfo.fileName, renderedChunkInfo];
+    }));
+}
+async function transformChunk(magicString, fileName, usedModules, chunkGraph, options, outputPluginDriver, log) {
+    let map = null;
+    const sourcemapChain = [];
+    let code = await outputPluginDriver.hookReduceArg0('renderChunk', [magicString.toString(), chunkGraph[fileName], options, { chunks: chunkGraph }], (code, result, plugin) => {
+        if (result == null)
+            return code;
+        if (typeof result === 'string')
+            result = {
+                code: result,
+                map: undefined
+            };
+        // strict null check allows 'null' maps to not be pushed to the chain, while 'undefined' gets the missing map warning
+        if (result.map !== null) {
+            const map = decodedSourcemap(result.map);
+            sourcemapChain.push(map || { missing: true, plugin: plugin.name });
+        }
+        return result.code;
+    });
+    const { compact, dir, file, sourcemap, sourcemapExcludeSources, sourcemapFile, sourcemapPathTransform, sourcemapIgnoreList } = options;
+    if (!compact && code[code.length - 1] !== '\n')
+        code += '\n';
+    if (sourcemap) {
+        timeStart('sourcemaps', 3);
+        let resultingFile;
+        if (file)
+            resultingFile = path.resolve(sourcemapFile || file);
+        else if (dir)
+            resultingFile = path.resolve(dir, fileName);
+        else
+            resultingFile = path.resolve(fileName);
+        const decodedMap = magicString.generateDecodedMap({});
+        map = collapseSourcemaps(resultingFile, decodedMap, usedModules, sourcemapChain, sourcemapExcludeSources, log);
+        for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
+            let sourcePath = map.sources[sourcesIndex];
+            const sourcemapPath = `${resultingFile}.map`;
+            const ignoreList = sourcemapIgnoreList(sourcePath, sourcemapPath);
+            if (typeof ignoreList !== 'boolean') {
+                parseAst_js.error(parseAst_js.logFailedValidation('sourcemapIgnoreList function must return a boolean.'));
+            }
+            if (ignoreList) {
+                if (map.x_google_ignoreList === undefined) {
+                    map.x_google_ignoreList = [];
+                }
+                if (!map.x_google_ignoreList.includes(sourcesIndex)) {
+                    map.x_google_ignoreList.push(sourcesIndex);
+                }
+            }
+            if (sourcemapPathTransform) {
+                sourcePath = sourcemapPathTransform(sourcePath, sourcemapPath);
+                if (typeof sourcePath !== 'string') {
+                    parseAst_js.error(parseAst_js.logFailedValidation(`sourcemapPathTransform function must return a string.`));
+                }
+            }
+            map.sources[sourcesIndex] = parseAst_js.normalize(sourcePath);
+        }
+        timeEnd('sourcemaps', 3);
+    }
+    return {
+        code,
+        map
+    };
+}
+async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log) {
+    const nonHashedChunksWithPlaceholders = [];
+    const renderedChunksByPlaceholder = new Map();
+    const hashDependenciesByPlaceholder = new Map();
+    const initialHashesByPlaceholder = new Map();
+    const placeholders = new Set();
+    for (const { preliminaryFileName: { hashPlaceholder } } of renderedChunks) {
+        if (hashPlaceholder)
+            placeholders.add(hashPlaceholder);
+    }
+    await Promise.all(renderedChunks.map(async ({ chunk, preliminaryFileName: { fileName, hashPlaceholder }, preliminarySourcemapFileName, magicString, usedModules }) => {
+        const transformedChunk = {
+            chunk,
+            fileName,
+            sourcemapFileName: preliminarySourcemapFileName?.fileName ?? null,
+            ...(await transformChunk(magicString, fileName, usedModules, chunkGraph, outputOptions, pluginDriver, log))
+        };
+        const { code, map } = transformedChunk;
+        if (hashPlaceholder) {
+            // To create a reproducible content-only hash, all placeholders are
+            // replaced with the same value before hashing
+            const { containedPlaceholders, transformedCode } = replacePlaceholdersWithDefaultAndGetContainedPlaceholders(code, placeholders);
+            let contentToHash = transformedCode;
+            const hashAugmentation = pluginDriver.hookReduceValueSync('augmentChunkHash', '', [chunk.getRenderedChunkInfo()], (augmentation, pluginHash) => {
+                if (pluginHash) {
+                    augmentation += pluginHash;
+                }
+                return augmentation;
+            });
+            if (hashAugmentation) {
+                contentToHash += hashAugmentation;
+            }
+            renderedChunksByPlaceholder.set(hashPlaceholder, transformedChunk);
+            hashDependenciesByPlaceholder.set(hashPlaceholder, {
+                containedPlaceholders,
+                contentHash: getHash(contentToHash)
+            });
+        }
+        else {
+            nonHashedChunksWithPlaceholders.push(transformedChunk);
+        }
+        const sourcemapHashPlaceholder = preliminarySourcemapFileName?.hashPlaceholder;
+        if (map && sourcemapHashPlaceholder) {
+            initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getHash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
+        }
+    }));
+    return {
+        hashDependenciesByPlaceholder,
+        initialHashesByPlaceholder,
+        nonHashedChunksWithPlaceholders,
+        placeholders,
+        renderedChunksByPlaceholder
+    };
+}
+function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, placeholders, bundle, getHash) {
+    const hashesByPlaceholder = new Map(initialHashesByPlaceholder);
+    for (const placeholder of placeholders) {
+        const { fileName } = renderedChunksByPlaceholder.get(placeholder);
+        let contentToHash = '';
+        const hashDependencyPlaceholders = new Set([placeholder]);
+        for (const dependencyPlaceholder of hashDependencyPlaceholders) {
+            const { containedPlaceholders, contentHash } = hashDependenciesByPlaceholder.get(dependencyPlaceholder);
+            contentToHash += contentHash;
+            for (const containedPlaceholder of containedPlaceholders) {
+                // When looping over a map, setting an entry only causes a new iteration if the key is new
+                hashDependencyPlaceholders.add(containedPlaceholder);
+            }
+        }
+        let finalFileName;
+        let finalHash;
+        do {
+            // In case of a hash collision, create a hash of the hash
+            if (finalHash) {
+                contentToHash = finalHash;
+            }
+            finalHash = getHash(contentToHash).slice(0, placeholder.length);
+            finalFileName = replaceSinglePlaceholder(fileName, placeholder, finalHash);
+        } while (bundle[lowercaseBundleKeys].has(finalFileName.toLowerCase()));
+        bundle[finalFileName] = FILE_PLACEHOLDER;
+        hashesByPlaceholder.set(placeholder, finalHash);
+    }
+    return hashesByPlaceholder;
+}
+function addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, options) {
+    for (const { chunk, code, fileName, sourcemapFileName, map } of renderedChunksByPlaceholder.values()) {
+        let updatedCode = replacePlaceholders(code, hashesByPlaceholder);
+        const finalFileName = replacePlaceholders(fileName, hashesByPlaceholder);
+        let finalSourcemapFileName = null;
+        if (map) {
+            finalSourcemapFileName = sourcemapFileName
+                ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
+                : `${finalFileName}.map`;
+            map.file = replacePlaceholders(map.file, hashesByPlaceholder);
+            updatedCode += emitSourceMapAndGetComment(finalSourcemapFileName, map, pluginDriver, options);
+        }
+        bundle[finalFileName] = chunk.finalizeChunk(updatedCode, map, finalSourcemapFileName, hashesByPlaceholder);
+    }
+    for (const { chunk, code, fileName, sourcemapFileName, map } of nonHashedChunksWithPlaceholders) {
+        let updatedCode = hashesByPlaceholder.size > 0 ? replacePlaceholders(code, hashesByPlaceholder) : code;
+        let finalSourcemapFileName = null;
+        if (map) {
+            finalSourcemapFileName = sourcemapFileName
+                ? replacePlaceholders(sourcemapFileName, hashesByPlaceholder)
+                : `${fileName}.map`;
+            updatedCode += emitSourceMapAndGetComment(finalSourcemapFileName, map, pluginDriver, options);
+        }
+        bundle[fileName] = chunk.finalizeChunk(updatedCode, map, finalSourcemapFileName, hashesByPlaceholder);
+    }
+}
+function emitSourceMapAndGetComment(fileName, map, pluginDriver, { sourcemap, sourcemapBaseUrl }) {
+    let url;
+    if (sourcemap === 'inline') {
+        url = map.toUrl();
+    }
+    else {
+        const sourcemapFileName = path.basename(fileName);
+        url = sourcemapBaseUrl
+            ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
+            : sourcemapFileName;
+        pluginDriver.emitFile({
+            fileName,
+            originalFileName: null,
+            source: map.toString(),
+            type: 'asset'
+        });
+    }
+    return sourcemap === 'hidden' ? '' : `//# ${SOURCEMAPPING_URL}=${url}\n`;
+}
+
+class Bundle {
+    constructor(outputOptions, unsetOptions, inputOptions, pluginDriver, graph) {
+        this.outputOptions = outputOptions;
+        this.unsetOptions = unsetOptions;
+        this.inputOptions = inputOptions;
+        this.pluginDriver = pluginDriver;
+        this.graph = graph;
+        this.facadeChunkByModule = new Map();
+        this.includedNamespaces = new Set();
+    }
+    async generate(isWrite) {
+        timeStart('GENERATE', 1);
+        const outputBundleBase = Object.create(null);
+        const outputBundle = getOutputBundle(outputBundleBase);
+        this.pluginDriver.setOutputBundle(outputBundle, this.outputOptions);
+        try {
+            timeStart('initialize render', 2);
+            await this.pluginDriver.hookParallel('renderStart', [this.outputOptions, this.inputOptions]);
+            timeEnd('initialize render', 2);
+            timeStart('generate chunks', 2);
+            const getHashPlaceholder = getHashPlaceholderGenerator();
+            const chunks = await this.generateChunks(outputBundle, getHashPlaceholder);
+            if (chunks.length > 1) {
+                validateOptionsForMultiChunkOutput(this.outputOptions, this.inputOptions.onLog);
+            }
+            this.pluginDriver.setChunkInformation(this.facadeChunkByModule);
+            for (const chunk of chunks) {
+                chunk.generateExports();
+            }
+            timeEnd('generate chunks', 2);
+            await renderChunks(chunks, outputBundle, this.pluginDriver, this.outputOptions, this.inputOptions.onLog);
+        }
+        catch (error_) {
+            await this.pluginDriver.hookParallel('renderError', [error_]);
+            throw error_;
+        }
+        removeUnreferencedAssets(outputBundle);
+        timeStart('generate bundle', 2);
+        await this.pluginDriver.hookSeq('generateBundle', [
+            this.outputOptions,
+            outputBundle,
+            isWrite
+        ]);
+        this.finaliseAssets(outputBundle);
+        timeEnd('generate bundle', 2);
+        timeEnd('GENERATE', 1);
+        return outputBundleBase;
+    }
+    async addManualChunks(manualChunks) {
+        const manualChunkAliasByEntry = new Map();
+        const chunkEntries = await Promise.all(Object.entries(manualChunks).map(async ([alias, files]) => ({
+            alias,
+            entries: await this.graph.moduleLoader.addAdditionalModules(files, true)
+        })));
+        for (const { alias, entries } of chunkEntries) {
+            for (const entry of entries) {
+                addModuleToManualChunk(alias, entry, manualChunkAliasByEntry);
+            }
+        }
+        return manualChunkAliasByEntry;
+    }
+    assignManualChunks(getManualChunk) {
+        const manualChunkAliasesWithEntry = [];
+        const manualChunksApi = {
+            getModuleIds: () => this.graph.modulesById.keys(),
+            getModuleInfo: this.graph.getModuleInfo
+        };
+        for (const module of this.graph.modulesById.values()) {
+            if (module instanceof Module) {
+                const manualChunkAlias = getManualChunk(module.id, manualChunksApi);
+                if (typeof manualChunkAlias === 'string') {
+                    manualChunkAliasesWithEntry.push([manualChunkAlias, module]);
+                }
+            }
+        }
+        manualChunkAliasesWithEntry.sort(([aliasA], [aliasB]) => aliasA > aliasB ? 1 : aliasA < aliasB ? -1 : 0);
+        const manualChunkAliasByEntry = new Map();
+        for (const [alias, module] of manualChunkAliasesWithEntry) {
+            addModuleToManualChunk(alias, module, manualChunkAliasByEntry);
+        }
+        return manualChunkAliasByEntry;
+    }
+    finaliseAssets(bundle) {
+        if (this.outputOptions.validate) {
+            for (const file of Object.values(bundle)) {
+                if ('code' in file) {
+                    try {
+                        parseAst_js.parseAst(file.code, { jsx: this.inputOptions.jsx !== false });
+                    }
+                    catch (error_) {
+                        this.inputOptions.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logChunkInvalid(file, error_));
+                    }
+                }
+            }
+        }
+        this.pluginDriver.finaliseAssets();
+    }
+    async generateChunks(bundle, getHashPlaceholder) {
+        const { experimentalMinChunkSize, inlineDynamicImports, manualChunks, preserveModules } = this.outputOptions;
+        const manualChunkAliasByEntry = typeof manualChunks === 'object'
+            ? await this.addManualChunks(manualChunks)
+            : this.assignManualChunks(manualChunks);
+        const snippets = getGenerateCodeSnippets(this.outputOptions);
+        const includedModules = getIncludedModules(this.graph.modulesById);
+        const inputBase = commondir(getAbsoluteEntryModulePaths(includedModules, preserveModules));
+        const externalChunkByModule = getExternalChunkByModule(this.graph.modulesById, this.outputOptions, inputBase);
+        const chunks = [];
+        const chunkByModule = new Map();
+        for (const { alias, modules } of inlineDynamicImports
+            ? [{ alias: null, modules: includedModules }]
+            : preserveModules
+                ? includedModules.map(module => ({ alias: null, modules: [module] }))
+                : getChunkAssignments(this.graph.entryModules, manualChunkAliasByEntry, experimentalMinChunkSize, this.inputOptions.onLog)) {
+            sortByExecutionOrder(modules);
+            const chunk = new Chunk(modules, this.inputOptions, this.outputOptions, this.unsetOptions, this.pluginDriver, this.graph.modulesById, chunkByModule, externalChunkByModule, this.facadeChunkByModule, this.includedNamespaces, alias, getHashPlaceholder, bundle, inputBase, snippets);
+            chunks.push(chunk);
+        }
+        for (const chunk of chunks) {
+            chunk.link();
+        }
+        const facades = [];
+        for (const chunk of chunks) {
+            facades.push(...chunk.generateFacades());
+        }
+        return [...chunks, ...facades];
+    }
+}
+function validateOptionsForMultiChunkOutput(outputOptions, log) {
+    if (outputOptions.format === 'umd' || outputOptions.format === 'iife')
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.format', parseAst_js.URL_OUTPUT_FORMAT, 'UMD and IIFE output formats are not supported for code-splitting builds', outputOptions.format));
+    if (typeof outputOptions.file === 'string')
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.file', parseAst_js.URL_OUTPUT_DIR, 'when building multiple chunks, the "output.dir" option must be used, not "output.file". To inline dynamic imports, set the "inlineDynamicImports" option'));
+    if (outputOptions.sourcemapFile)
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.sourcemapFile', parseAst_js.URL_OUTPUT_SOURCEMAPFILE, '"output.sourcemapFile" is only supported for single-file builds'));
+    if (!outputOptions.amd.autoId && outputOptions.amd.id)
+        log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInvalidOption('output.amd.id', parseAst_js.URL_OUTPUT_AMD_ID, 'this option is only properly supported for single-file builds. Use "output.amd.autoId" and "output.amd.basePath" instead'));
+}
+function getIncludedModules(modulesById) {
+    const includedModules = [];
+    for (const module of modulesById.values()) {
+        if (module instanceof Module &&
+            (module.isIncluded() || module.info.isEntry || module.includedDynamicImporters.length > 0)) {
+            includedModules.push(module);
+        }
+    }
+    return includedModules;
+}
+function getAbsoluteEntryModulePaths(includedModules, preserveModules) {
+    const absoluteEntryModulePaths = [];
+    for (const module of includedModules) {
+        if ((module.info.isEntry || preserveModules) && parseAst_js.isAbsolute(module.id)) {
+            absoluteEntryModulePaths.push(module.id);
+        }
+    }
+    return absoluteEntryModulePaths;
+}
+function getExternalChunkByModule(modulesById, outputOptions, inputBase) {
+    const externalChunkByModule = new Map();
+    for (const module of modulesById.values()) {
+        if (module instanceof ExternalModule) {
+            externalChunkByModule.set(module, new ExternalChunk(module, outputOptions, inputBase));
+        }
+    }
+    return externalChunkByModule;
+}
+function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
+    const existingAlias = manualChunkAliasByEntry.get(module);
+    if (typeof existingAlias === 'string' && existingAlias !== alias) {
+        return parseAst_js.error(parseAst_js.logCannotAssignModuleToChunk(module.id, alias, existingAlias));
+    }
+    manualChunkAliasByEntry.set(module, alias);
+}
+
+function flru (max) {
+	var num, curr, prev;
+	var limit = max;
+
+	function keep(key, value) {
+		if (++num > limit) {
+			prev = curr;
+			reset(1);
+			++num;
+		}
+		curr[key] = value;
+	}
+
+	function reset(isPartial) {
+		num = 0;
+		curr = Object.create(null);
+		isPartial || (prev=Object.create(null));
+	}
+
+	reset();
+
+	return {
+		clear: reset,
+		has: function (key) {
+			return curr[key] !== void 0 || prev[key] !== void 0;
+		},
+		get: function (key) {
+			var val = curr[key];
+			if (val !== void 0) return val;
+			if ((val=prev[key]) !== void 0) {
+				keep(key, val);
+				return val;
+			}
+		},
+		set: function (key, value) {
+			if (curr[key] !== void 0) {
+				curr[key] = value;
+			} else {
+				keep(key, value);
+			}
+		}
+	};
+}
+
+class GlobalScope extends Scope {
+    constructor() {
+        super();
+        this.parent = null;
+        this.variables.set('undefined', new UndefinedVariable());
+    }
+    findVariable(name) {
+        let variable = this.variables.get(name);
+        if (!variable) {
+            variable = new GlobalVariable(name);
+            this.variables.set(name, variable);
+        }
+        return variable;
+    }
+}
+
+function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
+    let skipped = null;
+    let replaceContext = null;
+    if (skip) {
+        skipped = new Set();
+        for (const skippedCall of skip) {
+            if (source === skippedCall.source && importer === skippedCall.importer) {
+                skipped.add(skippedCall.plugin);
+            }
+        }
+        replaceContext = (pluginContext, plugin) => ({
+            ...pluginContext,
+            resolve: (source, importer, { attributes, custom, isEntry, skipSelf } = parseAst_js.BLANK) => {
+                skipSelf ??= true;
+                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || parseAst_js.EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip);
+            }
+        });
+    }
+    return pluginDriver.hookFirstAndGetPlugin('resolveId', [source, importer, { attributes, custom: customOptions, isEntry }], replaceContext, skipped);
+}
+
+async function resolveId(source, importer, preserveSymlinks, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
+    const pluginResult = await resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes);
+    if (pluginResult != null) {
+        const [resolveIdResult, plugin] = pluginResult;
+        if (typeof resolveIdResult === 'object' && !resolveIdResult.resolvedBy) {
+            return {
+                ...resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        if (typeof resolveIdResult === 'string') {
+            return {
+                id: resolveIdResult,
+                resolvedBy: plugin.name
+            };
+        }
+        return resolveIdResult;
+    }
+    // external modules (non-entry modules that start with neither '.' or '/')
+    // are skipped at this stage.
+    if (importer !== undefined && !parseAst_js.isAbsolute(source) && source[0] !== '.')
+        return null;
+    // `resolve` processes paths from right to left, prepending them until an
+    // absolute path is created. Absolute importees therefore shortcircuit the
+    // resolve call and require no special handing on our part.
+    // See https://nodejs.org/api/path.html#path_path_resolve_paths
+    return addJsExtensionIfNecessary(importer ? path.resolve(path.dirname(importer), source) : path.resolve(source), preserveSymlinks);
+}
+async function addJsExtensionIfNecessary(file, preserveSymlinks) {
+    return ((await findFile(file, preserveSymlinks)) ??
+        (await findFile(file + '.mjs', preserveSymlinks)) ??
+        (await findFile(file + '.js', preserveSymlinks)));
+}
+async function findFile(file, preserveSymlinks) {
+    try {
+        const stats = await promises.lstat(file);
+        if (!preserveSymlinks && stats.isSymbolicLink())
+            return await findFile(await promises.realpath(file), preserveSymlinks);
+        if ((preserveSymlinks && stats.isSymbolicLink()) || stats.isFile()) {
+            // check case
+            const name = path.basename(file);
+            const files = await promises.readdir(path.dirname(file));
+            if (files.includes(name))
+                return file;
+        }
+    }
+    catch {
+        // suppress
+    }
+}
+
+async function transform(source, module, pluginDriver, log) {
+    const id = module.id;
+    const sourcemapChain = [];
+    let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
+    const originalCode = source.code;
+    let ast = source.ast;
+    const transformDependencies = [];
+    const emittedFiles = [];
+    let customTransformCache = false;
+    const useCustomTransformCache = () => (customTransformCache = true);
+    let pluginName = '';
+    let currentSource = source.code;
+    function transformReducer(previousCode, result, plugin) {
+        let code;
+        let map;
+        if (typeof result === 'string') {
+            code = result;
+        }
+        else if (result && typeof result === 'object') {
+            module.updateOptions(result);
+            if (result.code == null) {
+                if (result.map || result.ast) {
+                    log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logNoTransformMapOrAstWithoutCode(plugin.name));
+                }
+                return previousCode;
+            }
+            ({ code, map, ast } = result);
+        }
+        else {
+            return previousCode;
+        }
+        // strict null check allows 'null' maps to not be pushed to the chain,
+        // while 'undefined' gets the missing map warning
+        if (map !== null) {
+            sourcemapChain.push(decodedSourcemap(typeof map === 'string' ? JSON.parse(map) : map) || {
+                missing: true,
+                plugin: plugin.name
+            });
+        }
+        currentSource = code;
+        return code;
+    }
+    const getLogHandler = (handler) => (log, pos) => {
+        log = normalizeLog(log);
+        if (pos)
+            parseAst_js.augmentCodeLocation(log, pos, currentSource, id);
+        log.id = id;
+        log.hook = 'transform';
+        handler(log);
+    };
+    let code;
+    try {
+        code = await pluginDriver.hookReduceArg0('transform', [currentSource, id], transformReducer, (pluginContext, plugin) => {
+            pluginName = plugin.name;
+            return {
+                ...pluginContext,
+                addWatchFile(id) {
+                    transformDependencies.push(id);
+                    pluginContext.addWatchFile(id);
+                },
+                cache: customTransformCache
+                    ? pluginContext.cache
+                    : getTrackedPluginCache(pluginContext.cache, useCustomTransformCache),
+                debug: getLogHandler(pluginContext.debug),
+                emitFile(emittedFile) {
+                    emittedFiles.push(emittedFile);
+                    return pluginDriver.emitFile(emittedFile);
+                },
+                error(error_, pos) {
+                    if (typeof error_ === 'string')
+                        error_ = { message: error_ };
+                    if (pos)
+                        parseAst_js.augmentCodeLocation(error_, pos, currentSource, id);
+                    error_.id = id;
+                    error_.hook = 'transform';
+                    return pluginContext.error(error_);
+                },
+                getCombinedSourcemap() {
+                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log);
+                    if (!combinedMap) {
+                        const magicString = new MagicString(originalCode);
+                        return magicString.generateMap({ hires: true, includeContent: true, source: id });
+                    }
+                    if (originalSourcemap !== combinedMap) {
+                        originalSourcemap = combinedMap;
+                        sourcemapChain.length = 0;
+                    }
+                    return new SourceMap({
+                        ...combinedMap,
+                        file: null,
+                        sourcesContent: combinedMap.sourcesContent
+                    });
+                },
+                info: getLogHandler(pluginContext.info),
+                setAssetSource() {
+                    return this.error(parseAst_js.logInvalidSetAssetSourceCall());
+                },
+                warn: getLogHandler(pluginContext.warn)
+            };
+        });
+    }
+    catch (error_) {
+        return parseAst_js.error(parseAst_js.logPluginError(error_, pluginName, { hook: 'transform', id }));
+    }
+    if (!customTransformCache && // files emitted by a transform hook need to be emitted again if the hook is skipped
+        emittedFiles.length > 0)
+        module.transformFiles = emittedFiles;
+    return {
+        ast,
+        code,
+        customTransformCache,
+        originalCode,
+        originalSourcemap,
+        sourcemapChain,
+        transformDependencies
+    };
+}
+
+const RESOLVE_DEPENDENCIES = 'resolveDependencies';
+class ModuleLoader {
+    constructor(graph, modulesById, options, pluginDriver) {
+        this.graph = graph;
+        this.modulesById = modulesById;
+        this.options = options;
+        this.pluginDriver = pluginDriver;
+        this.implicitEntryModules = new Set();
+        this.indexedEntryModules = [];
+        this.latestLoadModulesPromise = Promise.resolve();
+        this.moduleLoadPromises = new Map();
+        this.modulesWithLoadedDependencies = new Set();
+        this.nextChunkNamePriority = 0;
+        this.nextEntryModuleIndex = 0;
+        this.resolveId = async (source, importer, customOptions, isEntry, attributes, skip = null) => this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
+            ? false
+            : await resolveId(source, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, skip, customOptions, typeof isEntry === 'boolean' ? isEntry : !importer, attributes), importer, source), attributes);
+        this.hasModuleSideEffects = options.treeshake
+            ? options.treeshake.moduleSideEffects
+            : () => true;
+    }
+    async addAdditionalModules(unresolvedModules, isAddForManualChunks) {
+        const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null, isAddForManualChunks))));
+        await this.awaitLoadModulesPromise();
+        return result;
+    }
+    async addEntryModules(unresolvedEntryModules, isUserDefined) {
+        const firstEntryModuleIndex = this.nextEntryModuleIndex;
+        this.nextEntryModuleIndex += unresolvedEntryModules.length;
+        const firstChunkNamePriority = this.nextChunkNamePriority;
+        this.nextChunkNamePriority += unresolvedEntryModules.length;
+        const newEntryModules = await this.extendLoadModulesPromise(Promise.all(unresolvedEntryModules.map(({ id, importer }) => this.loadEntryModule(id, true, importer, null))).then(entryModules => {
+            for (const [index, entryModule] of entryModules.entries()) {
+                entryModule.isUserDefinedEntryPoint =
+                    entryModule.isUserDefinedEntryPoint || isUserDefined;
+                addChunkNamesToModule(entryModule, unresolvedEntryModules[index], isUserDefined, firstChunkNamePriority + index);
+                const existingIndexedModule = this.indexedEntryModules.find(indexedModule => indexedModule.module === entryModule);
+                if (existingIndexedModule) {
+                    existingIndexedModule.index = Math.min(existingIndexedModule.index, firstEntryModuleIndex + index);
+                }
+                else {
+                    this.indexedEntryModules.push({
+                        index: firstEntryModuleIndex + index,
+                        module: entryModule
+                    });
+                }
+            }
+            this.indexedEntryModules.sort(({ index: indexA }, { index: indexB }) => indexA > indexB ? 1 : -1);
+            return entryModules;
+        }));
+        await this.awaitLoadModulesPromise();
+        return {
+            entryModules: this.indexedEntryModules.map(({ module }) => module),
+            implicitEntryModules: [...this.implicitEntryModules],
+            newEntryModules
+        };
+    }
+    async emitChunk({ fileName, id, importer, name, implicitlyLoadedAfterOneOf, preserveSignature }) {
+        const unresolvedModule = {
+            fileName: fileName || null,
+            id,
+            importer,
+            name: name || null
+        };
+        const module = implicitlyLoadedAfterOneOf
+            ? await this.addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfterOneOf)
+            : (await this.addEntryModules([unresolvedModule], false)).newEntryModules[0];
+        if (preserveSignature != null) {
+            module.preserveSignature = preserveSignature;
+        }
+        return module;
+    }
+    async preloadModule(resolvedId) {
+        const module = await this.fetchModule(this.getResolvedIdWithDefaults(resolvedId, parseAst_js.EMPTY_OBJECT), undefined, false, resolvedId.resolveDependencies ? RESOLVE_DEPENDENCIES : true);
+        return module.info;
+    }
+    addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfter) {
+        const chunkNamePriority = this.nextChunkNamePriority++;
+        return this.extendLoadModulesPromise(this.loadEntryModule(unresolvedModule.id, false, unresolvedModule.importer, null).then(async (entryModule) => {
+            addChunkNamesToModule(entryModule, unresolvedModule, false, chunkNamePriority);
+            if (!entryModule.info.isEntry) {
+                const implicitlyLoadedAfterModules = await Promise.all(implicitlyLoadedAfter.map(id => this.loadEntryModule(id, false, unresolvedModule.importer, entryModule.id)));
+                // We need to check again if this is still an entry module as these
+                // changes need to be performed atomically to avoid race conditions
+                // if the same module is re-emitted as an entry module.
+                // The inverse changes happen in "handleExistingModule"
+                if (!entryModule.info.isEntry) {
+                    this.implicitEntryModules.add(entryModule);
+                    for (const module of implicitlyLoadedAfterModules) {
+                        entryModule.implicitlyLoadedAfter.add(module);
+                    }
+                    for (const dependant of entryModule.implicitlyLoadedAfter) {
+                        dependant.implicitlyLoadedBefore.add(entryModule);
+                    }
+                }
+            }
+            return entryModule;
+        }));
+    }
+    async addModuleSource(id, importer, module) {
+        let source;
+        try {
+            source = await this.graph.fileOperationQueue.run(async () => {
+                const content = await this.pluginDriver.hookFirst('load', [id]);
+                if (content !== null)
+                    return content;
+                this.graph.watchFiles[id] = true;
+                return await promises.readFile(id, 'utf8');
+            });
+        }
+        catch (error_) {
+            let message = `Could not load ${id}`;
+            if (importer)
+                message += ` (imported by ${parseAst_js.relativeId(importer)})`;
+            message += `: ${error_.message}`;
+            error_.message = message;
+            throw error_;
+        }
+        const sourceDescription = typeof source === 'string'
+            ? { code: source }
+            : source != null && typeof source === 'object' && typeof source.code === 'string'
+                ? source
+                : parseAst_js.error(parseAst_js.logBadLoader(id));
+        const code = sourceDescription.code;
+        if (code.charCodeAt(0) === 0xfe_ff) {
+            sourceDescription.code = code.slice(1);
+        }
+        const cachedModule = this.graph.cachedModules.get(id);
+        if (cachedModule &&
+            !cachedModule.customTransformCache &&
+            cachedModule.originalCode === sourceDescription.code &&
+            !(await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
+                {
+                    ast: cachedModule.ast,
+                    code: cachedModule.code,
+                    id: cachedModule.id,
+                    meta: cachedModule.meta,
+                    moduleSideEffects: cachedModule.moduleSideEffects,
+                    resolvedSources: cachedModule.resolvedIds,
+                    syntheticNamedExports: cachedModule.syntheticNamedExports
+                }
+            ]))) {
+            if (cachedModule.transformFiles) {
+                for (const emittedFile of cachedModule.transformFiles)
+                    this.pluginDriver.emitFile(emittedFile);
+            }
+            await module.setSource(cachedModule);
+        }
+        else {
+            module.updateOptions(sourceDescription);
+            await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options.onLog));
+        }
+    }
+    async awaitLoadModulesPromise() {
+        let startingPromise;
+        do {
+            startingPromise = this.latestLoadModulesPromise;
+            await startingPromise;
+        } while (startingPromise !== this.latestLoadModulesPromise);
+    }
+    extendLoadModulesPromise(loadNewModulesPromise) {
+        this.latestLoadModulesPromise = Promise.all([
+            loadNewModulesPromise,
+            this.latestLoadModulesPromise
+        ]);
+        this.latestLoadModulesPromise.catch(() => {
+            /* Avoid unhandled Promise rejections */
+        });
+        return loadNewModulesPromise;
+    }
+    async fetchDynamicDependencies(module, resolveDynamicImportPromises) {
+        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([dynamicImport, resolvedId]) => {
+            if (resolvedId === null)
+                return null;
+            if (typeof resolvedId === 'string') {
+                dynamicImport.resolution = resolvedId;
+                return null;
+            }
+            return (dynamicImport.resolution = await this.fetchResolvedDependency(parseAst_js.relativeId(resolvedId.id), module.id, resolvedId));
+        })));
+        for (const dependency of dependencies) {
+            if (dependency) {
+                module.dynamicDependencies.add(dependency);
+                dependency.dynamicImporters.push(module.id);
+            }
+        }
+    }
+    // If this is a preload, then this method always waits for the dependencies of
+    // the module to be resolved.
+    // Otherwise, if the module does not exist, it waits for the module and all
+    // its dependencies to be loaded.
+    // Otherwise, it returns immediately.
+    async fetchModule({ attributes, id, meta, moduleSideEffects, syntheticNamedExports }, importer, isEntry, isPreload) {
+        const existingModule = this.modulesById.get(id);
+        if (existingModule instanceof Module) {
+            if (importer && doAttributesDiffer(attributes, existingModule.info.attributes)) {
+                this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInconsistentImportAttributes(existingModule.info.attributes, attributes, id, importer));
+            }
+            await this.handleExistingModule(existingModule, isEntry, isPreload);
+            return existingModule;
+        }
+        if (existingModule instanceof ExternalModule) {
+            return parseAst_js.error(parseAst_js.logExternalModulesCannotBeTransformedToModules(existingModule.id));
+        }
+        const module = new Module(this.graph, id, this.options, isEntry, moduleSideEffects, syntheticNamedExports, meta, attributes);
+        this.modulesById.set(id, module);
+        const loadPromise = this.addModuleSource(id, importer, module).then(() => [
+            this.getResolveStaticDependencyPromises(module),
+            this.getResolveDynamicImportPromises(module),
+            loadAndResolveDependenciesPromise
+        ]);
+        const loadAndResolveDependenciesPromise = waitForDependencyResolution(loadPromise).then(() => this.pluginDriver.hookParallel('moduleParsed', [module.info]));
+        loadAndResolveDependenciesPromise.catch(() => {
+            /* avoid unhandled promise rejections */
+        });
+        this.moduleLoadPromises.set(module, loadPromise);
+        const resolveDependencyPromises = await loadPromise;
+        if (!isPreload) {
+            await this.fetchModuleDependencies(module, ...resolveDependencyPromises);
+        }
+        else if (isPreload === RESOLVE_DEPENDENCIES) {
+            await loadAndResolveDependenciesPromise;
+        }
+        return module;
+    }
+    async fetchModuleDependencies(module, resolveStaticDependencyPromises, resolveDynamicDependencyPromises, loadAndResolveDependenciesPromise) {
+        if (this.modulesWithLoadedDependencies.has(module)) {
+            return;
+        }
+        this.modulesWithLoadedDependencies.add(module);
+        await Promise.all([
+            this.fetchStaticDependencies(module, resolveStaticDependencyPromises),
+            this.fetchDynamicDependencies(module, resolveDynamicDependencyPromises)
+        ]);
+        module.linkImports();
+        // To handle errors when resolving dependencies or in moduleParsed
+        await loadAndResolveDependenciesPromise;
+    }
+    fetchResolvedDependency(source, importer, resolvedId) {
+        if (resolvedId.external) {
+            const { attributes, external, id, moduleSideEffects, meta } = resolvedId;
+            let externalModule = this.modulesById.get(id);
+            if (!externalModule) {
+                externalModule = new ExternalModule(this.options, id, moduleSideEffects, meta, external !== 'absolute' && parseAst_js.isAbsolute(id), attributes);
+                this.modulesById.set(id, externalModule);
+            }
+            else if (!(externalModule instanceof ExternalModule)) {
+                return parseAst_js.error(parseAst_js.logInternalIdCannotBeExternal(source, importer));
+            }
+            else if (doAttributesDiffer(externalModule.info.attributes, attributes)) {
+                this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInconsistentImportAttributes(externalModule.info.attributes, attributes, source, importer));
+            }
+            return Promise.resolve(externalModule);
+        }
+        return this.fetchModule(resolvedId, importer, false, false);
+    }
+    async fetchStaticDependencies(module, resolveStaticDependencyPromises) {
+        for (const dependency of await Promise.all(resolveStaticDependencyPromises.map(resolveStaticDependencyPromise => resolveStaticDependencyPromise.then(([source, resolvedId]) => this.fetchResolvedDependency(source, module.id, resolvedId))))) {
+            module.dependencies.add(dependency);
+            dependency.importers.push(module.id);
+        }
+        if (!this.options.treeshake || module.info.moduleSideEffects === 'no-treeshake') {
+            for (const dependency of module.dependencies) {
+                if (dependency instanceof Module) {
+                    dependency.importedFromNotTreeshaken = true;
+                }
+            }
+        }
+    }
+    getNormalizedResolvedIdWithoutDefaults(resolveIdResult, importer, source) {
+        const { makeAbsoluteExternalsRelative } = this.options;
+        if (resolveIdResult) {
+            if (typeof resolveIdResult === 'object') {
+                const external = resolveIdResult.external || this.options.external(resolveIdResult.id, importer, true);
+                return {
+                    ...resolveIdResult,
+                    external: external &&
+                        (external === 'relative' ||
+                            !parseAst_js.isAbsolute(resolveIdResult.id) ||
+                            (external === true &&
+                                isNotAbsoluteExternal(resolveIdResult.id, source, makeAbsoluteExternalsRelative)) ||
+                            'absolute')
+                };
+            }
+            const external = this.options.external(resolveIdResult, importer, true);
+            return {
+                external: external &&
+                    (isNotAbsoluteExternal(resolveIdResult, source, makeAbsoluteExternalsRelative) ||
+                        'absolute'),
+                id: external && makeAbsoluteExternalsRelative
+                    ? normalizeRelativeExternalId(resolveIdResult, importer)
+                    : resolveIdResult
+            };
+        }
+        const id = makeAbsoluteExternalsRelative
+            ? normalizeRelativeExternalId(source, importer)
+            : source;
+        if (resolveIdResult !== false && !this.options.external(id, importer, true)) {
+            return null;
+        }
+        return {
+            external: isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) || 'absolute',
+            id
+        };
+    }
+    getResolveDynamicImportPromises(module) {
+        return module.dynamicImports.map(async (dynamicImport) => {
+            const resolvedId = await this.resolveDynamicImport(module, dynamicImport.argument, module.id, getAttributesFromImportExpression(dynamicImport.node));
+            if (resolvedId && typeof resolvedId === 'object') {
+                dynamicImport.id = resolvedId.id;
+            }
+            return [dynamicImport, resolvedId];
+        });
+    }
+    getResolveStaticDependencyPromises(module) {
+        return Array.from(module.sourcesWithAttributes, async ([source, attributes]) => [
+            source,
+            (module.resolvedIds[source] =
+                module.resolvedIds[source] ||
+                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, parseAst_js.EMPTY_OBJECT, false, attributes), source, module.id, attributes))
+        ]);
+    }
+    getResolvedIdWithDefaults(resolvedId, attributes) {
+        if (!resolvedId) {
+            return null;
+        }
+        const external = resolvedId.external || false;
+        return {
+            attributes: resolvedId.attributes || attributes,
+            external,
+            id: resolvedId.id,
+            meta: resolvedId.meta || {},
+            moduleSideEffects: resolvedId.moduleSideEffects ?? this.hasModuleSideEffects(resolvedId.id, !!external),
+            resolvedBy: resolvedId.resolvedBy ?? 'rollup',
+            syntheticNamedExports: resolvedId.syntheticNamedExports ?? false
+        };
+    }
+    async handleExistingModule(module, isEntry, isPreload) {
+        const loadPromise = this.moduleLoadPromises.get(module);
+        if (isPreload) {
+            return isPreload === RESOLVE_DEPENDENCIES
+                ? waitForDependencyResolution(loadPromise)
+                : loadPromise;
+        }
+        if (isEntry) {
+            // This reverts the changes in addEntryWithImplicitDependants and needs to
+            // be performed atomically
+            module.info.isEntry = true;
+            this.implicitEntryModules.delete(module);
+            for (const dependant of module.implicitlyLoadedAfter) {
+                dependant.implicitlyLoadedBefore.delete(module);
+            }
+            module.implicitlyLoadedAfter.clear();
+        }
+        return this.fetchModuleDependencies(module, ...(await loadPromise));
+    }
+    handleInvalidResolvedId(resolvedId, source, importer, attributes) {
+        if (resolvedId === null) {
+            if (parseAst_js.isRelative(source)) {
+                return parseAst_js.error(parseAst_js.logUnresolvedImport(source, importer));
+            }
+            this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logUnresolvedImportTreatedAsExternal(source, importer));
+            return {
+                attributes,
+                external: true,
+                id: source,
+                meta: {},
+                moduleSideEffects: this.hasModuleSideEffects(source, true),
+                resolvedBy: 'rollup',
+                syntheticNamedExports: false
+            };
+        }
+        else if (resolvedId.external && resolvedId.syntheticNamedExports) {
+            this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logExternalSyntheticExports(source, importer));
+        }
+        return resolvedId;
+    }
+    async loadEntryModule(unresolvedId, isEntry, importer, implicitlyLoadedBefore, isLoadForManualChunks = false) {
+        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, parseAst_js.EMPTY_OBJECT, true, parseAst_js.EMPTY_OBJECT);
+        if (resolveIdResult == null) {
+            return parseAst_js.error(implicitlyLoadedBefore === null
+                ? parseAst_js.logUnresolvedEntry(unresolvedId)
+                : parseAst_js.logUnresolvedImplicitDependant(unresolvedId, implicitlyLoadedBefore));
+        }
+        const isExternalModules = typeof resolveIdResult === 'object' && resolveIdResult.external;
+        if (resolveIdResult === false || isExternalModules) {
+            return parseAst_js.error(implicitlyLoadedBefore === null
+                ? isExternalModules && isLoadForManualChunks
+                    ? parseAst_js.logExternalModulesCannotBeIncludedInManualChunks(unresolvedId)
+                    : parseAst_js.logEntryCannotBeExternal(unresolvedId)
+                : parseAst_js.logImplicitDependantCannotBeExternal(unresolvedId, implicitlyLoadedBefore));
+        }
+        return this.fetchModule(this.getResolvedIdWithDefaults(typeof resolveIdResult === 'object'
+            ? resolveIdResult
+            : { id: resolveIdResult }, parseAst_js.EMPTY_OBJECT), undefined, isEntry, false);
+    }
+    async resolveDynamicImport(module, specifier, importer, attributes) {
+        const resolution = await this.pluginDriver.hookFirst('resolveDynamicImport', [
+            specifier,
+            importer,
+            { attributes }
+        ]);
+        if (typeof specifier !== 'string') {
+            if (typeof resolution === 'string') {
+                return resolution;
+            }
+            if (!resolution) {
+                return null;
+            }
+            return this.getResolvedIdWithDefaults(resolution, attributes);
+        }
+        if (resolution == null) {
+            const existingResolution = module.resolvedIds[specifier];
+            if (existingResolution) {
+                if (doAttributesDiffer(existingResolution.attributes, attributes)) {
+                    this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logInconsistentImportAttributes(existingResolution.attributes, attributes, specifier, importer));
+                }
+                return existingResolution;
+            }
+            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, parseAst_js.EMPTY_OBJECT, false, attributes), specifier, module.id, attributes));
+        }
+        return this.handleInvalidResolvedId(this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier), attributes), specifier, importer, attributes);
+    }
+}
+function normalizeRelativeExternalId(source, importer) {
+    return parseAst_js.isRelative(source)
+        ? importer
+            ? path.resolve(importer, '..', source)
+            : path.resolve(source)
+        : source;
+}
+function addChunkNamesToModule(module, { fileName, name }, isUserDefined, priority) {
+    if (fileName !== null) {
+        module.chunkFileNames.add(fileName);
+    }
+    else if (name !== null) {
+        // Always keep chunkNames sorted by priority
+        let namePosition = 0;
+        while (module.chunkNames[namePosition]?.priority < priority)
+            namePosition++;
+        module.chunkNames.splice(namePosition, 0, { isUserDefined, name, priority });
+    }
+}
+function isNotAbsoluteExternal(id, source, makeAbsoluteExternalsRelative) {
+    return (makeAbsoluteExternalsRelative === true ||
+        (makeAbsoluteExternalsRelative === 'ifRelativeSource' && parseAst_js.isRelative(source)) ||
+        !parseAst_js.isAbsolute(id));
+}
+async function waitForDependencyResolution(loadPromise) {
+    const [resolveStaticDependencyPromises, resolveDynamicImportPromises] = await loadPromise;
+    return Promise.all([...resolveStaticDependencyPromises, ...resolveDynamicImportPromises]);
+}
+
+class Queue {
+    constructor(maxParallel) {
+        this.maxParallel = maxParallel;
+        this.queue = [];
+        this.workerCount = 0;
+    }
+    run(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ reject, resolve, task });
+            this.work();
+        });
+    }
+    async work() {
+        if (this.workerCount >= this.maxParallel)
+            return;
+        this.workerCount++;
+        let entry;
+        while ((entry = this.queue.shift())) {
+            const { reject, resolve, task } = entry;
+            try {
+                const result = await task();
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }
+        this.workerCount--;
+    }
+}
+
+function normalizeEntryModules(entryModules) {
+    if (Array.isArray(entryModules)) {
+        return entryModules.map(id => ({
+            fileName: null,
+            id,
+            implicitlyLoadedAfter: [],
+            importer: undefined,
+            name: null
+        }));
+    }
+    return Object.entries(entryModules).map(([name, id]) => ({
+        fileName: null,
+        id,
+        implicitlyLoadedAfter: [],
+        importer: undefined,
+        name
+    }));
+}
+class Graph {
+    constructor(options, watcher) {
+        this.options = options;
+        this.astLru = flru(5);
+        this.cachedModules = new Map();
+        this.deoptimizationTracker = new PathTracker();
+        this.entryModules = [];
+        this.modulesById = new Map();
+        this.needsTreeshakingPass = false;
+        this.phase = BuildPhase.LOAD_AND_PARSE;
+        this.scope = new GlobalScope();
+        this.watchFiles = Object.create(null);
+        this.watchMode = false;
+        this.externalModules = [];
+        this.implicitEntryModules = [];
+        this.modules = [];
+        this.getModuleInfo = (moduleId) => {
+            const foundModule = this.modulesById.get(moduleId);
+            if (!foundModule)
+                return null;
+            return foundModule.info;
+        };
+        if (options.cache !== false) {
+            if (options.cache?.modules) {
+                for (const module of options.cache.modules)
+                    this.cachedModules.set(module.id, module);
+            }
+            this.pluginCache = options.cache?.plugins || Object.create(null);
+            // increment access counter
+            for (const name in this.pluginCache) {
+                const cache = this.pluginCache[name];
+                for (const value of Object.values(cache))
+                    value[0]++;
+            }
+        }
+        if (watcher) {
+            this.watchMode = true;
+            const handleChange = (...parameters) => this.pluginDriver.hookParallel('watchChange', parameters);
+            const handleClose = () => this.pluginDriver.hookParallel('closeWatcher', []);
+            watcher.onCurrentRun('change', handleChange);
+            watcher.onCurrentRun('close', handleClose);
+        }
+        this.pluginDriver = new PluginDriver(this, options, options.plugins, this.pluginCache);
+        this.moduleLoader = new ModuleLoader(this, this.modulesById, this.options, this.pluginDriver);
+        this.fileOperationQueue = new Queue(options.maxParallelFileOps);
+        this.pureFunctions = getPureFunctions(options);
+    }
+    async build() {
+        timeStart('generate module graph', 2);
+        await this.generateModuleGraph();
+        timeEnd('generate module graph', 2);
+        timeStart('sort and bind modules', 2);
+        this.phase = BuildPhase.ANALYSE;
+        this.sortModules();
+        timeEnd('sort and bind modules', 2);
+        timeStart('mark included statements', 2);
+        this.includeStatements();
+        timeEnd('mark included statements', 2);
+        this.phase = BuildPhase.GENERATE;
+    }
+    getCache() {
+        // handle plugin cache eviction
+        for (const name in this.pluginCache) {
+            const cache = this.pluginCache[name];
+            let allDeleted = true;
+            for (const [key, value] of Object.entries(cache)) {
+                if (value[0] >= this.options.experimentalCacheExpiry)
+                    delete cache[key];
+                else
+                    allDeleted = false;
+            }
+            if (allDeleted)
+                delete this.pluginCache[name];
+        }
+        return {
+            modules: this.modules.map(module => module.toJSON()),
+            plugins: this.pluginCache
+        };
+    }
+    async generateModuleGraph() {
+        ({ entryModules: this.entryModules, implicitEntryModules: this.implicitEntryModules } =
+            await this.moduleLoader.addEntryModules(normalizeEntryModules(this.options.input), true));
+        if (this.entryModules.length === 0) {
+            throw new Error('You must supply options.input to rollup');
+        }
+        for (const module of this.modulesById.values()) {
+            module.cacheInfoGetters();
+            if (module instanceof Module) {
+                this.modules.push(module);
+            }
+            else {
+                this.externalModules.push(module);
+            }
+        }
+    }
+    includeStatements() {
+        const entryModules = [...this.entryModules, ...this.implicitEntryModules];
+        for (const module of entryModules) {
+            markModuleAndImpureDependenciesAsExecuted(module);
+        }
+        if (this.options.treeshake) {
+            let treeshakingPass = 1;
+            do {
+                timeStart(`treeshaking pass ${treeshakingPass}`, 3);
+                this.needsTreeshakingPass = false;
+                for (const module of this.modules) {
+                    if (module.isExecuted) {
+                        module.hasTreeShakingPassStarted = true;
+                        if (module.info.moduleSideEffects === 'no-treeshake') {
+                            module.includeAllInBundle();
+                        }
+                        else {
+                            module.include();
+                        }
+                    }
+                }
+                if (treeshakingPass === 1) {
+                    // We only include exports after the first pass to avoid issues with
+                    // the TDZ detection logic
+                    for (const module of entryModules) {
+                        if (module.preserveSignature !== false) {
+                            module.includeAllExports(false);
+                            this.needsTreeshakingPass = true;
+                        }
+                    }
+                }
+                timeEnd(`treeshaking pass ${treeshakingPass++}`, 3);
+            } while (this.needsTreeshakingPass);
+        }
+        else {
+            for (const module of this.modules)
+                module.includeAllInBundle();
+        }
+        for (const externalModule of this.externalModules)
+            externalModule.warnUnusedImports();
+        for (const module of this.implicitEntryModules) {
+            for (const dependant of module.implicitlyLoadedAfter) {
+                if (!(dependant.info.isEntry || dependant.isIncluded())) {
+                    parseAst_js.error(parseAst_js.logImplicitDependantIsNotIncluded(dependant));
+                }
+            }
+        }
+    }
+    sortModules() {
+        const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
+        for (const cyclePath of cyclePaths) {
+            this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCircularDependency(cyclePath));
+        }
+        this.modules = orderedModules;
+        for (const module of this.modules) {
+            module.bindReferences();
+        }
+        this.warnForMissingExports();
+    }
+    warnForMissingExports() {
+        for (const module of this.modules) {
+            for (const importDescription of module.importDescriptions.values()) {
+                if (importDescription.name !== '*' &&
+                    !importDescription.module.getVariableForExportName(importDescription.name)[0]) {
+                    module.log(parseAst_js.LOGLEVEL_WARN, parseAst_js.logMissingExport(importDescription.name, module.id, importDescription.module.id), importDescription.start);
+                }
+            }
+        }
+    }
+}
+
+function formatAction([pluginName, hookName, parameters]) {
+    const action = `(${pluginName}) ${hookName}`;
+    const s = JSON.stringify;
+    switch (hookName) {
+        case 'resolveId': {
+            return `${action} ${s(parameters[0])} ${s(parameters[1])}`;
+        }
+        case 'load': {
+            return `${action} ${s(parameters[0])}`;
+        }
+        case 'transform': {
+            return `${action} ${s(parameters[1])}`;
+        }
+        case 'shouldTransformCachedModule': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
+        case 'moduleParsed': {
+            return `${action} ${s(parameters[0].id)}`;
+        }
+    }
+    return action;
+}
+let handleBeforeExit = null;
+const rejectByPluginDriver = new Map();
+async function catchUnfinishedHookActions(pluginDriver, callback) {
+    const emptyEventLoopPromise = new Promise((_, reject) => {
+        rejectByPluginDriver.set(pluginDriver, reject);
+        if (!handleBeforeExit) {
+            // We only ever create a single event listener to avoid max listener and
+            // other issues
+            handleBeforeExit = () => {
+                for (const [pluginDriver, reject] of rejectByPluginDriver) {
+                    const unfulfilledActions = pluginDriver.getUnfulfilledHookActions();
+                    reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
+                        [...unfulfilledActions].map(formatAction).join('\n')));
+                }
+            };
+            process$1.once('beforeExit', handleBeforeExit);
+        }
+    });
+    try {
+        return await Promise.race([callback(), emptyEventLoopPromise]);
+    }
+    finally {
+        rejectByPluginDriver.delete(pluginDriver);
+        if (rejectByPluginDriver.size === 0) {
+            process$1.off('beforeExit', handleBeforeExit);
+            handleBeforeExit = null;
+        }
+    }
+}
+
+async function initWasm() { }
+
+async function normalizeInputOptions(config, watchMode) {
+    // These are options that may trigger special warnings or behaviour later
+    // if the user did not select an explicit value
+    const unsetOptions = new Set();
+    const context = config.context ?? 'undefined';
+    const plugins = await normalizePluginOption(config.plugins);
+    const logLevel = config.logLevel || parseAst_js.LOGLEVEL_INFO;
+    const onLog = getLogger(plugins, getOnLog(config, logLevel), watchMode, logLevel);
+    const strictDeprecations = config.strictDeprecations || false;
+    const maxParallelFileOps = getMaxParallelFileOps(config);
+    const options = {
+        cache: getCache(config),
+        context,
+        experimentalCacheExpiry: config.experimentalCacheExpiry ?? 10,
+        experimentalLogSideEffects: config.experimentalLogSideEffects || false,
+        external: getIdMatcher(config.external),
+        input: getInput(config),
+        jsx: getJsx(config),
+        logLevel,
+        makeAbsoluteExternalsRelative: config.makeAbsoluteExternalsRelative ?? 'ifRelativeSource',
+        maxParallelFileOps,
+        moduleContext: getModuleContext(config, context),
+        onLog,
+        perf: config.perf || false,
+        plugins,
+        preserveEntrySignatures: config.preserveEntrySignatures ?? 'exports-only',
+        preserveSymlinks: config.preserveSymlinks || false,
+        shimMissingExports: config.shimMissingExports || false,
+        strictDeprecations,
+        treeshake: getTreeshake(config)
+    };
+    warnUnknownOptions(config, [...Object.keys(options), 'onwarn', 'watch'], 'input options', onLog, /^(output)$/);
+    return { options, unsetOptions };
+}
+const getCache = (config) => config.cache === true // `true` is the default
+    ? undefined
+    : config.cache?.cache || config.cache;
+const getIdMatcher = (option) => {
+    if (option === true) {
+        return () => true;
+    }
+    if (typeof option === 'function') {
+        return (id, ...parameters) => (!id.startsWith('\0') && option(id, ...parameters)) || false;
+    }
+    if (option) {
+        const ids = new Set();
+        const matchers = [];
+        for (const value of ensureArray$1(option)) {
+            if (value instanceof RegExp) {
+                matchers.push(value);
+            }
+            else {
+                ids.add(value);
+            }
+        }
+        return (id, ..._arguments) => ids.has(id) || matchers.some(matcher => matcher.test(id));
+    }
+    return () => false;
+};
+const getInput = (config) => {
+    const configInput = config.input;
+    return configInput == null ? [] : typeof configInput === 'string' ? [configInput] : configInput;
+};
+const getJsx = (config) => {
+    const configJsx = config.jsx;
+    if (!configJsx)
+        return false;
+    const configWithPreset = getOptionWithPreset(configJsx, jsxPresets, 'jsx', parseAst_js.URL_JSX, 'false, ');
+    const { factory, importSource, mode } = configWithPreset;
+    switch (mode) {
+        case 'automatic': {
+            return {
+                factory: factory || 'React.createElement',
+                importSource: importSource || 'react',
+                jsxImportSource: configWithPreset.jsxImportSource || 'react/jsx-runtime',
+                mode: 'automatic'
+            };
+        }
+        case 'preserve': {
+            if (importSource && !(factory || configWithPreset.fragment)) {
+                parseAst_js.error(parseAst_js.logInvalidOption('jsx', parseAst_js.URL_JSX, 'when preserving JSX and specifying an importSource, you also need to specify a factory or fragment'));
+            }
+            return {
+                factory: factory || null,
+                fragment: configWithPreset.fragment || null,
+                importSource: importSource || null,
+                mode: 'preserve'
+            };
+        }
+        // case 'classic':
+        default: {
+            if (mode && mode !== 'classic') {
+                parseAst_js.error(parseAst_js.logInvalidOption('jsx.mode', parseAst_js.URL_JSX, 'mode must be "automatic", "classic" or "preserve"', mode));
+            }
+            return {
+                factory: factory || 'React.createElement',
+                fragment: configWithPreset.fragment || 'React.Fragment',
+                importSource: importSource || null,
+                mode: 'classic'
+            };
+        }
+    }
+};
+const getMaxParallelFileOps = (config) => {
+    const maxParallelFileOps = config.maxParallelFileOps;
+    if (typeof maxParallelFileOps === 'number') {
+        if (maxParallelFileOps <= 0)
+            return Infinity;
+        return maxParallelFileOps;
+    }
+    return 20;
+};
+const getModuleContext = (config, context) => {
+    const configModuleContext = config.moduleContext;
+    if (typeof configModuleContext === 'function') {
+        return id => configModuleContext(id) ?? context;
+    }
+    if (configModuleContext) {
+        const contextByModuleId = Object.create(null);
+        for (const [key, moduleContext] of Object.entries(configModuleContext)) {
+            contextByModuleId[path.resolve(key)] = moduleContext;
+        }
+        return id => contextByModuleId[id] ?? context;
+    }
+    return () => context;
+};
+const getTreeshake = (config) => {
+    const configTreeshake = config.treeshake;
+    if (configTreeshake === false) {
+        return false;
+    }
+    const configWithPreset = getOptionWithPreset(config.treeshake, treeshakePresets, 'treeshake', parseAst_js.URL_TREESHAKE, 'false, true, ');
+    return {
+        annotations: configWithPreset.annotations !== false,
+        correctVarValueBeforeDeclaration: configWithPreset.correctVarValueBeforeDeclaration === true,
+        manualPureFunctions: configWithPreset.manualPureFunctions ?? parseAst_js.EMPTY_ARRAY,
+        moduleSideEffects: getHasModuleSideEffects(configWithPreset.moduleSideEffects),
+        propertyReadSideEffects: configWithPreset.propertyReadSideEffects === 'always'
+            ? 'always'
+            : configWithPreset.propertyReadSideEffects !== false,
+        tryCatchDeoptimization: configWithPreset.tryCatchDeoptimization !== false,
+        unknownGlobalSideEffects: configWithPreset.unknownGlobalSideEffects !== false
+    };
+};
+const getHasModuleSideEffects = (moduleSideEffectsOption) => {
+    if (typeof moduleSideEffectsOption === 'boolean') {
+        return () => moduleSideEffectsOption;
+    }
+    if (moduleSideEffectsOption === 'no-external') {
+        return (_id, external) => !external;
+    }
+    if (typeof moduleSideEffectsOption === 'function') {
+        return (id, external) => id.startsWith('\0') ? true : moduleSideEffectsOption(id, external) !== false;
+    }
+    if (Array.isArray(moduleSideEffectsOption)) {
+        const ids = new Set(moduleSideEffectsOption);
+        return id => ids.has(id);
+    }
+    if (moduleSideEffectsOption) {
+        parseAst_js.error(parseAst_js.logInvalidOption('treeshake.moduleSideEffects', parseAst_js.URL_TREESHAKE_MODULESIDEEFFECTS, 'please use one of false, "no-external", a function or an array'));
+    }
+    return () => true;
+};
+
+// https://datatracker.ietf.org/doc/html/rfc2396
+// eslint-disable-next-line no-control-regex
+const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$%&*+,:;<=>?[\]^`{|}\u007F]/g;
+const DRIVE_LETTER_REGEX = /^[a-z]:/i;
+function sanitizeFileName(name) {
+    const match = DRIVE_LETTER_REGEX.exec(name);
+    const driveLetter = match ? match[0] : '';
+    // A `:` is only allowed as part of a windows drive letter (ex: C:\foo)
+    // Otherwise, avoid them because they can refer to NTFS alternate data streams.
+    return driveLetter + name.slice(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
+}
+
+async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
+    // These are options that may trigger special warnings or behaviour later
+    // if the user did not select an explicit value
+    const unsetOptions = new Set(unsetInputOptions);
+    const compact = config.compact || false;
+    const format = getFormat(config);
+    const inlineDynamicImports = getInlineDynamicImports(config, inputOptions);
+    const preserveModules = getPreserveModules(config, inlineDynamicImports, inputOptions);
+    const file = getFile(config, preserveModules, inputOptions);
+    const generatedCode = getGeneratedCode(config);
+    const externalImportAttributes = getExternalImportAttributes(config, inputOptions);
+    const outputOptions = {
+        amd: getAmd(config),
+        assetFileNames: config.assetFileNames ?? 'assets/[name]-[hash][extname]',
+        banner: getAddon(config, 'banner'),
+        chunkFileNames: config.chunkFileNames ?? '[name]-[hash].js',
+        compact,
+        dir: getDir(config, file),
+        dynamicImportInCjs: config.dynamicImportInCjs ?? true,
+        entryFileNames: getEntryFileNames(config, unsetOptions),
+        esModule: config.esModule ?? 'if-default-prop',
+        experimentalMinChunkSize: config.experimentalMinChunkSize ?? 1,
+        exports: getExports(config, unsetOptions),
+        extend: config.extend || false,
+        externalImportAssertions: externalImportAttributes,
+        externalImportAttributes,
+        externalLiveBindings: config.externalLiveBindings ?? true,
+        file,
+        footer: getAddon(config, 'footer'),
+        format,
+        freeze: config.freeze ?? true,
+        generatedCode,
+        globals: config.globals || {},
+        hashCharacters: config.hashCharacters ?? 'base64',
+        hoistTransitiveImports: config.hoistTransitiveImports ?? true,
+        importAttributesKey: config.importAttributesKey ?? 'assert',
+        indent: getIndent(config, compact),
+        inlineDynamicImports,
+        interop: getInterop(config),
+        intro: getAddon(config, 'intro'),
+        manualChunks: getManualChunks(config, inlineDynamicImports, preserveModules),
+        minifyInternalExports: getMinifyInternalExports(config, format, compact),
+        name: config.name,
+        noConflict: config.noConflict || false,
+        outro: getAddon(config, 'outro'),
+        paths: config.paths || {},
+        plugins: await normalizePluginOption(config.plugins),
+        preserveModules,
+        preserveModulesRoot: getPreserveModulesRoot(config),
+        reexportProtoFromExternal: config.reexportProtoFromExternal ?? true,
+        sanitizeFileName: typeof config.sanitizeFileName === 'function'
+            ? config.sanitizeFileName
+            : config.sanitizeFileName === false
+                ? id => id
+                : sanitizeFileName,
+        sourcemap: config.sourcemap || false,
+        sourcemapBaseUrl: getSourcemapBaseUrl(config),
+        sourcemapExcludeSources: config.sourcemapExcludeSources || false,
+        sourcemapFile: config.sourcemapFile,
+        sourcemapFileNames: getSourcemapFileNames(config, unsetOptions),
+        sourcemapIgnoreList: typeof config.sourcemapIgnoreList === 'function'
+            ? config.sourcemapIgnoreList
+            : config.sourcemapIgnoreList === false
+                ? () => false
+                : relativeSourcePath => relativeSourcePath.includes('node_modules'),
+        sourcemapPathTransform: config.sourcemapPathTransform,
+        strict: config.strict ?? true,
+        systemNullSetters: config.systemNullSetters ?? true,
+        validate: config.validate || false,
+        virtualDirname: config.virtualDirname || '_virtual'
+    };
+    warnUnknownOptions(config, Object.keys(outputOptions), 'output options', inputOptions.onLog);
+    return { options: outputOptions, unsetOptions };
+}
+const getFile = (config, preserveModules, inputOptions) => {
+    const { file } = config;
+    if (typeof file === 'string') {
+        if (preserveModules) {
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.file', parseAst_js.URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when using the "output.preserveModules" option'));
+        }
+        if (!Array.isArray(inputOptions.input))
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.file', parseAst_js.URL_OUTPUT_DIR, 'you must set "output.dir" instead of "output.file" when providing named inputs'));
+    }
+    return file;
+};
+const getFormat = (config) => {
+    const configFormat = config.format;
+    switch (configFormat) {
+        case undefined:
+        case 'es':
+        case 'esm':
+        case 'module': {
+            return 'es';
+        }
+        case 'cjs':
+        case 'commonjs': {
+            return 'cjs';
+        }
+        case 'system':
+        case 'systemjs': {
+            return 'system';
+        }
+        case 'amd':
+        case 'iife':
+        case 'umd': {
+            return configFormat;
+        }
+        default: {
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.format', parseAst_js.URL_OUTPUT_FORMAT, `Valid values are "amd", "cjs", "system", "es", "iife" or "umd"`, configFormat));
+        }
+    }
+};
+const getInlineDynamicImports = (config, inputOptions) => {
+    const inlineDynamicImports = config.inlineDynamicImports || false;
+    const { input } = inputOptions;
+    if (inlineDynamicImports && (Array.isArray(input) ? input : Object.keys(input)).length > 1) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.inlineDynamicImports', parseAst_js.URL_OUTPUT_INLINEDYNAMICIMPORTS, 'multiple inputs are not supported when "output.inlineDynamicImports" is true'));
+    }
+    return inlineDynamicImports;
+};
+const getPreserveModules = (config, inlineDynamicImports, inputOptions) => {
+    const preserveModules = config.preserveModules || false;
+    if (preserveModules) {
+        if (inlineDynamicImports) {
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.inlineDynamicImports', parseAst_js.URL_OUTPUT_INLINEDYNAMICIMPORTS, `this option is not supported for "output.preserveModules"`));
+        }
+        if (inputOptions.preserveEntrySignatures === false) {
+            return parseAst_js.error(parseAst_js.logInvalidOption('preserveEntrySignatures', parseAst_js.URL_PRESERVEENTRYSIGNATURES, 'setting this option to false is not supported for "output.preserveModules"'));
+        }
+    }
+    return preserveModules;
+};
+const getPreserveModulesRoot = (config) => {
+    const { preserveModulesRoot } = config;
+    if (preserveModulesRoot === null || preserveModulesRoot === undefined) {
+        return undefined;
+    }
+    return path.resolve(preserveModulesRoot);
+};
+const getAmd = (config) => {
+    const mergedOption = {
+        autoId: false,
+        basePath: '',
+        define: 'define',
+        forceJsExtensionForImports: false,
+        ...config.amd
+    };
+    if ((mergedOption.autoId || mergedOption.basePath) && mergedOption.id) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.amd.id', parseAst_js.URL_OUTPUT_AMD_ID, 'this option cannot be used together with "output.amd.autoId"/"output.amd.basePath"'));
+    }
+    if (mergedOption.basePath && !mergedOption.autoId) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.amd.basePath', parseAst_js.URL_OUTPUT_AMD_BASEPATH, 'this option only works with "output.amd.autoId"'));
+    }
+    return mergedOption.autoId
+        ? {
+            autoId: true,
+            basePath: mergedOption.basePath,
+            define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports
+        }
+        : {
+            autoId: false,
+            define: mergedOption.define,
+            forceJsExtensionForImports: mergedOption.forceJsExtensionForImports,
+            id: mergedOption.id
+        };
+};
+const getAddon = (config, name) => {
+    const configAddon = config[name];
+    if (typeof configAddon === 'function') {
+        return configAddon;
+    }
+    return () => configAddon || '';
+};
+const getDir = (config, file) => {
+    const { dir } = config;
+    if (typeof dir === 'string' && typeof file === 'string') {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.dir', parseAst_js.URL_OUTPUT_DIR, 'you must set either "output.file" for a single-file build or "output.dir" when generating multiple chunks'));
+    }
+    return dir;
+};
+const getEntryFileNames = (config, unsetOptions) => {
+    const configEntryFileNames = config.entryFileNames;
+    if (configEntryFileNames == null) {
+        unsetOptions.add('entryFileNames');
+    }
+    return configEntryFileNames ?? '[name].js';
+};
+function getExports(config, unsetOptions) {
+    const configExports = config.exports;
+    if (configExports == null) {
+        unsetOptions.add('exports');
+    }
+    else if (!['default', 'named', 'none', 'auto'].includes(configExports)) {
+        return parseAst_js.error(parseAst_js.logInvalidExportOptionValue(configExports));
+    }
+    return configExports || 'auto';
+}
+const getExternalImportAttributes = (config, inputOptions) => {
+    if (config.externalImportAssertions != undefined) {
+        parseAst_js.warnDeprecation(`The "output.externalImportAssertions" option is deprecated. Use the "output.externalImportAttributes" option instead.`, parseAst_js.URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, true, inputOptions);
+    }
+    return config.externalImportAttributes ?? config.externalImportAssertions ?? true;
+};
+const getGeneratedCode = (config) => {
+    const configWithPreset = getOptionWithPreset(config.generatedCode, generatedCodePresets, 'output.generatedCode', parseAst_js.URL_OUTPUT_GENERATEDCODE, '');
+    return {
+        arrowFunctions: configWithPreset.arrowFunctions === true,
+        constBindings: configWithPreset.constBindings === true,
+        objectShorthand: configWithPreset.objectShorthand === true,
+        reservedNamesAsProps: configWithPreset.reservedNamesAsProps !== false,
+        symbols: configWithPreset.symbols === true
+    };
+};
+const getIndent = (config, compact) => {
+    if (compact) {
+        return '';
+    }
+    const configIndent = config.indent;
+    return configIndent === false ? '' : (configIndent ?? true);
+};
+const ALLOWED_INTEROP_TYPES = new Set([
+    'compat',
+    'auto',
+    'esModule',
+    'default',
+    'defaultOnly'
+]);
+const getInterop = (config) => {
+    const configInterop = config.interop;
+    if (typeof configInterop === 'function') {
+        const interopPerId = Object.create(null);
+        let defaultInterop = null;
+        return id => id === null
+            ? defaultInterop || validateInterop((defaultInterop = configInterop(id)))
+            : id in interopPerId
+                ? interopPerId[id]
+                : validateInterop((interopPerId[id] = configInterop(id)));
+    }
+    return configInterop === undefined ? () => 'default' : () => validateInterop(configInterop);
+};
+const validateInterop = (interop) => {
+    if (!ALLOWED_INTEROP_TYPES.has(interop)) {
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.interop', parseAst_js.URL_OUTPUT_INTEROP, `use one of ${Array.from(ALLOWED_INTEROP_TYPES, value => JSON.stringify(value)).join(', ')}`, interop));
+    }
+    return interop;
+};
+const getManualChunks = (config, inlineDynamicImports, preserveModules) => {
+    const configManualChunks = config.manualChunks;
+    if (configManualChunks) {
+        if (inlineDynamicImports) {
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.manualChunks', parseAst_js.URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.inlineDynamicImports"'));
+        }
+        if (preserveModules) {
+            return parseAst_js.error(parseAst_js.logInvalidOption('output.manualChunks', parseAst_js.URL_OUTPUT_MANUALCHUNKS, 'this option is not supported for "output.preserveModules"'));
+        }
+    }
+    return configManualChunks || {};
+};
+const getMinifyInternalExports = (config, format, compact) => config.minifyInternalExports ?? (compact || format === 'es' || format === 'system');
+const getSourcemapFileNames = (config, unsetOptions) => {
+    const configSourcemapFileNames = config.sourcemapFileNames;
+    if (configSourcemapFileNames == null) {
+        unsetOptions.add('sourcemapFileNames');
+    }
+    return configSourcemapFileNames;
+};
+const getSourcemapBaseUrl = (config) => {
+    const { sourcemapBaseUrl } = config;
+    if (sourcemapBaseUrl) {
+        if (parseAst_js.isValidUrl(sourcemapBaseUrl)) {
+            return parseAst_js.addTrailingSlashIfMissed(sourcemapBaseUrl);
+        }
+        return parseAst_js.error(parseAst_js.logInvalidOption('output.sourcemapBaseUrl', parseAst_js.URL_OUTPUT_SOURCEMAPBASEURL, `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
+    }
+};
+
+function rollup(rawInputOptions) {
+    return rollupInternal(rawInputOptions, null);
+}
+async function rollupInternal(rawInputOptions, watcher) {
+    const { options: inputOptions, unsetOptions: unsetInputOptions } = await getInputOptions(rawInputOptions, watcher !== null);
+    initialiseTimers(inputOptions);
+    await initWasm();
+    const graph = new Graph(inputOptions, watcher);
+    // remove the cache object from the memory after graph creation (cache is not used anymore)
+    const useCache = rawInputOptions.cache !== false;
+    if (rawInputOptions.cache) {
+        inputOptions.cache = undefined;
+        rawInputOptions.cache = undefined;
+    }
+    timeStart('BUILD', 1);
+    await catchUnfinishedHookActions(graph.pluginDriver, async () => {
+        try {
+            timeStart('initialize', 2);
+            await graph.pluginDriver.hookParallel('buildStart', [inputOptions]);
+            timeEnd('initialize', 2);
+            await graph.build();
+        }
+        catch (error_) {
+            const watchFiles = Object.keys(graph.watchFiles);
+            if (watchFiles.length > 0) {
+                error_.watchFiles = watchFiles;
+            }
+            await graph.pluginDriver.hookParallel('buildEnd', [error_]);
+            await graph.pluginDriver.hookParallel('closeBundle', []);
+            throw error_;
+        }
+        await graph.pluginDriver.hookParallel('buildEnd', []);
+    });
+    timeEnd('BUILD', 1);
+    const result = {
+        cache: useCache ? graph.getCache() : undefined,
+        async close() {
+            if (result.closed)
+                return;
+            result.closed = true;
+            await graph.pluginDriver.hookParallel('closeBundle', []);
+        },
+        closed: false,
+        async generate(rawOutputOptions) {
+            if (result.closed)
+                return parseAst_js.error(parseAst_js.logAlreadyClosed());
+            return handleGenerateWrite(false, inputOptions, unsetInputOptions, rawOutputOptions, graph);
+        },
+        get watchFiles() {
+            return Object.keys(graph.watchFiles);
+        },
+        async write(rawOutputOptions) {
+            if (result.closed)
+                return parseAst_js.error(parseAst_js.logAlreadyClosed());
+            return handleGenerateWrite(true, inputOptions, unsetInputOptions, rawOutputOptions, graph);
+        }
+    };
+    if (inputOptions.perf)
+        result.getTimings = getTimings;
+    return result;
+}
+async function getInputOptions(initialInputOptions, watchMode) {
+    if (!initialInputOptions) {
+        throw new Error('You must supply an options object to rollup');
+    }
+    const processedInputOptions = await getProcessedInputOptions(initialInputOptions, watchMode);
+    const { options, unsetOptions } = await normalizeInputOptions(processedInputOptions, watchMode);
+    normalizePlugins(options.plugins, ANONYMOUS_PLUGIN_PREFIX);
+    return { options, unsetOptions };
+}
+async function getProcessedInputOptions(inputOptions, watchMode) {
+    const plugins = getSortedValidatedPlugins('options', await normalizePluginOption(inputOptions.plugins));
+    const logLevel = inputOptions.logLevel || parseAst_js.LOGLEVEL_INFO;
+    const logger = getLogger(plugins, getOnLog(inputOptions, logLevel), watchMode, logLevel);
+    for (const plugin of plugins) {
+        const { name, options } = plugin;
+        const handler = 'handler' in options ? options.handler : options;
+        const processedOptions = await handler.call({
+            debug: getLogHandler(parseAst_js.LOGLEVEL_DEBUG, 'PLUGIN_LOG', logger, name, logLevel),
+            error: (error_) => parseAst_js.error(parseAst_js.logPluginError(normalizeLog(error_), name, { hook: 'onLog' })),
+            info: getLogHandler(parseAst_js.LOGLEVEL_INFO, 'PLUGIN_LOG', logger, name, logLevel),
+            meta: { rollupVersion: version, watchMode },
+            warn: getLogHandler(parseAst_js.LOGLEVEL_WARN, 'PLUGIN_WARNING', logger, name, logLevel)
+        }, inputOptions);
+        if (processedOptions) {
+            inputOptions = processedOptions;
+        }
+    }
+    return inputOptions;
+}
+function normalizePlugins(plugins, anonymousPrefix) {
+    for (const [index, plugin] of plugins.entries()) {
+        if (!plugin.name) {
+            plugin.name = `${anonymousPrefix}${index + 1}`;
+        }
+    }
+}
+async function handleGenerateWrite(isWrite, inputOptions, unsetInputOptions, rawOutputOptions, graph) {
+    const { options: outputOptions, outputPluginDriver, unsetOptions } = await getOutputOptionsAndPluginDriver(rawOutputOptions, graph.pluginDriver, inputOptions, unsetInputOptions);
+    return catchUnfinishedHookActions(outputPluginDriver, async () => {
+        const bundle = new Bundle(outputOptions, unsetOptions, inputOptions, outputPluginDriver, graph);
+        const generated = await bundle.generate(isWrite);
+        if (isWrite) {
+            timeStart('WRITE', 1);
+            if (!outputOptions.dir && !outputOptions.file) {
+                return parseAst_js.error(parseAst_js.logMissingFileOrDirOption());
+            }
+            await Promise.all(Object.values(generated).map(chunk => graph.fileOperationQueue.run(() => writeOutputFile(chunk, outputOptions))));
+            await outputPluginDriver.hookParallel('writeBundle', [outputOptions, generated]);
+            timeEnd('WRITE', 1);
+        }
+        return createOutput(generated);
+    });
+}
+async function getOutputOptionsAndPluginDriver(rawOutputOptions, inputPluginDriver, inputOptions, unsetInputOptions) {
+    if (!rawOutputOptions) {
+        throw new Error('You must supply an options object');
+    }
+    const rawPlugins = await normalizePluginOption(rawOutputOptions.plugins);
+    normalizePlugins(rawPlugins, ANONYMOUS_OUTPUT_PLUGIN_PREFIX);
+    const outputPluginDriver = inputPluginDriver.createOutputPluginDriver(rawPlugins);
+    return {
+        ...(await getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver)),
+        outputPluginDriver
+    };
+}
+function getOutputOptions(inputOptions, unsetInputOptions, rawOutputOptions, outputPluginDriver) {
+    return normalizeOutputOptions(outputPluginDriver.hookReduceArg0Sync('outputOptions', [rawOutputOptions], (outputOptions, result) => result || outputOptions, pluginContext => {
+        const emitError = () => pluginContext.error(parseAst_js.logCannotEmitFromOptionsHook());
+        return {
+            ...pluginContext,
+            emitFile: emitError,
+            setAssetSource: emitError
+        };
+    }), inputOptions, unsetInputOptions);
+}
+function createOutput(outputBundle) {
+    return {
+        output: Object.values(outputBundle).filter(outputFile => Object.keys(outputFile).length > 0).sort((outputFileA, outputFileB) => getSortingFileType(outputFileA) - getSortingFileType(outputFileB))
+    };
+}
+var SortingFileType;
+(function (SortingFileType) {
+    SortingFileType[SortingFileType["ENTRY_CHUNK"] = 0] = "ENTRY_CHUNK";
+    SortingFileType[SortingFileType["SECONDARY_CHUNK"] = 1] = "SECONDARY_CHUNK";
+    SortingFileType[SortingFileType["ASSET"] = 2] = "ASSET";
+})(SortingFileType || (SortingFileType = {}));
+function getSortingFileType(file) {
+    if (file.type === 'asset') {
+        return SortingFileType.ASSET;
+    }
+    if (file.isEntry) {
+        return SortingFileType.ENTRY_CHUNK;
+    }
+    return SortingFileType.SECONDARY_CHUNK;
+}
+async function writeOutputFile(outputFile, outputOptions) {
+    const fileName = path.resolve(outputOptions.dir || path.dirname(outputOptions.file), outputFile.fileName);
+    // 'recursive: true' does not throw if the folder structure, or parts of it, already exist
+    await promises.mkdir(path.dirname(fileName), { recursive: true });
+    return promises.writeFile(fileName, outputFile.type === 'asset' ? outputFile.source : outputFile.code);
+}
+/**
+ * Auxiliary function for defining rollup configuration
+ * Mainly to facilitate IDE code prompts, after all, export default does not
+ * prompt, even if you add @type annotations, it is not accurate
+ * @param options
+ */
+function defineConfig(options) {
+    return options;
+}
+
+exports.blue = blue;
+exports.bold = bold;
+exports.commandAliases = commandAliases;
+exports.createFilter = createFilter;
+exports.cyan = cyan$1;
+exports.cyan$1 = cyan;
+exports.defineConfig = defineConfig;
+exports.ensureArray = ensureArray$1;
+exports.getAugmentedNamespace = getAugmentedNamespace;
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
+exports.getNewArray = getNewArray;
+exports.getOrCreate = getOrCreate;
+exports.gray = gray;
+exports.green = green;
+exports.handleError = handleError;
+exports.isWatchEnabled = isWatchEnabled;
+exports.mergeOptions = mergeOptions;
+exports.normalizePluginOption = normalizePluginOption;
+exports.rollup = rollup;
+exports.rollupInternal = rollupInternal;
+exports.stderr = stderr;
+exports.underline = underline;
+exports.version = version;
+exports.yellow = yellow;
+//# sourceMappingURL=rollup.js.map
diff --git a/node_modules/rollup/dist/shared/watch-cli.js b/node_modules/rollup/dist/shared/watch-cli.js
new file mode 100644
index 0000000..694b02b
--- /dev/null
+++ b/node_modules/rollup/dist/shared/watch-cli.js
@@ -0,0 +1,563 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index = require('./index.js');
+const promises = require('node:fs/promises');
+const process$2 = require('node:process');
+const cli = require('../bin/rollup');
+const rollup = require('./rollup.js');
+const parseAst_js = require('./parseAst.js');
+const loadConfigFile_js = require('./loadConfigFile.js');
+const node_child_process = require('node:child_process');
+const rollup_js = require('../rollup.js');
+require('path');
+require('fs');
+require('util');
+require('stream');
+require('os');
+require('./fsevents-importer.js');
+require('events');
+require('node:path');
+require('tty');
+require('../native.js');
+require('node:perf_hooks');
+require('node:url');
+require('../getLogFilter.js');
+
+function timeZone(date = new Date()) {
+	const offset = date.getTimezoneOffset();
+	const absOffset = Math.abs(offset);
+	const hours = Math.floor(absOffset / 60);
+	const minutes = absOffset % 60;
+	const minutesOut = minutes > 0 ? ':' + ('0' + minutes).slice(-2) : '';
+	return (offset < 0 ? '+' : '-') + hours + minutesOut;
+}
+
+function dateTime(options = {}) {
+	let {
+		date = new Date(),
+		local = true,
+		showTimeZone = false,
+		showMilliseconds = false
+	} = options;
+
+	if (local) {
+		// Offset the date so it will return the correct value when getting the ISO string.
+		date = new Date(date.getTime() - (date.getTimezoneOffset() * 60000));
+	}
+
+	let end = '';
+
+	if (showTimeZone) {
+		end = ' UTC' + (local ? timeZone(date) : '');
+	}
+
+	if (showMilliseconds && date.getUTCMilliseconds() > 0) {
+		end = ` ${date.getUTCMilliseconds()}ms${end}`;
+	}
+
+	return date
+		.toISOString()
+		.replace(/T/, ' ')
+		.replace(/\..+/, end);
+}
+
+/**
+ * This is not the set of all possible signals.
+ *
+ * It IS, however, the set of all signals that trigger
+ * an exit on either Linux or BSD systems.  Linux is a
+ * superset of the signal names supported on BSD, and
+ * the unknown signals just fail to register, so we can
+ * catch that easily enough.
+ *
+ * Windows signals are a different set, since there are
+ * signals that terminate Windows processes, but don't
+ * terminate (or don't even exist) on Posix systems.
+ *
+ * Don't bother with SIGKILL.  It's uncatchable, which
+ * means that we can't fire any callbacks anyway.
+ *
+ * If a user does happen to register a handler on a non-
+ * fatal signal like SIGWINCH or something, and then
+ * exit, it'll end up firing `process.emit('exit')`, so
+ * the handler will be fired anyway.
+ *
+ * SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+ * artificially, inherently leave the process in a
+ * state from which it is not safe to try and enter JS
+ * listeners.
+ */
+const signals = [];
+signals.push('SIGHUP', 'SIGINT', 'SIGTERM');
+if (process.platform !== 'win32') {
+    signals.push('SIGALRM', 'SIGABRT', 'SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+    );
+}
+if (process.platform === 'linux') {
+    signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT');
+}
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+const processOk = (process) => !!process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function';
+const kExitEmitter = Symbol.for('signal-exit emitter');
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+// teeny special purpose ee
+class Emitter {
+    emitted = {
+        afterExit: false,
+        exit: false,
+    };
+    listeners = {
+        afterExit: [],
+        exit: [],
+    };
+    count = 0;
+    id = Math.random();
+    constructor() {
+        if (global[kExitEmitter]) {
+            return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+            value: this,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    }
+    on(ev, fn) {
+        this.listeners[ev].push(fn);
+    }
+    removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        /* c8 ignore start */
+        if (i === -1) {
+            return;
+        }
+        /* c8 ignore stop */
+        if (i === 0 && list.length === 1) {
+            list.length = 0;
+        }
+        else {
+            list.splice(i, 1);
+        }
+    }
+    emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+            return false;
+        }
+        this.emitted[ev] = true;
+        let ret = false;
+        for (const fn of this.listeners[ev]) {
+            ret = fn(code, signal) === true || ret;
+        }
+        if (ev === 'exit') {
+            ret = this.emit('afterExit', code, signal) || ret;
+        }
+        return ret;
+    }
+}
+class SignalExitBase {
+}
+const signalExitWrap = (handler) => {
+    return {
+        onExit(cb, opts) {
+            return handler.onExit(cb, opts);
+        },
+        load() {
+            return handler.load();
+        },
+        unload() {
+            return handler.unload();
+        },
+    };
+};
+class SignalExitFallback extends SignalExitBase {
+    onExit() {
+        return () => { };
+    }
+    load() { }
+    unload() { }
+}
+class SignalExit extends SignalExitBase {
+    // "SIGHUP" throws an `ENOSYS` error on Windows,
+    // so use a supported signal instead
+    /* c8 ignore start */
+    #hupSig = process$1.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
+    /* c8 ignore stop */
+    #emitter = new Emitter();
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process) {
+        super();
+        this.#process = process;
+        // { <signal>: <listener fn>, ... }
+        this.#sigListeners = {};
+        for (const sig of signals) {
+            this.#sigListeners[sig] = () => {
+                // If there are no other listeners, an exit is coming!
+                // Simplest way: remove us and then re-send the signal.
+                // We know that this will kill the process, so we can
+                // safely emit now.
+                const listeners = this.#process.listeners(sig);
+                let { count } = this.#emitter;
+                // This is a workaround for the fact that signal-exit v3 and signal
+                // exit v4 are not aware of each other, and each will attempt to let
+                // the other handle it, so neither of them do. To correct this, we
+                // detect if we're the only handler *except* for previous versions
+                // of signal-exit, and increment by the count of listeners it has
+                // created.
+                /* c8 ignore start */
+                const p = process;
+                if (typeof p.__signal_exit_emitter__ === 'object' &&
+                    typeof p.__signal_exit_emitter__.count === 'number') {
+                    count += p.__signal_exit_emitter__.count;
+                }
+                /* c8 ignore stop */
+                if (listeners.length === count) {
+                    this.unload();
+                    const ret = this.#emitter.emit('exit', null, sig);
+                    /* c8 ignore start */
+                    const s = sig === 'SIGHUP' ? this.#hupSig : sig;
+                    if (!ret)
+                        process.kill(process.pid, s);
+                    /* c8 ignore stop */
+                }
+            };
+        }
+        this.#originalProcessReallyExit = process.reallyExit;
+        this.#originalProcessEmit = process.emit;
+    }
+    onExit(cb, opts) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return () => { };
+        }
+        /* c8 ignore stop */
+        if (this.#loaded === false) {
+            this.load();
+        }
+        const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
+        this.#emitter.on(ev, cb);
+        return () => {
+            this.#emitter.removeListener(ev, cb);
+            if (this.#emitter.listeners['exit'].length === 0 &&
+                this.#emitter.listeners['afterExit'].length === 0) {
+                this.unload();
+            }
+        };
+    }
+    load() {
+        if (this.#loaded) {
+            return;
+        }
+        this.#loaded = true;
+        // This is the number of onSignalExit's that are in play.
+        // It's important so that we can count the correct number of
+        // listeners on signals, and don't wait for the other one to
+        // handle it instead of us.
+        this.#emitter.count += 1;
+        for (const sig of signals) {
+            try {
+                const fn = this.#sigListeners[sig];
+                if (fn)
+                    this.#process.on(sig, fn);
+            }
+            catch (_) { }
+        }
+        this.#process.emit = (ev, ...a) => {
+            return this.#processEmit(ev, ...a);
+        };
+        this.#process.reallyExit = (code) => {
+            return this.#processReallyExit(code);
+        };
+    }
+    unload() {
+        if (!this.#loaded) {
+            return;
+        }
+        this.#loaded = false;
+        signals.forEach(sig => {
+            const listener = this.#sigListeners[sig];
+            /* c8 ignore start */
+            if (!listener) {
+                throw new Error('Listener not defined for signal: ' + sig);
+            }
+            /* c8 ignore stop */
+            try {
+                this.#process.removeListener(sig, listener);
+                /* c8 ignore start */
+            }
+            catch (_) { }
+            /* c8 ignore stop */
+        });
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+        /* c8 ignore start */
+        if (!processOk(this.#process)) {
+            return 0;
+        }
+        this.#process.exitCode = code || 0;
+        /* c8 ignore stop */
+        this.#emitter.emit('exit', this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === 'exit' && processOk(this.#process)) {
+            if (typeof args[0] === 'number') {
+                this.#process.exitCode = args[0];
+                /* c8 ignore start */
+            }
+            /* c8 ignore start */
+            const ret = og.call(this.#process, ev, ...args);
+            /* c8 ignore start */
+            this.#emitter.emit('exit', this.#process.exitCode, null);
+            /* c8 ignore stop */
+            return ret;
+        }
+        else {
+            return og.call(this.#process, ev, ...args);
+        }
+    }
+}
+const process$1 = globalThis.process;
+// wrap so that we call the method on the actual handler, without
+// exporting it directly.
+const { 
+/**
+ * Called when the process is exiting, whether via signal, explicit
+ * exit, or running out of stuff to do.
+ *
+ * If the global process object is not suitable for instrumentation,
+ * then this will be a no-op.
+ *
+ * Returns a function that may be used to unload signal-exit.
+ */
+onExit, 
+/**
+ * Load the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+load, 
+/**
+ * Unload the listeners.  Likely you never need to call this, unless
+ * doing a rather deep integration with signal-exit functionality.
+ * Mostly exposed for the benefit of testing.
+ *
+ * @internal
+ */
+unload, } = signalExitWrap(processOk(process$1) ? new SignalExit(process$1) : new SignalExitFallback());
+
+const CLEAR_SCREEN = '\u001Bc';
+function getResetScreen(configs, allowClearScreen) {
+    let clearScreen = allowClearScreen;
+    for (const config of configs) {
+        if (config.watch && config.watch.clearScreen === false) {
+            clearScreen = false;
+        }
+    }
+    if (clearScreen) {
+        return (heading) => rollup.stderr(CLEAR_SCREEN + heading);
+    }
+    let firstRun = true;
+    return (heading) => {
+        if (firstRun) {
+            rollup.stderr(heading);
+            firstRun = false;
+        }
+    };
+}
+
+function extractWatchHooks(command) {
+    if (!Array.isArray(command.watch))
+        return {};
+    return command.watch
+        .filter(value => typeof value === 'object')
+        .reduce((accumulator, keyValueOption) => ({ ...accumulator, ...keyValueOption }), {});
+}
+function createWatchHooks(command) {
+    const watchHooks = extractWatchHooks(command);
+    return function (hook) {
+        if (watchHooks[hook]) {
+            const cmd = watchHooks[hook];
+            if (!command.silent) {
+                rollup.stderr(rollup.cyan$1(`watch.${hook} ${rollup.bold(`$ ${cmd}`)}`));
+            }
+            try {
+                // !! important - use stderr for all writes from execSync
+                const stdio = [process.stdin, process.stderr, process.stderr];
+                node_child_process.execSync(cmd, { stdio: command.silent ? 'ignore' : stdio });
+            }
+            catch (error) {
+                rollup.stderr(error.message);
+            }
+        }
+    };
+}
+
+async function watch(command) {
+    process$2.env.ROLLUP_WATCH = 'true';
+    const isTTY = process$2.stderr.isTTY;
+    const silent = command.silent;
+    let watcher;
+    let configWatcher;
+    let resetScreen;
+    const configFile = command.config ? await cli.getConfigPath(command.config) : null;
+    const runWatchHook = createWatchHooks(command);
+    onExit(close);
+    process$2.on('uncaughtException', closeWithError);
+    if (!process$2.stdin.isTTY) {
+        process$2.stdin.on('end', close);
+        process$2.stdin.resume();
+    }
+    async function loadConfigFromFileAndTrack(configFile) {
+        let configFileData = null;
+        let configFileRevision = 0;
+        configWatcher = index.chokidar.watch(configFile).on('change', reloadConfigFile);
+        await reloadConfigFile();
+        async function reloadConfigFile() {
+            try {
+                const newConfigFileData = await promises.readFile(configFile, 'utf8');
+                if (newConfigFileData === configFileData) {
+                    return;
+                }
+                configFileRevision++;
+                const currentConfigFileRevision = configFileRevision;
+                if (configFileData) {
+                    rollup.stderr(`\nReloading updated config...`);
+                }
+                configFileData = newConfigFileData;
+                const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command, true);
+                if (currentConfigFileRevision !== configFileRevision) {
+                    return;
+                }
+                if (watcher) {
+                    await watcher.close();
+                }
+                start(options, warnings);
+            }
+            catch (error) {
+                rollup.handleError(error, true);
+            }
+        }
+    }
+    if (configFile) {
+        await loadConfigFromFileAndTrack(configFile);
+    }
+    else {
+        const { options, warnings } = await cli.loadConfigFromCommand(command, true);
+        await start(options, warnings);
+    }
+    async function start(configs, warnings) {
+        watcher = rollup_js.watch(configs);
+        watcher.on('event', event => {
+            switch (event.code) {
+                case 'ERROR': {
+                    warnings.flush();
+                    rollup.handleError(event.error, true);
+                    runWatchHook('onError');
+                    break;
+                }
+                case 'START': {
+                    if (!silent) {
+                        if (!resetScreen) {
+                            resetScreen = getResetScreen(configs, isTTY);
+                        }
+                        resetScreen(rollup.underline(`rollup v${rollup.version}`));
+                    }
+                    runWatchHook('onStart');
+                    break;
+                }
+                case 'BUNDLE_START': {
+                    if (!silent) {
+                        let input = event.input;
+                        if (typeof input !== 'string') {
+                            input = Array.isArray(input)
+                                ? input.join(', ')
+                                : Object.values(input).join(', ');
+                        }
+                        rollup.stderr(rollup.cyan$1(`bundles ${rollup.bold(input)} → ${rollup.bold(event.output.map(parseAst_js.relativeId).join(', '))}...`));
+                    }
+                    runWatchHook('onBundleStart');
+                    break;
+                }
+                case 'BUNDLE_END': {
+                    warnings.flush();
+                    if (!silent)
+                        rollup.stderr(rollup.green(`created ${rollup.bold(event.output.map(parseAst_js.relativeId).join(', '))} in ${rollup.bold(cli.prettyMilliseconds(event.duration))}`));
+                    runWatchHook('onBundleEnd');
+                    if (event.result && event.result.getTimings) {
+                        cli.printTimings(event.result.getTimings());
+                    }
+                    break;
+                }
+                case 'END': {
+                    runWatchHook('onEnd');
+                    if (!silent && isTTY) {
+                        rollup.stderr(`\n[${dateTime()}] waiting for changes...`);
+                    }
+                }
+            }
+            if ('result' in event && event.result) {
+                event.result.close().catch(error => rollup.handleError(error, true));
+            }
+        });
+    }
+    function close(code) {
+        process$2.removeListener('uncaughtException', closeWithError);
+        // removing a non-existent listener is a no-op
+        process$2.stdin.removeListener('end', close);
+        if (configWatcher)
+            configWatcher.close();
+        Promise.resolve(watcher?.close()).finally(() => {
+            process$2.exit(typeof code === 'number' ? code : 0);
+        });
+        // Tell signal-exit that we are handling this gracefully
+        return true;
+    }
+    // return a promise that never resolves to keep the process running
+    return new Promise(() => { });
+}
+function closeWithError(error) {
+    error.name = `Uncaught ${error.name}`;
+    rollup.handleError(error);
+}
+
+exports.watch = watch;
+//# sourceMappingURL=watch-cli.js.map
diff --git a/node_modules/rollup/dist/shared/watch.js b/node_modules/rollup/dist/shared/watch.js
new file mode 100644
index 0000000..ab85be6
--- /dev/null
+++ b/node_modules/rollup/dist/shared/watch.js
@@ -0,0 +1,323 @@
+/*
+  @license
+	Rollup.js v4.24.0
+	Wed, 02 Oct 2024 09:36:48 GMT - commit d3c000f4fd453e39a354299f0cfaa6831f56d7d8
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const rollup = require('./rollup.js');
+const path = require('node:path');
+const process = require('node:process');
+const index = require('./index.js');
+const node_os = require('node:os');
+require('./parseAst.js');
+require('../native.js');
+require('tty');
+require('path');
+require('node:perf_hooks');
+require('node:fs/promises');
+require('fs');
+require('util');
+require('stream');
+require('os');
+require('./fsevents-importer.js');
+require('events');
+
+class FileWatcher {
+    constructor(task, chokidarOptions) {
+        this.transformWatchers = new Map();
+        this.chokidarOptions = chokidarOptions;
+        this.task = task;
+        this.watcher = this.createWatcher(null);
+    }
+    close() {
+        this.watcher.close();
+        for (const watcher of this.transformWatchers.values()) {
+            watcher.close();
+        }
+    }
+    unwatch(id) {
+        this.watcher.unwatch(id);
+        const transformWatcher = this.transformWatchers.get(id);
+        if (transformWatcher) {
+            this.transformWatchers.delete(id);
+            transformWatcher.close();
+        }
+    }
+    watch(id, isTransformDependency) {
+        if (isTransformDependency) {
+            const watcher = this.transformWatchers.get(id) ?? this.createWatcher(id);
+            watcher.add(id);
+            this.transformWatchers.set(id, watcher);
+        }
+        else {
+            this.watcher.add(id);
+        }
+    }
+    createWatcher(transformWatcherId) {
+        const task = this.task;
+        const isLinux = node_os.platform() === 'linux';
+        const isTransformDependency = transformWatcherId !== null;
+        const handleChange = (id, event) => {
+            const changedId = transformWatcherId || id;
+            if (isLinux) {
+                // unwatching and watching fixes an issue with chokidar where on certain systems,
+                // a file that was unlinked and immediately recreated would create a change event
+                // but then no longer any further events
+                watcher.unwatch(changedId);
+                watcher.add(changedId);
+            }
+            task.invalidate(changedId, { event, isTransformDependency });
+        };
+        const watcher = index.chokidar
+            .watch([], this.chokidarOptions)
+            .on('add', id => handleChange(id, 'create'))
+            .on('change', id => handleChange(id, 'update'))
+            .on('unlink', id => handleChange(id, 'delete'));
+        return watcher;
+    }
+}
+
+const eventsRewrites = {
+    create: {
+        create: 'buggy',
+        delete: null, //delete file from map
+        update: 'create'
+    },
+    delete: {
+        create: 'update',
+        delete: 'buggy',
+        update: 'buggy'
+    },
+    update: {
+        create: 'buggy',
+        delete: 'delete',
+        update: 'update'
+    }
+};
+class Watcher {
+    constructor(optionsList, emitter) {
+        this.buildDelay = 0;
+        this.buildTimeout = null;
+        this.closed = false;
+        this.invalidatedIds = new Map();
+        this.rerun = false;
+        this.running = true;
+        this.emitter = emitter;
+        emitter.close = this.close.bind(this);
+        this.tasks = optionsList.map(options => new Task(this, options));
+        for (const { watch } of optionsList) {
+            if (watch && typeof watch.buildDelay === 'number') {
+                this.buildDelay = Math.max(this.buildDelay, watch.buildDelay);
+            }
+        }
+        process.nextTick(() => this.run());
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        for (const task of this.tasks) {
+            task.close();
+        }
+        await this.emitter.emit('close');
+        this.emitter.removeAllListeners();
+    }
+    invalidate(file) {
+        if (file) {
+            const previousEvent = this.invalidatedIds.get(file.id);
+            const event = previousEvent ? eventsRewrites[previousEvent][file.event] : file.event;
+            if (event === 'buggy') {
+                //TODO: throws or warn? Currently just ignore, uses new event
+                this.invalidatedIds.set(file.id, file.event);
+            }
+            else if (event === null) {
+                this.invalidatedIds.delete(file.id);
+            }
+            else {
+                this.invalidatedIds.set(file.id, event);
+            }
+        }
+        if (this.running) {
+            this.rerun = true;
+            return;
+        }
+        if (this.buildTimeout)
+            clearTimeout(this.buildTimeout);
+        this.buildTimeout = setTimeout(async () => {
+            this.buildTimeout = null;
+            try {
+                await Promise.all([...this.invalidatedIds].map(([id, event]) => this.emitter.emit('change', id, { event })));
+                this.invalidatedIds.clear();
+                await this.emitter.emit('restart');
+                this.emitter.removeListenersForCurrentRun();
+                this.run();
+            }
+            catch (error) {
+                this.invalidatedIds.clear();
+                await this.emitter.emit('event', {
+                    code: 'ERROR',
+                    error,
+                    result: null
+                });
+                await this.emitter.emit('event', {
+                    code: 'END'
+                });
+            }
+        }, this.buildDelay);
+    }
+    async run() {
+        this.running = true;
+        await this.emitter.emit('event', {
+            code: 'START'
+        });
+        for (const task of this.tasks) {
+            await task.run();
+        }
+        this.running = false;
+        await this.emitter.emit('event', {
+            code: 'END'
+        });
+        if (this.rerun) {
+            this.rerun = false;
+            this.invalidate();
+        }
+    }
+}
+class Task {
+    constructor(watcher, options) {
+        this.cache = { modules: [] };
+        this.watchFiles = [];
+        this.closed = false;
+        this.invalidated = true;
+        this.watched = new Set();
+        this.watcher = watcher;
+        this.options = options;
+        this.skipWrite = Boolean(options.watch && options.watch.skipWrite);
+        this.outputs = this.options.output;
+        this.outputFiles = this.outputs.map(output => {
+            if (output.file || output.dir)
+                return path.resolve(output.file || output.dir);
+            return undefined;
+        });
+        const watchOptions = this.options.watch || {};
+        this.filter = rollup.createFilter(watchOptions.include, watchOptions.exclude);
+        this.fileWatcher = new FileWatcher(this, {
+            ...watchOptions.chokidar,
+            disableGlobbing: true,
+            ignoreInitial: true
+        });
+    }
+    close() {
+        this.closed = true;
+        this.fileWatcher.close();
+    }
+    invalidate(id, details) {
+        this.invalidated = true;
+        if (details.isTransformDependency) {
+            for (const module of this.cache.modules) {
+                if (!module.transformDependencies.includes(id))
+                    continue;
+                // effective invalidation
+                module.originalCode = null;
+            }
+        }
+        this.watcher.invalidate({ event: details.event, id });
+    }
+    async run() {
+        if (!this.invalidated)
+            return;
+        this.invalidated = false;
+        const options = {
+            ...this.options,
+            cache: this.cache
+        };
+        const start = Date.now();
+        await this.watcher.emitter.emit('event', {
+            code: 'BUNDLE_START',
+            input: this.options.input,
+            output: this.outputFiles
+        });
+        let result = null;
+        try {
+            result = await rollup.rollupInternal(options, this.watcher.emitter);
+            if (this.closed) {
+                return;
+            }
+            this.updateWatchedFiles(result);
+            if (!this.skipWrite) {
+                await Promise.all(this.outputs.map(output => result.write(output)));
+                if (this.closed) {
+                    return;
+                }
+                this.updateWatchedFiles(result);
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'BUNDLE_END',
+                duration: Date.now() - start,
+                input: this.options.input,
+                output: this.outputFiles,
+                result
+            });
+        }
+        catch (error) {
+            if (!this.closed) {
+                if (Array.isArray(error.watchFiles)) {
+                    for (const id of error.watchFiles) {
+                        this.watchFile(id);
+                    }
+                }
+                if (error.id) {
+                    this.cache.modules = this.cache.modules.filter(module => module.id !== error.id);
+                }
+            }
+            await this.watcher.emitter.emit('event', {
+                code: 'ERROR',
+                error,
+                result
+            });
+        }
+    }
+    updateWatchedFiles(result) {
+        const previouslyWatched = this.watched;
+        this.watched = new Set();
+        this.watchFiles = result.watchFiles;
+        this.cache = result.cache;
+        for (const id of this.watchFiles) {
+            this.watchFile(id);
+        }
+        for (const module of this.cache.modules) {
+            for (const depId of module.transformDependencies) {
+                this.watchFile(depId, true);
+            }
+        }
+        for (const id of previouslyWatched) {
+            if (!this.watched.has(id)) {
+                this.fileWatcher.unwatch(id);
+            }
+        }
+    }
+    watchFile(id, isTransformDependency = false) {
+        if (!this.filter(id))
+            return;
+        this.watched.add(id);
+        if (this.outputFiles.includes(id)) {
+            throw new Error('Cannot import the generated bundle');
+        }
+        // this is necessary to ensure that any 'renamed' files
+        // continue to be watched following an error
+        this.fileWatcher.watch(id, isTransformDependency);
+    }
+}
+
+exports.Task = Task;
+exports.Watcher = Watcher;
+//# sourceMappingURL=watch.js.map
diff --git a/node_modules/rollup/package.json b/node_modules/rollup/package.json
new file mode 100644
index 0000000..e69d472
--- /dev/null
+++ b/node_modules/rollup/package.json
@@ -0,0 +1,261 @@
+{
+  "name": "rollup",
+  "version": "4.24.0",
+  "description": "Next-generation ES module bundler",
+  "main": "dist/rollup.js",
+  "module": "dist/es/rollup.js",
+  "types": "dist/rollup.d.ts",
+  "bin": {
+    "rollup": "dist/bin/rollup"
+  },
+  "napi": {
+    "name": "rollup",
+    "package": {
+      "name": "@rollup/rollup"
+    },
+    "triples": {
+      "defaults": false,
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-linux-android",
+        "aarch64-pc-windows-msvc",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "armv7-linux-androideabi",
+        "armv7-unknown-linux-gnueabihf",
+        "armv7-unknown-linux-musleabihf",
+        "i686-pc-windows-msvc",
+        "riscv64gc-unknown-linux-gnu",
+        "powerpc64le-unknown-linux-gnu",
+        "s390x-unknown-linux-gnu",
+        "x86_64-apple-darwin",
+        "x86_64-pc-windows-msvc",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "concurrently -c green,blue \"npm run build:wasm\" \"npm:build:ast-converters\" && concurrently -c green,blue \"npm run build:napi -- --release\" \"npm:build:js\" && npm run build:copy-native",
+    "build:quick": "concurrently -c green,blue 'npm:build:napi' 'npm:build:cjs' && npm run build:copy-native",
+    "build:napi": "napi build --platform --dts native.d.ts --js false --cargo-cwd rust -p bindings_napi --cargo-name bindings_napi",
+    "build:wasm": "cross-env RUSTFLAGS=\"-C opt-level=z\" wasm-pack build rust/bindings_wasm --out-dir ../../wasm --target web --no-pack && shx rm wasm/.gitignore",
+    "build:wasm:node": "wasm-pack build rust/bindings_wasm --out-dir ../../wasm-node --target nodejs --no-pack && shx rm wasm-node/.gitignore",
+    "update:napi": "npm run build:napi && npm run build:copy-native",
+    "build:js": "rollup --config rollup.config.ts --configPlugin typescript --forceExit",
+    "build:js:node": "rollup --config rollup.config.ts --configPlugin typescript --configIsBuildNode --forceExit",
+    "build:prepare": "concurrently -c green,blue \"npm run build:napi -- --release\" \"npm:build:js:node\" && npm run build:copy-native",
+    "update:js": "npm run build:js && npm run build:copy-native",
+    "build:copy-native": "shx mkdir -p dist && shx cp rollup.*.node dist/",
+    "dev": "concurrently -kc green,blue 'nodemon --watch rust -e rs --exec \"npm run build:wasm\"' 'vitepress dev docs'",
+    "build:cjs": "rollup --config rollup.config.ts --configPlugin typescript --configTest --forceExit",
+    "build:bootstrap": "shx mv dist dist-build && node dist-build/bin/rollup --config rollup.config.ts --configPlugin typescript --forceExit && shx rm -rf dist-build",
+    "build:bootstrap:cjs": "shx mv dist dist-build && node dist-build/bin/rollup --config rollup.config.ts --configPlugin typescript --configTest --forceExit && shx rm -rf dist-build",
+    "build:docs": "vitepress build docs",
+    "build:ast-converters": "node scripts/generate-ast-converters.js",
+    "preview:docs": "vitepress preview docs",
+    "ci:artifacts": "napi artifacts",
+    "ci:lint": "concurrently -c red,yellow,green,blue 'npm:lint:js:nofix' 'npm:lint:native-js' 'npm:lint:markdown:nofix' 'npm:lint:rust:nofix'",
+    "ci:test:only": "npm run build:cjs && npm run build:copy-native && npm run build:bootstrap && npm run build:copy-native && npm run test:only",
+    "ci:test:all": "npm run build:cjs && npm run build:copy-native && npm run build:bootstrap && npm run build:copy-native && concurrently --kill-others-on-fail -c green,blue,magenta,cyan 'npm:test:only' 'npm:test:typescript' 'npm:test:leak' 'npm:test:browser'",
+    "ci:coverage": "npm run build:cjs && npm run build:copy-native && npm run build:bootstrap && npm run build:copy-native && nyc --reporter lcovonly mocha",
+    "lint": "concurrently -c red,yellow,green,blue 'npm:lint:js' 'npm:lint:native-js' 'npm:lint:markdown' 'npm:lint:rust'",
+    "lint:js": "eslint . --fix --cache",
+    "lint:js:nofix": "eslint . --cache",
+    "lint:native-js": "node scripts/lint-native-js.js",
+    "lint:markdown": "prettier --write \"**/*.md\"",
+    "lint:markdown:nofix": "prettier --check \"**/*.md\"",
+    "lint:rust": "cd rust && cargo fmt && cargo clippy --fix --allow-dirty",
+    "lint:rust:nofix": "cd rust && cargo fmt --check && cargo clippy",
+    "perf": "npm run build:bootstrap:cjs && node --expose-gc scripts/perf-report/index.js",
+    "prepare": "husky && node scripts/check-release.js || npm run build:prepare",
+    "prepublishOnly": "node scripts/check-release.js && node scripts/prepublish.js",
+    "postpublish": "node scripts/postpublish.js",
+    "prepublish:napi": "napi prepublish --skip-gh-release",
+    "release": "node scripts/prepare-release.js",
+    "release:docs": "git fetch --update-head-ok origin master:master && git branch --force documentation-published master && git push origin documentation-published",
+    "check-audit": "check-audit",
+    "resolve-audit": "resolve-audit",
+    "test": "npm run build && npm run test:all",
+    "test:update-snapshots": "node scripts/update-snapshots.js",
+    "test:cjs": "npm run build:cjs && npm run test:only",
+    "test:quick": "mocha -b test/test.js",
+    "test:all": "concurrently --kill-others-on-fail -c green,blue,magenta,cyan,red 'npm:test:only' 'npm:test:browser' 'npm:test:typescript' 'npm:test:package' 'npm:test:options'",
+    "test:coverage": "npm run build:cjs && shx rm -rf coverage/* && nyc --reporter html mocha test/test.js",
+    "test:coverage:browser": "npm run build && shx rm -rf coverage/* && nyc mocha test/browser/index.js",
+    "test:leak": "npm install --no-save weak-napi && node --expose-gc test/leak/index.js",
+    "test:package": "node scripts/test-package.js",
+    "test:options": "node scripts/test-options.js",
+    "test:only": "mocha test/test.js",
+    "test:typescript": "shx rm -rf test/typescript/dist && shx cp -r dist test/typescript/ && tsc --noEmit -p test/typescript && tsc --noEmit && tsc --noEmit -p scripts",
+    "test:browser": "mocha test/browser/index.js",
+    "watch": "rollup --config rollup.config.ts --configPlugin typescript --watch"
+  },
+  "repository": "rollup/rollup",
+  "keywords": [
+    "modules",
+    "bundler",
+    "bundling",
+    "es6",
+    "optimizer"
+  ],
+  "author": "Rich Harris",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rollup/rollup/issues"
+  },
+  "homepage": "https://rollupjs.org/",
+  "optionalDependencies": {
+    "fsevents": "~2.3.2",
+    "@rollup/rollup-darwin-arm64": "4.24.0",
+    "@rollup/rollup-android-arm64": "4.24.0",
+    "@rollup/rollup-win32-arm64-msvc": "4.24.0",
+    "@rollup/rollup-linux-arm64-gnu": "4.24.0",
+    "@rollup/rollup-linux-arm64-musl": "4.24.0",
+    "@rollup/rollup-android-arm-eabi": "4.24.0",
+    "@rollup/rollup-linux-arm-gnueabihf": "4.24.0",
+    "@rollup/rollup-linux-arm-musleabihf": "4.24.0",
+    "@rollup/rollup-win32-ia32-msvc": "4.24.0",
+    "@rollup/rollup-linux-riscv64-gnu": "4.24.0",
+    "@rollup/rollup-linux-powerpc64le-gnu": "4.24.0",
+    "@rollup/rollup-linux-s390x-gnu": "4.24.0",
+    "@rollup/rollup-darwin-x64": "4.24.0",
+    "@rollup/rollup-win32-x64-msvc": "4.24.0",
+    "@rollup/rollup-linux-x64-gnu": "4.24.0",
+    "@rollup/rollup-linux-x64-musl": "4.24.0"
+  },
+  "dependencies": {
+    "@types/estree": "1.0.6"
+  },
+  "devDependenciesComments": {
+    "core-js": "We only update manually as every update requires a snapshot update"
+  },
+  "devDependencies": {
+    "@codemirror/commands": "^6.6.2",
+    "@codemirror/lang-javascript": "^6.2.2",
+    "@codemirror/language": "^6.10.3",
+    "@codemirror/search": "^6.5.6",
+    "@codemirror/state": "^6.4.1",
+    "@codemirror/view": "^6.33.0",
+    "@eslint/js": "^9.11.1",
+    "@inquirer/prompts": "^6.0.1",
+    "@jridgewell/sourcemap-codec": "^1.5.0",
+    "@mermaid-js/mermaid-cli": "^11.2.0",
+    "@napi-rs/cli": "^2.18.4",
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-buble": "^1.0.3",
+    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-replace": "^6.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.0",
+    "@rollup/pluginutils": "^5.1.2",
+    "@shikijs/vitepress-twoslash": "^1.18.0",
+    "@types/mocha": "^10.0.8",
+    "@types/node": "^18.19.50",
+    "@types/semver": "^7.5.8",
+    "@types/yargs-parser": "^21.0.3",
+    "@vue/language-server": "^2.1.6",
+    "acorn": "^8.12.1",
+    "acorn-import-assertions": "^1.9.0",
+    "acorn-jsx": "^5.3.2",
+    "buble": "^0.20.0",
+    "builtin-modules": "^4.0.0",
+    "chokidar": "^3.6.0",
+    "colorette": "^2.0.20",
+    "concurrently": "^9.0.1",
+    "core-js": "3.38.1",
+    "cross-env": "^7.0.3",
+    "date-time": "^4.0.0",
+    "es5-shim": "^4.6.7",
+    "es6-shim": "^0.35.8",
+    "eslint": "^9.11.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-unicorn": "^55.0.0",
+    "eslint-plugin-vue": "^9.28.0",
+    "fixturify": "^3.0.0",
+    "flru": "^1.0.2",
+    "fs-extra": "^11.2.0",
+    "github-api": "^3.4.0",
+    "globals": "^15.9.0",
+    "husky": "^9.1.6",
+    "is-reference": "^3.0.2",
+    "lint-staged": "^15.2.10",
+    "locate-character": "^3.0.0",
+    "magic-string": "^0.30.11",
+    "mocha": "^10.7.3",
+    "nodemon": "^3.1.7",
+    "npm-audit-resolver": "^3.0.0-RC.0",
+    "nyc": "^17.1.0",
+    "pinia": "^2.2.2",
+    "prettier": "^3.3.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "pretty-bytes": "^6.1.1",
+    "pretty-ms": "^9.1.0",
+    "requirejs": "^2.3.7",
+    "rollup": "^4.22.4",
+    "rollup-plugin-license": "^3.5.3",
+    "rollup-plugin-string": "^3.0.0",
+    "semver": "^7.6.3",
+    "shx": "^0.3.4",
+    "signal-exit": "^4.1.0",
+    "source-map": "^0.7.4",
+    "source-map-support": "^0.5.21",
+    "systemjs": "^6.15.1",
+    "terser": "^5.33.0",
+    "tslib": "^2.7.0",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.7.0",
+    "vite": "^5.4.7",
+    "vitepress": "^1.3.4",
+    "vue": "^3.5.8",
+    "vue-tsc": "^2.1.6",
+    "wasm-pack": "^0.13.0",
+    "yargs-parser": "^21.1.1"
+  },
+  "overrides": {
+    "axios": "^1.7.7",
+    "semver": "^7.6.3",
+    "ws": "^8.18.0"
+  },
+  "comments": {
+    "vue-tsc": "This is necessary so that prettier-plugin-organize-imports works correctly in Vue templatges",
+    "ws": "mermaid requires an older 8.13.0 version via puppeteer with vulnerabilities"
+  },
+  "files": [
+    "dist/*.node",
+    "dist/**/*.js",
+    "dist/*.d.ts",
+    "dist/bin/rollup",
+    "dist/es/package.json"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/rollup.d.ts",
+      "require": "./dist/rollup.js",
+      "import": "./dist/es/rollup.js"
+    },
+    "./loadConfigFile": {
+      "types": "./dist/loadConfigFile.d.ts",
+      "require": "./dist/loadConfigFile.js",
+      "default": "./dist/loadConfigFile.js"
+    },
+    "./getLogFilter": {
+      "types": "./dist/getLogFilter.d.ts",
+      "require": "./dist/getLogFilter.js",
+      "import": "./dist/es/getLogFilter.js"
+    },
+    "./parseAst": {
+      "types": "./dist/parseAst.d.ts",
+      "require": "./dist/parseAst.js",
+      "import": "./dist/es/parseAst.js"
+    },
+    "./dist/*": "./dist/*"
+  }
+}
\ No newline at end of file
diff --git a/node_modules/source-map-js/LICENSE b/node_modules/source-map-js/LICENSE
new file mode 100644
index 0000000..ed1b7cf
--- /dev/null
+++ b/node_modules/source-map-js/LICENSE
@@ -0,0 +1,28 @@
+
+Copyright (c) 2009-2011, Mozilla Foundation and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the names of the Mozilla Foundation nor the names of project
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/source-map-js/README.md b/node_modules/source-map-js/README.md
new file mode 100644
index 0000000..614962d
--- /dev/null
+++ b/node_modules/source-map-js/README.md
@@ -0,0 +1,765 @@
+# Source Map JS
+
+[![NPM](https://nodei.co/npm/source-map-js.png?downloads=true&downloadRank=true)](https://www.npmjs.com/package/source-map-js)
+
+Difference between original [source-map](https://github.com/mozilla/source-map):
+
+> TL,DR: it's fork of original source-map@0.6, but with perfomance optimizations.
+
+This journey starts from [source-map@0.7.0](https://github.com/mozilla/source-map/blob/master/CHANGELOG.md#070). Some part of it was rewritten to Rust and WASM and API became async.
+
+It's still a major block for many libraries like PostCSS or Sass for example because they need to migrate the whole API to the async way. This is the reason why 0.6.1 has 2x more downloads than 0.7.3 while it's faster several times.
+
+![Downloads count](media/downloads.png)
+
+More important that WASM version has some optimizations in JS code too. This is why [community asked to create branch for 0.6 version](https://github.com/mozilla/source-map/issues/324) and port these optimizations but, sadly, the answer was «no». A bit later I discovered [the issue](https://github.com/mozilla/source-map/issues/370) created by [Ben Rothman (@benthemonkey)](https://github.com/benthemonkey) with no response at all.
+
+[Roman Dvornov (@lahmatiy)](https://github.com/lahmatiy) wrote a [serveral posts](https://t.me/gorshochekvarit/76) (russian, only, sorry) about source-map library in his own Telegram channel. He mentioned the article [«Maybe you don't need Rust and WASM to speed up your JS»](https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html) written by [Vyacheslav Egorov (@mraleph)](https://github.com/mraleph). This article contains optimizations and hacks that lead to almost the same performance compare to WASM implementation.
+
+I decided to fork the original source-map and port these optimizations from the article and several others PR from the original source-map.
+
+---------
+
+This is a library to generate and consume the source map format
+[described here][format].
+
+[format]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+
+## Use with Node
+
+    $ npm install source-map-js
+
+<!-- ## Use on the Web
+
+    <script src="https://raw.githubusercontent.com/mozilla/source-map/master/dist/source-map.min.js" defer></script> -->
+
+--------------------------------------------------------------------------------
+
+<!-- `npm run toc` to regenerate the Table of Contents -->
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+## Table of Contents
+
+- [Examples](#examples)
+  - [Consuming a source map](#consuming-a-source-map)
+  - [Generating a source map](#generating-a-source-map)
+    - [With SourceNode (high level API)](#with-sourcenode-high-level-api)
+    - [With SourceMapGenerator (low level API)](#with-sourcemapgenerator-low-level-api)
+- [API](#api)
+  - [SourceMapConsumer](#sourcemapconsumer)
+    - [new SourceMapConsumer(rawSourceMap)](#new-sourcemapconsumerrawsourcemap)
+    - [SourceMapConsumer.prototype.computeColumnSpans()](#sourcemapconsumerprototypecomputecolumnspans)
+    - [SourceMapConsumer.prototype.originalPositionFor(generatedPosition)](#sourcemapconsumerprototypeoriginalpositionforgeneratedposition)
+    - [SourceMapConsumer.prototype.generatedPositionFor(originalPosition)](#sourcemapconsumerprototypegeneratedpositionfororiginalposition)
+    - [SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)](#sourcemapconsumerprototypeallgeneratedpositionsfororiginalposition)
+    - [SourceMapConsumer.prototype.hasContentsOfAllSources()](#sourcemapconsumerprototypehascontentsofallsources)
+    - [SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])](#sourcemapconsumerprototypesourcecontentforsource-returnnullonmissing)
+    - [SourceMapConsumer.prototype.eachMapping(callback, context, order)](#sourcemapconsumerprototypeeachmappingcallback-context-order)
+  - [SourceMapGenerator](#sourcemapgenerator)
+    - [new SourceMapGenerator([startOfSourceMap])](#new-sourcemapgeneratorstartofsourcemap)
+    - [SourceMapGenerator.fromSourceMap(sourceMapConsumer)](#sourcemapgeneratorfromsourcemapsourcemapconsumer)
+    - [SourceMapGenerator.prototype.addMapping(mapping)](#sourcemapgeneratorprototypeaddmappingmapping)
+    - [SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)](#sourcemapgeneratorprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])](#sourcemapgeneratorprototypeapplysourcemapsourcemapconsumer-sourcefile-sourcemappath)
+    - [SourceMapGenerator.prototype.toString()](#sourcemapgeneratorprototypetostring)
+  - [SourceNode](#sourcenode)
+    - [new SourceNode([line, column, source[, chunk[, name]]])](#new-sourcenodeline-column-source-chunk-name)
+    - [SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])](#sourcenodefromstringwithsourcemapcode-sourcemapconsumer-relativepath)
+    - [SourceNode.prototype.add(chunk)](#sourcenodeprototypeaddchunk)
+    - [SourceNode.prototype.prepend(chunk)](#sourcenodeprototypeprependchunk)
+    - [SourceNode.prototype.setSourceContent(sourceFile, sourceContent)](#sourcenodeprototypesetsourcecontentsourcefile-sourcecontent)
+    - [SourceNode.prototype.walk(fn)](#sourcenodeprototypewalkfn)
+    - [SourceNode.prototype.walkSourceContents(fn)](#sourcenodeprototypewalksourcecontentsfn)
+    - [SourceNode.prototype.join(sep)](#sourcenodeprototypejoinsep)
+    - [SourceNode.prototype.replaceRight(pattern, replacement)](#sourcenodeprototypereplacerightpattern-replacement)
+    - [SourceNode.prototype.toString()](#sourcenodeprototypetostring)
+    - [SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])](#sourcenodeprototypetostringwithsourcemapstartofsourcemap)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Examples
+
+### Consuming a source map
+
+```js
+var rawSourceMap = {
+  version: 3,
+  file: 'min.js',
+  names: ['bar', 'baz', 'n'],
+  sources: ['one.js', 'two.js'],
+  sourceRoot: 'http://example.com/www/js/',
+  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
+};
+
+var smc = new SourceMapConsumer(rawSourceMap);
+
+console.log(smc.sources);
+// [ 'http://example.com/www/js/one.js',
+//   'http://example.com/www/js/two.js' ]
+
+console.log(smc.originalPositionFor({
+  line: 2,
+  column: 28
+}));
+// { source: 'http://example.com/www/js/two.js',
+//   line: 2,
+//   column: 10,
+//   name: 'n' }
+
+console.log(smc.generatedPositionFor({
+  source: 'http://example.com/www/js/two.js',
+  line: 2,
+  column: 10
+}));
+// { line: 2, column: 28 }
+
+smc.eachMapping(function (m) {
+  // ...
+});
+```
+
+### Generating a source map
+
+In depth guide:
+[**Compiling to JavaScript, and Debugging with Source Maps**](https://hacks.mozilla.org/2013/05/compiling-to-javascript-and-debugging-with-source-maps/)
+
+#### With SourceNode (high level API)
+
+```js
+function compile(ast) {
+  switch (ast.type) {
+  case 'BinaryExpression':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      [compile(ast.left), " + ", compile(ast.right)]
+    );
+  case 'Literal':
+    return new SourceNode(
+      ast.location.line,
+      ast.location.column,
+      ast.location.source,
+      String(ast.value)
+    );
+  // ...
+  default:
+    throw new Error("Bad AST");
+  }
+}
+
+var ast = parse("40 + 2", "add.js");
+console.log(compile(ast).toStringWithSourceMap({
+  file: 'add.js'
+}));
+// { code: '40 + 2',
+//   map: [object SourceMapGenerator] }
+```
+
+#### With SourceMapGenerator (low level API)
+
+```js
+var map = new SourceMapGenerator({
+  file: "source-mapped.js"
+});
+
+map.addMapping({
+  generated: {
+    line: 10,
+    column: 35
+  },
+  source: "foo.js",
+  original: {
+    line: 33,
+    column: 2
+  },
+  name: "christopher"
+});
+
+console.log(map.toString());
+// '{"version":3,"file":"source-mapped.js","sources":["foo.js"],"names":["christopher"],"mappings":";;;;;;;;;mCAgCEA"}'
+```
+
+## API
+
+Get a reference to the module:
+
+```js
+// Node.js
+var sourceMap = require('source-map');
+
+// Browser builds
+var sourceMap = window.sourceMap;
+
+// Inside Firefox
+const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
+```
+
+### SourceMapConsumer
+
+A SourceMapConsumer instance represents a parsed source map which we can query
+for information about the original file positions by giving it a file position
+in the generated source.
+
+#### new SourceMapConsumer(rawSourceMap)
+
+The only parameter is the raw source map (either as a string which can be
+`JSON.parse`'d, or an object). According to the spec, source maps have the
+following attributes:
+
+* `version`: Which version of the source map spec this map is following.
+
+* `sources`: An array of URLs to the original source files.
+
+* `names`: An array of identifiers which can be referenced by individual
+  mappings.
+
+* `sourceRoot`: Optional. The URL root from which all sources are relative.
+
+* `sourcesContent`: Optional. An array of contents of the original source files.
+
+* `mappings`: A string of base64 VLQs which contain the actual mappings.
+
+* `file`: Optional. The generated filename this source map is associated with.
+
+```js
+var consumer = new sourceMap.SourceMapConsumer(rawSourceMapJsonData);
+```
+
+#### SourceMapConsumer.prototype.computeColumnSpans()
+
+Compute the last column for each generated mapping. The last column is
+inclusive.
+
+```js
+// Before:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+
+consumer.computeColumnSpans();
+
+// After:
+consumer.allGeneratedPositionsFor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1,
+//     lastColumn: 9 },
+//   { line: 2,
+//     column: 10,
+//     lastColumn: 19 },
+//   { line: 2,
+//     column: 20,
+//     lastColumn: Infinity } ]
+
+```
+
+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
+
+Returns the original source, line, and column information for the generated
+source's line and column positions provided. The only argument is an object with
+the following properties:
+
+* `line`: The line number in the generated source.  Line numbers in
+  this library are 1-based (note that the underlying source map
+  specification uses 0-based line numbers -- this library handles the
+  translation).
+
+* `column`: The column number in the generated source.  Column numbers
+  in this library are 0-based.
+
+* `bias`: Either `SourceMapConsumer.GREATEST_LOWER_BOUND` or
+  `SourceMapConsumer.LEAST_UPPER_BOUND`. Specifies whether to return the closest
+  element that is smaller than or greater than the one we are searching for,
+  respectively, if the exact element cannot be found.  Defaults to
+  `SourceMapConsumer.GREATEST_LOWER_BOUND`.
+
+and an object is returned with the following properties:
+
+* `source`: The original source file, or null if this information is not
+  available.
+
+* `line`: The line number in the original source, or null if this information is
+  not available.  The line number is 1-based.
+
+* `column`: The column number in the original source, or null if this
+  information is not available.  The column number is 0-based.
+
+* `name`: The original identifier, or null if this information is not available.
+
+```js
+consumer.originalPositionFor({ line: 2, column: 10 })
+// { source: 'foo.coffee',
+//   line: 2,
+//   column: 2,
+//   name: null }
+
+consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
+// { source: null,
+//   line: null,
+//   column: null,
+//   name: null }
+```
+
+#### SourceMapConsumer.prototype.generatedPositionFor(originalPosition)
+
+Returns the generated line and column information for the original source,
+line, and column positions provided. The only argument is an object with
+the following properties:
+
+* `source`: The filename of the original source.
+
+* `line`: The line number in the original source.  The line number is
+  1-based.
+
+* `column`: The column number in the original source.  The column
+  number is 0-based.
+
+and an object is returned with the following properties:
+
+* `line`: The line number in the generated source, or null.  The line
+  number is 1-based.
+
+* `column`: The column number in the generated source, or null.  The
+  column number is 0-based.
+
+```js
+consumer.generatedPositionFor({ source: "example.js", line: 2, column: 10 })
+// { line: 1,
+//   column: 56 }
+```
+
+#### SourceMapConsumer.prototype.allGeneratedPositionsFor(originalPosition)
+
+Returns all generated line and column information for the original source, line,
+and column provided. If no column is provided, returns all mappings
+corresponding to a either the line we are searching for or the next closest line
+that has any mappings. Otherwise, returns all mappings corresponding to the
+given line and either the column we are searching for or the next closest column
+that has any offsets.
+
+The only argument is an object with the following properties:
+
+* `source`: The filename of the original source.
+
+* `line`: The line number in the original source.  The line number is
+  1-based.
+
+* `column`: Optional. The column number in the original source.  The
+  column number is 0-based.
+
+and an array of objects is returned, each with the following properties:
+
+* `line`: The line number in the generated source, or null.  The line
+  number is 1-based.
+
+* `column`: The column number in the generated source, or null.  The
+  column number is 0-based.
+
+```js
+consumer.allGeneratedpositionsfor({ line: 2, source: "foo.coffee" })
+// [ { line: 2,
+//     column: 1 },
+//   { line: 2,
+//     column: 10 },
+//   { line: 2,
+//     column: 20 } ]
+```
+
+#### SourceMapConsumer.prototype.hasContentsOfAllSources()
+
+Return true if we have the embedded source content for every source listed in
+the source map, false otherwise.
+
+In other words, if this method returns `true`, then
+`consumer.sourceContentFor(s)` will succeed for every source `s` in
+`consumer.sources`.
+
+```js
+// ...
+if (consumer.hasContentsOfAllSources()) {
+  consumerReadyCallback(consumer);
+} else {
+  fetchSources(consumer, consumerReadyCallback);
+}
+// ...
+```
+
+#### SourceMapConsumer.prototype.sourceContentFor(source[, returnNullOnMissing])
+
+Returns the original source content for the source provided. The only
+argument is the URL of the original source file.
+
+If the source content for the given source is not found, then an error is
+thrown. Optionally, pass `true` as the second param to have `null` returned
+instead.
+
+```js
+consumer.sources
+// [ "my-cool-lib.clj" ]
+
+consumer.sourceContentFor("my-cool-lib.clj")
+// "..."
+
+consumer.sourceContentFor("this is not in the source map");
+// Error: "this is not in the source map" is not in the source map
+
+consumer.sourceContentFor("this is not in the source map", true);
+// null
+```
+
+#### SourceMapConsumer.prototype.eachMapping(callback, context, order)
+
+Iterate over each mapping between an original source/line/column and a
+generated line/column in this source map.
+
+* `callback`: The function that is called with each mapping. Mappings have the
+  form `{ source, generatedLine, generatedColumn, originalLine, originalColumn,
+  name }`
+
+* `context`: Optional. If specified, this object will be the value of `this`
+  every time that `callback` is called.
+
+* `order`: Either `SourceMapConsumer.GENERATED_ORDER` or
+  `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to iterate over
+  the mappings sorted by the generated file's line/column order or the
+  original's source/line/column order, respectively. Defaults to
+  `SourceMapConsumer.GENERATED_ORDER`.
+
+```js
+consumer.eachMapping(function (m) { console.log(m); })
+// ...
+// { source: 'illmatic.js',
+//   generatedLine: 1,
+//   generatedColumn: 0,
+//   originalLine: 1,
+//   originalColumn: 0,
+//   name: null }
+// { source: 'illmatic.js',
+//   generatedLine: 2,
+//   generatedColumn: 0,
+//   originalLine: 2,
+//   originalColumn: 0,
+//   name: null }
+// ...
+```
+### SourceMapGenerator
+
+An instance of the SourceMapGenerator represents a source map which is being
+built incrementally.
+
+#### new SourceMapGenerator([startOfSourceMap])
+
+You may pass an object with the following properties:
+
+* `file`: The filename of the generated source that this source map is
+  associated with.
+
+* `sourceRoot`: A root for all relative URLs in this source map.
+
+* `skipValidation`: Optional. When `true`, disables validation of mappings as
+  they are added. This can improve performance but should be used with
+  discretion, as a last resort. Even then, one should avoid using this flag when
+  running tests, if possible.
+
+* `ignoreInvalidMapping`: Optional. When `true`, instead of throwing error on
+  invalid mapping, it will be ignored.
+
+```js
+var generator = new sourceMap.SourceMapGenerator({
+  file: "my-generated-javascript-file.js",
+  sourceRoot: "http://example.com/app/js/"
+});
+```
+
+#### SourceMapGenerator.fromSourceMap(sourceMapConsumer, sourceMapGeneratorOptions)
+
+Creates a new `SourceMapGenerator` from an existing `SourceMapConsumer` instance.
+
+* `sourceMapConsumer` The SourceMap.
+
+* `sourceMapGeneratorOptions` options that will be passed to the SourceMapGenerator constructor which used under the hood.
+
+```js
+var generator = sourceMap.SourceMapGenerator.fromSourceMap(consumer, {
+  ignoreInvalidMapping: true,
+});
+```
+
+#### SourceMapGenerator.prototype.addMapping(mapping)
+
+Add a single mapping from original source line and column to the generated
+source's line and column for this source map being created. The mapping object
+should have the following properties:
+
+* `generated`: An object with the generated line and column positions.
+
+* `original`: An object with the original line and column positions.
+
+* `source`: The original source file (relative to the sourceRoot).
+
+* `name`: An optional original token name for this mapping.
+
+```js
+generator.addMapping({
+  source: "module-one.scm",
+  original: { line: 128, column: 0 },
+  generated: { line: 3, column: 456 }
+})
+```
+
+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for an original source file.
+
+* `sourceFile` the URL of the original source file.
+
+* `sourceContent` the content of the source file.
+
+```js
+generator.setSourceContent("module-one.scm",
+                           fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])
+
+Applies a SourceMap for a source file to the SourceMap.
+Each mapping to the supplied source file is rewritten using the
+supplied SourceMap. Note: The resolution for the resulting mappings
+is the minimum of this map and the supplied map.
+
+* `sourceMapConsumer`: The SourceMap to be applied.
+
+* `sourceFile`: Optional. The filename of the source file.
+  If omitted, sourceMapConsumer.file will be used, if it exists.
+  Otherwise an error will be thrown.
+
+* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
+  to be applied. If relative, it is relative to the SourceMap.
+
+  This parameter is needed when the two SourceMaps aren't in the same
+  directory, and the SourceMap to be applied contains relative source
+  paths. If so, those relative source paths need to be rewritten
+  relative to the SourceMap.
+
+  If omitted, it is assumed that both SourceMaps are in the same directory,
+  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
+
+#### SourceMapGenerator.prototype.toString()
+
+Renders the source map being generated to a string.
+
+```js
+generator.toString()
+// '{"version":3,"sources":["module-one.scm"],"names":[],"mappings":"...snip...","file":"my-generated-javascript-file.js","sourceRoot":"http://example.com/app/js/"}'
+```
+
+### SourceNode
+
+SourceNodes provide a way to abstract over interpolating and/or concatenating
+snippets of generated JavaScript source code, while maintaining the line and
+column information associated between those snippets and the original source
+code. This is useful as the final intermediate representation a compiler might
+use before outputting the generated JS and source map.
+
+#### new SourceNode([line, column, source[, chunk[, name]]])
+
+* `line`: The original line number associated with this source node, or null if
+  it isn't associated with an original line.  The line number is 1-based.
+
+* `column`: The original column number associated with this source node, or null
+  if it isn't associated with an original column.  The column number
+  is 0-based.
+
+* `source`: The original source's filename; null if no filename is provided.
+
+* `chunk`: Optional. Is immediately passed to `SourceNode.prototype.add`, see
+  below.
+
+* `name`: Optional. The original identifier.
+
+```js
+var node = new SourceNode(1, 2, "a.cpp", [
+  new SourceNode(3, 4, "b.cpp", "extern int status;\n"),
+  new SourceNode(5, 6, "c.cpp", "std::string* make_string(size_t n);\n"),
+  new SourceNode(7, 8, "d.cpp", "int main(int argc, char** argv) {}\n"),
+]);
+```
+
+#### SourceNode.fromStringWithSourceMap(code, sourceMapConsumer[, relativePath])
+
+Creates a SourceNode from generated code and a SourceMapConsumer.
+
+* `code`: The generated code
+
+* `sourceMapConsumer` The SourceMap for the generated code
+
+* `relativePath` The optional path that relative sources in `sourceMapConsumer`
+  should be relative to.
+
+```js
+var consumer = new SourceMapConsumer(fs.readFileSync("path/to/my-file.js.map", "utf8"));
+var node = SourceNode.fromStringWithSourceMap(fs.readFileSync("path/to/my-file.js"),
+                                              consumer);
+```
+
+#### SourceNode.prototype.add(chunk)
+
+Add a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.add(" + ");
+node.add(otherNode);
+node.add([leftHandOperandNode, " + ", rightHandOperandNode]);
+```
+
+#### SourceNode.prototype.prepend(chunk)
+
+Prepend a chunk of generated JS to this source node.
+
+* `chunk`: A string snippet of generated JS code, another instance of
+   `SourceNode`, or an array where each member is one of those things.
+
+```js
+node.prepend("/** Build Id: f783haef86324gf **/\n\n");
+```
+
+#### SourceNode.prototype.setSourceContent(sourceFile, sourceContent)
+
+Set the source content for a source file. This will be added to the
+`SourceMap` in the `sourcesContent` field.
+
+* `sourceFile`: The filename of the source file
+
+* `sourceContent`: The content of the source file
+
+```js
+node.setSourceContent("module-one.scm",
+                      fs.readFileSync("path/to/module-one.scm"))
+```
+
+#### SourceNode.prototype.walk(fn)
+
+Walk over the tree of JS snippets in this node and its children. The walking
+function is called once for each snippet of JS and is passed that snippet and
+the its original associated source's line/column location.
+
+* `fn`: The traversal function.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.walk(function (code, loc) { console.log("WALK:", code, loc); })
+// WALK: uno { source: 'b.js', line: 3, column: 4, name: null }
+// WALK: dos { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: tres { source: 'a.js', line: 1, column: 2, name: null }
+// WALK: quatro { source: 'c.js', line: 5, column: 6, name: null }
+```
+
+#### SourceNode.prototype.walkSourceContents(fn)
+
+Walk over the tree of SourceNodes. The walking function is called for each
+source file content and is passed the filename and source content.
+
+* `fn`: The traversal function.
+
+```js
+var a = new SourceNode(1, 2, "a.js", "generated from a");
+a.setSourceContent("a.js", "original a");
+var b = new SourceNode(1, 2, "b.js", "generated from b");
+b.setSourceContent("b.js", "original b");
+var c = new SourceNode(1, 2, "c.js", "generated from c");
+c.setSourceContent("c.js", "original c");
+
+var node = new SourceNode(null, null, null, [a, b, c]);
+node.walkSourceContents(function (source, contents) { console.log("WALK:", source, ":", contents); })
+// WALK: a.js : original a
+// WALK: b.js : original b
+// WALK: c.js : original c
+```
+
+#### SourceNode.prototype.join(sep)
+
+Like `Array.prototype.join` except for SourceNodes. Inserts the separator
+between each of this source node's children.
+
+* `sep`: The separator.
+
+```js
+var lhs = new SourceNode(1, 2, "a.rs", "my_copy");
+var operand = new SourceNode(3, 4, "a.rs", "=");
+var rhs = new SourceNode(5, 6, "a.rs", "orig.clone()");
+
+var node = new SourceNode(null, null, null, [ lhs, operand, rhs ]);
+var joinedNode = node.join(" ");
+```
+
+#### SourceNode.prototype.replaceRight(pattern, replacement)
+
+Call `String.prototype.replace` on the very right-most source snippet. Useful
+for trimming white space from the end of a source node, etc.
+
+* `pattern`: The pattern to replace.
+
+* `replacement`: The thing to replace the pattern with.
+
+```js
+// Trim trailing white space.
+node.replaceRight(/\s*$/, "");
+```
+
+#### SourceNode.prototype.toString()
+
+Return the string representation of this source node. Walks over the tree and
+concatenates all the various snippets together to one string.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toString()
+// 'unodostresquatro'
+```
+
+#### SourceNode.prototype.toStringWithSourceMap([startOfSourceMap])
+
+Returns the string representation of this tree of source nodes, plus a
+SourceMapGenerator which contains all the mappings between the generated and
+original sources.
+
+The arguments are the same as those to `new SourceMapGenerator`.
+
+```js
+var node = new SourceNode(1, 2, "a.js", [
+  new SourceNode(3, 4, "b.js", "uno"),
+  "dos",
+  [
+    "tres",
+    new SourceNode(5, 6, "c.js", "quatro")
+  ]
+]);
+
+node.toStringWithSourceMap({ file: "my-output-file.js" })
+// { code: 'unodostresquatro',
+//   map: [object SourceMapGenerator] }
+```
diff --git a/node_modules/source-map-js/lib/array-set.js b/node_modules/source-map-js/lib/array-set.js
new file mode 100644
index 0000000..fbd5c81
--- /dev/null
+++ b/node_modules/source-map-js/lib/array-set.js
@@ -0,0 +1,121 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+var has = Object.prototype.hasOwnProperty;
+var hasNativeMap = typeof Map !== "undefined";
+
+/**
+ * A data structure which is a combination of an array and a set. Adding a new
+ * member is O(1), testing for membership is O(1), and finding the index of an
+ * element is O(1). Removing elements from the set is not supported. Only
+ * strings are supported for membership.
+ */
+function ArraySet() {
+  this._array = [];
+  this._set = hasNativeMap ? new Map() : Object.create(null);
+}
+
+/**
+ * Static method for creating ArraySet instances from an existing array.
+ */
+ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+  var set = new ArraySet();
+  for (var i = 0, len = aArray.length; i < len; i++) {
+    set.add(aArray[i], aAllowDuplicates);
+  }
+  return set;
+};
+
+/**
+ * Return how many unique items are in this ArraySet. If duplicates have been
+ * added, than those do not count towards the size.
+ *
+ * @returns Number
+ */
+ArraySet.prototype.size = function ArraySet_size() {
+  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+};
+
+/**
+ * Add the given string to this set.
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+  var idx = this._array.length;
+  if (!isDuplicate || aAllowDuplicates) {
+    this._array.push(aStr);
+  }
+  if (!isDuplicate) {
+    if (hasNativeMap) {
+      this._set.set(aStr, idx);
+    } else {
+      this._set[sStr] = idx;
+    }
+  }
+};
+
+/**
+ * Is the given string a member of this set?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.has = function ArraySet_has(aStr) {
+  if (hasNativeMap) {
+    return this._set.has(aStr);
+  } else {
+    var sStr = util.toSetString(aStr);
+    return has.call(this._set, sStr);
+  }
+};
+
+/**
+ * What is the index of the given string in the array?
+ *
+ * @param String aStr
+ */
+ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+  if (hasNativeMap) {
+    var idx = this._set.get(aStr);
+    if (idx >= 0) {
+        return idx;
+    }
+  } else {
+    var sStr = util.toSetString(aStr);
+    if (has.call(this._set, sStr)) {
+      return this._set[sStr];
+    }
+  }
+
+  throw new Error('"' + aStr + '" is not in the set.');
+};
+
+/**
+ * What is the element at the given index?
+ *
+ * @param Number aIdx
+ */
+ArraySet.prototype.at = function ArraySet_at(aIdx) {
+  if (aIdx >= 0 && aIdx < this._array.length) {
+    return this._array[aIdx];
+  }
+  throw new Error('No element indexed by ' + aIdx);
+};
+
+/**
+ * Returns the array representation of this set (which has the proper indices
+ * indicated by indexOf). Note that this is a copy of the internal array used
+ * for storing the members so that no one can mess with internal state.
+ */
+ArraySet.prototype.toArray = function ArraySet_toArray() {
+  return this._array.slice();
+};
+
+exports.ArraySet = ArraySet;
diff --git a/node_modules/source-map-js/lib/base64-vlq.js b/node_modules/source-map-js/lib/base64-vlq.js
new file mode 100644
index 0000000..612b404
--- /dev/null
+++ b/node_modules/source-map-js/lib/base64-vlq.js
@@ -0,0 +1,140 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ *
+ * Based on the Base 64 VLQ implementation in Closure Compiler:
+ * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
+ *
+ * Copyright 2011 The Closure Compiler Authors. All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *  * Neither the name of Google Inc. nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+var base64 = require('./base64');
+
+// A single base 64 digit can contain 6 bits of data. For the base 64 variable
+// length quantities we use in the source map spec, the first bit is the sign,
+// the next four bits are the actual value, and the 6th bit is the
+// continuation bit. The continuation bit tells us whether there are more
+// digits in this value following this digit.
+//
+//   Continuation
+//   |    Sign
+//   |    |
+//   V    V
+//   101011
+
+var VLQ_BASE_SHIFT = 5;
+
+// binary: 100000
+var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+
+// binary: 011111
+var VLQ_BASE_MASK = VLQ_BASE - 1;
+
+// binary: 100000
+var VLQ_CONTINUATION_BIT = VLQ_BASE;
+
+/**
+ * Converts from a two-complement value to a value where the sign bit is
+ * placed in the least significant bit.  For example, as decimals:
+ *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
+ *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
+ */
+function toVLQSigned(aValue) {
+  return aValue < 0
+    ? ((-aValue) << 1) + 1
+    : (aValue << 1) + 0;
+}
+
+/**
+ * Converts to a two-complement value from a value where the sign bit is
+ * placed in the least significant bit.  For example, as decimals:
+ *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
+ *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
+ */
+function fromVLQSigned(aValue) {
+  var isNegative = (aValue & 1) === 1;
+  var shifted = aValue >> 1;
+  return isNegative
+    ? -shifted
+    : shifted;
+}
+
+/**
+ * Returns the base 64 VLQ encoded value.
+ */
+exports.encode = function base64VLQ_encode(aValue) {
+  var encoded = "";
+  var digit;
+
+  var vlq = toVLQSigned(aValue);
+
+  do {
+    digit = vlq & VLQ_BASE_MASK;
+    vlq >>>= VLQ_BASE_SHIFT;
+    if (vlq > 0) {
+      // There are still more digits in this value, so we must make sure the
+      // continuation bit is marked.
+      digit |= VLQ_CONTINUATION_BIT;
+    }
+    encoded += base64.encode(digit);
+  } while (vlq > 0);
+
+  return encoded;
+};
+
+/**
+ * Decodes the next base 64 VLQ value from the given string and returns the
+ * value and the rest of the string via the out parameter.
+ */
+exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+  var strLen = aStr.length;
+  var result = 0;
+  var shift = 0;
+  var continuation, digit;
+
+  do {
+    if (aIndex >= strLen) {
+      throw new Error("Expected more digits in base 64 VLQ value.");
+    }
+
+    digit = base64.decode(aStr.charCodeAt(aIndex++));
+    if (digit === -1) {
+      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+    }
+
+    continuation = !!(digit & VLQ_CONTINUATION_BIT);
+    digit &= VLQ_BASE_MASK;
+    result = result + (digit << shift);
+    shift += VLQ_BASE_SHIFT;
+  } while (continuation);
+
+  aOutParam.value = fromVLQSigned(result);
+  aOutParam.rest = aIndex;
+};
diff --git a/node_modules/source-map-js/lib/base64.js b/node_modules/source-map-js/lib/base64.js
new file mode 100644
index 0000000..8aa86b3
--- /dev/null
+++ b/node_modules/source-map-js/lib/base64.js
@@ -0,0 +1,67 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
+
+/**
+ * Encode an integer in the range of 0 to 63 to a single base 64 digit.
+ */
+exports.encode = function (number) {
+  if (0 <= number && number < intToCharMap.length) {
+    return intToCharMap[number];
+  }
+  throw new TypeError("Must be between 0 and 63: " + number);
+};
+
+/**
+ * Decode a single base 64 character code digit to an integer. Returns -1 on
+ * failure.
+ */
+exports.decode = function (charCode) {
+  var bigA = 65;     // 'A'
+  var bigZ = 90;     // 'Z'
+
+  var littleA = 97;  // 'a'
+  var littleZ = 122; // 'z'
+
+  var zero = 48;     // '0'
+  var nine = 57;     // '9'
+
+  var plus = 43;     // '+'
+  var slash = 47;    // '/'
+
+  var littleOffset = 26;
+  var numberOffset = 52;
+
+  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+  if (bigA <= charCode && charCode <= bigZ) {
+    return (charCode - bigA);
+  }
+
+  // 26 - 51: abcdefghijklmnopqrstuvwxyz
+  if (littleA <= charCode && charCode <= littleZ) {
+    return (charCode - littleA + littleOffset);
+  }
+
+  // 52 - 61: 0123456789
+  if (zero <= charCode && charCode <= nine) {
+    return (charCode - zero + numberOffset);
+  }
+
+  // 62: +
+  if (charCode == plus) {
+    return 62;
+  }
+
+  // 63: /
+  if (charCode == slash) {
+    return 63;
+  }
+
+  // Invalid base64 digit.
+  return -1;
+};
diff --git a/node_modules/source-map-js/lib/binary-search.js b/node_modules/source-map-js/lib/binary-search.js
new file mode 100644
index 0000000..010ac94
--- /dev/null
+++ b/node_modules/source-map-js/lib/binary-search.js
@@ -0,0 +1,111 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+exports.GREATEST_LOWER_BOUND = 1;
+exports.LEAST_UPPER_BOUND = 2;
+
+/**
+ * Recursive implementation of binary search.
+ *
+ * @param aLow Indices here and lower do not contain the needle.
+ * @param aHigh Indices here and higher do not contain the needle.
+ * @param aNeedle The element being searched for.
+ * @param aHaystack The non-empty array being searched.
+ * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+ * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+ *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ */
+function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+  // This function terminates when one of the following is true:
+  //
+  //   1. We find the exact element we are looking for.
+  //
+  //   2. We did not find the exact element, but we can return the index of
+  //      the next-closest element.
+  //
+  //   3. We did not find the exact element, and there is no next-closest
+  //      element than the one we are searching for, so we return -1.
+  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+  var cmp = aCompare(aNeedle, aHaystack[mid], true);
+  if (cmp === 0) {
+    // Found the element we are looking for.
+    return mid;
+  }
+  else if (cmp > 0) {
+    // Our needle is greater than aHaystack[mid].
+    if (aHigh - mid > 1) {
+      // The element is in the upper half.
+      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+    }
+
+    // The exact needle element was not found in this haystack. Determine if
+    // we are in termination case (3) or (2) and return the appropriate thing.
+    if (aBias == exports.LEAST_UPPER_BOUND) {
+      return aHigh < aHaystack.length ? aHigh : -1;
+    } else {
+      return mid;
+    }
+  }
+  else {
+    // Our needle is less than aHaystack[mid].
+    if (mid - aLow > 1) {
+      // The element is in the lower half.
+      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+    }
+
+    // we are in termination case (3) or (2) and return the appropriate thing.
+    if (aBias == exports.LEAST_UPPER_BOUND) {
+      return mid;
+    } else {
+      return aLow < 0 ? -1 : aLow;
+    }
+  }
+}
+
+/**
+ * This is an implementation of binary search which will always try and return
+ * the index of the closest element if there is no exact hit. This is because
+ * mappings between original and generated line/col pairs are single points,
+ * and there is an implicit region between each of them, so a miss just means
+ * that you aren't on the very start of a region.
+ *
+ * @param aNeedle The element you are looking for.
+ * @param aHaystack The array that is being searched.
+ * @param aCompare A function which takes the needle and an element in the
+ *     array and returns -1, 0, or 1 depending on whether the needle is less
+ *     than, equal to, or greater than the element, respectively.
+ * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+ *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
+ */
+exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+  if (aHaystack.length === 0) {
+    return -1;
+  }
+
+  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
+                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+  if (index < 0) {
+    return -1;
+  }
+
+  // We have found either the exact element, or the next-closest element than
+  // the one we are searching for. However, there may be more than one such
+  // element. Make sure we always return the smallest of these.
+  while (index - 1 >= 0) {
+    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+      break;
+    }
+    --index;
+  }
+
+  return index;
+};
diff --git a/node_modules/source-map-js/lib/mapping-list.js b/node_modules/source-map-js/lib/mapping-list.js
new file mode 100644
index 0000000..06d1274
--- /dev/null
+++ b/node_modules/source-map-js/lib/mapping-list.js
@@ -0,0 +1,79 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2014 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+
+/**
+ * Determine whether mappingB is after mappingA with respect to generated
+ * position.
+ */
+function generatedPositionAfter(mappingA, mappingB) {
+  // Optimized for most common case
+  var lineA = mappingA.generatedLine;
+  var lineB = mappingB.generatedLine;
+  var columnA = mappingA.generatedColumn;
+  var columnB = mappingB.generatedColumn;
+  return lineB > lineA || lineB == lineA && columnB >= columnA ||
+         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+}
+
+/**
+ * A data structure to provide a sorted view of accumulated mappings in a
+ * performance conscious manner. It trades a neglibable overhead in general
+ * case for a large speedup in case of mappings being added in order.
+ */
+function MappingList() {
+  this._array = [];
+  this._sorted = true;
+  // Serves as infimum
+  this._last = {generatedLine: -1, generatedColumn: 0};
+}
+
+/**
+ * Iterate through internal items. This method takes the same arguments that
+ * `Array.prototype.forEach` takes.
+ *
+ * NOTE: The order of the mappings is NOT guaranteed.
+ */
+MappingList.prototype.unsortedForEach =
+  function MappingList_forEach(aCallback, aThisArg) {
+    this._array.forEach(aCallback, aThisArg);
+  };
+
+/**
+ * Add the given source mapping.
+ *
+ * @param Object aMapping
+ */
+MappingList.prototype.add = function MappingList_add(aMapping) {
+  if (generatedPositionAfter(this._last, aMapping)) {
+    this._last = aMapping;
+    this._array.push(aMapping);
+  } else {
+    this._sorted = false;
+    this._array.push(aMapping);
+  }
+};
+
+/**
+ * Returns the flat, sorted array of mappings. The mappings are sorted by
+ * generated position.
+ *
+ * WARNING: This method returns internal data without copying, for
+ * performance. The return value must NOT be mutated, and should be treated as
+ * an immutable borrow. If you want to take ownership, you must make your own
+ * copy.
+ */
+MappingList.prototype.toArray = function MappingList_toArray() {
+  if (!this._sorted) {
+    this._array.sort(util.compareByGeneratedPositionsInflated);
+    this._sorted = true;
+  }
+  return this._array;
+};
+
+exports.MappingList = MappingList;
diff --git a/node_modules/source-map-js/lib/quick-sort.js b/node_modules/source-map-js/lib/quick-sort.js
new file mode 100644
index 0000000..23f9eda
--- /dev/null
+++ b/node_modules/source-map-js/lib/quick-sort.js
@@ -0,0 +1,132 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+// It turns out that some (most?) JavaScript engines don't self-host
+// `Array.prototype.sort`. This makes sense because C++ will likely remain
+// faster than JS when doing raw CPU-intensive sorting. However, when using a
+// custom comparator function, calling back and forth between the VM's C++ and
+// JIT'd JS is rather slow *and* loses JIT type information, resulting in
+// worse generated code for the comparator function than would be optimal. In
+// fact, when sorting with a comparator, these costs outweigh the benefits of
+// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
+// a ~3500ms mean speed-up in `bench/bench.html`.
+
+function SortTemplate(comparator) {
+
+/**
+ * Swap the elements indexed by `x` and `y` in the array `ary`.
+ *
+ * @param {Array} ary
+ *        The array.
+ * @param {Number} x
+ *        The index of the first item.
+ * @param {Number} y
+ *        The index of the second item.
+ */
+function swap(ary, x, y) {
+  var temp = ary[x];
+  ary[x] = ary[y];
+  ary[y] = temp;
+}
+
+/**
+ * Returns a random integer within the range `low .. high` inclusive.
+ *
+ * @param {Number} low
+ *        The lower bound on the range.
+ * @param {Number} high
+ *        The upper bound on the range.
+ */
+function randomIntInRange(low, high) {
+  return Math.round(low + (Math.random() * (high - low)));
+}
+
+/**
+ * The Quick Sort algorithm.
+ *
+ * @param {Array} ary
+ *        An array to sort.
+ * @param {function} comparator
+ *        Function to use to compare two items.
+ * @param {Number} p
+ *        Start index of the array
+ * @param {Number} r
+ *        End index of the array
+ */
+function doQuickSort(ary, comparator, p, r) {
+  // If our lower bound is less than our upper bound, we (1) partition the
+  // array into two pieces and (2) recurse on each half. If it is not, this is
+  // the empty array and our base case.
+
+  if (p < r) {
+    // (1) Partitioning.
+    //
+    // The partitioning chooses a pivot between `p` and `r` and moves all
+    // elements that are less than or equal to the pivot to the before it, and
+    // all the elements that are greater than it after it. The effect is that
+    // once partition is done, the pivot is in the exact place it will be when
+    // the array is put in sorted order, and it will not need to be moved
+    // again. This runs in O(n) time.
+
+    // Always choose a random pivot so that an input array which is reverse
+    // sorted does not cause O(n^2) running time.
+    var pivotIndex = randomIntInRange(p, r);
+    var i = p - 1;
+
+    swap(ary, pivotIndex, r);
+    var pivot = ary[r];
+
+    // Immediately after `j` is incremented in this loop, the following hold
+    // true:
+    //
+    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
+    //
+    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
+    for (var j = p; j < r; j++) {
+      if (comparator(ary[j], pivot, false) <= 0) {
+        i += 1;
+        swap(ary, i, j);
+      }
+    }
+
+    swap(ary, i + 1, j);
+    var q = i + 1;
+
+    // (2) Recurse on each half.
+
+    doQuickSort(ary, comparator, p, q - 1);
+    doQuickSort(ary, comparator, q + 1, r);
+  }
+}
+
+  return doQuickSort;
+}
+
+function cloneSort(comparator) {
+  let template = SortTemplate.toString();
+  let templateFn = new Function(`return ${template}`)();
+  return templateFn(comparator);
+}
+
+/**
+ * Sort the given array in-place with the given comparator function.
+ *
+ * @param {Array} ary
+ *        An array to sort.
+ * @param {function} comparator
+ *        Function to use to compare two items.
+ */
+
+let sortCache = new WeakMap();
+exports.quickSort = function (ary, comparator, start = 0) {
+  let doQuickSort = sortCache.get(comparator);
+  if (doQuickSort === void 0) {
+    doQuickSort = cloneSort(comparator);
+    sortCache.set(comparator, doQuickSort);
+  }
+  doQuickSort(ary, comparator, start, ary.length - 1);
+};
diff --git a/node_modules/source-map-js/lib/source-map-consumer.d.ts b/node_modules/source-map-js/lib/source-map-consumer.d.ts
new file mode 100644
index 0000000..744bda7
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-map-consumer.d.ts
@@ -0,0 +1 @@
+export { SourceMapConsumer } from '..';
diff --git a/node_modules/source-map-js/lib/source-map-consumer.js b/node_modules/source-map-js/lib/source-map-consumer.js
new file mode 100644
index 0000000..ee66114
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-map-consumer.js
@@ -0,0 +1,1188 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var util = require('./util');
+var binarySearch = require('./binary-search');
+var ArraySet = require('./array-set').ArraySet;
+var base64VLQ = require('./base64-vlq');
+var quickSort = require('./quick-sort').quickSort;
+
+function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  return sourceMap.sections != null
+    ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
+    : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+}
+
+SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+}
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+SourceMapConsumer.prototype._version = 3;
+
+// `__generatedMappings` and `__originalMappings` are arrays that hold the
+// parsed mapping coordinates from the source map's "mappings" attribute. They
+// are lazily instantiated, accessed via the `_generatedMappings` and
+// `_originalMappings` getters respectively, and we only parse the mappings
+// and create these arrays once queried for a source location. We jump through
+// these hoops because there can be many thousands of mappings, and parsing
+// them is expensive, so we only want to do it if we must.
+//
+// Each object in the arrays is of the form:
+//
+//     {
+//       generatedLine: The line number in the generated code,
+//       generatedColumn: The column number in the generated code,
+//       source: The path to the original source file that generated this
+//               chunk of code,
+//       originalLine: The line number in the original source that
+//                     corresponds to this chunk of generated code,
+//       originalColumn: The column number in the original source that
+//                       corresponds to this chunk of generated code,
+//       name: The name of the original symbol which generated this chunk of
+//             code.
+//     }
+//
+// All properties except for `generatedLine` and `generatedColumn` can be
+// `null`.
+//
+// `_generatedMappings` is ordered by the generated positions.
+//
+// `_originalMappings` is ordered by the original positions.
+
+SourceMapConsumer.prototype.__generatedMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    if (!this.__generatedMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+
+    return this.__generatedMappings;
+  }
+});
+
+SourceMapConsumer.prototype.__originalMappings = null;
+Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
+  configurable: true,
+  enumerable: true,
+  get: function () {
+    if (!this.__originalMappings) {
+      this._parseMappings(this._mappings, this.sourceRoot);
+    }
+
+    return this.__originalMappings;
+  }
+});
+
+SourceMapConsumer.prototype._charIsMappingSeparator =
+  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+    var c = aStr.charAt(index);
+    return c === ";" || c === ",";
+  };
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+SourceMapConsumer.prototype._parseMappings =
+  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    throw new Error("Subclasses must implement _parseMappings");
+  };
+
+SourceMapConsumer.GENERATED_ORDER = 1;
+SourceMapConsumer.ORIGINAL_ORDER = 2;
+
+SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+
+/**
+ * Iterate over each mapping between an original source/line/column and a
+ * generated line/column in this source map.
+ *
+ * @param Function aCallback
+ *        The function that is called with each mapping.
+ * @param Object aContext
+ *        Optional. If specified, this object will be the value of `this` every
+ *        time that `aCallback` is called.
+ * @param aOrder
+ *        Either `SourceMapConsumer.GENERATED_ORDER` or
+ *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+ *        iterate over the mappings sorted by the generated file's line/column
+ *        order or the original's source/line/column order, respectively. Defaults to
+ *        `SourceMapConsumer.GENERATED_ORDER`.
+ */
+SourceMapConsumer.prototype.eachMapping =
+  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+    var context = aContext || null;
+    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+
+    var mappings;
+    switch (order) {
+    case SourceMapConsumer.GENERATED_ORDER:
+      mappings = this._generatedMappings;
+      break;
+    case SourceMapConsumer.ORIGINAL_ORDER:
+      mappings = this._originalMappings;
+      break;
+    default:
+      throw new Error("Unknown order of iteration.");
+    }
+
+    var sourceRoot = this.sourceRoot;
+    var boundCallback = aCallback.bind(context);
+    var names = this._names;
+    var sources = this._sources;
+    var sourceMapURL = this._sourceMapURL;
+
+    for (var i = 0, n = mappings.length; i < n; i++) {
+      var mapping = mappings[i];
+      var source = mapping.source === null ? null : sources.at(mapping.source);
+      if(source !== null) {
+        source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
+      }
+      boundCallback({
+        source: source,
+        generatedLine: mapping.generatedLine,
+        generatedColumn: mapping.generatedColumn,
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name: mapping.name === null ? null : names.at(mapping.name)
+      });
+    }
+  };
+
+/**
+ * Returns all generated line and column information for the original source,
+ * line, and column provided. If no column is provided, returns all mappings
+ * corresponding to a either the line we are searching for or the next
+ * closest line that has any mappings. Otherwise, returns all mappings
+ * corresponding to the given line and either the column we are searching for
+ * or the next closest column that has any offsets.
+ *
+ * The only argument is an object with the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number is 1-based.
+ *   - column: Optional. the column number in the original source.
+ *    The column number is 0-based.
+ *
+ * and an array of objects is returned, each with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *    line number is 1-based.
+ *   - column: The column number in the generated source, or null.
+ *    The column number is 0-based.
+ */
+SourceMapConsumer.prototype.allGeneratedPositionsFor =
+  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+    var line = util.getArg(aArgs, 'line');
+
+    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
+    // returns the index of the closest mapping less than the needle. By
+    // setting needle.originalColumn to 0, we thus find the last mapping for
+    // the given line, provided such a mapping exists.
+    var needle = {
+      source: util.getArg(aArgs, 'source'),
+      originalLine: line,
+      originalColumn: util.getArg(aArgs, 'column', 0)
+    };
+
+    needle.source = this._findSourceIndex(needle.source);
+    if (needle.source < 0) {
+      return [];
+    }
+
+    var mappings = [];
+
+    var index = this._findMapping(needle,
+                                  this._originalMappings,
+                                  "originalLine",
+                                  "originalColumn",
+                                  util.compareByOriginalPositions,
+                                  binarySearch.LEAST_UPPER_BOUND);
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+
+      if (aArgs.column === undefined) {
+        var originalLine = mapping.originalLine;
+
+        // Iterate until either we run out of mappings, or we run into
+        // a mapping for a different line than the one we found. Since
+        // mappings are sorted, this is guaranteed to find all mappings for
+        // the line we found.
+        while (mapping && mapping.originalLine === originalLine) {
+          mappings.push({
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
+            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+          });
+
+          mapping = this._originalMappings[++index];
+        }
+      } else {
+        var originalColumn = mapping.originalColumn;
+
+        // Iterate until either we run out of mappings, or we run into
+        // a mapping for a different line than the one we were searching for.
+        // Since mappings are sorted, this is guaranteed to find all mappings for
+        // the line we are searching for.
+        while (mapping &&
+               mapping.originalLine === line &&
+               mapping.originalColumn == originalColumn) {
+          mappings.push({
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
+            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+          });
+
+          mapping = this._originalMappings[++index];
+        }
+      }
+    }
+
+    return mappings;
+  };
+
+exports.SourceMapConsumer = SourceMapConsumer;
+
+/**
+ * A BasicSourceMapConsumer instance represents a parsed source map which we can
+ * query for information about the original file positions by giving it a file
+ * position in the generated source.
+ *
+ * The first parameter is the raw source map (either as a JSON string, or
+ * already parsed to an object). According to the spec, source maps have the
+ * following attributes:
+ *
+ *   - version: Which version of the source map spec this map is following.
+ *   - sources: An array of URLs to the original source files.
+ *   - names: An array of identifiers which can be referrenced by individual mappings.
+ *   - sourceRoot: Optional. The URL root from which all sources are relative.
+ *   - sourcesContent: Optional. An array of contents of the original source files.
+ *   - mappings: A string of base64 VLQs which contain the actual mappings.
+ *   - file: Optional. The generated file this source map is associated with.
+ *
+ * Here is an example source map, taken from the source map spec[0]:
+ *
+ *     {
+ *       version : 3,
+ *       file: "out.js",
+ *       sourceRoot : "",
+ *       sources: ["foo.js", "bar.js"],
+ *       names: ["src", "maps", "are", "fun"],
+ *       mappings: "AA,AB;;ABCDE;"
+ *     }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found.  This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+ */
+function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  var version = util.getArg(sourceMap, 'version');
+  var sources = util.getArg(sourceMap, 'sources');
+  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+  // requires the array) to play nice here.
+  var names = util.getArg(sourceMap, 'names', []);
+  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+  var mappings = util.getArg(sourceMap, 'mappings');
+  var file = util.getArg(sourceMap, 'file', null);
+
+  // Once again, Sass deviates from the spec and supplies the version as a
+  // string rather than a number, so we use loose equality checking here.
+  if (version != this._version) {
+    throw new Error('Unsupported version: ' + version);
+  }
+
+  if (sourceRoot) {
+    sourceRoot = util.normalize(sourceRoot);
+  }
+
+  sources = sources
+    .map(String)
+    // Some source maps produce relative source paths like "./foo.js" instead of
+    // "foo.js".  Normalize these first so that future comparisons will succeed.
+    // See bugzil.la/1090768.
+    .map(util.normalize)
+    // Always ensure that absolute sources are internally stored relative to
+    // the source root, if the source root is absolute. Not doing this would
+    // be particularly problematic when the source root is a prefix of the
+    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
+    .map(function (source) {
+      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
+        ? util.relative(sourceRoot, source)
+        : source;
+    });
+
+  // Pass `true` below to allow duplicate names and sources. While source maps
+  // are intended to be compressed and deduplicated, the TypeScript compiler
+  // sometimes generates source maps with duplicates in them. See Github issue
+  // #72 and bugzil.la/889492.
+  this._names = ArraySet.fromArray(names.map(String), true);
+  this._sources = ArraySet.fromArray(sources, true);
+
+  this._absoluteSources = this._sources.toArray().map(function (s) {
+    return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+  });
+
+  this.sourceRoot = sourceRoot;
+  this.sourcesContent = sourcesContent;
+  this._mappings = mappings;
+  this._sourceMapURL = aSourceMapURL;
+  this.file = file;
+}
+
+BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+
+/**
+ * Utility function to find the index of a source.  Returns -1 if not
+ * found.
+ */
+BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+  var relativeSource = aSource;
+  if (this.sourceRoot != null) {
+    relativeSource = util.relative(this.sourceRoot, relativeSource);
+  }
+
+  if (this._sources.has(relativeSource)) {
+    return this._sources.indexOf(relativeSource);
+  }
+
+  // Maybe aSource is an absolute URL as returned by |sources|.  In
+  // this case we can't simply undo the transform.
+  var i;
+  for (i = 0; i < this._absoluteSources.length; ++i) {
+    if (this._absoluteSources[i] == aSource) {
+      return i;
+    }
+  }
+
+  return -1;
+};
+
+/**
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+ *
+ * @param SourceMapGenerator aSourceMap
+ *        The source map that will be consumed.
+ * @param String aSourceMapURL
+ *        The URL at which the source map can be found (optional)
+ * @returns BasicSourceMapConsumer
+ */
+BasicSourceMapConsumer.fromSourceMap =
+  function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+    var smc = Object.create(BasicSourceMapConsumer.prototype);
+
+    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+    smc.sourceRoot = aSourceMap._sourceRoot;
+    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
+                                                            smc.sourceRoot);
+    smc.file = aSourceMap._file;
+    smc._sourceMapURL = aSourceMapURL;
+    smc._absoluteSources = smc._sources.toArray().map(function (s) {
+      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+    });
+
+    // Because we are modifying the entries (by converting string sources and
+    // names to indices into the sources and names ArraySets), we have to make
+    // a copy of the entry or else bad things happen. Shared mutable state
+    // strikes again! See github issue #191.
+
+    var generatedMappings = aSourceMap._mappings.toArray().slice();
+    var destGeneratedMappings = smc.__generatedMappings = [];
+    var destOriginalMappings = smc.__originalMappings = [];
+
+    for (var i = 0, length = generatedMappings.length; i < length; i++) {
+      var srcMapping = generatedMappings[i];
+      var destMapping = new Mapping;
+      destMapping.generatedLine = srcMapping.generatedLine;
+      destMapping.generatedColumn = srcMapping.generatedColumn;
+
+      if (srcMapping.source) {
+        destMapping.source = sources.indexOf(srcMapping.source);
+        destMapping.originalLine = srcMapping.originalLine;
+        destMapping.originalColumn = srcMapping.originalColumn;
+
+        if (srcMapping.name) {
+          destMapping.name = names.indexOf(srcMapping.name);
+        }
+
+        destOriginalMappings.push(destMapping);
+      }
+
+      destGeneratedMappings.push(destMapping);
+    }
+
+    quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+
+    return smc;
+  };
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+BasicSourceMapConsumer.prototype._version = 3;
+
+/**
+ * The list of original sources.
+ */
+Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
+  get: function () {
+    return this._absoluteSources.slice();
+  }
+});
+
+/**
+ * Provide the JIT with a nice shape / hidden class.
+ */
+function Mapping() {
+  this.generatedLine = 0;
+  this.generatedColumn = 0;
+  this.source = null;
+  this.originalLine = null;
+  this.originalColumn = null;
+  this.name = null;
+}
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+
+const compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
+function sortGenerated(array, start) {
+  let l = array.length;
+  let n = array.length - start;
+  if (n <= 1) {
+    return;
+  } else if (n == 2) {
+    let a = array[start];
+    let b = array[start + 1];
+    if (compareGenerated(a, b) > 0) {
+      array[start] = b;
+      array[start + 1] = a;
+    }
+  } else if (n < 20) {
+    for (let i = start; i < l; i++) {
+      for (let j = i; j > start; j--) {
+        let a = array[j - 1];
+        let b = array[j];
+        if (compareGenerated(a, b) <= 0) {
+          break;
+        }
+        array[j - 1] = b;
+        array[j] = a;
+      }
+    }
+  } else {
+    quickSort(array, compareGenerated, start);
+  }
+}
+BasicSourceMapConsumer.prototype._parseMappings =
+  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    var generatedLine = 1;
+    var previousGeneratedColumn = 0;
+    var previousOriginalLine = 0;
+    var previousOriginalColumn = 0;
+    var previousSource = 0;
+    var previousName = 0;
+    var length = aStr.length;
+    var index = 0;
+    var cachedSegments = {};
+    var temp = {};
+    var originalMappings = [];
+    var generatedMappings = [];
+    var mapping, str, segment, end, value;
+
+    let subarrayStart = 0;
+    while (index < length) {
+      if (aStr.charAt(index) === ';') {
+        generatedLine++;
+        index++;
+        previousGeneratedColumn = 0;
+
+        sortGenerated(generatedMappings, subarrayStart);
+        subarrayStart = generatedMappings.length;
+      }
+      else if (aStr.charAt(index) === ',') {
+        index++;
+      }
+      else {
+        mapping = new Mapping();
+        mapping.generatedLine = generatedLine;
+
+        for (end = index; end < length; end++) {
+          if (this._charIsMappingSeparator(aStr, end)) {
+            break;
+          }
+        }
+        str = aStr.slice(index, end);
+
+        segment = [];
+        while (index < end) {
+          base64VLQ.decode(aStr, index, temp);
+          value = temp.value;
+          index = temp.rest;
+          segment.push(value);
+        }
+
+        if (segment.length === 2) {
+          throw new Error('Found a source, but no line and column');
+        }
+
+        if (segment.length === 3) {
+          throw new Error('Found a source and line, but no column');
+        }
+
+        // Generated column.
+        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+        previousGeneratedColumn = mapping.generatedColumn;
+
+        if (segment.length > 1) {
+          // Original source.
+          mapping.source = previousSource + segment[1];
+          previousSource += segment[1];
+
+          // Original line.
+          mapping.originalLine = previousOriginalLine + segment[2];
+          previousOriginalLine = mapping.originalLine;
+          // Lines are stored 0-based
+          mapping.originalLine += 1;
+
+          // Original column.
+          mapping.originalColumn = previousOriginalColumn + segment[3];
+          previousOriginalColumn = mapping.originalColumn;
+
+          if (segment.length > 4) {
+            // Original name.
+            mapping.name = previousName + segment[4];
+            previousName += segment[4];
+          }
+        }
+
+        generatedMappings.push(mapping);
+        if (typeof mapping.originalLine === 'number') {
+          let currentSource = mapping.source;
+          while (originalMappings.length <= currentSource) {
+            originalMappings.push(null);
+          }
+          if (originalMappings[currentSource] === null) {
+            originalMappings[currentSource] = [];
+          }
+          originalMappings[currentSource].push(mapping);
+        }
+      }
+    }
+
+    sortGenerated(generatedMappings, subarrayStart);
+    this.__generatedMappings = generatedMappings;
+
+    for (var i = 0; i < originalMappings.length; i++) {
+      if (originalMappings[i] != null) {
+        quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
+      }
+    }
+    this.__originalMappings = [].concat(...originalMappings);
+  };
+
+/**
+ * Find the mapping that best matches the hypothetical "needle" mapping that
+ * we are searching for in the given "haystack" of mappings.
+ */
+BasicSourceMapConsumer.prototype._findMapping =
+  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
+                                         aColumnName, aComparator, aBias) {
+    // To return the position we are searching for, we must first find the
+    // mapping for the given position and then return the opposite position it
+    // points to. Because the mappings are sorted, we can use binary search to
+    // find the best mapping.
+
+    if (aNeedle[aLineName] <= 0) {
+      throw new TypeError('Line must be greater than or equal to 1, got '
+                          + aNeedle[aLineName]);
+    }
+    if (aNeedle[aColumnName] < 0) {
+      throw new TypeError('Column must be greater than or equal to 0, got '
+                          + aNeedle[aColumnName]);
+    }
+
+    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+  };
+
+/**
+ * Compute the last column for each generated mapping. The last column is
+ * inclusive.
+ */
+BasicSourceMapConsumer.prototype.computeColumnSpans =
+  function SourceMapConsumer_computeColumnSpans() {
+    for (var index = 0; index < this._generatedMappings.length; ++index) {
+      var mapping = this._generatedMappings[index];
+
+      // Mappings do not contain a field for the last generated columnt. We
+      // can come up with an optimistic estimate, however, by assuming that
+      // mappings are contiguous (i.e. given two consecutive mappings, the
+      // first mapping ends where the second one starts).
+      if (index + 1 < this._generatedMappings.length) {
+        var nextMapping = this._generatedMappings[index + 1];
+
+        if (mapping.generatedLine === nextMapping.generatedLine) {
+          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+          continue;
+        }
+      }
+
+      // The last mapping for each line spans the entire line.
+      mapping.lastGeneratedColumn = Infinity;
+    }
+  };
+
+/**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ *   - line: The line number in the generated source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the generated source.  The column
+ *     number is 0-based.
+ *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - source: The original source file, or null.
+ *   - line: The line number in the original source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the original source, or null.  The
+ *     column number is 0-based.
+ *   - name: The original identifier, or null.
+ */
+BasicSourceMapConsumer.prototype.originalPositionFor =
+  function SourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column')
+    };
+
+    var index = this._findMapping(
+      needle,
+      this._generatedMappings,
+      "generatedLine",
+      "generatedColumn",
+      util.compareByGeneratedPositionsDeflated,
+      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+
+    if (index >= 0) {
+      var mapping = this._generatedMappings[index];
+
+      if (mapping.generatedLine === needle.generatedLine) {
+        var source = util.getArg(mapping, 'source', null);
+        if (source !== null) {
+          source = this._sources.at(source);
+          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+        }
+        var name = util.getArg(mapping, 'name', null);
+        if (name !== null) {
+          name = this._names.at(name);
+        }
+        return {
+          source: source,
+          line: util.getArg(mapping, 'originalLine', null),
+          column: util.getArg(mapping, 'originalColumn', null),
+          name: name
+        };
+      }
+    }
+
+    return {
+      source: null,
+      line: null,
+      column: null,
+      name: null
+    };
+  };
+
+/**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
+  function BasicSourceMapConsumer_hasContentsOfAllSources() {
+    if (!this.sourcesContent) {
+      return false;
+    }
+    return this.sourcesContent.length >= this._sources.size() &&
+      !this.sourcesContent.some(function (sc) { return sc == null; });
+  };
+
+/**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+BasicSourceMapConsumer.prototype.sourceContentFor =
+  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    if (!this.sourcesContent) {
+      return null;
+    }
+
+    var index = this._findSourceIndex(aSource);
+    if (index >= 0) {
+      return this.sourcesContent[index];
+    }
+
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+
+    var url;
+    if (this.sourceRoot != null
+        && (url = util.urlParse(this.sourceRoot))) {
+      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+      // many users. We can help them out when they expect file:// URIs to
+      // behave like it would if they were running a local HTTP server. See
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+      var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+      if (url.scheme == "file"
+          && this._sources.has(fileUriAbsPath)) {
+        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+      }
+
+      if ((!url.path || url.path == "/")
+          && this._sources.has("/" + relativeSource)) {
+        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+      }
+    }
+
+    // This function is used recursively from
+    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
+    // don't want to throw if we can't find the source - we just want to
+    // return null, so we provide a flag to exit gracefully.
+    if (nullOnMissing) {
+      return null;
+    }
+    else {
+      throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+    }
+  };
+
+/**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the original source.  The column
+ *     number is 0-based.
+ *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ *     closest element that is smaller than or greater than the one we are
+ *     searching for, respectively, if the exact element cannot be found.
+ *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the generated source, or null.
+ *     The column number is 0-based.
+ */
+BasicSourceMapConsumer.prototype.generatedPositionFor =
+  function SourceMapConsumer_generatedPositionFor(aArgs) {
+    var source = util.getArg(aArgs, 'source');
+    source = this._findSourceIndex(source);
+    if (source < 0) {
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    }
+
+    var needle = {
+      source: source,
+      originalLine: util.getArg(aArgs, 'line'),
+      originalColumn: util.getArg(aArgs, 'column')
+    };
+
+    var index = this._findMapping(
+      needle,
+      this._originalMappings,
+      "originalLine",
+      "originalColumn",
+      util.compareByOriginalPositions,
+      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
+    );
+
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+
+      if (mapping.source === needle.source) {
+        return {
+          line: util.getArg(mapping, 'generatedLine', null),
+          column: util.getArg(mapping, 'generatedColumn', null),
+          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
+        };
+      }
+    }
+
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  };
+
+exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+
+/**
+ * An IndexedSourceMapConsumer instance represents a parsed source map which
+ * we can query for information. It differs from BasicSourceMapConsumer in
+ * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+ * input.
+ *
+ * The first parameter is a raw source map (either as a JSON string, or already
+ * parsed to an object). According to the spec for indexed source maps, they
+ * have the following attributes:
+ *
+ *   - version: Which version of the source map spec this map is following.
+ *   - file: Optional. The generated file this source map is associated with.
+ *   - sections: A list of section definitions.
+ *
+ * Each value under the "sections" field has two fields:
+ *   - offset: The offset into the original specified at which this section
+ *       begins to apply, defined as an object with a "line" and "column"
+ *       field.
+ *   - map: A source map definition. This source map could also be indexed,
+ *       but doesn't have to be.
+ *
+ * Instead of the "map" field, it's also possible to have a "url" field
+ * specifying a URL to retrieve a source map from, but that's currently
+ * unsupported.
+ *
+ * Here's an example source map, taken from the source map spec[0], but
+ * modified to omit a section which uses the "url" field.
+ *
+ *  {
+ *    version : 3,
+ *    file: "app.js",
+ *    sections: [{
+ *      offset: {line:100, column:10},
+ *      map: {
+ *        version : 3,
+ *        file: "section.js",
+ *        sources: ["foo.js", "bar.js"],
+ *        names: ["src", "maps", "are", "fun"],
+ *        mappings: "AAAA,E;;ABCDE;"
+ *      }
+ *    }],
+ *  }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found.  This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+ */
+function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+  var sourceMap = aSourceMap;
+  if (typeof aSourceMap === 'string') {
+    sourceMap = util.parseSourceMapInput(aSourceMap);
+  }
+
+  var version = util.getArg(sourceMap, 'version');
+  var sections = util.getArg(sourceMap, 'sections');
+
+  if (version != this._version) {
+    throw new Error('Unsupported version: ' + version);
+  }
+
+  this._sources = new ArraySet();
+  this._names = new ArraySet();
+
+  var lastOffset = {
+    line: -1,
+    column: 0
+  };
+  this._sections = sections.map(function (s) {
+    if (s.url) {
+      // The url field will require support for asynchronicity.
+      // See https://github.com/mozilla/source-map/issues/16
+      throw new Error('Support for url field in sections not implemented.');
+    }
+    var offset = util.getArg(s, 'offset');
+    var offsetLine = util.getArg(offset, 'line');
+    var offsetColumn = util.getArg(offset, 'column');
+
+    if (offsetLine < lastOffset.line ||
+        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
+      throw new Error('Section offsets must be ordered and non-overlapping.');
+    }
+    lastOffset = offset;
+
+    return {
+      generatedOffset: {
+        // The offset fields are 0-based, but we use 1-based indices when
+        // encoding/decoding from VLQ.
+        generatedLine: offsetLine + 1,
+        generatedColumn: offsetColumn + 1
+      },
+      consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
+    }
+  });
+}
+
+IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+IndexedSourceMapConsumer.prototype._version = 3;
+
+/**
+ * The list of original sources.
+ */
+Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
+  get: function () {
+    var sources = [];
+    for (var i = 0; i < this._sections.length; i++) {
+      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
+        sources.push(this._sections[i].consumer.sources[j]);
+      }
+    }
+    return sources;
+  }
+});
+
+/**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ *   - line: The line number in the generated source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the generated source.  The column
+ *     number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - source: The original source file, or null.
+ *   - line: The line number in the original source, or null.  The
+ *     line number is 1-based.
+ *   - column: The column number in the original source, or null.  The
+ *     column number is 0-based.
+ *   - name: The original identifier, or null.
+ */
+IndexedSourceMapConsumer.prototype.originalPositionFor =
+  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column')
+    };
+
+    // Find the section containing the generated position we're trying to map
+    // to an original position.
+    var sectionIndex = binarySearch.search(needle, this._sections,
+      function(needle, section) {
+        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
+        if (cmp) {
+          return cmp;
+        }
+
+        return (needle.generatedColumn -
+                section.generatedOffset.generatedColumn);
+      });
+    var section = this._sections[sectionIndex];
+
+    if (!section) {
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    }
+
+    return section.consumer.originalPositionFor({
+      line: needle.generatedLine -
+        (section.generatedOffset.generatedLine - 1),
+      column: needle.generatedColumn -
+        (section.generatedOffset.generatedLine === needle.generatedLine
+         ? section.generatedOffset.generatedColumn - 1
+         : 0),
+      bias: aArgs.bias
+    });
+  };
+
+/**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
+  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+    return this._sections.every(function (s) {
+      return s.consumer.hasContentsOfAllSources();
+    });
+  };
+
+/**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+IndexedSourceMapConsumer.prototype.sourceContentFor =
+  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+
+      var content = section.consumer.sourceContentFor(aSource, true);
+      if (content || content === '') {
+        return content;
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    }
+    else {
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    }
+  };
+
+/**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ *   - source: The filename of the original source.
+ *   - line: The line number in the original source.  The line number
+ *     is 1-based.
+ *   - column: The column number in the original source.  The column
+ *     number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ *   - line: The line number in the generated source, or null.  The
+ *     line number is 1-based. 
+ *   - column: The column number in the generated source, or null.
+ *     The column number is 0-based.
+ */
+IndexedSourceMapConsumer.prototype.generatedPositionFor =
+  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+
+      // Only consider this section if the requested source is in the list of
+      // sources of the consumer.
+      if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
+        continue;
+      }
+      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+      if (generatedPosition) {
+        var ret = {
+          line: generatedPosition.line +
+            (section.generatedOffset.generatedLine - 1),
+          column: generatedPosition.column +
+            (section.generatedOffset.generatedLine === generatedPosition.line
+             ? section.generatedOffset.generatedColumn - 1
+             : 0)
+        };
+        return ret;
+      }
+    }
+
+    return {
+      line: null,
+      column: null
+    };
+  };
+
+/**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+IndexedSourceMapConsumer.prototype._parseMappings =
+  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    this.__generatedMappings = [];
+    this.__originalMappings = [];
+    for (var i = 0; i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var sectionMappings = section.consumer._generatedMappings;
+      for (var j = 0; j < sectionMappings.length; j++) {
+        var mapping = sectionMappings[j];
+
+        var source = section.consumer._sources.at(mapping.source);
+        if(source !== null) {
+          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+        }
+        this._sources.add(source);
+        source = this._sources.indexOf(source);
+
+        var name = null;
+        if (mapping.name) {
+          name = section.consumer._names.at(mapping.name);
+          this._names.add(name);
+          name = this._names.indexOf(name);
+        }
+
+        // The mappings coming from the consumer for the section have
+        // generated positions relative to the start of the section, so we
+        // need to offset them to be relative to the start of the concatenated
+        // generated file.
+        var adjustedMapping = {
+          source: source,
+          generatedLine: mapping.generatedLine +
+            (section.generatedOffset.generatedLine - 1),
+          generatedColumn: mapping.generatedColumn +
+            (section.generatedOffset.generatedLine === mapping.generatedLine
+            ? section.generatedOffset.generatedColumn - 1
+            : 0),
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name: name
+        };
+
+        this.__generatedMappings.push(adjustedMapping);
+        if (typeof adjustedMapping.originalLine === 'number') {
+          this.__originalMappings.push(adjustedMapping);
+        }
+      }
+    }
+
+    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+    quickSort(this.__originalMappings, util.compareByOriginalPositions);
+  };
+
+exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
diff --git a/node_modules/source-map-js/lib/source-map-generator.d.ts b/node_modules/source-map-js/lib/source-map-generator.d.ts
new file mode 100644
index 0000000..f59d70a
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-map-generator.d.ts
@@ -0,0 +1 @@
+export { SourceMapGenerator } from '..';
diff --git a/node_modules/source-map-js/lib/source-map-generator.js b/node_modules/source-map-js/lib/source-map-generator.js
new file mode 100644
index 0000000..bab04ff
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-map-generator.js
@@ -0,0 +1,444 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var base64VLQ = require('./base64-vlq');
+var util = require('./util');
+var ArraySet = require('./array-set').ArraySet;
+var MappingList = require('./mapping-list').MappingList;
+
+/**
+ * An instance of the SourceMapGenerator represents a source map which is
+ * being built incrementally. You may pass an object with the following
+ * properties:
+ *
+ *   - file: The filename of the generated source.
+ *   - sourceRoot: A root for all relative URLs in this source map.
+ */
+function SourceMapGenerator(aArgs) {
+  if (!aArgs) {
+    aArgs = {};
+  }
+  this._file = util.getArg(aArgs, 'file', null);
+  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
+  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
+  this._ignoreInvalidMapping = util.getArg(aArgs, 'ignoreInvalidMapping', false);
+  this._sources = new ArraySet();
+  this._names = new ArraySet();
+  this._mappings = new MappingList();
+  this._sourcesContents = null;
+}
+
+SourceMapGenerator.prototype._version = 3;
+
+/**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param aSourceMapConsumer The SourceMap.
+ */
+SourceMapGenerator.fromSourceMap =
+  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
+    var sourceRoot = aSourceMapConsumer.sourceRoot;
+    var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
+      file: aSourceMapConsumer.file,
+      sourceRoot: sourceRoot
+    }));
+    aSourceMapConsumer.eachMapping(function (mapping) {
+      var newMapping = {
+        generated: {
+          line: mapping.generatedLine,
+          column: mapping.generatedColumn
+        }
+      };
+
+      if (mapping.source != null) {
+        newMapping.source = mapping.source;
+        if (sourceRoot != null) {
+          newMapping.source = util.relative(sourceRoot, newMapping.source);
+        }
+
+        newMapping.original = {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        };
+
+        if (mapping.name != null) {
+          newMapping.name = mapping.name;
+        }
+      }
+
+      generator.addMapping(newMapping);
+    });
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var sourceRelative = sourceFile;
+      if (sourceRoot !== null) {
+        sourceRelative = util.relative(sourceRoot, sourceFile);
+      }
+
+      if (!generator._sources.has(sourceRelative)) {
+        generator._sources.add(sourceRelative);
+      }
+
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        generator.setSourceContent(sourceFile, content);
+      }
+    });
+    return generator;
+  };
+
+/**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ *   - generated: An object with the generated line and column positions.
+ *   - original: An object with the original line and column positions.
+ *   - source: The original source file (relative to the sourceRoot).
+ *   - name: An optional original token name for this mapping.
+ */
+SourceMapGenerator.prototype.addMapping =
+  function SourceMapGenerator_addMapping(aArgs) {
+    var generated = util.getArg(aArgs, 'generated');
+    var original = util.getArg(aArgs, 'original', null);
+    var source = util.getArg(aArgs, 'source', null);
+    var name = util.getArg(aArgs, 'name', null);
+
+    if (!this._skipValidation) {
+      if (this._validateMapping(generated, original, source, name) === false) {
+        return;
+      }
+    }
+
+    if (source != null) {
+      source = String(source);
+      if (!this._sources.has(source)) {
+        this._sources.add(source);
+      }
+    }
+
+    if (name != null) {
+      name = String(name);
+      if (!this._names.has(name)) {
+        this._names.add(name);
+      }
+    }
+
+    this._mappings.add({
+      generatedLine: generated.line,
+      generatedColumn: generated.column,
+      originalLine: original != null && original.line,
+      originalColumn: original != null && original.column,
+      source: source,
+      name: name
+    });
+  };
+
+/**
+ * Set the source content for a source file.
+ */
+SourceMapGenerator.prototype.setSourceContent =
+  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+    var source = aSourceFile;
+    if (this._sourceRoot != null) {
+      source = util.relative(this._sourceRoot, source);
+    }
+
+    if (aSourceContent != null) {
+      // Add the source content to the _sourcesContents map.
+      // Create a new _sourcesContents map if the property is null.
+      if (!this._sourcesContents) {
+        this._sourcesContents = Object.create(null);
+      }
+      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+    } else if (this._sourcesContents) {
+      // Remove the source file from the _sourcesContents map.
+      // If the _sourcesContents map is empty, set the property to null.
+      delete this._sourcesContents[util.toSetString(source)];
+      if (Object.keys(this._sourcesContents).length === 0) {
+        this._sourcesContents = null;
+      }
+    }
+  };
+
+/**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param aSourceMapConsumer The source map to be applied.
+ * @param aSourceFile Optional. The filename of the source file.
+ *        If omitted, SourceMapConsumer's file property will be used.
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
+ *        to be applied. If relative, it is relative to the SourceMapConsumer.
+ *        This parameter is needed when the two source maps aren't in the same
+ *        directory, and the source map to be applied contains relative source
+ *        paths. If so, those relative source paths need to be rewritten
+ *        relative to the SourceMapGenerator.
+ */
+SourceMapGenerator.prototype.applySourceMap =
+  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+    var sourceFile = aSourceFile;
+    // If aSourceFile is omitted, we will use the file property of the SourceMap
+    if (aSourceFile == null) {
+      if (aSourceMapConsumer.file == null) {
+        throw new Error(
+          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+          'or the source map\'s "file" property. Both were omitted.'
+        );
+      }
+      sourceFile = aSourceMapConsumer.file;
+    }
+    var sourceRoot = this._sourceRoot;
+    // Make "sourceFile" relative if an absolute Url is passed.
+    if (sourceRoot != null) {
+      sourceFile = util.relative(sourceRoot, sourceFile);
+    }
+    // Applying the SourceMap can add and remove items from the sources and
+    // the names array.
+    var newSources = new ArraySet();
+    var newNames = new ArraySet();
+
+    // Find mappings for the "sourceFile"
+    this._mappings.unsortedForEach(function (mapping) {
+      if (mapping.source === sourceFile && mapping.originalLine != null) {
+        // Check if it can be mapped by the source map, then update the mapping.
+        var original = aSourceMapConsumer.originalPositionFor({
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        });
+        if (original.source != null) {
+          // Copy mapping
+          mapping.source = original.source;
+          if (aSourceMapPath != null) {
+            mapping.source = util.join(aSourceMapPath, mapping.source)
+          }
+          if (sourceRoot != null) {
+            mapping.source = util.relative(sourceRoot, mapping.source);
+          }
+          mapping.originalLine = original.line;
+          mapping.originalColumn = original.column;
+          if (original.name != null) {
+            mapping.name = original.name;
+          }
+        }
+      }
+
+      var source = mapping.source;
+      if (source != null && !newSources.has(source)) {
+        newSources.add(source);
+      }
+
+      var name = mapping.name;
+      if (name != null && !newNames.has(name)) {
+        newNames.add(name);
+      }
+
+    }, this);
+    this._sources = newSources;
+    this._names = newNames;
+
+    // Copy sourcesContents of applied map.
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aSourceMapPath != null) {
+          sourceFile = util.join(aSourceMapPath, sourceFile);
+        }
+        if (sourceRoot != null) {
+          sourceFile = util.relative(sourceRoot, sourceFile);
+        }
+        this.setSourceContent(sourceFile, content);
+      }
+    }, this);
+  };
+
+/**
+ * A mapping can have one of the three levels of data:
+ *
+ *   1. Just the generated position.
+ *   2. The Generated position, original position, and original source.
+ *   3. Generated and original position, original source, as well as a name
+ *      token.
+ *
+ * To maintain consistency, we validate that any new mapping being added falls
+ * in to one of these categories.
+ */
+SourceMapGenerator.prototype._validateMapping =
+  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
+                                              aName) {
+    // When aOriginal is truthy but has empty values for .line and .column,
+    // it is most likely a programmer error. In this case we throw a very
+    // specific error message to try to guide them the right way.
+    // For example: https://github.com/Polymer/polymer-bundler/pull/519
+    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
+      var message = 'original.line and original.column are not numbers -- you probably meant to omit ' +
+      'the original mapping entirely and only map the generated position. If so, pass ' +
+      'null for the original mapping instead of an object with empty or null values.'
+
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+
+    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+        && aGenerated.line > 0 && aGenerated.column >= 0
+        && !aOriginal && !aSource && !aName) {
+      // Case 1.
+      return;
+    }
+    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
+             && aOriginal && 'line' in aOriginal && 'column' in aOriginal
+             && aGenerated.line > 0 && aGenerated.column >= 0
+             && aOriginal.line > 0 && aOriginal.column >= 0
+             && aSource) {
+      // Cases 2 and 3.
+      return;
+    }
+    else {
+      var message = 'Invalid mapping: ' + JSON.stringify({
+        generated: aGenerated,
+        source: aSource,
+        original: aOriginal,
+        name: aName
+      });
+
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== 'undefined' && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message)
+      }
+    }
+  };
+
+/**
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
+ * specified by the source map format.
+ */
+SourceMapGenerator.prototype._serializeMappings =
+  function SourceMapGenerator_serializeMappings() {
+    var previousGeneratedColumn = 0;
+    var previousGeneratedLine = 1;
+    var previousOriginalColumn = 0;
+    var previousOriginalLine = 0;
+    var previousName = 0;
+    var previousSource = 0;
+    var result = '';
+    var next;
+    var mapping;
+    var nameIdx;
+    var sourceIdx;
+
+    var mappings = this._mappings.toArray();
+    for (var i = 0, len = mappings.length; i < len; i++) {
+      mapping = mappings[i];
+      next = ''
+
+      if (mapping.generatedLine !== previousGeneratedLine) {
+        previousGeneratedColumn = 0;
+        while (mapping.generatedLine !== previousGeneratedLine) {
+          next += ';';
+          previousGeneratedLine++;
+        }
+      }
+      else {
+        if (i > 0) {
+          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+            continue;
+          }
+          next += ',';
+        }
+      }
+
+      next += base64VLQ.encode(mapping.generatedColumn
+                                 - previousGeneratedColumn);
+      previousGeneratedColumn = mapping.generatedColumn;
+
+      if (mapping.source != null) {
+        sourceIdx = this._sources.indexOf(mapping.source);
+        next += base64VLQ.encode(sourceIdx - previousSource);
+        previousSource = sourceIdx;
+
+        // lines are stored 0-based in SourceMap spec version 3
+        next += base64VLQ.encode(mapping.originalLine - 1
+                                   - previousOriginalLine);
+        previousOriginalLine = mapping.originalLine - 1;
+
+        next += base64VLQ.encode(mapping.originalColumn
+                                   - previousOriginalColumn);
+        previousOriginalColumn = mapping.originalColumn;
+
+        if (mapping.name != null) {
+          nameIdx = this._names.indexOf(mapping.name);
+          next += base64VLQ.encode(nameIdx - previousName);
+          previousName = nameIdx;
+        }
+      }
+
+      result += next;
+    }
+
+    return result;
+  };
+
+SourceMapGenerator.prototype._generateSourcesContent =
+  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+    return aSources.map(function (source) {
+      if (!this._sourcesContents) {
+        return null;
+      }
+      if (aSourceRoot != null) {
+        source = util.relative(aSourceRoot, source);
+      }
+      var key = util.toSetString(source);
+      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+        ? this._sourcesContents[key]
+        : null;
+    }, this);
+  };
+
+/**
+ * Externalize the source map.
+ */
+SourceMapGenerator.prototype.toJSON =
+  function SourceMapGenerator_toJSON() {
+    var map = {
+      version: this._version,
+      sources: this._sources.toArray(),
+      names: this._names.toArray(),
+      mappings: this._serializeMappings()
+    };
+    if (this._file != null) {
+      map.file = this._file;
+    }
+    if (this._sourceRoot != null) {
+      map.sourceRoot = this._sourceRoot;
+    }
+    if (this._sourcesContents) {
+      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+    }
+
+    return map;
+  };
+
+/**
+ * Render the source map being generated to a string.
+ */
+SourceMapGenerator.prototype.toString =
+  function SourceMapGenerator_toString() {
+    return JSON.stringify(this.toJSON());
+  };
+
+exports.SourceMapGenerator = SourceMapGenerator;
diff --git a/node_modules/source-map-js/lib/source-node.d.ts b/node_modules/source-map-js/lib/source-node.d.ts
new file mode 100644
index 0000000..4df6a1a
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-node.d.ts
@@ -0,0 +1 @@
+export { SourceNode } from '..';
diff --git a/node_modules/source-map-js/lib/source-node.js b/node_modules/source-map-js/lib/source-node.js
new file mode 100644
index 0000000..8bcdbe3
--- /dev/null
+++ b/node_modules/source-map-js/lib/source-node.js
@@ -0,0 +1,413 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
+var util = require('./util');
+
+// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+// operating systems these days (capturing the result).
+var REGEX_NEWLINE = /(\r?\n)/;
+
+// Newline character code for charCodeAt() comparisons
+var NEWLINE_CODE = 10;
+
+// Private symbol for identifying `SourceNode`s when multiple versions of
+// the source-map library are loaded. This MUST NOT CHANGE across
+// versions!
+var isSourceNode = "$$$isSourceNode$$$";
+
+/**
+ * SourceNodes provide a way to abstract over interpolating/concatenating
+ * snippets of generated JavaScript source code while maintaining the line and
+ * column information associated with the original source code.
+ *
+ * @param aLine The original line number.
+ * @param aColumn The original column number.
+ * @param aSource The original source's filename.
+ * @param aChunks Optional. An array of strings which are snippets of
+ *        generated JS, or other SourceNodes.
+ * @param aName The original identifier.
+ */
+function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+  this.children = [];
+  this.sourceContents = {};
+  this.line = aLine == null ? null : aLine;
+  this.column = aColumn == null ? null : aColumn;
+  this.source = aSource == null ? null : aSource;
+  this.name = aName == null ? null : aName;
+  this[isSourceNode] = true;
+  if (aChunks != null) this.add(aChunks);
+}
+
+/**
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
+ *
+ * @param aGeneratedCode The generated code
+ * @param aSourceMapConsumer The SourceMap for the generated code
+ * @param aRelativePath Optional. The path that relative sources in the
+ *        SourceMapConsumer should be relative to.
+ */
+SourceNode.fromStringWithSourceMap =
+  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+    // The SourceNode we want to fill with the generated code
+    // and the SourceMap
+    var node = new SourceNode();
+
+    // All even indices of this array are one line of the generated code,
+    // while all odd indices are the newlines between two adjacent lines
+    // (since `REGEX_NEWLINE` captures its match).
+    // Processed fragments are accessed by calling `shiftNextLine`.
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      // The last line of a file might not have a newline.
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ?
+            remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+
+    // We need to remember the position of "remainingLines"
+    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+    // The generate SourceNodes we need a code range.
+    // To extract it current and last mapping is used.
+    // Here we store the last mapping.
+    var lastMapping = null;
+
+    aSourceMapConsumer.eachMapping(function (mapping) {
+      if (lastMapping !== null) {
+        // We add the code from "lastMapping" to "mapping":
+        // First check if there is a new line in between.
+        if (lastGeneratedLine < mapping.generatedLine) {
+          // Associate first line with "lastMapping"
+          addMappingWithCode(lastMapping, shiftNextLine());
+          lastGeneratedLine++;
+          lastGeneratedColumn = 0;
+          // The remaining code is added without mapping
+        } else {
+          // There is no new line in between.
+          // Associate the code between "lastGeneratedColumn" and
+          // "mapping.generatedColumn" with "lastMapping"
+          var nextLine = remainingLines[remainingLinesIndex] || '';
+          var code = nextLine.substr(0, mapping.generatedColumn -
+                                        lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
+                                              lastGeneratedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+          addMappingWithCode(lastMapping, code);
+          // No more remaining code, continue
+          lastMapping = mapping;
+          return;
+        }
+      }
+      // We add the generated code until the first mapping
+      // to the SourceNode without any mapping.
+      // Each line is added as separate string.
+      while (lastGeneratedLine < mapping.generatedLine) {
+        node.add(shiftNextLine());
+        lastGeneratedLine++;
+      }
+      if (lastGeneratedColumn < mapping.generatedColumn) {
+        var nextLine = remainingLines[remainingLinesIndex] || '';
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    // We have processed all mappings.
+    if (remainingLinesIndex < remainingLines.length) {
+      if (lastMapping) {
+        // Associate the remaining code in the current line with "lastMapping"
+        addMappingWithCode(lastMapping, shiftNextLine());
+      }
+      // and add the remaining lines without any mapping
+      node.add(remainingLines.splice(remainingLinesIndex).join(""));
+    }
+
+    // Copy sourcesContent into SourceNode
+    aSourceMapConsumer.sources.forEach(function (sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aRelativePath != null) {
+          sourceFile = util.join(aRelativePath, sourceFile);
+        }
+        node.setSourceContent(sourceFile, content);
+      }
+    });
+
+    return node;
+
+    function addMappingWithCode(mapping, code) {
+      if (mapping === null || mapping.source === undefined) {
+        node.add(code);
+      } else {
+        var source = aRelativePath
+          ? util.join(aRelativePath, mapping.source)
+          : mapping.source;
+        node.add(new SourceNode(mapping.originalLine,
+                                mapping.originalColumn,
+                                source,
+                                code,
+                                mapping.name));
+      }
+    }
+  };
+
+/**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.add = function SourceNode_add(aChunk) {
+  if (Array.isArray(aChunk)) {
+    aChunk.forEach(function (chunk) {
+      this.add(chunk);
+    }, this);
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    if (aChunk) {
+      this.children.push(aChunk);
+    }
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ *        SourceNode, or an array where each member is one of those things.
+ */
+SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+  if (Array.isArray(aChunk)) {
+    for (var i = aChunk.length-1; i >= 0; i--) {
+      this.prepend(aChunk[i]);
+    }
+  }
+  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+    this.children.unshift(aChunk);
+  }
+  else {
+    throw new TypeError(
+      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
+    );
+  }
+  return this;
+};
+
+/**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+  var chunk;
+  for (var i = 0, len = this.children.length; i < len; i++) {
+    chunk = this.children[i];
+    if (chunk[isSourceNode]) {
+      chunk.walk(aFn);
+    }
+    else {
+      if (chunk !== '') {
+        aFn(chunk, { source: this.source,
+                     line: this.line,
+                     column: this.column,
+                     name: this.name });
+      }
+    }
+  }
+};
+
+/**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+SourceNode.prototype.join = function SourceNode_join(aSep) {
+  var newChildren;
+  var i;
+  var len = this.children.length;
+  if (len > 0) {
+    newChildren = [];
+    for (i = 0; i < len-1; i++) {
+      newChildren.push(this.children[i]);
+      newChildren.push(aSep);
+    }
+    newChildren.push(this.children[i]);
+    this.children = newChildren;
+  }
+  return this;
+};
+
+/**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+  var lastChild = this.children[this.children.length - 1];
+  if (lastChild[isSourceNode]) {
+    lastChild.replaceRight(aPattern, aReplacement);
+  }
+  else if (typeof lastChild === 'string') {
+    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+  }
+  else {
+    this.children.push(''.replace(aPattern, aReplacement));
+  }
+  return this;
+};
+
+/**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+SourceNode.prototype.setSourceContent =
+  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+
+/**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+SourceNode.prototype.walkSourceContents =
+  function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length; i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
+      }
+    }
+
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length; i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+
+/**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+SourceNode.prototype.toString = function SourceNode_toString() {
+  var str = "";
+  this.walk(function (chunk) {
+    str += chunk;
+  });
+  return str;
+};
+
+/**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+  var generated = {
+    code: "",
+    line: 1,
+    column: 0
+  };
+  var map = new SourceMapGenerator(aArgs);
+  var sourceMappingActive = false;
+  var lastOriginalSource = null;
+  var lastOriginalLine = null;
+  var lastOriginalColumn = null;
+  var lastOriginalName = null;
+  this.walk(function (chunk, original) {
+    generated.code += chunk;
+    if (original.source !== null
+        && original.line !== null
+        && original.column !== null) {
+      if(lastOriginalSource !== original.source
+         || lastOriginalLine !== original.line
+         || lastOriginalColumn !== original.column
+         || lastOriginalName !== original.name) {
+        map.addMapping({
+          source: original.source,
+          original: {
+            line: original.line,
+            column: original.column
+          },
+          generated: {
+            line: generated.line,
+            column: generated.column
+          },
+          name: original.name
+        });
+      }
+      lastOriginalSource = original.source;
+      lastOriginalLine = original.line;
+      lastOriginalColumn = original.column;
+      lastOriginalName = original.name;
+      sourceMappingActive = true;
+    } else if (sourceMappingActive) {
+      map.addMapping({
+        generated: {
+          line: generated.line,
+          column: generated.column
+        }
+      });
+      lastOriginalSource = null;
+      sourceMappingActive = false;
+    }
+    for (var idx = 0, length = chunk.length; idx < length; idx++) {
+      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+        generated.line++;
+        generated.column = 0;
+        // Mappings end at eol
+        if (idx + 1 === length) {
+          lastOriginalSource = null;
+          sourceMappingActive = false;
+        } else if (sourceMappingActive) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+      } else {
+        generated.column++;
+      }
+    }
+  });
+  this.walkSourceContents(function (sourceFile, sourceContent) {
+    map.setSourceContent(sourceFile, sourceContent);
+  });
+
+  return { code: generated.code, map: map };
+};
+
+exports.SourceNode = SourceNode;
diff --git a/node_modules/source-map-js/lib/util.js b/node_modules/source-map-js/lib/util.js
new file mode 100644
index 0000000..430e2d0
--- /dev/null
+++ b/node_modules/source-map-js/lib/util.js
@@ -0,0 +1,594 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * This is a helper function for getting values from parameter/options
+ * objects.
+ *
+ * @param args The object we are extracting values from
+ * @param name The name of the property we are getting.
+ * @param defaultValue An optional value to return if the property is missing
+ * from the object. If this is not specified and the property is missing, an
+ * error will be thrown.
+ */
+function getArg(aArgs, aName, aDefaultValue) {
+  if (aName in aArgs) {
+    return aArgs[aName];
+  } else if (arguments.length === 3) {
+    return aDefaultValue;
+  } else {
+    throw new Error('"' + aName + '" is a required argument.');
+  }
+}
+exports.getArg = getArg;
+
+var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+var dataUrlRegexp = /^data:.+\,.+$/;
+
+function urlParse(aUrl) {
+  var match = aUrl.match(urlRegexp);
+  if (!match) {
+    return null;
+  }
+  return {
+    scheme: match[1],
+    auth: match[2],
+    host: match[3],
+    port: match[4],
+    path: match[5]
+  };
+}
+exports.urlParse = urlParse;
+
+function urlGenerate(aParsedUrl) {
+  var url = '';
+  if (aParsedUrl.scheme) {
+    url += aParsedUrl.scheme + ':';
+  }
+  url += '//';
+  if (aParsedUrl.auth) {
+    url += aParsedUrl.auth + '@';
+  }
+  if (aParsedUrl.host) {
+    url += aParsedUrl.host;
+  }
+  if (aParsedUrl.port) {
+    url += ":" + aParsedUrl.port
+  }
+  if (aParsedUrl.path) {
+    url += aParsedUrl.path;
+  }
+  return url;
+}
+exports.urlGenerate = urlGenerate;
+
+var MAX_CACHED_INPUTS = 32;
+
+/**
+ * Takes some function `f(input) -> result` and returns a memoized version of
+ * `f`.
+ *
+ * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
+ * memoization is a dumb-simple, linear least-recently-used cache.
+ */
+function lruMemoize(f) {
+  var cache = [];
+
+  return function(input) {
+    for (var i = 0; i < cache.length; i++) {
+      if (cache[i].input === input) {
+        var temp = cache[0];
+        cache[0] = cache[i];
+        cache[i] = temp;
+        return cache[0].result;
+      }
+    }
+
+    var result = f(input);
+
+    cache.unshift({
+      input,
+      result,
+    });
+
+    if (cache.length > MAX_CACHED_INPUTS) {
+      cache.pop();
+    }
+
+    return result;
+  };
+}
+
+/**
+ * Normalizes a path, or the path portion of a URL:
+ *
+ * - Replaces consecutive slashes with one slash.
+ * - Removes unnecessary '.' parts.
+ * - Removes unnecessary '<dir>/..' parts.
+ *
+ * Based on code in the Node.js 'path' core module.
+ *
+ * @param aPath The path or url to normalize.
+ */
+var normalize = lruMemoize(function normalize(aPath) {
+  var path = aPath;
+  var url = urlParse(aPath);
+  if (url) {
+    if (!url.path) {
+      return aPath;
+    }
+    path = url.path;
+  }
+  var isAbsolute = exports.isAbsolute(path);
+  // Split the path into parts between `/` characters. This is much faster than
+  // using `.split(/\/+/g)`.
+  var parts = [];
+  var start = 0;
+  var i = 0;
+  while (true) {
+    start = i;
+    i = path.indexOf("/", start);
+    if (i === -1) {
+      parts.push(path.slice(start));
+      break;
+    } else {
+      parts.push(path.slice(start, i));
+      while (i < path.length && path[i] === "/") {
+        i++;
+      }
+    }
+  }
+
+  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
+    part = parts[i];
+    if (part === '.') {
+      parts.splice(i, 1);
+    } else if (part === '..') {
+      up++;
+    } else if (up > 0) {
+      if (part === '') {
+        // The first part is blank if the path is absolute. Trying to go
+        // above the root is a no-op. Therefore we can remove all '..' parts
+        // directly after the root.
+        parts.splice(i + 1, up);
+        up = 0;
+      } else {
+        parts.splice(i, 2);
+        up--;
+      }
+    }
+  }
+  path = parts.join('/');
+
+  if (path === '') {
+    path = isAbsolute ? '/' : '.';
+  }
+
+  if (url) {
+    url.path = path;
+    return urlGenerate(url);
+  }
+  return path;
+});
+exports.normalize = normalize;
+
+/**
+ * Joins two paths/URLs.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be joined with the root.
+ *
+ * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+ *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+ *   first.
+ * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+ *   is updated with the result and aRoot is returned. Otherwise the result
+ *   is returned.
+ *   - If aPath is absolute, the result is aPath.
+ *   - Otherwise the two paths are joined with a slash.
+ * - Joining for example 'http://' and 'www.example.com' is also supported.
+ */
+function join(aRoot, aPath) {
+  if (aRoot === "") {
+    aRoot = ".";
+  }
+  if (aPath === "") {
+    aPath = ".";
+  }
+  var aPathUrl = urlParse(aPath);
+  var aRootUrl = urlParse(aRoot);
+  if (aRootUrl) {
+    aRoot = aRootUrl.path || '/';
+  }
+
+  // `join(foo, '//www.example.org')`
+  if (aPathUrl && !aPathUrl.scheme) {
+    if (aRootUrl) {
+      aPathUrl.scheme = aRootUrl.scheme;
+    }
+    return urlGenerate(aPathUrl);
+  }
+
+  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+    return aPath;
+  }
+
+  // `join('http://', 'www.example.com')`
+  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+    aRootUrl.host = aPath;
+    return urlGenerate(aRootUrl);
+  }
+
+  var joined = aPath.charAt(0) === '/'
+    ? aPath
+    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+  if (aRootUrl) {
+    aRootUrl.path = joined;
+    return urlGenerate(aRootUrl);
+  }
+  return joined;
+}
+exports.join = join;
+
+exports.isAbsolute = function (aPath) {
+  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
+};
+
+/**
+ * Make a path relative to a URL or another path.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be made relative to aRoot.
+ */
+function relative(aRoot, aPath) {
+  if (aRoot === "") {
+    aRoot = ".";
+  }
+
+  aRoot = aRoot.replace(/\/$/, '');
+
+  // It is possible for the path to be above the root. In this case, simply
+  // checking whether the root is a prefix of the path won't work. Instead, we
+  // need to remove components from the root one by one, until either we find
+  // a prefix that fits, or we run out of components to remove.
+  var level = 0;
+  while (aPath.indexOf(aRoot + '/') !== 0) {
+    var index = aRoot.lastIndexOf("/");
+    if (index < 0) {
+      return aPath;
+    }
+
+    // If the only part of the root that is left is the scheme (i.e. http://,
+    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+    // have exhausted all components, so the path is not relative to the root.
+    aRoot = aRoot.slice(0, index);
+    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+      return aPath;
+    }
+
+    ++level;
+  }
+
+  // Make sure we add a "../" for each component we removed from the root.
+  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+}
+exports.relative = relative;
+
+var supportsNullProto = (function () {
+  var obj = Object.create(null);
+  return !('__proto__' in obj);
+}());
+
+function identity (s) {
+  return s;
+}
+
+/**
+ * Because behavior goes wacky when you set `__proto__` on objects, we
+ * have to prefix all the strings in our set with an arbitrary character.
+ *
+ * See https://github.com/mozilla/source-map/pull/31 and
+ * https://github.com/mozilla/source-map/issues/30
+ *
+ * @param String aStr
+ */
+function toSetString(aStr) {
+  if (isProtoString(aStr)) {
+    return '$' + aStr;
+  }
+
+  return aStr;
+}
+exports.toSetString = supportsNullProto ? identity : toSetString;
+
+function fromSetString(aStr) {
+  if (isProtoString(aStr)) {
+    return aStr.slice(1);
+  }
+
+  return aStr;
+}
+exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+function isProtoString(s) {
+  if (!s) {
+    return false;
+  }
+
+  var length = s.length;
+
+  if (length < 9 /* "__proto__".length */) {
+    return false;
+  }
+
+  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
+      s.charCodeAt(length - 9) !== 95  /* '_' */) {
+    return false;
+  }
+
+  for (var i = length - 10; i >= 0; i--) {
+    if (s.charCodeAt(i) !== 36 /* '$' */) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Comparator between two mappings where the original positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same original source/line/column, but different generated
+ * line and column the same. Useful when searching for a mapping with a
+ * stubbed out mapping.
+ */
+function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+  var cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0 || onlyCompareOriginal) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByOriginalPositions = compareByOriginalPositions;
+
+function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
+  var cmp
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0 || onlyCompareOriginal) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
+
+/**
+ * Comparator between two mappings with deflated source and name indices where
+ * the generated positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same generated line and column, but different
+ * source/name/original line and column the same. Useful when searching for a
+ * mapping with a stubbed out mapping.
+ */
+function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0 || onlyCompareGenerated) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+
+function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
+  var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0 || onlyCompareGenerated) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
+
+function strcmp(aStr1, aStr2) {
+  if (aStr1 === aStr2) {
+    return 0;
+  }
+
+  if (aStr1 === null) {
+    return 1; // aStr2 !== null
+  }
+
+  if (aStr2 === null) {
+    return -1; // aStr1 !== null
+  }
+
+  if (aStr1 > aStr2) {
+    return 1;
+  }
+
+  return -1;
+}
+
+/**
+ * Comparator between two mappings with inflated source and name strings where
+ * the generated positions are compared.
+ */
+function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+  var cmp = mappingA.generatedLine - mappingB.generatedLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = strcmp(mappingA.source, mappingB.source);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalLine - mappingB.originalLine;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = mappingA.originalColumn - mappingB.originalColumn;
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return strcmp(mappingA.name, mappingB.name);
+}
+exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+
+/**
+ * Strip any JSON XSSI avoidance prefix from the string (as documented
+ * in the source maps specification), and then parse the string as
+ * JSON.
+ */
+function parseSourceMapInput(str) {
+  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
+}
+exports.parseSourceMapInput = parseSourceMapInput;
+
+/**
+ * Compute the URL of a source given the the source root, the source's
+ * URL, and the source map's URL.
+ */
+function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+  sourceURL = sourceURL || '';
+
+  if (sourceRoot) {
+    // This follows what Chrome does.
+    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+      sourceRoot += '/';
+    }
+    // The spec says:
+    //   Line 4: An optional source root, useful for relocating source
+    //   files on a server or removing repeated values in the
+    //   “sources” entry.  This value is prepended to the individual
+    //   entries in the “source” field.
+    sourceURL = sourceRoot + sourceURL;
+  }
+
+  // Historically, SourceMapConsumer did not take the sourceMapURL as
+  // a parameter.  This mode is still somewhat supported, which is why
+  // this code block is conditional.  However, it's preferable to pass
+  // the source map URL to SourceMapConsumer, so that this function
+  // can implement the source URL resolution algorithm as outlined in
+  // the spec.  This block is basically the equivalent of:
+  //    new URL(sourceURL, sourceMapURL).toString()
+  // ... except it avoids using URL, which wasn't available in the
+  // older releases of node still supported by this library.
+  //
+  // The spec says:
+  //   If the sources are not absolute URLs after prepending of the
+  //   “sourceRoot”, the sources are resolved relative to the
+  //   SourceMap (like resolving script src in a html document).
+  if (sourceMapURL) {
+    var parsed = urlParse(sourceMapURL);
+    if (!parsed) {
+      throw new Error("sourceMapURL could not be parsed");
+    }
+    if (parsed.path) {
+      // Strip the last path component, but keep the "/".
+      var index = parsed.path.lastIndexOf('/');
+      if (index >= 0) {
+        parsed.path = parsed.path.substring(0, index + 1);
+      }
+    }
+    sourceURL = join(urlGenerate(parsed), sourceURL);
+  }
+
+  return normalize(sourceURL);
+}
+exports.computeSourceURL = computeSourceURL;
diff --git a/node_modules/source-map-js/package.json b/node_modules/source-map-js/package.json
new file mode 100644
index 0000000..f58dbeb
--- /dev/null
+++ b/node_modules/source-map-js/package.json
@@ -0,0 +1,71 @@
+{
+  "name": "source-map-js",
+  "description": "Generates and consumes source maps",
+  "version": "1.2.1",
+  "homepage": "https://github.com/7rulnik/source-map-js",
+  "author": "Valentin 7rulnik Semirulnik <v7rulnik@gmail.com>",
+  "contributors": [
+    "Nick Fitzgerald <nfitzgerald@mozilla.com>",
+    "Tobias Koppers <tobias.koppers@googlemail.com>",
+    "Duncan Beevers <duncan@dweebd.com>",
+    "Stephen Crane <scrane@mozilla.com>",
+    "Ryan Seddon <seddon.ryan@gmail.com>",
+    "Miles Elam <miles.elam@deem.com>",
+    "Mihai Bazon <mihai.bazon@gmail.com>",
+    "Michael Ficarra <github.public.email@michael.ficarra.me>",
+    "Todd Wolfson <todd@twolfson.com>",
+    "Alexander Solovyov <alexander@solovyov.net>",
+    "Felix Gnass <fgnass@gmail.com>",
+    "Conrad Irwin <conrad.irwin@gmail.com>",
+    "usrbincc <usrbincc@yahoo.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Chase Douglas <chase@newrelic.com>",
+    "Evan Wallace <evan.exe@gmail.com>",
+    "Heather Arthur <fayearthur@gmail.com>",
+    "Hugh Kennedy <hughskennedy@gmail.com>",
+    "David Glasser <glasser@davidglasser.net>",
+    "Simon Lydell <simon.lydell@gmail.com>",
+    "Jmeas Smith <jellyes2@gmail.com>",
+    "Michael Z Goddard <mzgoddard@gmail.com>",
+    "azu <azu@users.noreply.github.com>",
+    "John Gozde <john@gozde.ca>",
+    "Adam Kirkton <akirkton@truefitinnovation.com>",
+    "Chris Montgomery <christopher.montgomery@dowjones.com>",
+    "J. Ryan Stinnett <jryans@gmail.com>",
+    "Jack Herrington <jherrington@walmartlabs.com>",
+    "Chris Truter <jeffpalentine@gmail.com>",
+    "Daniel Espeset <daniel@danielespeset.com>",
+    "Jamie Wong <jamie.lf.wong@gmail.com>",
+    "Eddy Bruël <ejpbruel@mozilla.com>",
+    "Hawken Rives <hawkrives@gmail.com>",
+    "Gilad Peleg <giladp007@gmail.com>",
+    "djchie <djchie.dev@gmail.com>",
+    "Gary Ye <garysye@gmail.com>",
+    "Nicolas Lalevée <nicolas.lalevee@hibnet.org>"
+  ],
+  "repository": "7rulnik/source-map-js",
+  "main": "./source-map.js",
+  "files": [
+    "source-map.js",
+    "source-map.d.ts",
+    "lib/"
+  ],
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "npm run build && node test/run-tests.js",
+    "build": "webpack --color",
+    "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
+  },
+  "devDependencies": {
+    "clean-publish": "^3.1.0",
+    "doctoc": "^0.15.0",
+    "webpack": "^1.12.0"
+  },
+  "clean-publish": {
+    "cleanDocs": true
+  },
+  "typings": "source-map.d.ts"
+}
diff --git a/node_modules/source-map-js/source-map.d.ts b/node_modules/source-map-js/source-map.d.ts
new file mode 100644
index 0000000..ec8892f
--- /dev/null
+++ b/node_modules/source-map-js/source-map.d.ts
@@ -0,0 +1,104 @@
+export interface StartOfSourceMap {
+    file?: string;
+    sourceRoot?: string;
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+    version: string;
+    sources: string[];
+    names: string[];
+    sourcesContent?: string[];
+    mappings: string;
+}
+
+export interface Position {
+    line: number;
+    column: number;
+}
+
+export interface LineRange extends Position {
+    lastColumn: number;
+}
+
+export interface FindPosition extends Position {
+    // SourceMapConsumer.GREATEST_LOWER_BOUND or SourceMapConsumer.LEAST_UPPER_BOUND
+    bias?: number;
+}
+
+export interface SourceFindPosition extends FindPosition {
+    source: string;
+}
+
+export interface MappedPosition extends Position {
+    source: string;
+    name?: string;
+}
+
+export interface MappingItem {
+    source: string | null;
+    generatedLine: number;
+    generatedColumn: number;
+    originalLine: number | null;
+    originalColumn: number | null;
+    name: string | null;
+}
+
+export class SourceMapConsumer {
+    static GENERATED_ORDER: number;
+    static ORIGINAL_ORDER: number;
+
+    static GREATEST_LOWER_BOUND: number;
+    static LEAST_UPPER_BOUND: number;
+
+    constructor(rawSourceMap: RawSourceMap);
+    readonly file: string | undefined | null;
+    readonly sourceRoot: string | undefined | null;
+    readonly sourcesContent: readonly string[] | null | undefined;
+    readonly sources: readonly string[]
+
+    computeColumnSpans(): void;
+    originalPositionFor(generatedPosition: FindPosition): MappedPosition;
+    generatedPositionFor(originalPosition: SourceFindPosition): LineRange;
+    allGeneratedPositionsFor(originalPosition: MappedPosition): Position[];
+    hasContentsOfAllSources(): boolean;
+    sourceContentFor(source: string, returnNullOnMissing?: boolean): string | null;
+    eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+}
+
+export interface Mapping {
+    generated: Position;
+    original?: Position | null;
+    source?: string | null;
+    name?: string | null;
+}
+
+export class SourceMapGenerator {
+    constructor(startOfSourceMap?: StartOfSourceMap);
+    static fromSourceMap(sourceMapConsumer: SourceMapConsumer, startOfSourceMap?: StartOfSourceMap): SourceMapGenerator;
+    addMapping(mapping: Mapping): void;
+    setSourceContent(sourceFile: string, sourceContent: string | null | undefined): void;
+    applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+    toString(): string;
+    toJSON(): RawSourceMap;
+}
+
+export interface CodeWithSourceMap {
+    code: string;
+    map: SourceMapGenerator;
+}
+
+export class SourceNode {
+    constructor();
+    constructor(line: number, column: number, source: string);
+    constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+    static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+    add(chunk: string): void;
+    prepend(chunk: string): void;
+    setSourceContent(sourceFile: string, sourceContent: string): void;
+    walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+    walkSourceContents(fn: (file: string, content: string) => void): void;
+    join(sep: string): SourceNode;
+    replaceRight(pattern: string, replacement: string): SourceNode;
+    toString(): string;
+    toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+}
diff --git a/node_modules/source-map-js/source-map.js b/node_modules/source-map-js/source-map.js
new file mode 100644
index 0000000..bc88fe8
--- /dev/null
+++ b/node_modules/source-map-js/source-map.js
@@ -0,0 +1,8 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator = require('./lib/source-map-generator').SourceMapGenerator;
+exports.SourceMapConsumer = require('./lib/source-map-consumer').SourceMapConsumer;
+exports.SourceNode = require('./lib/source-node').SourceNode;
diff --git a/node_modules/vite/LICENSE.md b/node_modules/vite/LICENSE.md
new file mode 100644
index 0000000..ddd5a62
--- /dev/null
+++ b/node_modules/vite/LICENSE.md
@@ -0,0 +1,3423 @@
+# Vite core license
+Vite is released under the MIT license:
+
+MIT License
+
+Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+# Licenses of bundled dependencies
+The published Vite artifact additionally contains code with the following licenses:
+Apache-2.0, BSD-2-Clause, BlueOak-1.0.0, CC0-1.0, ISC, MIT
+
+# Bundled dependencies:
+## @ampproject/remapping
+License: Apache-2.0
+By: Justin Ridgewell
+Repository: git+https://github.com/ampproject/remapping.git
+
+> Apache License
+>                            Version 2.0, January 2004
+>                         http://www.apache.org/licenses/
+> 
+>    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+> 
+>    1. Definitions.
+> 
+>       "License" shall mean the terms and conditions for use, reproduction,
+>       and distribution as defined by Sections 1 through 9 of this document.
+> 
+>       "Licensor" shall mean the copyright owner or entity authorized by
+>       the copyright owner that is granting the License.
+> 
+>       "Legal Entity" shall mean the union of the acting entity and all
+>       other entities that control, are controlled by, or are under common
+>       control with that entity. For the purposes of this definition,
+>       "control" means (i) the power, direct or indirect, to cause the
+>       direction or management of such entity, whether by contract or
+>       otherwise, or (ii) ownership of fifty percent (50%) or more of the
+>       outstanding shares, or (iii) beneficial ownership of such entity.
+> 
+>       "You" (or "Your") shall mean an individual or Legal Entity
+>       exercising permissions granted by this License.
+> 
+>       "Source" form shall mean the preferred form for making modifications,
+>       including but not limited to software source code, documentation
+>       source, and configuration files.
+> 
+>       "Object" form shall mean any form resulting from mechanical
+>       transformation or translation of a Source form, including but
+>       not limited to compiled object code, generated documentation,
+>       and conversions to other media types.
+> 
+>       "Work" shall mean the work of authorship, whether in Source or
+>       Object form, made available under the License, as indicated by a
+>       copyright notice that is included in or attached to the work
+>       (an example is provided in the Appendix below).
+> 
+>       "Derivative Works" shall mean any work, whether in Source or Object
+>       form, that is based on (or derived from) the Work and for which the
+>       editorial revisions, annotations, elaborations, or other modifications
+>       represent, as a whole, an original work of authorship. For the purposes
+>       of this License, Derivative Works shall not include works that remain
+>       separable from, or merely link (or bind by name) to the interfaces of,
+>       the Work and Derivative Works thereof.
+> 
+>       "Contribution" shall mean any work of authorship, including
+>       the original version of the Work and any modifications or additions
+>       to that Work or Derivative Works thereof, that is intentionally
+>       submitted to Licensor for inclusion in the Work by the copyright owner
+>       or by an individual or Legal Entity authorized to submit on behalf of
+>       the copyright owner. For the purposes of this definition, "submitted"
+>       means any form of electronic, verbal, or written communication sent
+>       to the Licensor or its representatives, including but not limited to
+>       communication on electronic mailing lists, source code control systems,
+>       and issue tracking systems that are managed by, or on behalf of, the
+>       Licensor for the purpose of discussing and improving the Work, but
+>       excluding communication that is conspicuously marked or otherwise
+>       designated in writing by the copyright owner as "Not a Contribution."
+> 
+>       "Contributor" shall mean Licensor and any individual or Legal Entity
+>       on behalf of whom a Contribution has been received by Licensor and
+>       subsequently incorporated within the Work.
+> 
+>    2. Grant of Copyright License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       copyright license to reproduce, prepare Derivative Works of,
+>       publicly display, publicly perform, sublicense, and distribute the
+>       Work and such Derivative Works in Source or Object form.
+> 
+>    3. Grant of Patent License. Subject to the terms and conditions of
+>       this License, each Contributor hereby grants to You a perpetual,
+>       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+>       (except as stated in this section) patent license to make, have made,
+>       use, offer to sell, sell, import, and otherwise transfer the Work,
+>       where such license applies only to those patent claims licensable
+>       by such Contributor that are necessarily infringed by their
+>       Contribution(s) alone or by combination of their Contribution(s)
+>       with the Work to which such Contribution(s) was submitted. If You
+>       institute patent litigation against any entity (including a
+>       cross-claim or counterclaim in a lawsuit) alleging that the Work
+>       or a Contribution incorporated within the Work constitutes direct
+>       or contributory patent infringement, then any patent licenses
+>       granted to You under this License for that Work shall terminate
+>       as of the date such litigation is filed.
+> 
+>    4. Redistribution. You may reproduce and distribute copies of the
+>       Work or Derivative Works thereof in any medium, with or without
+>       modifications, and in Source or Object form, provided that You
+>       meet the following conditions:
+> 
+>       (a) You must give any other recipients of the Work or
+>           Derivative Works a copy of this License; and
+> 
+>       (b) You must cause any modified files to carry prominent notices
+>           stating that You changed the files; and
+> 
+>       (c) You must retain, in the Source form of any Derivative Works
+>           that You distribute, all copyright, patent, trademark, and
+>           attribution notices from the Source form of the Work,
+>           excluding those notices that do not pertain to any part of
+>           the Derivative Works; and
+> 
+>       (d) If the Work includes a "NOTICE" text file as part of its
+>           distribution, then any Derivative Works that You distribute must
+>           include a readable copy of the attribution notices contained
+>           within such NOTICE file, excluding those notices that do not
+>           pertain to any part of the Derivative Works, in at least one
+>           of the following places: within a NOTICE text file distributed
+>           as part of the Derivative Works; within the Source form or
+>           documentation, if provided along with the Derivative Works; or,
+>           within a display generated by the Derivative Works, if and
+>           wherever such third-party notices normally appear. The contents
+>           of the NOTICE file are for informational purposes only and
+>           do not modify the License. You may add Your own attribution
+>           notices within Derivative Works that You distribute, alongside
+>           or as an addendum to the NOTICE text from the Work, provided
+>           that such additional attribution notices cannot be construed
+>           as modifying the License.
+> 
+>       You may add Your own copyright statement to Your modifications and
+>       may provide additional or different license terms and conditions
+>       for use, reproduction, or distribution of Your modifications, or
+>       for any such Derivative Works as a whole, provided Your use,
+>       reproduction, and distribution of the Work otherwise complies with
+>       the conditions stated in this License.
+> 
+>    5. Submission of Contributions. Unless You explicitly state otherwise,
+>       any Contribution intentionally submitted for inclusion in the Work
+>       by You to the Licensor shall be under the terms and conditions of
+>       this License, without any additional terms or conditions.
+>       Notwithstanding the above, nothing herein shall supersede or modify
+>       the terms of any separate license agreement you may have executed
+>       with Licensor regarding such Contributions.
+> 
+>    6. Trademarks. This License does not grant permission to use the trade
+>       names, trademarks, service marks, or product names of the Licensor,
+>       except as required for reasonable and customary use in describing the
+>       origin of the Work and reproducing the content of the NOTICE file.
+> 
+>    7. Disclaimer of Warranty. Unless required by applicable law or
+>       agreed to in writing, Licensor provides the Work (and each
+>       Contributor provides its Contributions) on an "AS IS" BASIS,
+>       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+>       implied, including, without limitation, any warranties or conditions
+>       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+>       PARTICULAR PURPOSE. You are solely responsible for determining the
+>       appropriateness of using or redistributing the Work and assume any
+>       risks associated with Your exercise of permissions under this License.
+> 
+>    8. Limitation of Liability. In no event and under no legal theory,
+>       whether in tort (including negligence), contract, or otherwise,
+>       unless required by applicable law (such as deliberate and grossly
+>       negligent acts) or agreed to in writing, shall any Contributor be
+>       liable to You for damages, including any direct, indirect, special,
+>       incidental, or consequential damages of any character arising as a
+>       result of this License or out of the use or inability to use the
+>       Work (including but not limited to damages for loss of goodwill,
+>       work stoppage, computer failure or malfunction, or any and all
+>       other commercial damages or losses), even if such Contributor
+>       has been advised of the possibility of such damages.
+> 
+>    9. Accepting Warranty or Additional Liability. While redistributing
+>       the Work or Derivative Works thereof, You may choose to offer,
+>       and charge a fee for, acceptance of support, warranty, indemnity,
+>       or other liability obligations and/or rights consistent with this
+>       License. However, in accepting such obligations, You may act only
+>       on Your own behalf and on Your sole responsibility, not on behalf
+>       of any other Contributor, and only if You agree to indemnify,
+>       defend, and hold each Contributor harmless for any liability
+>       incurred by, or claims asserted against, such Contributor by reason
+>       of your accepting any such warranty or additional liability.
+> 
+>    END OF TERMS AND CONDITIONS
+> 
+>    APPENDIX: How to apply the Apache License to your work.
+> 
+>       To apply the Apache License to your work, attach the following
+>       boilerplate notice, with the fields enclosed by brackets "[]"
+>       replaced with your own identifying information. (Don't include
+>       the brackets!)  The text should be enclosed in the appropriate
+>       comment syntax for the file format. We also recommend that a
+>       file or class name and description of purpose be included on the
+>       same "printed page" as the copyright notice for easier
+>       identification within third-party archives.
+> 
+>    Copyright [yyyy] [name of copyright owner]
+> 
+>    Licensed under the Apache License, Version 2.0 (the "License");
+>    you may not use this file except in compliance with the License.
+>    You may obtain a copy of the License at
+> 
+>        http://www.apache.org/licenses/LICENSE-2.0
+> 
+>    Unless required by applicable law or agreed to in writing, software
+>    distributed under the License is distributed on an "AS IS" BASIS,
+>    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+>    See the License for the specific language governing permissions and
+>    limitations under the License.
+
+---------------------------------------
+
+## @jridgewell/gen-mapping
+License: MIT
+By: Justin Ridgewell
+Repository: https://github.com/jridgewell/gen-mapping
+
+> Copyright 2022 Justin Ridgewell <jridgewell@google.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @jridgewell/resolve-uri
+License: MIT
+By: Justin Ridgewell
+Repository: https://github.com/jridgewell/resolve-uri
+
+> Copyright 2019 Justin Ridgewell <jridgewell@google.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @jridgewell/set-array
+License: MIT
+By: Justin Ridgewell
+Repository: https://github.com/jridgewell/set-array
+
+> Copyright 2022 Justin Ridgewell <jridgewell@google.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @jridgewell/sourcemap-codec
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/jridgewell/sourcemap-codec.git
+
+> The MIT License
+> 
+> Copyright (c) 2015 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## @jridgewell/trace-mapping
+License: MIT
+By: Justin Ridgewell
+Repository: git+https://github.com/jridgewell/trace-mapping.git
+
+> Copyright 2022 Justin Ridgewell <justin@ridgewell.name>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @nodelib/fs.scandir
+License: MIT
+Repository: https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.scandir
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Denis Malinochkin
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @nodelib/fs.stat
+License: MIT
+Repository: https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.stat
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Denis Malinochkin
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @nodelib/fs.walk
+License: MIT
+Repository: https://github.com/nodelib/nodelib/tree/master/packages/fs/fs.walk
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Denis Malinochkin
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## @polka/compression
+License: MIT
+Repository: lukeed/polka
+
+---------------------------------------
+
+## @polka/url
+License: MIT
+By: Luke Edwards
+Repository: lukeed/polka
+
+---------------------------------------
+
+## @rollup/plugin-alias
+License: MIT
+By: Johannes Stein
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## @rollup/plugin-commonjs
+License: MIT
+By: Rich Harris
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## @rollup/plugin-dynamic-import-vars
+License: MIT
+By: LarsDenBakker
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## @rollup/pluginutils
+License: MIT
+By: Rich Harris
+Repository: rollup/plugins
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## ansi-regex
+License: MIT
+By: Sindre Sorhus
+Repository: chalk/ansi-regex
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## anymatch
+License: ISC
+By: Elan Shanker
+Repository: https://github.com/micromatch/anymatch
+
+> The ISC License
+> 
+> Copyright (c) 2019 Elan Shanker, Paul Miller (https://paulmillr.com)
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## artichokie
+License: MIT
+By: sapphi-red, Evan You
+Repository: git+https://github.com/sapphi-red/artichokie.git
+
+> MIT License
+> 
+> Copyright (c) 2020-present, Yuxi (Evan) You
+> Copyright (c) 2023-present, sapphi-red
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## astring
+License: MIT
+By: David Bonnet
+Repository: https://github.com/davidbonnet/astring.git
+
+> Copyright (c) 2015, David Bonnet <david@bonnet.cc>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## balanced-match
+License: MIT
+By: Julian Gruber
+Repository: git://github.com/juliangruber/balanced-match.git
+
+> (MIT)
+> 
+> Copyright (c) 2013 Julian Gruber &lt;julian@juliangruber.com&gt;
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+> of the Software, and to permit persons to whom the Software is furnished to do
+> so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## binary-extensions
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/binary-extensions
+
+> MIT License
+> 
+> Copyright (c) 2019 Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com), Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## brace-expansion
+License: MIT
+By: Julian Gruber
+Repository: git://github.com/juliangruber/brace-expansion.git
+
+> MIT License
+> 
+> Copyright (c) 2013 Julian Gruber <julian@juliangruber.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## braces
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Elan Shanker, Eugene Sharygin, hemanth.hm
+Repository: micromatch/braces
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## cac
+License: MIT
+By: egoist
+Repository: egoist/cac
+
+> The MIT License (MIT)
+> 
+> Copyright (c) EGOIST <0x142857@gmail.com> (https://github.com/egoist)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## chokidar
+License: MIT
+By: Paul Miller, Elan Shanker
+Repository: git+https://github.com/paulmillr/chokidar.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2012-2019 Paul Miller (https://paulmillr.com), Elan Shanker
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the “Software”), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## commondir
+License: MIT
+By: James Halliday
+Repository: http://github.com/substack/node-commondir.git
+
+> The MIT License
+> 
+> Copyright (c) 2013 James Halliday (mail@substack.net)
+> 
+> Permission is hereby granted, free of charge, 
+> to any person obtaining a copy of this software and 
+> associated documentation files (the "Software"), to 
+> deal in the Software without restriction, including 
+> without limitation the rights to use, copy, modify, 
+> merge, publish, distribute, sublicense, and/or sell 
+> copies of the Software, and to permit persons to whom 
+> the Software is furnished to do so, 
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice 
+> shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+> ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## connect
+License: MIT
+By: TJ Holowaychuk, Douglas Christopher Wilson, Jonathan Ong, Tim Caswell
+Repository: senchalabs/connect
+
+> (The MIT License)
+> 
+> Copyright (c) 2010 Sencha Inc.
+> Copyright (c) 2011 LearnBoost
+> Copyright (c) 2011-2014 TJ Holowaychuk
+> Copyright (c) 2015 Douglas Christopher Wilson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## convert-source-map
+License: MIT
+By: Thorsten Lorenz
+Repository: git://github.com/thlorenz/convert-source-map.git
+
+> Copyright 2013 Thorsten Lorenz. 
+> All rights reserved.
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use,
+> copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following
+> conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+> OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## cors
+License: MIT
+By: Troy Goode
+Repository: expressjs/cors
+
+> (The MIT License)
+> 
+> Copyright (c) 2013 Troy Goode <troygoode@gmail.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## cross-spawn
+License: MIT
+By: André Cruz
+Repository: git@github.com:moxystudio/node-cross-spawn.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2018 Made With MOXY Lda <hello@moxy.studio>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## cssesc
+License: MIT
+By: Mathias Bynens
+Repository: https://github.com/mathiasbynens/cssesc.git
+
+> Copyright Mathias Bynens <https://mathiasbynens.be/>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> "Software"), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## debug
+License: MIT
+By: Josh Junon, TJ Holowaychuk, Nathan Rajlich, Andrew Rhyne
+Repository: git://github.com/debug-js/debug.git
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+> Copyright (c) 2018-2021 Josh Junon
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+> and associated documentation files (the 'Software'), to deal in the Software without restriction,
+> including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+> and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial
+> portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+> LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## define-lazy-prop
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/define-lazy-prop
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## dotenv
+License: BSD-2-Clause
+Repository: git://github.com/motdotla/dotenv.git
+
+> Copyright (c) 2015, Scott Motte
+> All rights reserved.
+> 
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted provided that the following conditions are met:
+> 
+> * Redistributions of source code must retain the above copyright notice, this
+>   list of conditions and the following disclaimer.
+> 
+> * Redistributions in binary form must reproduce the above copyright notice,
+>   this list of conditions and the following disclaimer in the documentation
+>   and/or other materials provided with the distribution.
+> 
+> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+> AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+> IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------
+
+## dotenv-expand
+License: BSD-2-Clause
+By: motdotla
+Repository: https://github.com/motdotla/dotenv-expand
+
+> Copyright (c) 2016, Scott Motte
+> All rights reserved.
+> 
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted provided that the following conditions are met:
+> 
+> * Redistributions of source code must retain the above copyright notice, this
+>   list of conditions and the following disclaimer.
+> 
+> * Redistributions in binary form must reproduce the above copyright notice,
+>   this list of conditions and the following disclaimer in the documentation
+>   and/or other materials provided with the distribution.
+> 
+> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+> AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+> IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------
+
+## ee-first
+License: MIT
+By: Jonathan Ong, Douglas Christopher Wilson
+Repository: jonathanong/ee-first
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Jonathan Ong me@jongleberry.com
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## encodeurl
+License: MIT
+By: Douglas Christopher Wilson
+Repository: pillarjs/encodeurl
+
+> (The MIT License)
+> 
+> Copyright (c) 2016 Douglas Christopher Wilson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## entities
+License: BSD-2-Clause
+By: Felix Boehm
+Repository: git://github.com/fb55/entities.git
+
+> Copyright (c) Felix Böhm
+> All rights reserved.
+> 
+> Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+> 
+> Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+> 
+> Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+> 
+> THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+> EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---------------------------------------
+
+## es-module-lexer
+License: MIT
+By: Guy Bedford
+Repository: git+https://github.com/guybedford/es-module-lexer.git
+
+> MIT License
+> -----------
+> 
+> Copyright (C) 2018-2022 Guy Bedford
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## escape-html
+License: MIT
+Repository: component/escape-html
+
+> (The MIT License)
+> 
+> Copyright (c) 2012-2013 TJ Holowaychuk
+> Copyright (c) 2015 Andreas Lubbe
+> Copyright (c) 2015 Tiancheng "Timothy" Gu
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## estree-walker
+License: MIT
+By: Rich Harris
+Repository: https://github.com/Rich-Harris/estree-walker
+
+> Copyright (c) 2015-20 [these people](https://github.com/Rich-Harris/estree-walker/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## etag
+License: MIT
+By: Douglas Christopher Wilson, David Björklund
+Repository: jshttp/etag
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2016 Douglas Christopher Wilson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## eventemitter3
+License: MIT
+By: Arnout Kazemier
+Repository: git://github.com/primus/eventemitter3.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Arnout Kazemier
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## fast-glob
+License: MIT
+By: Denis Malinochkin
+Repository: mrmlnc/fast-glob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Denis Malinochkin
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## fastq
+License: ISC
+By: Matteo Collina
+Repository: git+https://github.com/mcollina/fastq.git
+
+> Copyright (c) 2015-2020, Matteo Collina <matteo.collina@gmail.com>
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## fill-range
+License: MIT
+By: Jon Schlinkert, Edo Rivai, Paul Miller, Rouven Weßling
+Repository: jonschlinkert/fill-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## finalhandler
+License: MIT
+By: Douglas Christopher Wilson
+Repository: pillarjs/finalhandler
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2017 Douglas Christopher Wilson <doug@somethingdoug.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## follow-redirects
+License: MIT
+By: Ruben Verborgh, Olivier Lalonde, James Talmage
+Repository: git@github.com:follow-redirects/follow-redirects.git
+
+> Copyright 2014–present Olivier Lalonde <olalonde@gmail.com>, James Talmage <james@talmage.io>, Ruben Verborgh
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+> of the Software, and to permit persons to whom the Software is furnished to do
+> so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+> IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## generic-names
+License: MIT
+By: Alexey Litvinov
+Repository: git+https://github.com/css-modules/generic-names.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015 Alexey Litvinov
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## glob
+License: ISC
+By: Isaac Z. Schlueter
+Repository: git://github.com/isaacs/node-glob.git
+
+> The ISC License
+> 
+> Copyright (c) 2009-2023 Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## glob-parent
+License: ISC
+By: Gulp Team, Elan Shanker, Blaine Bublitz
+Repository: gulpjs/glob-parent
+
+> The ISC License
+> 
+> Copyright (c) 2015, 2019 Elan Shanker
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## http-proxy
+License: MIT
+By: Charlie Robbins, jcrugzz <jcrugzz@gmail.com>
+Repository: https://github.com/http-party/node-http-proxy.git
+
+> node-http-proxy
+> 
+>   Copyright (c) 2010-2016 Charlie Robbins, Jarrett Cruger & the Contributors.
+> 
+>   Permission is hereby granted, free of charge, to any person obtaining
+>   a copy of this software and associated documentation files (the
+>   "Software"), to deal in the Software without restriction, including
+>   without limitation the rights to use, copy, modify, merge, publish,
+>   distribute, sublicense, and/or sell copies of the Software, and to
+>   permit persons to whom the Software is furnished to do so, subject to
+>   the following conditions:
+> 
+>   The above copyright notice and this permission notice shall be
+>   included in all copies or substantial portions of the Software.
+> 
+>   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+>   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+>   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+>   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+>   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+>   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+>   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## icss-utils
+License: ISC
+By: Glen Maddern
+Repository: git+https://github.com/css-modules/icss-utils.git
+
+> ISC License (ISC)
+> Copyright 2018 Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## is-binary-path
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/is-binary-path
+
+> MIT License
+> 
+> Copyright (c) 2019 Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com), Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## is-docker
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/is-docker
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## is-extglob
+License: MIT
+By: Jon Schlinkert
+Repository: jonschlinkert/is-extglob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2016, Jon Schlinkert
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-glob
+License: MIT
+By: Jon Schlinkert, Brian Woodward, Daniel Perez
+Repository: micromatch/is-glob
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2017, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-number
+License: MIT
+By: Jon Schlinkert, Olsten Larck, Rouven Weßling
+Repository: jonschlinkert/is-number
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## is-reference
+License: MIT
+By: Rich Harris
+Repository: git+https://github.com/Rich-Harris/is-reference.git
+
+---------------------------------------
+
+## is-wsl
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/is-wsl
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## isexe
+License: ISC
+By: Isaac Z. Schlueter
+Repository: git+https://github.com/isaacs/isexe.git
+
+> The ISC License
+> 
+> Copyright (c) Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## js-tokens
+License: MIT
+By: Simon Lydell
+Repository: lydell/js-tokens
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024 Simon Lydell
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## launch-editor
+License: MIT
+By: Evan You
+Repository: git+https://github.com/yyx990803/launch-editor.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Yuxi (Evan) You
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## launch-editor-middleware
+License: MIT
+By: Evan You
+Repository: git+https://github.com/yyx990803/launch-editor.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Yuxi (Evan) You
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## lilconfig
+License: MIT
+By: antonk52
+Repository: https://github.com/antonk52/lilconfig
+
+> MIT License
+> 
+> Copyright (c) 2022 Anton Kastritskiy
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## loader-utils
+License: MIT
+By: Tobias Koppers @sokra
+Repository: https://github.com/webpack/loader-utils.git
+
+> Copyright JS Foundation and other contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## lodash.camelcase
+License: MIT
+By: John-David Dalton, Blaine Bublitz, Mathias Bynens
+Repository: lodash/lodash
+
+> Copyright jQuery Foundation and other contributors <https://jquery.org/>
+> 
+> Based on Underscore.js, copyright Jeremy Ashkenas,
+> DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+> 
+> This software consists of voluntary contributions made by many
+> individuals. For exact contribution history, see the revision history
+> available at https://github.com/lodash/lodash
+> 
+> The following license applies to all parts of this software except as
+> documented below:
+> 
+> ====
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> "Software"), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+> 
+> ====
+> 
+> Copyright and related rights for sample code are waived via CC0. Sample
+> code is defined as all source code displayed within the prose of the
+> documentation.
+> 
+> CC0: http://creativecommons.org/publicdomain/zero/1.0/
+> 
+> ====
+> 
+> Files located in the node_modules and vendor directories are externally
+> maintained libraries used by this software which have their own
+> licenses; we recommend you read them, as their terms may differ from the
+> terms above.
+
+---------------------------------------
+
+## lru-cache
+License: ISC
+By: Isaac Z. Schlueter
+Repository: git://github.com/isaacs/node-lru-cache.git
+
+> The ISC License
+> 
+> Copyright (c) 2010-2023 Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## magic-string
+License: MIT
+By: Rich Harris
+Repository: https://github.com/rich-harris/magic-string
+
+> Copyright 2018 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## merge2
+License: MIT
+Repository: git@github.com:teambition/merge2.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2020 Teambition
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## micromatch
+License: MIT
+By: Jon Schlinkert, Amila Welihinda, Bogdan Chadkin, Brian Woodward, Devon Govett, Elan Shanker, Fabrício Matté, Martin Kolárik, Olsten Larck, Paul Miller, Tom Byrer, Tyler Akins, Peter Bright, Kuba Juszczyk
+Repository: micromatch/micromatch
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## minimatch
+License: ISC
+By: Isaac Z. Schlueter
+Repository: git://github.com/isaacs/minimatch.git
+
+> The ISC License
+> 
+> Copyright (c) 2011-2023 Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## minipass
+License: ISC
+By: Isaac Z. Schlueter
+Repository: https://github.com/isaacs/minipass
+
+> The ISC License
+> 
+> Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## mlly
+License: MIT
+Repository: unjs/mlly
+
+> MIT License
+> 
+> Copyright (c) Pooya Parsa <pooya@pi0.io>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## mrmime
+License: MIT
+By: Luke Edwards
+Repository: lukeed/mrmime
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (https://lukeed.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## ms
+License: MIT
+Repository: zeit/ms
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2016 Zeit, Inc.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## normalize-path
+License: MIT
+By: Jon Schlinkert, Blaine Bublitz
+Repository: jonschlinkert/normalize-path
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014-2018, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## object-assign
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/object-assign
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## on-finished
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: jshttp/on-finished
+
+> (The MIT License)
+> 
+> Copyright (c) 2013 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2014 Douglas Christopher Wilson <doug@somethingdoug.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## open
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/open
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## parse5
+License: MIT
+By: Ivan Nikulin, https://github.com/inikulin/parse5/graphs/contributors
+Repository: git://github.com/inikulin/parse5.git
+
+> Copyright (c) 2013-2019 Ivan Nikulin (ifaaan@gmail.com, https://github.com/inikulin)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## parseurl
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: pillarjs/parseurl
+
+> (The MIT License)
+> 
+> Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2014-2017 Douglas Christopher Wilson <doug@somethingdoug.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## path-key
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/path-key
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## path-scurry
+License: BlueOak-1.0.0
+By: Isaac Z. Schlueter
+Repository: git+https://github.com/isaacs/path-scurry
+
+> # Blue Oak Model License
+> 
+> Version 1.0.0
+> 
+> ## Purpose
+> 
+> This license gives everyone as much permission to work with
+> this software as possible, while protecting contributors
+> from liability.
+> 
+> ## Acceptance
+> 
+> In order to receive this license, you must agree to its
+> rules.  The rules of this license are both obligations
+> under that agreement and conditions to your license.
+> You must not do anything with this software that triggers
+> a rule that you cannot or will not follow.
+> 
+> ## Copyright
+> 
+> Each contributor licenses you to do everything with this
+> software that would otherwise infringe that contributor's
+> copyright in it.
+> 
+> ## Notices
+> 
+> You must ensure that everyone who gets a copy of
+> any part of this software from you, with or without
+> changes, also gets the text of this license or a link to
+> <https://blueoakcouncil.org/license/1.0.0>.
+> 
+> ## Excuse
+> 
+> If anyone notifies you in writing that you have not
+> complied with [Notices](#notices), you can keep your
+> license by taking all practical steps to comply within 30
+> days after the notice.  If you do not do so, your license
+> ends immediately.
+> 
+> ## Patent
+> 
+> Each contributor licenses you to do everything with this
+> software that would otherwise infringe any patent claims
+> they can license or become able to license.
+> 
+> ## Reliability
+> 
+> No contributor can revoke this license.
+> 
+> ## No Liability
+> 
+> ***As far as the law allows, this software comes as is,
+> without any warranty or condition, and no contributor
+> will be liable to anyone for any damages related to this
+> software or this license, under any kind of legal claim.***
+
+---------------------------------------
+
+## periscopic
+License: MIT
+Repository: Rich-Harris/periscopic
+
+> Copyright (c) 2019 Rich Harris
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## picocolors
+License: ISC
+By: Alexey Raspopov
+Repository: alexeyraspopov/picocolors
+
+> ISC License
+> 
+> Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+> OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## picomatch
+License: MIT
+By: Jon Schlinkert
+Repository: micromatch/picomatch
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2017-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## pify
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/pify
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-import
+License: MIT
+By: Maxime Thirouin
+Repository: https://github.com/postcss/postcss-import.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Maxime Thirouin, Jason Campbell & Kevin Mårtensson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-load-config
+License: MIT
+By: Michael Ciniawky, Ryan Dunckel, Mateusz Derks, Dalton Santos, Patrick Gilday, François Wouts
+Repository: postcss/postcss-load-config
+
+> The MIT License (MIT)
+> 
+> Copyright Michael Ciniawsky <michael.ciniawsky@gmail.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules
+License: MIT
+By: Alexander Madyankin
+Repository: https://github.com/css-modules/postcss-modules.git
+
+> The MIT License (MIT)
+> 
+> Copyright 2015-present Alexander Madyankin <alexander@madyankin.name>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-extract-imports
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/postcss-modules-extract-imports.git
+
+> Copyright 2015 Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-local-by-default
+License: MIT
+By: Mark Dalgleish
+Repository: https://github.com/css-modules/postcss-modules-local-by-default.git
+
+> The MIT License (MIT)
+> 
+> Copyright 2015 Mark Dalgleish <mark.john.dalgleish@gmail.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-scope
+License: ISC
+By: Glen Maddern
+Repository: https://github.com/css-modules/postcss-modules-scope.git
+
+> ISC License (ISC)
+> 
+> Copyright (c) 2015, Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-modules-values
+License: ISC
+By: Glen Maddern
+Repository: git+https://github.com/css-modules/postcss-modules-values.git
+
+> ISC License (ISC)
+> 
+> Copyright (c) 2015, Glen Maddern
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## postcss-selector-parser
+License: MIT
+By: Ben Briggs, Chris Eppstein
+Repository: postcss/postcss-selector-parser
+
+> Copyright (c) Ben Briggs <beneb.info@gmail.com> (http://beneb.info)
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use,
+> copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following
+> conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+> OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## postcss-value-parser
+License: MIT
+By: Bogdan Chadkin
+Repository: https://github.com/TrySound/postcss-value-parser.git
+
+> Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use,
+> copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following
+> conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+> OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## queue-microtask
+License: MIT
+By: Feross Aboukhadijeh
+Repository: git://github.com/feross/queue-microtask.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Feross Aboukhadijeh
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## read-cache
+License: MIT
+By: Bogdan Chadkin
+Repository: git+https://github.com/TrySound/read-cache.git
+
+> The MIT License (MIT)
+> 
+> Copyright 2016 Bogdan Chadkin <trysound@yandex.ru>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## readdirp
+License: MIT
+By: Thorsten Lorenz, Paul Miller
+Repository: git://github.com/paulmillr/readdirp.git
+
+> MIT License
+> 
+> Copyright (c) 2012-2019 Thorsten Lorenz, Paul Miller (https://paulmillr.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## requires-port
+License: MIT
+By: Arnout Kazemier
+Repository: https://github.com/unshiftio/requires-port
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015 Unshift.io, Arnout Kazemier,  the Contributors.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## resolve.exports
+License: MIT
+By: Luke Edwards
+Repository: lukeed/resolve.exports
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## reusify
+License: MIT
+By: Matteo Collina
+Repository: git+https://github.com/mcollina/reusify.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015 Matteo Collina
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## run-parallel
+License: MIT
+By: Feross Aboukhadijeh
+Repository: git://github.com/feross/run-parallel.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Feross Aboukhadijeh
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## shebang-command
+License: MIT
+By: Kevin Mårtensson
+Repository: kevva/shebang-command
+
+> MIT License
+> 
+> Copyright (c) Kevin Mårtensson <kevinmartensson@gmail.com> (github.com/kevva)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## shebang-regex
+License: MIT
+By: Sindre Sorhus
+Repository: sindresorhus/shebang-regex
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## shell-quote
+License: MIT
+By: James Halliday
+Repository: http://github.com/ljharb/shell-quote.git
+
+> The MIT License
+> 
+> Copyright (c) 2013 James Halliday (mail@substack.net)
+> 
+> Permission is hereby granted, free of charge, 
+> to any person obtaining a copy of this software and 
+> associated documentation files (the "Software"), to 
+> deal in the Software without restriction, including 
+> without limitation the rights to use, copy, modify, 
+> merge, publish, distribute, sublicense, and/or sell 
+> copies of the Software, and to permit persons to whom 
+> the Software is furnished to do so, 
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice 
+> shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+> ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## sirv
+License: MIT
+By: Luke Edwards
+Repository: lukeed/sirv
+
+---------------------------------------
+
+## statuses
+License: MIT
+By: Douglas Christopher Wilson, Jonathan Ong
+Repository: jshttp/statuses
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+> Copyright (c) 2016 Douglas Christopher Wilson <doug@somethingdoug.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## string-hash
+License: CC0-1.0
+By: The Dark Sky Company
+Repository: git://github.com/darkskyapp/string-hash.git
+
+---------------------------------------
+
+## strip-ansi
+License: MIT
+By: Sindre Sorhus
+Repository: chalk/strip-ansi
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## strip-literal
+License: MIT
+By: Anthony Fu
+Repository: git+https://github.com/antfu/strip-literal.git
+
+> MIT License
+> 
+> Copyright (c) 2022 Anthony Fu <https://github.com/antfu>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## to-regex-range
+License: MIT
+By: Jon Schlinkert, Rouven Weßling
+Repository: micromatch/to-regex-range
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2015-present, Jon Schlinkert.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## totalist
+License: MIT
+By: Luke Edwards
+Repository: lukeed/totalist
+
+> The MIT License (MIT)
+> 
+> Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
+---------------------------------------
+
+## tsconfck
+License: MIT
+By: dominikg
+Repository: git+https://github.com/dominikg/tsconfck.git
+
+> MIT License
+> 
+> Copyright (c) 2021-present dominikg and [contributors](https://github.com/dominikg/tsconfck/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+> 
+> -- Licenses for 3rd-party code included in tsconfck --
+> 
+> # strip-bom and strip-json-comments
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## ufo
+License: MIT
+Repository: unjs/ufo
+
+> MIT License
+> 
+> Copyright (c) Pooya Parsa <pooya@pi0.io>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
+## unpipe
+License: MIT
+By: Douglas Christopher Wilson
+Repository: stream-utils/unpipe
+
+> (The MIT License)
+> 
+> Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## util-deprecate
+License: MIT
+By: Nathan Rajlich
+Repository: git://github.com/TooTallNate/util-deprecate.git
+
+> (The MIT License)
+> 
+> Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use,
+> copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following
+> conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+> OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## utils-merge
+License: MIT
+By: Jared Hanson
+Repository: git://github.com/jaredhanson/utils-merge.git
+
+> The MIT License (MIT)
+> 
+> Copyright (c) 2013-2017 Jared Hanson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## vary
+License: MIT
+By: Douglas Christopher Wilson
+Repository: jshttp/vary
+
+> (The MIT License)
+> 
+> Copyright (c) 2014-2017 Douglas Christopher Wilson
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> 'Software'), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## which
+License: ISC
+By: Isaac Z. Schlueter
+Repository: git://github.com/isaacs/node-which.git
+
+> The ISC License
+> 
+> Copyright (c) Isaac Z. Schlueter and Contributors
+> 
+> Permission to use, copy, modify, and/or distribute this software for any
+> purpose with or without fee is hereby granted, provided that the above
+> copyright notice and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+> WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+> MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+> ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+> WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+> ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+> IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---------------------------------------
+
+## ws
+License: MIT
+By: Einar Otto Stangvik
+Repository: git+https://github.com/websockets/ws.git
+
+> Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+> Copyright (c) 2013 Arnout Kazemier and contributors
+> Copyright (c) 2016 Luigi Pinca and contributors
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the "Software"), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## yaml
+License: ISC
+By: Eemeli Aro
+Repository: github:eemeli/yaml
+
+> Copyright Eemeli Aro <eemeli@gmail.com>
+> 
+> Permission to use, copy, modify, and/or distribute this software for any purpose
+> with or without fee is hereby granted, provided that the above copyright notice
+> and this permission notice appear in all copies.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+> REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+> FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+> INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+> OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+> TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+> THIS SOFTWARE.
diff --git a/node_modules/vite/README.md b/node_modules/vite/README.md
new file mode 100644
index 0000000..89490d7
--- /dev/null
+++ b/node_modules/vite/README.md
@@ -0,0 +1,20 @@
+# vite ⚡
+
+> Next Generation Frontend Tooling
+
+- 💡 Instant Server Start
+- ⚡️ Lightning Fast HMR
+- 🛠️ Rich Features
+- 📦 Optimized Build
+- 🔩 Universal Plugin Interface
+- 🔑 Fully Typed APIs
+
+Vite (French word for "fast", pronounced `/vit/`) is a new breed of frontend build tool that significantly improves the frontend development experience. It consists of two major parts:
+
+- A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vitejs.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vitejs.dev/guide/features.html#hot-module-replacement).
+
+- A [build command](https://vitejs.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.
+
+In addition, Vite is highly extensible via its [Plugin API](https://vitejs.dev/guide/api-plugin.html) and [JavaScript API](https://vitejs.dev/guide/api-javascript.html) with full typing support.
+
+[Read the Docs to Learn More](https://vitejs.dev).
diff --git a/node_modules/vite/bin/openChrome.applescript b/node_modules/vite/bin/openChrome.applescript
new file mode 100644
index 0000000..9ce2293
--- /dev/null
+++ b/node_modules/vite/bin/openChrome.applescript
@@ -0,0 +1,95 @@
+(*
+Copyright (c) 2015-present, Facebook, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file at
+https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+*)
+
+property targetTab: null
+property targetTabIndex: -1
+property targetWindow: null
+property theProgram: "Google Chrome"
+
+on run argv
+  set theURL to item 1 of argv
+
+  -- Allow requested program to be optional,
+  -- default to Google Chrome
+  if (count of argv) > 1 then
+    set theProgram to item 2 of argv
+  end if
+
+  using terms from application "Google Chrome"
+    tell application theProgram
+
+      if (count every window) = 0 then
+        make new window
+      end if
+
+      -- 1: Looking for tab running debugger
+      -- then, Reload debugging tab if found
+      -- then return
+      set found to my lookupTabWithUrl(theURL)
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        tell targetTab to reload
+        tell targetWindow to activate
+        set index of targetWindow to 1
+        return
+      end if
+
+      -- 2: Looking for Empty tab
+      -- In case debugging tab was not found
+      -- We try to find an empty tab instead
+      set found to my lookupTabWithUrl("chrome://newtab/")
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        set URL of targetTab to theURL
+        tell targetWindow to activate
+        return
+      end if
+
+      -- 3: Create new tab
+      -- both debugging and empty tab were not found
+      -- make a new tab with url
+      tell window 1
+        activate
+        make new tab with properties {URL:theURL}
+      end tell
+    end tell
+  end using terms from
+end run
+
+-- Function:
+-- Lookup tab with given url
+-- if found, store tab, index, and window in properties
+-- (properties were declared on top of file)
+on lookupTabWithUrl(lookupUrl)
+  using terms from application "Google Chrome"
+    tell application theProgram
+      -- Find a tab with the given url
+      set found to false
+      set theTabIndex to -1
+      repeat with theWindow in every window
+        set theTabIndex to 0
+        repeat with theTab in every tab of theWindow
+          set theTabIndex to theTabIndex + 1
+          if (theTab's URL as string) contains lookupUrl then
+            -- assign tab, tab index, and window to properties
+            set targetTab to theTab
+            set targetTabIndex to theTabIndex
+            set targetWindow to theWindow
+            set found to true
+            exit repeat
+          end if
+        end repeat
+
+        if found then
+          exit repeat
+        end if
+      end repeat
+    end tell
+  end using terms from
+  return found
+end lookupTabWithUrl
diff --git a/node_modules/vite/bin/vite.js b/node_modules/vite/bin/vite.js
new file mode 100755
index 0000000..a9bbb9c
--- /dev/null
+++ b/node_modules/vite/bin/vite.js
@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { performance } from 'node:perf_hooks'
+
+if (!import.meta.url.includes('node_modules')) {
+  try {
+    // only available as dev dependency
+    await import('source-map-support').then((r) => r.default.install())
+  } catch (e) {}
+}
+
+global.__vite_start_time = performance.now()
+
+// check debug mode first before requiring the CLI.
+const debugIndex = process.argv.findIndex((arg) => /^(?:-d|--debug)$/.test(arg))
+const filterIndex = process.argv.findIndex((arg) =>
+  /^(?:-f|--filter)$/.test(arg),
+)
+const profileIndex = process.argv.indexOf('--profile')
+
+if (debugIndex > 0) {
+  let value = process.argv[debugIndex + 1]
+  if (!value || value.startsWith('-')) {
+    value = 'vite:*'
+  } else {
+    // support debugging multiple flags with comma-separated list
+    value = value
+      .split(',')
+      .map((v) => `vite:${v}`)
+      .join(',')
+  }
+  process.env.DEBUG = `${
+    process.env.DEBUG ? process.env.DEBUG + ',' : ''
+  }${value}`
+
+  if (filterIndex > 0) {
+    const filter = process.argv[filterIndex + 1]
+    if (filter && !filter.startsWith('-')) {
+      process.env.VITE_DEBUG_FILTER = filter
+    }
+  }
+}
+
+function start() {
+  return import('../dist/node/cli.js')
+}
+
+if (profileIndex > 0) {
+  process.argv.splice(profileIndex, 1)
+  const next = process.argv[profileIndex]
+  if (next && !next.startsWith('-')) {
+    process.argv.splice(profileIndex, 1)
+  }
+  const inspector = await import('node:inspector').then((r) => r.default)
+  const session = (global.__vite_profile_session = new inspector.Session())
+  session.connect()
+  session.post('Profiler.enable', () => {
+    session.post('Profiler.start', start)
+  })
+} else {
+  start()
+}
diff --git a/node_modules/vite/client.d.ts b/node_modules/vite/client.d.ts
new file mode 100644
index 0000000..b2dd559
--- /dev/null
+++ b/node_modules/vite/client.d.ts
@@ -0,0 +1,256 @@
+/// <reference path="./types/importMeta.d.ts" />
+
+// CSS modules
+type CSSModuleClasses = { readonly [key: string]: string }
+
+declare module '*.module.css' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.scss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.sass' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.less' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.styl' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.stylus' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.pcss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+declare module '*.module.sss' {
+  const classes: CSSModuleClasses
+  export default classes
+}
+
+// CSS
+declare module '*.css' {}
+declare module '*.scss' {}
+declare module '*.sass' {}
+declare module '*.less' {}
+declare module '*.styl' {}
+declare module '*.stylus' {}
+declare module '*.pcss' {}
+declare module '*.sss' {}
+
+// Built-in asset types
+// see `src/node/constants.ts`
+
+// images
+declare module '*.apng' {
+  const src: string
+  export default src
+}
+declare module '*.bmp' {
+  const src: string
+  export default src
+}
+declare module '*.png' {
+  const src: string
+  export default src
+}
+declare module '*.jpg' {
+  const src: string
+  export default src
+}
+declare module '*.jpeg' {
+  const src: string
+  export default src
+}
+declare module '*.jfif' {
+  const src: string
+  export default src
+}
+declare module '*.pjpeg' {
+  const src: string
+  export default src
+}
+declare module '*.pjp' {
+  const src: string
+  export default src
+}
+declare module '*.gif' {
+  const src: string
+  export default src
+}
+declare module '*.svg' {
+  const src: string
+  export default src
+}
+declare module '*.ico' {
+  const src: string
+  export default src
+}
+declare module '*.webp' {
+  const src: string
+  export default src
+}
+declare module '*.avif' {
+  const src: string
+  export default src
+}
+
+// media
+declare module '*.mp4' {
+  const src: string
+  export default src
+}
+declare module '*.webm' {
+  const src: string
+  export default src
+}
+declare module '*.ogg' {
+  const src: string
+  export default src
+}
+declare module '*.mp3' {
+  const src: string
+  export default src
+}
+declare module '*.wav' {
+  const src: string
+  export default src
+}
+declare module '*.flac' {
+  const src: string
+  export default src
+}
+declare module '*.aac' {
+  const src: string
+  export default src
+}
+declare module '*.opus' {
+  const src: string
+  export default src
+}
+declare module '*.mov' {
+  const src: string
+  export default src
+}
+declare module '*.m4a' {
+  const src: string
+  export default src
+}
+declare module '*.vtt' {
+  const src: string
+  export default src
+}
+
+// fonts
+declare module '*.woff' {
+  const src: string
+  export default src
+}
+declare module '*.woff2' {
+  const src: string
+  export default src
+}
+declare module '*.eot' {
+  const src: string
+  export default src
+}
+declare module '*.ttf' {
+  const src: string
+  export default src
+}
+declare module '*.otf' {
+  const src: string
+  export default src
+}
+
+// other
+declare module '*.webmanifest' {
+  const src: string
+  export default src
+}
+declare module '*.pdf' {
+  const src: string
+  export default src
+}
+declare module '*.txt' {
+  const src: string
+  export default src
+}
+
+// wasm?init
+declare module '*.wasm?init' {
+  const initWasm: (
+    options?: WebAssembly.Imports,
+  ) => Promise<WebAssembly.Instance>
+  export default initWasm
+}
+
+// web worker
+declare module '*?worker' {
+  const workerConstructor: {
+    new (options?: { name?: string }): Worker
+  }
+  export default workerConstructor
+}
+
+declare module '*?worker&inline' {
+  const workerConstructor: {
+    new (options?: { name?: string }): Worker
+  }
+  export default workerConstructor
+}
+
+declare module '*?worker&url' {
+  const src: string
+  export default src
+}
+
+declare module '*?sharedworker' {
+  const sharedWorkerConstructor: {
+    new (options?: { name?: string }): SharedWorker
+  }
+  export default sharedWorkerConstructor
+}
+
+declare module '*?sharedworker&inline' {
+  const sharedWorkerConstructor: {
+    new (options?: { name?: string }): SharedWorker
+  }
+  export default sharedWorkerConstructor
+}
+
+declare module '*?sharedworker&url' {
+  const src: string
+  export default src
+}
+
+declare module '*?raw' {
+  const src: string
+  export default src
+}
+
+declare module '*?url' {
+  const src: string
+  export default src
+}
+
+declare module '*?inline' {
+  const src: string
+  export default src
+}
+
+declare interface VitePreloadErrorEvent extends Event {
+  payload: Error
+}
+
+declare interface WindowEventMap {
+  'vite:preloadError': VitePreloadErrorEvent
+}
diff --git a/node_modules/vite/dist/client/client.mjs b/node_modules/vite/dist/client/client.mjs
new file mode 100644
index 0000000..ccb59cc
--- /dev/null
+++ b/node_modules/vite/dist/client/client.mjs
@@ -0,0 +1,825 @@
+import '@vite/env';
+
+class HMRContext {
+  constructor(hmrClient, ownerPath) {
+    this.hmrClient = hmrClient;
+    this.ownerPath = ownerPath;
+    if (!hmrClient.dataMap.has(ownerPath)) {
+      hmrClient.dataMap.set(ownerPath, {});
+    }
+    const mod = hmrClient.hotModulesMap.get(ownerPath);
+    if (mod) {
+      mod.callbacks = [];
+    }
+    const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+    if (staleListeners) {
+      for (const [event, staleFns] of staleListeners) {
+        const listeners = hmrClient.customListenersMap.get(event);
+        if (listeners) {
+          hmrClient.customListenersMap.set(
+            event,
+            listeners.filter((l) => !staleFns.includes(l))
+          );
+        }
+      }
+    }
+    this.newListeners = /* @__PURE__ */ new Map();
+    hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+  }
+  get data() {
+    return this.hmrClient.dataMap.get(this.ownerPath);
+  }
+  accept(deps, callback) {
+    if (typeof deps === "function" || !deps) {
+      this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+    } else if (typeof deps === "string") {
+      this.acceptDeps([deps], ([mod]) => callback?.(mod));
+    } else if (Array.isArray(deps)) {
+      this.acceptDeps(deps, callback);
+    } else {
+      throw new Error(`invalid hot.accept() usage.`);
+    }
+  }
+  // export names (first arg) are irrelevant on the client side, they're
+  // extracted in the server for propagation
+  acceptExports(_, callback) {
+    this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+  }
+  dispose(cb) {
+    this.hmrClient.disposeMap.set(this.ownerPath, cb);
+  }
+  prune(cb) {
+    this.hmrClient.pruneMap.set(this.ownerPath, cb);
+  }
+  // Kept for backward compatibility (#11036)
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  decline() {
+  }
+  invalidate(message) {
+    this.hmrClient.notifyListeners("vite:invalidate", {
+      path: this.ownerPath,
+      message
+    });
+    this.send("vite:invalidate", { path: this.ownerPath, message });
+    this.hmrClient.logger.debug(
+      `[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`
+    );
+  }
+  on(event, cb) {
+    const addToMap = (map) => {
+      const existing = map.get(event) || [];
+      existing.push(cb);
+      map.set(event, existing);
+    };
+    addToMap(this.hmrClient.customListenersMap);
+    addToMap(this.newListeners);
+  }
+  off(event, cb) {
+    const removeFromMap = (map) => {
+      const existing = map.get(event);
+      if (existing === void 0) {
+        return;
+      }
+      const pruned = existing.filter((l) => l !== cb);
+      if (pruned.length === 0) {
+        map.delete(event);
+        return;
+      }
+      map.set(event, pruned);
+    };
+    removeFromMap(this.hmrClient.customListenersMap);
+    removeFromMap(this.newListeners);
+  }
+  send(event, data) {
+    this.hmrClient.messenger.send(
+      JSON.stringify({ type: "custom", event, data })
+    );
+  }
+  acceptDeps(deps, callback = () => {
+  }) {
+    const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+      id: this.ownerPath,
+      callbacks: []
+    };
+    mod.callbacks.push({
+      deps,
+      fn: callback
+    });
+    this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+  }
+}
+class HMRMessenger {
+  constructor(connection) {
+    this.connection = connection;
+    this.queue = [];
+  }
+  send(message) {
+    this.queue.push(message);
+    this.flush();
+  }
+  flush() {
+    if (this.connection.isReady()) {
+      this.queue.forEach((msg) => this.connection.send(msg));
+      this.queue = [];
+    }
+  }
+}
+class HMRClient {
+  constructor(logger, connection, importUpdatedModule) {
+    this.logger = logger;
+    this.importUpdatedModule = importUpdatedModule;
+    this.hotModulesMap = /* @__PURE__ */ new Map();
+    this.disposeMap = /* @__PURE__ */ new Map();
+    this.pruneMap = /* @__PURE__ */ new Map();
+    this.dataMap = /* @__PURE__ */ new Map();
+    this.customListenersMap = /* @__PURE__ */ new Map();
+    this.ctxToListenersMap = /* @__PURE__ */ new Map();
+    this.updateQueue = [];
+    this.pendingUpdateQueue = false;
+    this.messenger = new HMRMessenger(connection);
+  }
+  async notifyListeners(event, data) {
+    const cbs = this.customListenersMap.get(event);
+    if (cbs) {
+      await Promise.allSettled(cbs.map((cb) => cb(data)));
+    }
+  }
+  clear() {
+    this.hotModulesMap.clear();
+    this.disposeMap.clear();
+    this.pruneMap.clear();
+    this.dataMap.clear();
+    this.customListenersMap.clear();
+    this.ctxToListenersMap.clear();
+  }
+  // After an HMR update, some modules are no longer imported on the page
+  // but they may have left behind side effects that need to be cleaned up
+  // (.e.g style injections)
+  async prunePaths(paths) {
+    await Promise.all(
+      paths.map((path) => {
+        const disposer = this.disposeMap.get(path);
+        if (disposer) return disposer(this.dataMap.get(path));
+      })
+    );
+    paths.forEach((path) => {
+      const fn = this.pruneMap.get(path);
+      if (fn) {
+        fn(this.dataMap.get(path));
+      }
+    });
+  }
+  warnFailedUpdate(err, path) {
+    if (!err.message.includes("fetch")) {
+      this.logger.error(err);
+    }
+    this.logger.error(
+      `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+    );
+  }
+  /**
+   * buffer multiple hot updates triggered by the same src change
+   * so that they are invoked in the same order they were sent.
+   * (otherwise the order may be inconsistent because of the http request round trip)
+   */
+  async queueUpdate(payload) {
+    this.updateQueue.push(this.fetchUpdate(payload));
+    if (!this.pendingUpdateQueue) {
+      this.pendingUpdateQueue = true;
+      await Promise.resolve();
+      this.pendingUpdateQueue = false;
+      const loading = [...this.updateQueue];
+      this.updateQueue = [];
+      (await Promise.all(loading)).forEach((fn) => fn && fn());
+    }
+  }
+  async fetchUpdate(update) {
+    const { path, acceptedPath } = update;
+    const mod = this.hotModulesMap.get(path);
+    if (!mod) {
+      return;
+    }
+    let fetchedModule;
+    const isSelfUpdate = path === acceptedPath;
+    const qualifiedCallbacks = mod.callbacks.filter(
+      ({ deps }) => deps.includes(acceptedPath)
+    );
+    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+      const disposer = this.disposeMap.get(acceptedPath);
+      if (disposer) await disposer(this.dataMap.get(acceptedPath));
+      try {
+        fetchedModule = await this.importUpdatedModule(update);
+      } catch (e) {
+        this.warnFailedUpdate(e, acceptedPath);
+      }
+    }
+    return () => {
+      for (const { deps, fn } of qualifiedCallbacks) {
+        fn(
+          deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0)
+        );
+      }
+      const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+    };
+  }
+}
+
+const hmrConfigName = __HMR_CONFIG_NAME__;
+const base$1 = __BASE__ || "/";
+function h(e, attrs = {}, ...children) {
+  const elem = document.createElement(e);
+  for (const [k, v] of Object.entries(attrs)) {
+    elem.setAttribute(k, v);
+  }
+  elem.append(...children);
+  return elem;
+}
+const templateStyle = (
+  /*css*/
+  `
+:host {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 99999;
+  --monospace: 'SFMono-Regular', Consolas,
+  'Liberation Mono', Menlo, Courier, monospace;
+  --red: #ff5555;
+  --yellow: #e2aa53;
+  --purple: #cfa4ff;
+  --cyan: #2dd9da;
+  --dim: #c9c9c9;
+
+  --window-background: #181818;
+  --window-color: #d8d8d8;
+}
+
+.backdrop {
+  position: fixed;
+  z-index: 99999;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow-y: scroll;
+  margin: 0;
+  background: rgba(0, 0, 0, 0.66);
+}
+
+.window {
+  font-family: var(--monospace);
+  line-height: 1.5;
+  max-width: 80vw;
+  color: var(--window-color);
+  box-sizing: border-box;
+  margin: 30px auto;
+  padding: 2.5vh 4vw;
+  position: relative;
+  background: var(--window-background);
+  border-radius: 6px 6px 8px 8px;
+  box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+  overflow: hidden;
+  border-top: 8px solid var(--red);
+  direction: ltr;
+  text-align: left;
+}
+
+pre {
+  font-family: var(--monospace);
+  font-size: 16px;
+  margin-top: 0;
+  margin-bottom: 1em;
+  overflow-x: scroll;
+  scrollbar-width: none;
+}
+
+pre::-webkit-scrollbar {
+  display: none;
+}
+
+pre.frame::-webkit-scrollbar {
+  display: block;
+  height: 5px;
+}
+
+pre.frame::-webkit-scrollbar-thumb {
+  background: #999;
+  border-radius: 5px;
+}
+
+pre.frame {
+  scrollbar-width: thin;
+}
+
+.message {
+  line-height: 1.3;
+  font-weight: 600;
+  white-space: pre-wrap;
+}
+
+.message-body {
+  color: var(--red);
+}
+
+.plugin {
+  color: var(--purple);
+}
+
+.file {
+  color: var(--cyan);
+  margin-bottom: 0;
+  white-space: pre-wrap;
+  word-break: break-all;
+}
+
+.frame {
+  color: var(--yellow);
+}
+
+.stack {
+  font-size: 13px;
+  color: var(--dim);
+}
+
+.tip {
+  font-size: 13px;
+  color: #999;
+  border-top: 1px dotted #999;
+  padding-top: 13px;
+  line-height: 1.8;
+}
+
+code {
+  font-size: 13px;
+  font-family: var(--monospace);
+  color: var(--yellow);
+}
+
+.file-link {
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+kbd {
+  line-height: 1.5;
+  font-family: ui-monospace, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 0.75rem;
+  font-weight: 700;
+  background-color: rgb(38, 40, 44);
+  color: rgb(166, 167, 171);
+  padding: 0.15rem 0.3rem;
+  border-radius: 0.25rem;
+  border-width: 0.0625rem 0.0625rem 0.1875rem;
+  border-style: solid;
+  border-color: rgb(54, 57, 64);
+  border-image: initial;
+}
+`
+);
+const createTemplate = () => h(
+  "div",
+  { class: "backdrop", part: "backdrop" },
+  h(
+    "div",
+    { class: "window", part: "window" },
+    h(
+      "pre",
+      { class: "message", part: "message" },
+      h("span", { class: "plugin", part: "plugin" }),
+      h("span", { class: "message-body", part: "message-body" })
+    ),
+    h("pre", { class: "file", part: "file" }),
+    h("pre", { class: "frame", part: "frame" }),
+    h("pre", { class: "stack", part: "stack" }),
+    h(
+      "div",
+      { class: "tip", part: "tip" },
+      "Click outside, press ",
+      h("kbd", {}, "Esc"),
+      " key, or fix the code to dismiss.",
+      h("br"),
+      "You can also disable this overlay by setting ",
+      h("code", { part: "config-option-name" }, "server.hmr.overlay"),
+      " to ",
+      h("code", { part: "config-option-value" }, "false"),
+      " in ",
+      h("code", { part: "config-file-name" }, hmrConfigName),
+      "."
+    )
+  ),
+  h("style", {}, templateStyle)
+);
+const fileRE = /(?:[a-zA-Z]:\\|\/).*?:\d+:\d+/g;
+const codeframeRE = /^(?:>?\s*\d+\s+\|.*|\s+\|\s*\^.*)\r?\n/gm;
+const { HTMLElement = class {
+} } = globalThis;
+class ErrorOverlay extends HTMLElement {
+  constructor(err, links = true) {
+    super();
+    this.root = this.attachShadow({ mode: "open" });
+    this.root.appendChild(createTemplate());
+    codeframeRE.lastIndex = 0;
+    const hasFrame = err.frame && codeframeRE.test(err.frame);
+    const message = hasFrame ? err.message.replace(codeframeRE, "") : err.message;
+    if (err.plugin) {
+      this.text(".plugin", `[plugin:${err.plugin}] `);
+    }
+    this.text(".message-body", message.trim());
+    const [file] = (err.loc?.file || err.id || "unknown file").split(`?`);
+    if (err.loc) {
+      this.text(".file", `${file}:${err.loc.line}:${err.loc.column}`, links);
+    } else if (err.id) {
+      this.text(".file", file);
+    }
+    if (hasFrame) {
+      this.text(".frame", err.frame.trim());
+    }
+    this.text(".stack", err.stack, links);
+    this.root.querySelector(".window").addEventListener("click", (e) => {
+      e.stopPropagation();
+    });
+    this.addEventListener("click", () => {
+      this.close();
+    });
+    this.closeOnEsc = (e) => {
+      if (e.key === "Escape" || e.code === "Escape") {
+        this.close();
+      }
+    };
+    document.addEventListener("keydown", this.closeOnEsc);
+  }
+  text(selector, text, linkFiles = false) {
+    const el = this.root.querySelector(selector);
+    if (!linkFiles) {
+      el.textContent = text;
+    } else {
+      let curIndex = 0;
+      let match;
+      fileRE.lastIndex = 0;
+      while (match = fileRE.exec(text)) {
+        const { 0: file, index } = match;
+        if (index != null) {
+          const frag = text.slice(curIndex, index);
+          el.appendChild(document.createTextNode(frag));
+          const link = document.createElement("a");
+          link.textContent = file;
+          link.className = "file-link";
+          link.onclick = () => {
+            fetch(
+              new URL(
+                `${base$1}__open-in-editor?file=${encodeURIComponent(file)}`,
+                import.meta.url
+              )
+            );
+          };
+          el.appendChild(link);
+          curIndex += frag.length + file.length;
+        }
+      }
+    }
+  }
+  close() {
+    this.parentNode?.removeChild(this);
+    document.removeEventListener("keydown", this.closeOnEsc);
+  }
+}
+const overlayId = "vite-error-overlay";
+const { customElements } = globalThis;
+if (customElements && !customElements.get(overlayId)) {
+  customElements.define(overlayId, ErrorOverlay);
+}
+
+console.debug("[vite] connecting...");
+const importMetaUrl = new URL(import.meta.url);
+const serverHost = __SERVER_HOST__;
+const socketProtocol = __HMR_PROTOCOL__ || (importMetaUrl.protocol === "https:" ? "wss" : "ws");
+const hmrPort = __HMR_PORT__;
+const socketHost = `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}${__HMR_BASE__}`;
+const directSocketHost = __HMR_DIRECT_TARGET__;
+const base = __BASE__ || "/";
+let socket;
+try {
+  let fallback;
+  if (!hmrPort) {
+    fallback = () => {
+      socket = setupWebSocket(socketProtocol, directSocketHost, () => {
+        const currentScriptHostURL = new URL(import.meta.url);
+        const currentScriptHost = currentScriptHostURL.host + currentScriptHostURL.pathname.replace(/@vite\/client$/, "");
+        console.error(
+          `[vite] failed to connect to websocket.
+your current setup:
+  (browser) ${currentScriptHost} <--[HTTP]--> ${serverHost} (server)
+  (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)
+Check out your Vite / network configuration and https://vitejs.dev/config/server-options.html#server-hmr .`
+        );
+      });
+      socket.addEventListener(
+        "open",
+        () => {
+          console.info(
+            "[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error."
+          );
+        },
+        { once: true }
+      );
+    };
+  }
+  socket = setupWebSocket(socketProtocol, socketHost, fallback);
+} catch (error) {
+  console.error(`[vite] failed to connect to websocket (${error}). `);
+}
+function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
+  const socket2 = new WebSocket(`${protocol}://${hostAndPath}`, "vite-hmr");
+  let isOpened = false;
+  socket2.addEventListener(
+    "open",
+    () => {
+      isOpened = true;
+      notifyListeners("vite:ws:connect", { webSocket: socket2 });
+    },
+    { once: true }
+  );
+  socket2.addEventListener("message", async ({ data }) => {
+    handleMessage(JSON.parse(data));
+  });
+  socket2.addEventListener("close", async ({ wasClean }) => {
+    if (wasClean) return;
+    if (!isOpened && onCloseWithoutOpen) {
+      onCloseWithoutOpen();
+      return;
+    }
+    notifyListeners("vite:ws:disconnect", { webSocket: socket2 });
+    if (hasDocument) {
+      console.log(`[vite] server connection lost. Polling for restart...`);
+      await waitForSuccessfulPing(protocol, hostAndPath);
+      location.reload();
+    }
+  });
+  return socket2;
+}
+function cleanUrl(pathname) {
+  const url = new URL(pathname, "http://vitejs.dev");
+  url.searchParams.delete("direct");
+  return url.pathname + url.search;
+}
+let isFirstUpdate = true;
+const outdatedLinkTags = /* @__PURE__ */ new WeakSet();
+const debounceReload = (time) => {
+  let timer;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    timer = setTimeout(() => {
+      location.reload();
+    }, time);
+  };
+};
+const pageReload = debounceReload(50);
+const hmrClient = new HMRClient(
+  console,
+  {
+    isReady: () => socket && socket.readyState === 1,
+    send: (message) => socket.send(message)
+  },
+  async function importUpdatedModule({
+    acceptedPath,
+    timestamp,
+    explicitImportRequired,
+    isWithinCircularImport
+  }) {
+    const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
+    const importPromise = import(
+      /* @vite-ignore */
+      base + acceptedPathWithoutQuery.slice(1) + `?${explicitImportRequired ? "import&" : ""}t=${timestamp}${query ? `&${query}` : ""}`
+    );
+    if (isWithinCircularImport) {
+      importPromise.catch(() => {
+        console.info(
+          `[hmr] ${acceptedPath} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order. To debug and break the circular import, you can run \`vite --debug hmr\` to log the circular dependency path if a file change triggered it.`
+        );
+        pageReload();
+      });
+    }
+    return await importPromise;
+  }
+);
+async function handleMessage(payload) {
+  switch (payload.type) {
+    case "connected":
+      console.debug(`[vite] connected.`);
+      hmrClient.messenger.flush();
+      setInterval(() => {
+        if (socket.readyState === socket.OPEN) {
+          socket.send('{"type":"ping"}');
+        }
+      }, __HMR_TIMEOUT__);
+      break;
+    case "update":
+      notifyListeners("vite:beforeUpdate", payload);
+      if (hasDocument) {
+        if (isFirstUpdate && hasErrorOverlay()) {
+          location.reload();
+          return;
+        } else {
+          if (enableOverlay) {
+            clearErrorOverlay();
+          }
+          isFirstUpdate = false;
+        }
+      }
+      await Promise.all(
+        payload.updates.map(async (update) => {
+          if (update.type === "js-update") {
+            return hmrClient.queueUpdate(update);
+          }
+          const { path, timestamp } = update;
+          const searchUrl = cleanUrl(path);
+          const el = Array.from(
+            document.querySelectorAll("link")
+          ).find(
+            (e) => !outdatedLinkTags.has(e) && cleanUrl(e.href).includes(searchUrl)
+          );
+          if (!el) {
+            return;
+          }
+          const newPath = `${base}${searchUrl.slice(1)}${searchUrl.includes("?") ? "&" : "?"}t=${timestamp}`;
+          return new Promise((resolve) => {
+            const newLinkTag = el.cloneNode();
+            newLinkTag.href = new URL(newPath, el.href).href;
+            const removeOldEl = () => {
+              el.remove();
+              console.debug(`[vite] css hot updated: ${searchUrl}`);
+              resolve();
+            };
+            newLinkTag.addEventListener("load", removeOldEl);
+            newLinkTag.addEventListener("error", removeOldEl);
+            outdatedLinkTags.add(el);
+            el.after(newLinkTag);
+          });
+        })
+      );
+      notifyListeners("vite:afterUpdate", payload);
+      break;
+    case "custom": {
+      notifyListeners(payload.event, payload.data);
+      break;
+    }
+    case "full-reload":
+      notifyListeners("vite:beforeFullReload", payload);
+      if (hasDocument) {
+        if (payload.path && payload.path.endsWith(".html")) {
+          const pagePath = decodeURI(location.pathname);
+          const payloadPath = base + payload.path.slice(1);
+          if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) {
+            pageReload();
+          }
+          return;
+        } else {
+          pageReload();
+        }
+      }
+      break;
+    case "prune":
+      notifyListeners("vite:beforePrune", payload);
+      await hmrClient.prunePaths(payload.paths);
+      break;
+    case "error": {
+      notifyListeners("vite:error", payload);
+      if (hasDocument) {
+        const err = payload.err;
+        if (enableOverlay) {
+          createErrorOverlay(err);
+        } else {
+          console.error(
+            `[vite] Internal Server Error
+${err.message}
+${err.stack}`
+          );
+        }
+      }
+      break;
+    }
+    default: {
+      const check = payload;
+      return check;
+    }
+  }
+}
+function notifyListeners(event, data) {
+  hmrClient.notifyListeners(event, data);
+}
+const enableOverlay = __HMR_ENABLE_OVERLAY__;
+const hasDocument = "document" in globalThis;
+function createErrorOverlay(err) {
+  clearErrorOverlay();
+  document.body.appendChild(new ErrorOverlay(err));
+}
+function clearErrorOverlay() {
+  document.querySelectorAll(overlayId).forEach((n) => n.close());
+}
+function hasErrorOverlay() {
+  return document.querySelectorAll(overlayId).length;
+}
+async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
+  const pingHostProtocol = socketProtocol2 === "wss" ? "https" : "http";
+  const ping = async () => {
+    try {
+      await fetch(`${pingHostProtocol}://${hostAndPath}`, {
+        mode: "no-cors",
+        headers: {
+          // Custom headers won't be included in a request with no-cors so (ab)use one of the
+          // safelisted headers to identify the ping request
+          Accept: "text/x-vite-ping"
+        }
+      });
+      return true;
+    } catch {
+    }
+    return false;
+  };
+  if (await ping()) {
+    return;
+  }
+  await wait(ms);
+  while (true) {
+    if (document.visibilityState === "visible") {
+      if (await ping()) {
+        break;
+      }
+      await wait(ms);
+    } else {
+      await waitForWindowShow();
+    }
+  }
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function waitForWindowShow() {
+  return new Promise((resolve) => {
+    const onChange = async () => {
+      if (document.visibilityState === "visible") {
+        resolve();
+        document.removeEventListener("visibilitychange", onChange);
+      }
+    };
+    document.addEventListener("visibilitychange", onChange);
+  });
+}
+const sheetsMap = /* @__PURE__ */ new Map();
+if ("document" in globalThis) {
+  document.querySelectorAll("style[data-vite-dev-id]").forEach((el) => {
+    sheetsMap.set(el.getAttribute("data-vite-dev-id"), el);
+  });
+}
+const cspNonce = "document" in globalThis ? document.querySelector("meta[property=csp-nonce]")?.nonce : void 0;
+let lastInsertedStyle;
+function updateStyle(id, content) {
+  let style = sheetsMap.get(id);
+  if (!style) {
+    style = document.createElement("style");
+    style.setAttribute("type", "text/css");
+    style.setAttribute("data-vite-dev-id", id);
+    style.textContent = content;
+    if (cspNonce) {
+      style.setAttribute("nonce", cspNonce);
+    }
+    if (!lastInsertedStyle) {
+      document.head.appendChild(style);
+      setTimeout(() => {
+        lastInsertedStyle = void 0;
+      }, 0);
+    } else {
+      lastInsertedStyle.insertAdjacentElement("afterend", style);
+    }
+    lastInsertedStyle = style;
+  } else {
+    style.textContent = content;
+  }
+  sheetsMap.set(id, style);
+}
+function removeStyle(id) {
+  const style = sheetsMap.get(id);
+  if (style) {
+    document.head.removeChild(style);
+    sheetsMap.delete(id);
+  }
+}
+function createHotContext(ownerPath) {
+  return new HMRContext(hmrClient, ownerPath);
+}
+function injectQuery(url, queryToInject) {
+  if (url[0] !== "." && url[0] !== "/") {
+    return url;
+  }
+  const pathname = url.replace(/[?#].*$/, "");
+  const { search, hash } = new URL(url, "http://vitejs.dev");
+  return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
+
+export { ErrorOverlay, createHotContext, injectQuery, removeStyle, updateStyle };
diff --git a/node_modules/vite/dist/client/env.mjs b/node_modules/vite/dist/client/env.mjs
new file mode 100644
index 0000000..b58bfc1
--- /dev/null
+++ b/node_modules/vite/dist/client/env.mjs
@@ -0,0 +1,24 @@
+const context = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  } else if (typeof self !== "undefined") {
+    return self;
+  } else if (typeof window !== "undefined") {
+    return window;
+  } else {
+    return Function("return this")();
+  }
+})();
+const defines = __DEFINES__;
+Object.keys(defines).forEach((key) => {
+  const segments = key.split(".");
+  let target = context;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (i === segments.length - 1) {
+      target[segment] = defines[key];
+    } else {
+      target = target[segment] || (target[segment] = {});
+    }
+  }
+});
diff --git a/node_modules/vite/dist/node-cjs/publicUtils.cjs b/node_modules/vite/dist/node-cjs/publicUtils.cjs
new file mode 100644
index 0000000..e8eac71
--- /dev/null
+++ b/node_modules/vite/dist/node-cjs/publicUtils.cjs
@@ -0,0 +1,6165 @@
+'use strict';
+
+var path$3 = require('node:path');
+var node_url = require('node:url');
+var fs$1 = require('node:fs');
+var esbuild = require('esbuild');
+var node_module = require('node:module');
+var require$$0 = require('tty');
+var require$$1 = require('util');
+var require$$0$1 = require('path');
+var require$$0$2 = require('crypto');
+var fs$2 = require('fs');
+var readline = require('node:readline');
+var require$$2 = require('os');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const { version: version$2 } = JSON.parse(
+  fs$1.readFileSync(new URL("../../package.json", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))).toString()
+);
+const VERSION = version$2;
+const FS_PREFIX = `/@fs/`;
+const VITE_PACKAGE_DIR = path$3.resolve(
+  // import.meta.url is `dist/node/constants.js` after bundle
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))),
+  "../../.."
+);
+const CLIENT_ENTRY = path$3.resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
+path$3.resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
+path$3.dirname(CLIENT_ENTRY);
+
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+
+const bufLength = 1024 * 16;
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+function encode(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0)
+            writer.write(semicolon);
+        if (line.length === 0)
+            continue;
+        let genColumn = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (j > 0)
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+                continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4)
+                continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var picocolors = {exports: {}};
+
+let argv = process.argv || [],
+	env = process.env;
+let isColorSupported =
+	!("NO_COLOR" in env || argv.includes("--no-color")) &&
+	("FORCE_COLOR" in env ||
+		argv.includes("--color") ||
+		process.platform === "win32" ||
+		(commonjsRequire != null && require$$0.isatty(1) && env.TERM !== "dumb") ||
+		"CI" in env);
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input;
+		let index = string.indexOf(close, open.length);
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	};
+
+let replaceClose = (string, close, replace, index) => {
+	let result = "";
+	let cursor = 0;
+	do {
+		result += string.substring(cursor, index) + replace;
+		cursor = index + close.length;
+		index = string.indexOf(close, cursor);
+	} while (~index)
+	return result + string.substring(cursor)
+};
+
+let createColors = (enabled = isColorSupported) => {
+	let init = enabled ? formatter : () => String;
+	return {
+		isColorSupported: enabled,
+		reset: init("\x1b[0m", "\x1b[0m"),
+		bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: init("\x1b[3m", "\x1b[23m"),
+		underline: init("\x1b[4m", "\x1b[24m"),
+		inverse: init("\x1b[7m", "\x1b[27m"),
+		hidden: init("\x1b[8m", "\x1b[28m"),
+		strikethrough: init("\x1b[9m", "\x1b[29m"),
+		black: init("\x1b[30m", "\x1b[39m"),
+		red: init("\x1b[31m", "\x1b[39m"),
+		green: init("\x1b[32m", "\x1b[39m"),
+		yellow: init("\x1b[33m", "\x1b[39m"),
+		blue: init("\x1b[34m", "\x1b[39m"),
+		magenta: init("\x1b[35m", "\x1b[39m"),
+		cyan: init("\x1b[36m", "\x1b[39m"),
+		white: init("\x1b[37m", "\x1b[39m"),
+		gray: init("\x1b[90m", "\x1b[39m"),
+		bgBlack: init("\x1b[40m", "\x1b[49m"),
+		bgRed: init("\x1b[41m", "\x1b[49m"),
+		bgGreen: init("\x1b[42m", "\x1b[49m"),
+		bgYellow: init("\x1b[43m", "\x1b[49m"),
+		bgBlue: init("\x1b[44m", "\x1b[49m"),
+		bgMagenta: init("\x1b[45m", "\x1b[49m"),
+		bgCyan: init("\x1b[46m", "\x1b[49m"),
+		bgWhite: init("\x1b[47m", "\x1b[49m"),
+	}
+};
+
+picocolors.exports = createColors();
+picocolors.exports.createColors = createColors;
+
+var picocolorsExports = picocolors.exports;
+var colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+
+var src = {exports: {}};
+
+var browser$1 = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+var common;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
+
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
+
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
+
+				const self = debug;
+
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+
+				args[0] = createDebug.coerce(args[0]);
+
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
+				}
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
+					}
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
+			}
+
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
+					}
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
+				}
+			});
+
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
+			}
+
+			return debug;
+		}
+
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			let i;
+			const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+			const len = split.length;
+
+			for (i = 0; i < len; i++) {
+				if (!split[i]) {
+					// ignore empty strings
+					continue;
+				}
+
+				namespaces = split[i].replace(/\*/g, '.*?');
+
+				if (namespaces[0] === '-') {
+					createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+				} else {
+					createDebug.names.push(new RegExp('^' + namespaces + '$'));
+				}
+			}
+		}
+
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names.map(toNamespace),
+				...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
+		}
+
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			if (name[name.length - 1] === '*') {
+				return true;
+			}
+
+			let i;
+			let len;
+
+			for (i = 0, len = createDebug.skips.length; i < len; i++) {
+				if (createDebug.skips[i].test(name)) {
+					return false;
+				}
+			}
+
+			for (i = 0, len = createDebug.names.length; i < len; i++) {
+				if (createDebug.names[i].test(name)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		* Convert regexp to namespace
+		*
+		* @param {RegExp} regxep
+		* @return {String} namespace
+		* @api private
+		*/
+		function toNamespace(regexp) {
+			return regexp.toString()
+				.substring(2, regexp.toString().length - 2)
+				.replace(/\.\*\?$/, '*');
+		}
+
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
+			}
+			return val;
+		}
+
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+
+		createDebug.enable(createDebug.load());
+
+		return createDebug;
+	}
+
+	common = setup;
+	return common;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser$1.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
+			}
+
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
+
+			let m;
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+		}
+
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
+
+			if (!this.useColors) {
+				return;
+			}
+
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
+		}
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		}; 
+	} (browser$1, browser$1.exports));
+	return browser$1.exports;
+}
+
+var node = {exports: {}};
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		const tty = require$$0;
+		const util = require$$1;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
+			() => {},
+			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+		);
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const supportsColor = require('supports-color');
+
+			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+				exports.colors = [
+					20,
+					21,
+					26,
+					27,
+					32,
+					33,
+					38,
+					39,
+					40,
+					41,
+					42,
+					43,
+					44,
+					45,
+					56,
+					57,
+					62,
+					63,
+					68,
+					69,
+					74,
+					75,
+					76,
+					77,
+					78,
+					79,
+					80,
+					81,
+					92,
+					93,
+					98,
+					99,
+					112,
+					113,
+					128,
+					129,
+					134,
+					135,
+					148,
+					149,
+					160,
+					161,
+					162,
+					163,
+					164,
+					165,
+					166,
+					167,
+					168,
+					169,
+					170,
+					171,
+					172,
+					173,
+					178,
+					179,
+					184,
+					185,
+					196,
+					197,
+					198,
+					199,
+					200,
+					201,
+					202,
+					203,
+					204,
+					205,
+					206,
+					207,
+					208,
+					209,
+					214,
+					215,
+					220,
+					221
+				];
+			}
+		} catch (error) {
+			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		}
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		}; 
+	} (node, node.exports));
+	return node.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	src.exports = requireBrowser();
+} else {
+	src.exports = requireNode();
+}
+
+var srcExports = src.exports;
+var debug$2 = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+
+var utils$3 = {};
+
+const path$2 = require$$0$1;
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR = `${QMARK}*?`;
+
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR,
+  START_ANCHOR
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+  ...POSIX_CHARS,
+
+  SLASH_LITERAL: `[${WIN_SLASH}]`,
+  QMARK: WIN_NO_SLASH,
+  STAR: `${WIN_NO_SLASH}*?`,
+  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+  NO_DOT: `(?!${DOT_LITERAL})`,
+  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE$1 = {
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  ascii: '\\x00-\\x7F',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E ',
+  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word: 'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9'
+};
+
+var constants$2 = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    '***': '*',
+    '**/**': '**',
+    '**/**/**': '**'
+  },
+
+  // Digits
+  CHAR_0: 48, /* 0 */
+  CHAR_9: 57, /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65, /* A */
+  CHAR_LOWERCASE_A: 97, /* a */
+  CHAR_UPPERCASE_Z: 90, /* Z */
+  CHAR_LOWERCASE_Z: 122, /* z */
+
+  CHAR_LEFT_PARENTHESES: 40, /* ( */
+  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+  CHAR_ASTERISK: 42, /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38, /* & */
+  CHAR_AT: 64, /* @ */
+  CHAR_BACKWARD_SLASH: 92, /* \ */
+  CHAR_CARRIAGE_RETURN: 13, /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+  CHAR_COLON: 58, /* : */
+  CHAR_COMMA: 44, /* , */
+  CHAR_DOT: 46, /* . */
+  CHAR_DOUBLE_QUOTE: 34, /* " */
+  CHAR_EQUAL: 61, /* = */
+  CHAR_EXCLAMATION_MARK: 33, /* ! */
+  CHAR_FORM_FEED: 12, /* \f */
+  CHAR_FORWARD_SLASH: 47, /* / */
+  CHAR_GRAVE_ACCENT: 96, /* ` */
+  CHAR_HASH: 35, /* # */
+  CHAR_HYPHEN_MINUS: 45, /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+  CHAR_LINE_FEED: 10, /* \n */
+  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+  CHAR_PERCENT: 37, /* % */
+  CHAR_PLUS: 43, /* + */
+  CHAR_QUESTION_MARK: 63, /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+  CHAR_SEMICOLON: 59, /* ; */
+  CHAR_SINGLE_QUOTE: 39, /* ' */
+  CHAR_SPACE: 32, /*   */
+  CHAR_TAB: 9, /* \t */
+  CHAR_UNDERSCORE: 95, /* _ */
+  CHAR_VERTICAL_LINE: 124, /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+  SEP: path$2.sep,
+
+  /**
+   * Create EXTGLOB_CHARS
+   */
+
+  extglobChars(chars) {
+    return {
+      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+      '?': { type: 'qmark', open: '(?:', close: ')?' },
+      '+': { type: 'plus', open: '(?:', close: ')+' },
+      '*': { type: 'star', open: '(?:', close: ')*' },
+      '@': { type: 'at', open: '(?:', close: ')' }
+    };
+  },
+
+  /**
+   * Create GLOB_CHARS
+   */
+
+  globChars(win32) {
+    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
+};
+
+(function (exports) {
+
+	const path = require$$0$1;
+	const win32 = process.platform === 'win32';
+	const {
+	  REGEX_BACKSLASH,
+	  REGEX_REMOVE_BACKSLASH,
+	  REGEX_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_GLOBAL
+	} = constants$2;
+
+	exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+	exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+	exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+	exports.removeBackslashes = str => {
+	  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+	    return match === '\\' ? '' : match;
+	  });
+	};
+
+	exports.supportsLookbehinds = () => {
+	  const segs = process.version.slice(1).split('.').map(Number);
+	  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+	    return true;
+	  }
+	  return false;
+	};
+
+	exports.isWindows = options => {
+	  if (options && typeof options.windows === 'boolean') {
+	    return options.windows;
+	  }
+	  return win32 === true || path.sep === '\\';
+	};
+
+	exports.escapeLast = (input, char, lastIdx) => {
+	  const idx = input.lastIndexOf(char, lastIdx);
+	  if (idx === -1) return input;
+	  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+	  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+
+	exports.removePrefix = (input, state = {}) => {
+	  let output = input;
+	  if (output.startsWith('./')) {
+	    output = output.slice(2);
+	    state.prefix = './';
+	  }
+	  return output;
+	};
+
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+	  const prepend = options.contains ? '' : '^';
+	  const append = options.contains ? '' : '$';
+
+	  let output = `${prepend}(?:${input})${append}`;
+	  if (state.negated === true) {
+	    output = `(?:^(?!${output}).*$)`;
+	  }
+	  return output;
+	}; 
+} (utils$3));
+
+const utils$2 = utils$3;
+const {
+  CHAR_ASTERISK,             /* * */
+  CHAR_AT,                   /* @ */
+  CHAR_BACKWARD_SLASH,       /* \ */
+  CHAR_COMMA,                /* , */
+  CHAR_DOT,                  /* . */
+  CHAR_EXCLAMATION_MARK,     /* ! */
+  CHAR_FORWARD_SLASH,        /* / */
+  CHAR_LEFT_CURLY_BRACE,     /* { */
+  CHAR_LEFT_PARENTHESES,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+  CHAR_PLUS,                 /* + */
+  CHAR_QUESTION_MARK,        /* ? */
+  CHAR_RIGHT_CURLY_BRACE,    /* } */
+  CHAR_RIGHT_PARENTHESES,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+} = constants$2;
+
+const isPathSeparator = code => {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+const depth = token => {
+  if (token.isPrefix !== true) {
+    token.depth = token.isGlobstar ? Infinity : 1;
+  }
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+const scan$1 = (input, options) => {
+  const opts = options || {};
+
+  const length = input.length - 1;
+  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+  const slashes = [];
+  const tokens = [];
+  const parts = [];
+
+  let str = input;
+  let index = -1;
+  let start = 0;
+  let lastIndex = 0;
+  let isBrace = false;
+  let isBracket = false;
+  let isGlob = false;
+  let isExtglob = false;
+  let isGlobstar = false;
+  let braceEscaped = false;
+  let backslashes = false;
+  let negated = false;
+  let negatedExtglob = false;
+  let finished = false;
+  let braces = 0;
+  let prev;
+  let code;
+  let token = { value: '', depth: 0, isGlob: false };
+
+  const eos = () => index >= length;
+  const peek = () => str.charCodeAt(index + 1);
+  const advance = () => {
+    prev = code;
+    return str.charCodeAt(++index);
+  };
+
+  while (index < length) {
+    code = advance();
+    let next;
+
+    if (code === CHAR_BACKWARD_SLASH) {
+      backslashes = token.backslashes = true;
+      code = advance();
+
+      if (code === CHAR_LEFT_CURLY_BRACE) {
+        braceEscaped = true;
+      }
+      continue;
+    }
+
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+      braces++;
+
+      while (eos() !== true && (code = advance())) {
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          continue;
+        }
+
+        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (braceEscaped !== true && code === CHAR_COMMA) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (code === CHAR_RIGHT_CURLY_BRACE) {
+          braces--;
+
+          if (braces === 0) {
+            braceEscaped = false;
+            isBrace = token.isBrace = true;
+            finished = true;
+            break;
+          }
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (code === CHAR_FORWARD_SLASH) {
+      slashes.push(index);
+      tokens.push(token);
+      token = { value: '', depth: 0, isGlob: false };
+
+      if (finished === true) continue;
+      if (prev === CHAR_DOT && index === (start + 1)) {
+        start += 2;
+        continue;
+      }
+
+      lastIndex = index + 1;
+      continue;
+    }
+
+    if (opts.noext !== true) {
+      const isExtglobChar = code === CHAR_PLUS
+        || code === CHAR_AT
+        || code === CHAR_ASTERISK
+        || code === CHAR_QUESTION_MARK
+        || code === CHAR_EXCLAMATION_MARK;
+
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+        isGlob = token.isGlob = true;
+        isExtglob = token.isExtglob = true;
+        finished = true;
+        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+          negatedExtglob = true;
+        }
+
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
+
+            if (code === CHAR_RIGHT_PARENTHESES) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+    }
+
+    if (code === CHAR_ASTERISK) {
+      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_QUESTION_MARK) {
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+      while (eos() !== true && (next = advance())) {
+        if (next === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+          isBracket = token.isBracket = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          break;
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+      negated = token.negated = true;
+      start++;
+      continue;
+    }
+
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+      isGlob = token.isGlob = true;
+
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES) {
+            backslashes = token.backslashes = true;
+            code = advance();
+            continue;
+          }
+
+          if (code === CHAR_RIGHT_PARENTHESES) {
+            finished = true;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+
+    if (isGlob === true) {
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  if (opts.noext === true) {
+    isExtglob = false;
+    isGlob = false;
+  }
+
+  let base = str;
+  let prefix = '';
+  let glob = '';
+
+  if (start > 0) {
+    prefix = str.slice(0, start);
+    str = str.slice(start);
+    lastIndex -= start;
+  }
+
+  if (base && isGlob === true && lastIndex > 0) {
+    base = str.slice(0, lastIndex);
+    glob = str.slice(lastIndex);
+  } else if (isGlob === true) {
+    base = '';
+    glob = str;
+  } else {
+    base = str;
+  }
+
+  if (base && base !== '' && base !== '/' && base !== str) {
+    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+      base = base.slice(0, -1);
+    }
+  }
+
+  if (opts.unescape === true) {
+    if (glob) glob = utils$2.removeBackslashes(glob);
+
+    if (base && backslashes === true) {
+      base = utils$2.removeBackslashes(base);
+    }
+  }
+
+  const state = {
+    prefix,
+    input,
+    start,
+    base,
+    glob,
+    isBrace,
+    isBracket,
+    isGlob,
+    isExtglob,
+    isGlobstar,
+    negated,
+    negatedExtglob
+  };
+
+  if (opts.tokens === true) {
+    state.maxDepth = 0;
+    if (!isPathSeparator(code)) {
+      tokens.push(token);
+    }
+    state.tokens = tokens;
+  }
+
+  if (opts.parts === true || opts.tokens === true) {
+    let prevIndex;
+
+    for (let idx = 0; idx < slashes.length; idx++) {
+      const n = prevIndex ? prevIndex + 1 : start;
+      const i = slashes[idx];
+      const value = input.slice(n, i);
+      if (opts.tokens) {
+        if (idx === 0 && start !== 0) {
+          tokens[idx].isPrefix = true;
+          tokens[idx].value = prefix;
+        } else {
+          tokens[idx].value = value;
+        }
+        depth(tokens[idx]);
+        state.maxDepth += tokens[idx].depth;
+      }
+      if (idx !== 0 || value !== '') {
+        parts.push(value);
+      }
+      prevIndex = i;
+    }
+
+    if (prevIndex && prevIndex + 1 < input.length) {
+      const value = input.slice(prevIndex + 1);
+      parts.push(value);
+
+      if (opts.tokens) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
+    }
+
+    state.slashes = slashes;
+    state.parts = parts;
+  }
+
+  return state;
+};
+
+var scan_1 = scan$1;
+
+const constants$1 = constants$2;
+const utils$1 = utils$3;
+
+/**
+ * Constants
+ */
+
+const {
+  MAX_LENGTH,
+  POSIX_REGEX_SOURCE,
+  REGEX_NON_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_BACKREF,
+  REPLACEMENTS
+} = constants$1;
+
+/**
+ * Helpers
+ */
+
+const expandRange = (args, options) => {
+  if (typeof options.expandRange === 'function') {
+    return options.expandRange(...args, options);
+  }
+
+  args.sort();
+  const value = `[${args.join('-')}]`;
+
+  return value;
+};
+
+/**
+ * Create the message for a syntax error
+ */
+
+const syntaxError = (type, char) => {
+  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
+
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
+
+const parse$2 = (input, options) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  input = REPLACEMENTS[input] || input;
+
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+
+  let len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+  const tokens = [bos];
+
+  const capture = opts.capture ? '' : '?:';
+  const win32 = utils$1.isWindows(options);
+
+  // create constants based on platform, for windows or posix
+  const PLATFORM_CHARS = constants$1.globChars(win32);
+  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+
+  const {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR
+  } = PLATFORM_CHARS;
+
+  const globstar = opts => {
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const nodot = opts.dot ? '' : NO_DOT;
+  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+  let star = opts.bash === true ? globstar(opts) : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  // minimatch options support
+  if (typeof opts.noext === 'boolean') {
+    opts.noextglob = opts.noext;
+  }
+
+  const state = {
+    input,
+    index: -1,
+    start: 0,
+    dot: opts.dot === true,
+    consumed: '',
+    output: '',
+    prefix: '',
+    backtrack: false,
+    negated: false,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: false,
+    tokens
+  };
+
+  input = utils$1.removePrefix(input, state);
+  len = input.length;
+
+  const extglobs = [];
+  const braces = [];
+  const stack = [];
+  let prev = bos;
+  let value;
+
+  /**
+   * Tokenizing helpers
+   */
+
+  const eos = () => state.index === len - 1;
+  const peek = state.peek = (n = 1) => input[state.index + n];
+  const advance = state.advance = () => input[++state.index] || '';
+  const remaining = () => input.slice(state.index + 1);
+  const consume = (value = '', num = 0) => {
+    state.consumed += value;
+    state.index += num;
+  };
+
+  const append = token => {
+    state.output += token.output != null ? token.output : token.value;
+    consume(token.value);
+  };
+
+  const negate = () => {
+    let count = 1;
+
+    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+      advance();
+      state.start++;
+      count++;
+    }
+
+    if (count % 2 === 0) {
+      return false;
+    }
+
+    state.negated = true;
+    state.start++;
+    return true;
+  };
+
+  const increment = type => {
+    state[type]++;
+    stack.push(type);
+  };
+
+  const decrement = type => {
+    state[type]--;
+    stack.pop();
+  };
+
+  /**
+   * Push tokens onto the tokens array. This helper speeds up
+   * tokenizing by 1) helping us avoid backtracking as much as possible,
+   * and 2) helping us avoid creating extra tokens when consecutive
+   * characters are plain text. This improves performance and simplifies
+   * lookbehinds.
+   */
+
+  const push = tok => {
+    if (prev.type === 'globstar') {
+      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = 'star';
+        prev.value = '*';
+        prev.output = star;
+        state.output += prev.output;
+      }
+    }
+
+    if (extglobs.length && tok.type !== 'paren') {
+      extglobs[extglobs.length - 1].inner += tok.value;
+    }
+
+    if (tok.value || tok.output) append(tok);
+    if (prev && prev.type === 'text' && tok.type === 'text') {
+      prev.value += tok.value;
+      prev.output = (prev.output || '') + tok.value;
+      return;
+    }
+
+    tok.prev = prev;
+    tokens.push(tok);
+    prev = tok;
+  };
+
+  const extglobOpen = (type, value) => {
+    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+    token.prev = prev;
+    token.parens = state.parens;
+    token.output = state.output;
+    const output = (opts.capture ? '(' : '') + token.open;
+
+    increment('parens');
+    push({ type, value, output: state.output ? '' : ONE_CHAR });
+    push({ type: 'paren', extglob: true, value: advance(), output });
+    extglobs.push(token);
+  };
+
+  const extglobClose = token => {
+    let output = token.close + (opts.capture ? ')' : '');
+    let rest;
+
+    if (token.type === 'negate') {
+      let extglobStar = star;
+
+      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+        extglobStar = globstar(opts);
+      }
+
+      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+        output = token.close = `)$))${extglobStar}`;
+      }
+
+      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+        // In this case, we need to parse the string and use it in the output of the original pattern.
+        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+        //
+        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+        const expression = parse$2(rest, { ...options, fastpaths: false }).output;
+
+        output = token.close = `)${expression})${extglobStar})`;
+      }
+
+      if (token.prev.type === 'bos') {
+        state.negatedExtglob = true;
+      }
+    }
+
+    push({ type: 'paren', extglob: true, value, output });
+    decrement('parens');
+  };
+
+  /**
+   * Fast paths
+   */
+
+  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+    let backslashes = false;
+
+    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+      if (first === '\\') {
+        backslashes = true;
+        return m;
+      }
+
+      if (first === '?') {
+        if (esc) {
+          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        if (index === 0) {
+          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        return QMARK.repeat(chars.length);
+      }
+
+      if (first === '.') {
+        return DOT_LITERAL.repeat(chars.length);
+      }
+
+      if (first === '*') {
+        if (esc) {
+          return esc + first + (rest ? star : '');
+        }
+        return star;
+      }
+      return esc ? m : `\\${m}`;
+    });
+
+    if (backslashes === true) {
+      if (opts.unescape === true) {
+        output = output.replace(/\\/g, '');
+      } else {
+        output = output.replace(/\\+/g, m => {
+          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+        });
+      }
+    }
+
+    if (output === input && opts.contains === true) {
+      state.output = input;
+      return state;
+    }
+
+    state.output = utils$1.wrapOutput(output, state, options);
+    return state;
+  }
+
+  /**
+   * Tokenize input until we reach end-of-string
+   */
+
+  while (!eos()) {
+    value = advance();
+
+    if (value === '\u0000') {
+      continue;
+    }
+
+    /**
+     * Escaped characters
+     */
+
+    if (value === '\\') {
+      const next = peek();
+
+      if (next === '/' && opts.bash !== true) {
+        continue;
+      }
+
+      if (next === '.' || next === ';') {
+        continue;
+      }
+
+      if (!next) {
+        value += '\\';
+        push({ type: 'text', value });
+        continue;
+      }
+
+      // collapse slashes to reduce potential for exploits
+      const match = /^\\+/.exec(remaining());
+      let slashes = 0;
+
+      if (match && match[0].length > 2) {
+        slashes = match[0].length;
+        state.index += slashes;
+        if (slashes % 2 !== 0) {
+          value += '\\';
+        }
+      }
+
+      if (opts.unescape === true) {
+        value = advance();
+      } else {
+        value += advance();
+      }
+
+      if (state.brackets === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
+    }
+
+    /**
+     * If we're inside a regex character class, continue
+     * until we reach the closing bracket.
+     */
+
+    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+      if (opts.posix !== false && value === ':') {
+        const inner = prev.value.slice(1);
+        if (inner.includes('[')) {
+          prev.posix = true;
+
+          if (inner.includes(':')) {
+            const idx = prev.value.lastIndexOf('[');
+            const pre = prev.value.slice(0, idx);
+            const rest = prev.value.slice(idx + 2);
+            const posix = POSIX_REGEX_SOURCE[rest];
+            if (posix) {
+              prev.value = pre + posix;
+              state.backtrack = true;
+              advance();
+
+              if (!bos.output && tokens.indexOf(prev) === 1) {
+                bos.output = ONE_CHAR;
+              }
+              continue;
+            }
+          }
+        }
+      }
+
+      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+        value = `\\${value}`;
+      }
+
+      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+        value = `\\${value}`;
+      }
+
+      if (opts.posix === true && value === '!' && prev.value === '[') {
+        value = '^';
+      }
+
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * If we're inside a quoted string, continue
+     * until we reach the closing double quote.
+     */
+
+    if (state.quotes === 1 && value !== '"') {
+      value = utils$1.escapeRegex(value);
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * Double quotes
+     */
+
+    if (value === '"') {
+      state.quotes = state.quotes === 1 ? 0 : 1;
+      if (opts.keepQuotes === true) {
+        push({ type: 'text', value });
+      }
+      continue;
+    }
+
+    /**
+     * Parentheses
+     */
+
+    if (value === '(') {
+      increment('parens');
+      push({ type: 'paren', value });
+      continue;
+    }
+
+    if (value === ')') {
+      if (state.parens === 0 && opts.strictBrackets === true) {
+        throw new SyntaxError(syntaxError('opening', '('));
+      }
+
+      const extglob = extglobs[extglobs.length - 1];
+      if (extglob && state.parens === extglob.parens + 1) {
+        extglobClose(extglobs.pop());
+        continue;
+      }
+
+      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+      decrement('parens');
+      continue;
+    }
+
+    /**
+     * Square brackets
+     */
+
+    if (value === '[') {
+      if (opts.nobracket === true || !remaining().includes(']')) {
+        if (opts.nobracket !== true && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('closing', ']'));
+        }
+
+        value = `\\${value}`;
+      } else {
+        increment('brackets');
+      }
+
+      push({ type: 'bracket', value });
+      continue;
+    }
+
+    if (value === ']') {
+      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      if (state.brackets === 0) {
+        if (opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('opening', '['));
+        }
+
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      decrement('brackets');
+
+      const prevValue = prev.value.slice(1);
+      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+        value = `/${value}`;
+      }
+
+      prev.value += value;
+      append({ value });
+
+      // when literal brackets are explicitly disabled
+      // assume we should match with a regex character class
+      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
+        continue;
+      }
+
+      const escaped = utils$1.escapeRegex(prev.value);
+      state.output = state.output.slice(0, -prev.value.length);
+
+      // when literal brackets are explicitly enabled
+      // assume we should escape the brackets to match literal characters
+      if (opts.literalBrackets === true) {
+        state.output += escaped;
+        prev.value = escaped;
+        continue;
+      }
+
+      // when the user specifies nothing, try to match both
+      prev.value = `(${capture}${escaped}|${prev.value})`;
+      state.output += prev.value;
+      continue;
+    }
+
+    /**
+     * Braces
+     */
+
+    if (value === '{' && opts.nobrace !== true) {
+      increment('braces');
+
+      const open = {
+        type: 'brace',
+        value,
+        output: '(',
+        outputIndex: state.output.length,
+        tokensIndex: state.tokens.length
+      };
+
+      braces.push(open);
+      push(open);
+      continue;
+    }
+
+    if (value === '}') {
+      const brace = braces[braces.length - 1];
+
+      if (opts.nobrace === true || !brace) {
+        push({ type: 'text', value, output: value });
+        continue;
+      }
+
+      let output = ')';
+
+      if (brace.dots === true) {
+        const arr = tokens.slice();
+        const range = [];
+
+        for (let i = arr.length - 1; i >= 0; i--) {
+          tokens.pop();
+          if (arr[i].type === 'brace') {
+            break;
+          }
+          if (arr[i].type !== 'dots') {
+            range.unshift(arr[i].value);
+          }
+        }
+
+        output = expandRange(range, opts);
+        state.backtrack = true;
+      }
+
+      if (brace.comma !== true && brace.dots !== true) {
+        const out = state.output.slice(0, brace.outputIndex);
+        const toks = state.tokens.slice(brace.tokensIndex);
+        brace.value = brace.output = '\\{';
+        value = output = '\\}';
+        state.output = out;
+        for (const t of toks) {
+          state.output += (t.output || t.value);
+        }
+      }
+
+      push({ type: 'brace', value, output });
+      decrement('braces');
+      braces.pop();
+      continue;
+    }
+
+    /**
+     * Pipes
+     */
+
+    if (value === '|') {
+      if (extglobs.length > 0) {
+        extglobs[extglobs.length - 1].conditions++;
+      }
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Commas
+     */
+
+    if (value === ',') {
+      let output = value;
+
+      const brace = braces[braces.length - 1];
+      if (brace && stack[stack.length - 1] === 'braces') {
+        brace.comma = true;
+        output = '|';
+      }
+
+      push({ type: 'comma', value, output });
+      continue;
+    }
+
+    /**
+     * Slashes
+     */
+
+    if (value === '/') {
+      // if the beginning of the glob is "./", advance the start
+      // to the current index, and don't add the "./" characters
+      // to the state. This greatly simplifies lookbehinds when
+      // checking for BOS characters like "!" and "." (not "./")
+      if (prev.type === 'dot' && state.index === state.start + 1) {
+        state.start = state.index + 1;
+        state.consumed = '';
+        state.output = '';
+        tokens.pop();
+        prev = bos; // reset "prev" to the first token
+        continue;
+      }
+
+      push({ type: 'slash', value, output: SLASH_LITERAL });
+      continue;
+    }
+
+    /**
+     * Dots
+     */
+
+    if (value === '.') {
+      if (state.braces > 0 && prev.type === 'dot') {
+        if (prev.value === '.') prev.output = DOT_LITERAL;
+        const brace = braces[braces.length - 1];
+        prev.type = 'dots';
+        prev.output += value;
+        prev.value += value;
+        brace.dots = true;
+        continue;
+      }
+
+      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+        push({ type: 'text', value, output: DOT_LITERAL });
+        continue;
+      }
+
+      push({ type: 'dot', value, output: DOT_LITERAL });
+      continue;
+    }
+
+    /**
+     * Question marks
+     */
+
+    if (value === '?') {
+      const isGroup = prev && prev.value === '(';
+      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('qmark', value);
+        continue;
+      }
+
+      if (prev && prev.type === 'paren') {
+        const next = peek();
+        let output = value;
+
+        if (next === '<' && !utils$1.supportsLookbehinds()) {
+          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+        }
+
+        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+          output = `\\${value}`;
+        }
+
+        push({ type: 'text', value, output });
+        continue;
+      }
+
+      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+        continue;
+      }
+
+      push({ type: 'qmark', value, output: QMARK });
+      continue;
+    }
+
+    /**
+     * Exclamation
+     */
+
+    if (value === '!') {
+      if (opts.noextglob !== true && peek() === '(') {
+        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+          extglobOpen('negate', value);
+          continue;
+        }
+      }
+
+      if (opts.nonegate !== true && state.index === 0) {
+        negate();
+        continue;
+      }
+    }
+
+    /**
+     * Plus
+     */
+
+    if (value === '+') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('plus', value);
+        continue;
+      }
+
+      if ((prev && prev.value === '(') || opts.regex === false) {
+        push({ type: 'plus', value, output: PLUS_LITERAL });
+        continue;
+      }
+
+      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+        push({ type: 'plus', value });
+        continue;
+      }
+
+      push({ type: 'plus', value: PLUS_LITERAL });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value === '@') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        push({ type: 'at', extglob: true, value, output: '' });
+        continue;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value !== '*') {
+      if (value === '$' || value === '^') {
+        value = `\\${value}`;
+      }
+
+      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+      if (match) {
+        value += match[0];
+        state.index += match[0].length;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Stars
+     */
+
+    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+      prev.type = 'star';
+      prev.star = true;
+      prev.value += value;
+      prev.output = star;
+      state.backtrack = true;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    let rest = remaining();
+    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+      extglobOpen('star', value);
+      continue;
+    }
+
+    if (prev.type === 'star') {
+      if (opts.noglobstar === true) {
+        consume(value);
+        continue;
+      }
+
+      const prior = prev.prev;
+      const before = prior.prev;
+      const isStart = prior.type === 'slash' || prior.type === 'bos';
+      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      // strip consecutive `/**/`
+      while (rest.slice(0, 3) === '/**') {
+        const after = input[state.index + 4];
+        if (after && after !== '/') {
+          break;
+        }
+        rest = rest.slice(3);
+        consume('/**', 3);
+      }
+
+      if (prior.type === 'bos' && eos()) {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = globstar(opts);
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+        prev.value += value;
+        state.globstar = true;
+        state.output += prior.output + prev.output;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+        const end = rest[1] !== void 0 ? '|$' : '';
+
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+        prev.value += value;
+
+        state.output += prior.output + prev.output;
+        state.globstar = true;
+
+        consume(value + advance());
+
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      if (prior.type === 'bos' && rest[0] === '/') {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value + advance());
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      // remove single star from output
+      state.output = state.output.slice(0, -prev.output.length);
+
+      // reset previous token to globstar
+      prev.type = 'globstar';
+      prev.output = globstar(opts);
+      prev.value += value;
+
+      // reset output with globstar
+      state.output += prev.output;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    const token = { type: 'star', value, output: star };
+
+    if (opts.bash === true) {
+      token.output = '.*?';
+      if (prev.type === 'bos' || prev.type === 'slash') {
+        token.output = nodot + token.output;
+      }
+      push(token);
+      continue;
+    }
+
+    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+      token.output = value;
+      push(token);
+      continue;
+    }
+
+    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+      if (prev.type === 'dot') {
+        state.output += NO_DOT_SLASH;
+        prev.output += NO_DOT_SLASH;
+
+      } else if (opts.dot === true) {
+        state.output += NO_DOTS_SLASH;
+        prev.output += NO_DOTS_SLASH;
+
+      } else {
+        state.output += nodot;
+        prev.output += nodot;
+      }
+
+      if (peek() !== '*') {
+        state.output += ONE_CHAR;
+        prev.output += ONE_CHAR;
+      }
+    }
+
+    push(token);
+  }
+
+  while (state.brackets > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+    state.output = utils$1.escapeLast(state.output, '[');
+    decrement('brackets');
+  }
+
+  while (state.parens > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+    state.output = utils$1.escapeLast(state.output, '(');
+    decrement('parens');
+  }
+
+  while (state.braces > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+    state.output = utils$1.escapeLast(state.output, '{');
+    decrement('braces');
+  }
+
+  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+  }
+
+  // rebuild the output if we had to backtrack at any point
+  if (state.backtrack === true) {
+    state.output = '';
+
+    for (const token of state.tokens) {
+      state.output += token.output != null ? token.output : token.value;
+
+      if (token.suffix) {
+        state.output += token.suffix;
+      }
+    }
+  }
+
+  return state;
+};
+
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse$2.fastpaths = (input, options) => {
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  const len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  input = REPLACEMENTS[input] || input;
+  const win32 = utils$1.isWindows(options);
+
+  // create constants based on platform, for windows or posix
+  const {
+    DOT_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOTS_SLASH,
+    STAR,
+    START_ANCHOR
+  } = constants$1.globChars(win32);
+
+  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+  const capture = opts.capture ? '' : '?:';
+  const state = { negated: false, prefix: '' };
+  let star = opts.bash === true ? '.*?' : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  const globstar = opts => {
+    if (opts.noglobstar === true) return star;
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const create = str => {
+    switch (str) {
+      case '*':
+        return `${nodot}${ONE_CHAR}${star}`;
+
+      case '.*':
+        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*.*':
+        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*/*':
+        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+      case '**':
+        return nodot + globstar(opts);
+
+      case '**/*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+      case '**/*.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '**/.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      default: {
+        const match = /^(.*?)\.(\w+)$/.exec(str);
+        if (!match) return;
+
+        const source = create(match[1]);
+        if (!source) return;
+
+        return source + DOT_LITERAL + match[2];
+      }
+    }
+  };
+
+  const output = utils$1.removePrefix(input, state);
+  let source = create(output);
+
+  if (source && opts.strictSlashes !== true) {
+    source += `${SLASH_LITERAL}?`;
+  }
+
+  return source;
+};
+
+var parse_1$1 = parse$2;
+
+const path$1 = require$$0$1;
+const scan = scan_1;
+const parse$1 = parse_1$1;
+const utils = utils$3;
+const constants = constants$2;
+const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch$1 = (glob, options, returnState = false) => {
+  if (Array.isArray(glob)) {
+    const fns = glob.map(input => picomatch$1(input, options, returnState));
+    const arrayMatcher = str => {
+      for (const isMatch of fns) {
+        const state = isMatch(str);
+        if (state) return state;
+      }
+      return false;
+    };
+    return arrayMatcher;
+  }
+
+  const isState = isObject$2(glob) && glob.tokens && glob.input;
+
+  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+    throw new TypeError('Expected pattern to be a non-empty string');
+  }
+
+  const opts = options || {};
+  const posix = utils.isWindows(options);
+  const regex = isState
+    ? picomatch$1.compileRe(glob, options)
+    : picomatch$1.makeRe(glob, options, false, true);
+
+  const state = regex.state;
+  delete regex.state;
+
+  let isIgnored = () => false;
+  if (opts.ignore) {
+    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
+  }
+
+  const matcher = (input, returnObject = false) => {
+    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
+    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+    if (typeof opts.onResult === 'function') {
+      opts.onResult(result);
+    }
+
+    if (isMatch === false) {
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (isIgnored(input)) {
+      if (typeof opts.onIgnore === 'function') {
+        opts.onIgnore(result);
+      }
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (typeof opts.onMatch === 'function') {
+      opts.onMatch(result);
+    }
+    return returnObject ? result : true;
+  };
+
+  if (returnState) {
+    matcher.state = state;
+  }
+
+  return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
+
+  if (input === '') {
+    return { isMatch: false, output: '' };
+  }
+
+  const opts = options || {};
+  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+  let match = input === glob;
+  let output = (match && format) ? format(input) : input;
+
+  if (match === false) {
+    output = format ? format(input) : input;
+    match = output === glob;
+  }
+
+  if (match === false || opts.capture === true) {
+    if (opts.matchBase === true || opts.basename === true) {
+      match = picomatch$1.matchBase(input, regex, options, posix);
+    } else {
+      match = regex.exec(output);
+    }
+  }
+
+  return { isMatch: Boolean(match), match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
+  return regex.test(path$1.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch$1.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
+  return parse$1(pattern, { ...options, fastpaths: false });
+};
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch$1.scan = (input, options) => scan(input, options);
+
+/**
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
+ *
+ * @param {Object} `state`
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
+  if (returnOutput === true) {
+    return state.output;
+  }
+
+  const opts = options || {};
+  const prepend = opts.contains ? '' : '^';
+  const append = opts.contains ? '' : '$';
+
+  let source = `${prepend}(?:${state.output})${append}`;
+  if (state && state.negated === true) {
+    source = `^(?!${source}).*$`;
+  }
+
+  const regex = picomatch$1.toRegex(source, options);
+  if (returnState === true) {
+    regex.state = state;
+  }
+
+  return regex;
+};
+
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+  if (!input || typeof input !== 'string') {
+    throw new TypeError('Expected a non-empty string');
+  }
+
+  let parsed = { negated: false, fastpaths: true };
+
+  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    parsed.output = parse$1.fastpaths(input, options);
+  }
+
+  if (!parsed.output) {
+    parsed = parse$1(input, options);
+  }
+
+  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch$1.toRegex = (source, options) => {
+  try {
+    const opts = options || {};
+    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+  } catch (err) {
+    if (options && options.debug === true) throw err;
+    return /$^/;
+  }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch$1.constants = constants;
+
+/**
+ * Expose "picomatch"
+ */
+
+var picomatch_1 = picomatch$1;
+
+var picomatch = picomatch_1;
+
+var pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+const normalizePath$1 = function normalizePath(filename) {
+    return filename.split(require$$0$1.win32.sep).join(require$$0$1.posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || require$$0$1.isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath$1(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath$1(require$$0$1.resolve(resolutionBase || ''))
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return require$$0$1.posix.join(basePath, normalizePath$1(id));
+}
+const createFilter$1 = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = pm(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (/\0/.test(id))
+            return false;
+        const pathId = normalizePath$1(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function withTrailingSlash(path) {
+  if (path[path.length - 1] !== "/") {
+    return `${path}/`;
+  }
+  return path;
+}
+
+if (process.versions.pnp) {
+  try {
+    node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)))("pnpapi");
+  } catch {
+  }
+}
+
+const createFilter = createFilter$1;
+node_module.builtinModules.filter((id) => !id.includes(":"));
+function isInNodeModules(id) {
+  return id.includes("node_modules");
+}
+const _require = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href)));
+function resolveDependencyVersion(dep, pkgRelativePath = "../../package.json") {
+  const pkgPath = path$3.resolve(_require.resolve(dep), pkgRelativePath);
+  return JSON.parse(fs$1.readFileSync(pkgPath, "utf-8")).version;
+}
+const rollupVersion = resolveDependencyVersion("rollup");
+const filter = process.env.VITE_DEBUG_FILTER;
+const DEBUG = process.env.DEBUG;
+function createDebugger(namespace, options = {}) {
+  const log = debug$2(namespace);
+  const { onlyWhenFocused } = options;
+  let enabled = log.enabled;
+  if (enabled && onlyWhenFocused) {
+    const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
+    enabled = !!DEBUG?.includes(ns);
+  }
+  if (enabled) {
+    return (...args) => {
+      if (!filter || args.some((a) => a?.includes?.(filter))) {
+        log(...args);
+      }
+    };
+  }
+}
+function testCaseInsensitiveFS() {
+  if (!CLIENT_ENTRY.endsWith("client.mjs")) {
+    throw new Error(
+      `cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`
+    );
+  }
+  if (!fs$1.existsSync(CLIENT_ENTRY)) {
+    throw new Error(
+      "cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY
+    );
+  }
+  return fs$1.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
+}
+const isCaseInsensitiveFS = testCaseInsensitiveFS();
+const VOLUME_RE = /^[A-Z]:/i;
+function normalizePath(id) {
+  return path$3.posix.normalize(isWindows ? slash(id) : id);
+}
+function fsPathFromId(id) {
+  const fsPath = normalizePath(
+    id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
+  );
+  return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+}
+function fsPathFromUrl(url) {
+  return fsPathFromId(cleanUrl(url));
+}
+function isParentDirectory(dir, file) {
+  dir = withTrailingSlash(dir);
+  return file.startsWith(dir) || isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
+}
+function isSameFileUri(file1, file2) {
+  return file1 === file2 || isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
+}
+const trailingSeparatorRE = /[?&]$/;
+const timestampRE = /\bt=\d{13}&?\b/;
+function removeTimestampQuery(url) {
+  return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
+}
+function isObject$1(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function tryStatSync(file) {
+  try {
+    return fs$1.statSync(file, { throwIfNoEntry: false });
+  } catch {
+  }
+}
+function isFileReadable(filename) {
+  if (!tryStatSync(filename)) {
+    return false;
+  }
+  try {
+    fs$1.accessSync(filename, fs$1.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function arraify(target) {
+  return Array.isArray(target) ? target : [target];
+}
+path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
+function backwardCompatibleWorkerPlugins(plugins) {
+  if (Array.isArray(plugins)) {
+    return plugins;
+  }
+  if (typeof plugins === "function") {
+    return plugins();
+  }
+  return [];
+}
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
+    }
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "alias" && (rootPath === "resolve" || rootPath === "")) {
+      merged[key] = mergeAlias(existing, value);
+      continue;
+    } else if (key === "assetsInclude" && rootPath === "") {
+      merged[key] = [].concat(existing, value);
+      continue;
+    } else if (key === "noExternal" && rootPath === "ssr" && (existing === true || value === true)) {
+      merged[key] = true;
+      continue;
+    } else if (key === "plugins" && rootPath === "worker") {
+      merged[key] = () => [
+        ...backwardCompatibleWorkerPlugins(existing),
+        ...backwardCompatibleWorkerPlugins(value)
+      ];
+      continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing), ...arraify(value)];
+      continue;
+    }
+    if (isObject$1(existing) && isObject$1(value)) {
+      merged[key] = mergeConfigRecursively(
+        existing,
+        value,
+        rootPath ? `${rootPath}.${key}` : key
+      );
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+  if (typeof defaults === "function" || typeof overrides === "function") {
+    throw new Error(`Cannot merge config in form of callback`);
+  }
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
+function mergeAlias(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  if (isObject$1(a) && isObject$1(b)) {
+    return { ...a, ...b };
+  }
+  return [...normalizeAlias(b), ...normalizeAlias(a)];
+}
+function normalizeAlias(o = []) {
+  return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map(
+    (find) => normalizeSingleAlias({
+      find,
+      replacement: o[find]
+    })
+  );
+}
+function normalizeSingleAlias({
+  find,
+  replacement,
+  customResolver
+}) {
+  if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
+    find = find.slice(0, find.length - 1);
+    replacement = replacement.slice(0, replacement.length - 1);
+  }
+  const alias = {
+    find,
+    replacement
+  };
+  if (customResolver) {
+    alias.customResolver = customResolver;
+  }
+  return alias;
+}
+
+const CSS_LANGS_RE = (
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/
+);
+const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
+class SplitVendorChunkCache {
+  cache;
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+}
+function splitVendorChunk(options = {}) {
+  const cache = options.cache ?? new SplitVendorChunkCache();
+  return (id, { getModuleInfo }) => {
+    if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
+      return "vendor";
+    }
+  };
+}
+function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  if (importStack.includes(id)) {
+    cache.set(id, false);
+    return false;
+  }
+  const mod = getModuleInfo(id);
+  if (!mod) {
+    cache.set(id, false);
+    return false;
+  }
+  if (mod.isEntry) {
+    cache.set(id, true);
+    return true;
+  }
+  const someImporterIs = mod.importers.some(
+    (importer) => staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  );
+  cache.set(id, someImporterIs);
+  return someImporterIs;
+}
+function splitVendorChunkPlugin() {
+  const caches = [];
+  function createSplitVendorChunk(output, config) {
+    const cache = new SplitVendorChunkCache();
+    caches.push(cache);
+    const build = config.build ?? {};
+    const format = output?.format;
+    if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
+      return splitVendorChunk({ cache });
+    }
+  }
+  return {
+    name: "vite:split-vendor-chunk",
+    config(config) {
+      let outputs = config?.build?.rollupOptions?.output;
+      if (outputs) {
+        outputs = arraify(outputs);
+        for (const output of outputs) {
+          const viteManualChunks = createSplitVendorChunk(output, config);
+          if (viteManualChunks) {
+            if (output.manualChunks) {
+              if (typeof output.manualChunks === "function") {
+                const userManualChunks = output.manualChunks;
+                output.manualChunks = (id, api) => {
+                  return userManualChunks(id, api) ?? viteManualChunks(id, api);
+                };
+              } else {
+                console.warn(
+                  "(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
+                );
+              }
+            } else {
+              output.manualChunks = viteManualChunks;
+            }
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
+        };
+      }
+    },
+    buildStart() {
+      caches.forEach((cache) => cache.reset());
+    }
+  };
+}
+
+var convertSourceMap$1 = {};
+
+(function (exports) {
+
+	Object.defineProperty(exports, 'commentRegex', {
+	  get: function getCommentRegex () {
+	    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+	    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+	  }
+	});
+
+
+	Object.defineProperty(exports, 'mapFileCommentRegex', {
+	  get: function getMapFileCommentRegex () {
+	    // Matches sourceMappingURL in either // or /* comment styles.
+	    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+	  }
+	});
+
+	var decodeBase64;
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    decodeBase64 = decodeBase64WithBufferFrom;
+	  } else {
+	    decodeBase64 = decodeBase64WithNewBuffer;
+	  }
+	} else {
+	  decodeBase64 = decodeBase64WithAtob;
+	}
+
+	function decodeBase64WithBufferFrom(base64) {
+	  return Buffer.from(base64, 'base64').toString();
+	}
+
+	function decodeBase64WithNewBuffer(base64) {
+	  if (typeof value === 'number') {
+	    throw new TypeError('The value to decode must not be of type number.');
+	  }
+	  return new Buffer(base64, 'base64').toString();
+	}
+
+	function decodeBase64WithAtob(base64) {
+	  return decodeURIComponent(escape(atob(base64)));
+	}
+
+	function stripComment(sm) {
+	  return sm.split(',').pop();
+	}
+
+	function readFromFileMap(sm, read) {
+	  var r = exports.mapFileCommentRegex.exec(sm);
+	  // for some odd reason //# .. captures in 1 and /* .. */ in 2
+	  var filename = r[1] || r[2];
+
+	  try {
+	    var sm = read(filename);
+	    if (sm != null && typeof sm.catch === 'function') {
+	      return sm.catch(throwError);
+	    } else {
+	      return sm;
+	    }
+	  } catch (e) {
+	    throwError(e);
+	  }
+
+	  function throwError(e) {
+	    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+	  }
+	}
+
+	function Converter (sm, opts) {
+	  opts = opts || {};
+
+	  if (opts.hasComment) {
+	    sm = stripComment(sm);
+	  }
+
+	  if (opts.encoding === 'base64') {
+	    sm = decodeBase64(sm);
+	  } else if (opts.encoding === 'uri') {
+	    sm = decodeURIComponent(sm);
+	  }
+
+	  if (opts.isJSON || opts.encoding) {
+	    sm = JSON.parse(sm);
+	  }
+
+	  this.sourcemap = sm;
+	}
+
+	Converter.prototype.toJSON = function (space) {
+	  return JSON.stringify(this.sourcemap, null, space);
+	};
+
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+	  } else {
+	    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+	  }
+	} else {
+	  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+	}
+
+	function encodeBase64WithBufferFrom() {
+	  var json = this.toJSON();
+	  return Buffer.from(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithNewBuffer() {
+	  var json = this.toJSON();
+	  if (typeof json === 'number') {
+	    throw new TypeError('The json to encode must not be of type number.');
+	  }
+	  return new Buffer(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithBtoa() {
+	  var json = this.toJSON();
+	  return btoa(unescape(encodeURIComponent(json)));
+	}
+
+	Converter.prototype.toURI = function () {
+	  var json = this.toJSON();
+	  return encodeURIComponent(json);
+	};
+
+	Converter.prototype.toComment = function (options) {
+	  var encoding, content, data;
+	  if (options != null && options.encoding === 'uri') {
+	    encoding = '';
+	    content = this.toURI();
+	  } else {
+	    encoding = ';base64';
+	    content = this.toBase64();
+	  }
+	  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+	  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+	};
+
+	// returns copy instead of original
+	Converter.prototype.toObject = function () {
+	  return JSON.parse(this.toJSON());
+	};
+
+	Converter.prototype.addProperty = function (key, value) {
+	  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+	  return this.setProperty(key, value);
+	};
+
+	Converter.prototype.setProperty = function (key, value) {
+	  this.sourcemap[key] = value;
+	  return this;
+	};
+
+	Converter.prototype.getProperty = function (key) {
+	  return this.sourcemap[key];
+	};
+
+	exports.fromObject = function (obj) {
+	  return new Converter(obj);
+	};
+
+	exports.fromJSON = function (json) {
+	  return new Converter(json, { isJSON: true });
+	};
+
+	exports.fromURI = function (uri) {
+	  return new Converter(uri, { encoding: 'uri' });
+	};
+
+	exports.fromBase64 = function (base64) {
+	  return new Converter(base64, { encoding: 'base64' });
+	};
+
+	exports.fromComment = function (comment) {
+	  var m, encoding;
+	  comment = comment
+	    .replace(/^\/\*/g, '//')
+	    .replace(/\*\/$/g, '');
+	  m = exports.commentRegex.exec(comment);
+	  encoding = m && m[4] || 'uri';
+	  return new Converter(comment, { encoding: encoding, hasComment: true });
+	};
+
+	function makeConverter(sm) {
+	  return new Converter(sm, { isJSON: true });
+	}
+
+	exports.fromMapFileComment = function (comment, read) {
+	  if (typeof read === 'string') {
+	    throw new Error(
+	      'String directory paths are no longer supported with `fromMapFileComment`\n' +
+	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+	    )
+	  }
+
+	  var sm = readFromFileMap(comment, read);
+	  if (sm != null && typeof sm.then === 'function') {
+	    return sm.then(makeConverter);
+	  } else {
+	    return makeConverter(sm);
+	  }
+	};
+
+	// Finds last sourcemap comment in file or returns null if none was found
+	exports.fromSource = function (content) {
+	  var m = content.match(exports.commentRegex);
+	  return m ? exports.fromComment(m.pop()) : null;
+	};
+
+	// Finds last sourcemap comment in file or returns null if none was found
+	exports.fromMapFileSource = function (content, read) {
+	  if (typeof read === 'string') {
+	    throw new Error(
+	      'String directory paths are no longer supported with `fromMapFileSource`\n' +
+	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+	    )
+	  }
+	  var m = content.match(exports.mapFileCommentRegex);
+	  return m ? exports.fromMapFileComment(m.pop(), read) : null;
+	};
+
+	exports.removeComments = function (src) {
+	  return src.replace(exports.commentRegex, '');
+	};
+
+	exports.removeMapFileComments = function (src) {
+	  return src.replace(exports.mapFileCommentRegex, '');
+	};
+
+	exports.generateMapFileComment = function (file, options) {
+	  var data = 'sourceMappingURL=' + file;
+	  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+	}; 
+} (convertSourceMap$1));
+
+var convertSourceMap = /*@__PURE__*/getDefaultExportFromCjs(convertSourceMap$1);
+
+/*!
+ * etag
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var etag_1 = etag;
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var crypto$1 = require$$0$2;
+var Stats = fs$2.Stats;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var toString$1 = Object.prototype.toString;
+
+/**
+ * Generate an entity tag.
+ *
+ * @param {Buffer|string} entity
+ * @return {string}
+ * @private
+ */
+
+function entitytag (entity) {
+  if (entity.length === 0) {
+    // fast-path empty
+    return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
+  }
+
+  // compute hash of entity
+  var hash = crypto$1
+    .createHash('sha1')
+    .update(entity, 'utf8')
+    .digest('base64')
+    .substring(0, 27);
+
+  // compute length of entity
+  var len = typeof entity === 'string'
+    ? Buffer.byteLength(entity, 'utf8')
+    : entity.length;
+
+  return '"' + len.toString(16) + '-' + hash + '"'
+}
+
+/**
+ * Create a simple ETag.
+ *
+ * @param {string|Buffer|Stats} entity
+ * @param {object} [options]
+ * @param {boolean} [options.weak]
+ * @return {String}
+ * @public
+ */
+
+function etag (entity, options) {
+  if (entity == null) {
+    throw new TypeError('argument entity is required')
+  }
+
+  // support fs.Stats object
+  var isStats = isstats(entity);
+  var weak = options && typeof options.weak === 'boolean'
+    ? options.weak
+    : isStats;
+
+  // validate argument
+  if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
+    throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
+  }
+
+  // generate entity tag
+  var tag = isStats
+    ? stattag(entity)
+    : entitytag(entity);
+
+  return weak
+    ? 'W/' + tag
+    : tag
+}
+
+/**
+ * Determine if object is a Stats object.
+ *
+ * @param {object} obj
+ * @return {boolean}
+ * @api private
+ */
+
+function isstats (obj) {
+  // genuine fs.Stats
+  if (typeof Stats === 'function' && obj instanceof Stats) {
+    return true
+  }
+
+  // quack quack
+  return obj && typeof obj === 'object' &&
+    'ctime' in obj && toString$1.call(obj.ctime) === '[object Date]' &&
+    'mtime' in obj && toString$1.call(obj.mtime) === '[object Date]' &&
+    'ino' in obj && typeof obj.ino === 'number' &&
+    'size' in obj && typeof obj.size === 'number'
+}
+
+/**
+ * Generate a tag for a stat.
+ *
+ * @param {object} stat
+ * @return {string}
+ * @private
+ */
+
+function stattag (stat) {
+  var mtime = stat.mtime.getTime().toString(16);
+  var size = stat.size.toString(16);
+
+  return '"' + size + '-' + mtime + '"'
+}
+
+var getEtag = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
+
+class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+
+	has(n) {
+		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+	}
+}
+
+class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+
+		this.intro = '';
+		this.outro = '';
+
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+
+		{
+			this.previous = null;
+			this.next = null;
+		}
+	}
+
+	appendLeft(content) {
+		this.outro += content;
+	}
+
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+
+		return chunk;
+	}
+
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = '';
+			this.outro = '';
+		}
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	}
+
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
+	split(index) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+
+		this.original = originalBefore;
+
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = '';
+
+		this.end = index;
+
+		if (this.edited) {
+			// after split we should save the edit content record into the correct chunk
+			// to make sure sourcemap correct
+			// For example:
+			// '  test'.trim()
+			//     split   -> '  ' + 'test'
+			//   ✔️ edit    -> '' + 'test'
+			//   ✖️ edit    -> 'test' + '' 
+			// TODO is this block necessary?...
+			newChunk.edit('', false);
+			this.content = '';
+		} else {
+			this.content = originalBefore;
+		}
+
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+
+		return newChunk;
+	}
+
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit('', undefined, true);
+				if (this.edited) {
+					// save the change, if it has been edited
+					this.edit(trimmed, this.storeName, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.intro = this.intro.replace(rx, '');
+			if (this.intro.length) return true;
+		}
+	}
+
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) {
+					// save the change, if it has been edited
+					newChunk.edit(trimmed, this.storeName, true);
+				}
+				this.edit('', undefined, true);
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.outro = this.outro.replace(rx, '');
+			if (this.outro.length) return true;
+		}
+	}
+}
+
+function getBtoa() {
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
+}
+
+const btoa$1 = /*#__PURE__*/ getBtoa();
+
+class SourceMap {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + btoa$1(this.toString());
+	}
+}
+
+function guessIndent(code) {
+	const lines = code.split('\n');
+
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+	if (tabbed.length === 0 && spaced.length === 0) {
+		return null;
+	}
+
+	// More lines tabbed than spaced? Assume tabs, and
+	// default to tabs in the case of a tie (or nothing
+	// to go on)
+	if (tabbed.length >= spaced.length) {
+		return '\t';
+	}
+
+	// Otherwise, we need to guess the multiple
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+
+	return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+
+	fromParts.pop(); // get dirname
+
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = '..';
+	}
+
+	return fromParts.concat(toParts).join('/');
+}
+
+const toString = Object.prototype.toString;
+
+function isObject(thing) {
+	return toString.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+	const originalLines = source.split('\n');
+	const lineOffsets = [];
+
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
+		}
+		const line = i - 1;
+		const column = index - lineOffsets[line];
+		return { line, column };
+	};
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
+			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+			if (nameIndex >= 0) {
+				segment.push(nameIndex);
+			}
+			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+
+		this.pending = null;
+	}
+
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
+
+		while (originalCharIndex < chunk.end) {
+			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+				if (this.hires === 'boundary') {
+					// in hires "boundary", group segments per word boundary than per char
+					if (wordRegex.test(original[originalCharIndex])) {
+						// for first char in the boundary found, start the boundary by pushing a segment
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						// for non-word char, end the boundary by pushing a segment
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+				} else {
+					this.rawSegments.push(segment);
+				}
+			}
+
+			if (original[originalCharIndex] === '\n') {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+			} else {
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+
+			originalCharIndex += 1;
+		}
+
+		this.pending = null;
+	}
+
+	advance(str) {
+		if (!str) return;
+
+		const lines = str.split('\n');
+
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+}
+
+const n = '\n';
+
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false,
+};
+
+class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+
+		Object.defineProperties(this, {
+			original: { writable: true, value: string },
+			outro: { writable: true, value: '' },
+			intro: { writable: true, value: '' },
+			firstChunk: { writable: true, value: chunk },
+			lastChunk: { writable: true, value: chunk },
+			lastSearchedChunk: { writable: true, value: chunk },
+			byStart: { writable: true, value: {} },
+			byEnd: { writable: true, value: {} },
+			filename: { writable: true, value: options.filename },
+			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+			sourcemapLocations: { writable: true, value: new BitSet() },
+			storedNames: { writable: true, value: {} },
+			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
+		});
+
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+
+	append(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.outro += content;
+		return this;
+	}
+
+	appendLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.appendLeft(content);
+		} else {
+			this.intro += content;
+		}
+		return this;
+	}
+
+	appendRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.appendRight(content);
+		} else {
+			this.outro += content;
+		}
+		return this;
+	}
+
+	clone() {
+		const cloned = new MagicString(this.original, { filename: this.filename });
+
+		let originalChunk = this.firstChunk;
+		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+
+				clonedChunk = nextClonedChunk;
+			}
+
+			originalChunk = nextOriginalChunk;
+		}
+
+		cloned.lastChunk = clonedChunk;
+
+		if (this.indentExclusionRanges) {
+			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		}
+
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+
+		return cloned;
+	}
+
+	generateDecodedMap(options) {
+		options = options || {};
+
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+
+		const locate = getLocator(this.original);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+
+			if (chunk.edited) {
+				mappings.addEdit(
+					sourceIndex,
+					chunk.content,
+					loc,
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
+				);
+			} else {
+				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			}
+
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap(this.generateDecodedMap(options));
+	}
+
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? '\t' : this.indentStr;
+	}
+
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = undefined;
+		}
+
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
+
+		if (indentStr === '') return this; // noop
+
+		options = options || {};
+
+		// Process exclusion ranges
+		const isExcluded = {};
+
+		if (options.exclude) {
+			const exclusions =
+				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+			exclusions.forEach((exclusion) => {
+				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+					isExcluded[i] = true;
+				}
+			});
+		}
+
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+
+		this.intro = this.intro.replace(pattern, replacer);
+
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+
+		while (chunk) {
+			const end = chunk.end;
+
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+
+					if (chunk.content.length) {
+						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					}
+				}
+			} else {
+				charIndex = chunk.start;
+
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+
+						if (char === '\n') {
+							shouldIndentNextCharacter = true;
+						} else if (char !== '\r' && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+
+							if (charIndex === chunk.start) {
+								chunk.prependRight(indentStr);
+							} else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+
+					charIndex += 1;
+				}
+			}
+
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+
+		this.outro = this.outro.replace(pattern, replacer);
+
+		return this;
+	}
+
+	insert() {
+		throw new Error(
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+		);
+	}
+
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn(
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft(index, content);
+	}
+
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn(
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertRight = true;
+		}
+
+		return this.prependRight(index, content);
+	}
+
+	move(start, end, index) {
+		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+		this._split(start);
+		this._split(end);
+		this._split(index);
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+
+		first.previous = newLeft;
+		last.next = newRight || null;
+
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
+		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (end > this.original.length) throw new Error('end is out of bounds');
+		if (start === end)
+			throw new Error(
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+			);
+
+		this._split(start);
+		this._split(end);
+
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn(
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+				); // eslint-disable-line no-console
+				warned.storeName = true;
+			}
+
+			options = { storeName: true };
+		}
+		const storeName = options !== undefined ? options.storeName : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
+
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true,
+			});
+		}
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) {
+					throw new Error('Cannot overwrite across a split point');
+				}
+				chunk = chunk.next;
+				chunk.edit('', false);
+			}
+
+			first.edit(content, storeName, !overwrite);
+		} else {
+			// must be inserting at the end
+			const newChunk = new Chunk(start, end, '').edit(content, storeName);
+
+			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+
+	prepend(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.intro = content + this.intro;
+		return this;
+	}
+
+	prependLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.prependLeft(content);
+		} else {
+			this.intro = content + this.intro;
+		}
+		return this;
+	}
+
+	prependRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.prependRight(content);
+		} else {
+			this.outro = content + this.outro;
+		}
+		return this;
+	}
+
+	remove(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit('');
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	reset(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while ((chunk = chunk.previous));
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return '';
+	}
+
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while ((chunk = chunk.previous));
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+
+	slice(start = 0, end = this.original.length) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		let result = '';
+
+		// find start chunk
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			// found end chunk before start
+			if (chunk.start < end && chunk.end >= end) {
+				return result;
+			}
+
+			chunk = chunk.next;
+		}
+
+		if (chunk && chunk.edited && chunk.start !== start)
+			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+				result += chunk.intro;
+			}
+
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end)
+				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+			result += chunk.content.slice(sliceStart, sliceEnd);
+
+			if (chunk.outro && (!containsEnd || chunk.end === end)) {
+				result += chunk.outro;
+			}
+
+			if (containsEnd) {
+				break;
+			}
+
+			chunk = chunk.next;
+		}
+
+		return result;
+	}
+
+	// TODO deprecate this? not really very useful
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+
+		return clone;
+	}
+
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+
+		let chunk = this.lastSearchedChunk;
+		const searchForward = index > chunk.end;
+
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+		}
+	}
+
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			// zero-length edited chunks are a special case (overlapping replacements)
+			const loc = getLocator(this.original)(index);
+			throw new Error(
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+			);
+		}
+
+		const newChunk = chunk.split(index);
+
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+
+	toString() {
+		let str = this.intro;
+
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+
+		return str + this.outro;
+	}
+
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do {
+			if (
+				(chunk.intro.length && chunk.intro.trim()) ||
+				(chunk.content.length && chunk.content.trim()) ||
+				(chunk.outro.length && chunk.outro.trim())
+			)
+				return false;
+		} while ((chunk = chunk.next));
+		return true;
+	}
+
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		} while ((chunk = chunk.next));
+		return length;
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		let chunk = this.lastChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+
+			// if chunk was trimmed, we have a new lastChunk
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) {
+					this.lastChunk = chunk.next;
+				}
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		let chunk = this.firstChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+
+			if (chunk.end !== end) {
+				// special case...
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === 'string') {
+				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+					if (i === '$') return '$';
+					if (i === '&') return match[0];
+					const num = +i;
+					if (num < match.length) return match[+i];
+					return `$${i}`;
+				});
+			} else {
+				return replacement(...match, match.index, str, match.groups);
+			}
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while ((match = re.exec(str))) {
+				matches.push(match);
+			}
+			return matches;
+		}
+		if (searchValue.global) {
+			const matches = matchAll(searchValue, this.original);
+			matches.forEach((match) => {
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
+					this.overwrite(
+						match.index,
+						match.index + match[0].length,
+						replacement
+					);
+				}
+			}
+		}
+		return this;
+	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+}
+
+const debug$1 = createDebugger("vite:sourcemap", {
+  onlyWhenFocused: true
+});
+function genSourceMapUrl(map) {
+  if (typeof map !== "string") {
+    map = JSON.stringify(map);
+  }
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getCodeWithSourcemap(type, code, map) {
+  if (debug$1) {
+    code += `
+/*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/
+`;
+  }
+  if (type === "js") {
+    code += `
+//# sourceMappingURL=${genSourceMapUrl(map)}`;
+  } else if (type === "css") {
+    code += `
+/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
+  }
+  return code;
+}
+
+const debug = createDebugger("vite:send", {
+  onlyWhenFocused: true
+});
+const alias = {
+  js: "text/javascript",
+  css: "text/css",
+  html: "text/html",
+  json: "application/json"
+};
+function send(req, res, content, type, options) {
+  const {
+    etag = getEtag(content, { weak: true }),
+    cacheControl = "no-cache",
+    headers,
+    map
+  } = options;
+  if (res.writableEnded) {
+    return;
+  }
+  if (req.headers["if-none-match"] === etag) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  res.setHeader("Content-Type", alias[type] || type);
+  res.setHeader("Cache-Control", cacheControl);
+  res.setHeader("Etag", etag);
+  if (headers) {
+    for (const name in headers) {
+      res.setHeader(name, headers[name]);
+    }
+  }
+  if (map && "version" in map && map.mappings) {
+    if (type === "js" || type === "css") {
+      content = getCodeWithSourcemap(type, content.toString(), map);
+    }
+  } else if (type === "js" && (!map || map.mappings !== "")) {
+    const code = content.toString();
+    if (convertSourceMap.mapFileCommentRegex.test(code)) {
+      debug?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+    } else {
+      const urlWithoutTimestamp = removeTimestampQuery(req.url);
+      const ms = new MagicString(code);
+      content = getCodeWithSourcemap(
+        type,
+        code,
+        ms.generateMap({
+          source: path$3.basename(urlWithoutTimestamp),
+          hires: "boundary",
+          includeContent: true
+        })
+      );
+    }
+  }
+  res.statusCode = 200;
+  res.end(content);
+  return;
+}
+
+const LogLevels = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
+};
+let lastType;
+let lastMsg;
+let sameCount = 0;
+function clearScreen() {
+  const repeatCount = process.stdout.rows - 2;
+  const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+  console.log(blank);
+  readline.cursorTo(process.stdout, 0, 0);
+  readline.clearScreenDown(process.stdout);
+}
+let timeFormatter;
+function getTimeFormatter() {
+  timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  return timeFormatter;
+}
+function createLogger(level = "info", options = {}) {
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const { prefix = "[vite]", allowClearScreen = true } = options;
+  const thresh = LogLevels[level];
+  const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+  const clear = canClearScreen ? clearScreen : () => {
+  };
+  function format(type, msg, options2 = {}) {
+    if (options2.timestamp) {
+      let tag = "";
+      if (type === "info") {
+        tag = colors.cyan(colors.bold(prefix));
+      } else if (type === "warn") {
+        tag = colors.yellow(colors.bold(prefix));
+      } else {
+        tag = colors.red(colors.bold(prefix));
+      }
+      return `${colors.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
+    } else {
+      return msg;
+    }
+  }
+  function output(type, msg, options2 = {}) {
+    if (thresh >= LogLevels[type]) {
+      const method = type === "info" ? "log" : type;
+      if (options2.error) {
+        loggedErrors.add(options2.error);
+      }
+      if (canClearScreen) {
+        if (type === lastType && msg === lastMsg) {
+          sameCount++;
+          clear();
+          console[method](
+            format(type, msg, options2),
+            colors.yellow(`(x${sameCount + 1})`)
+          );
+        } else {
+          sameCount = 0;
+          lastMsg = msg;
+          lastType = type;
+          if (options2.clear) {
+            clear();
+          }
+          console[method](format(type, msg, options2));
+        }
+      } else {
+        console[method](format(type, msg, options2));
+      }
+    }
+  }
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const logger = {
+    hasWarned: false,
+    info(msg, opts) {
+      output("info", msg, opts);
+    },
+    warn(msg, opts) {
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+    },
+    warnOnce(msg, opts) {
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      logger.hasWarned = true;
+      output("error", msg, opts);
+    },
+    clearScreen(type) {
+      if (thresh >= LogLevels[type]) {
+        clear();
+      }
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
+    }
+  };
+  return logger;
+}
+
+const ROOT_FILES = [
+  // '.git',
+  // https://pnpm.io/workspaces/
+  "pnpm-workspace.yaml",
+  // https://rushjs.io/pages/advanced/config_files/
+  // 'rush.json',
+  // https://nx.dev/latest/react/getting-started/nx-setup
+  // 'workspace.json',
+  // 'nx.json',
+  // https://github.com/lerna/lerna#lernajson
+  "lerna.json"
+];
+function hasWorkspacePackageJSON(root) {
+  const path = path$3.join(root, "package.json");
+  if (!isFileReadable(path)) {
+    return false;
+  }
+  try {
+    const content = JSON.parse(fs$1.readFileSync(path, "utf-8")) || {};
+    return !!content.workspaces;
+  } catch {
+    return false;
+  }
+}
+function hasRootFile(root) {
+  return ROOT_FILES.some((file) => fs$1.existsSync(path$3.join(root, file)));
+}
+function hasPackageJSON(root) {
+  const path = path$3.join(root, "package.json");
+  return fs$1.existsSync(path);
+}
+function searchForPackageRoot(current, root = current) {
+  if (hasPackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForPackageRoot(dir, root);
+}
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+  if (hasRootFile(current)) return current;
+  if (hasWorkspacePackageJSON(current)) return current;
+  const dir = path$3.dirname(current);
+  if (!dir || dir === current) return root;
+  return searchForWorkspaceRoot(dir, root);
+}
+
+function isFileServingAllowed(url, server) {
+  if (!server.config.server.fs.strict) return true;
+  const file = fsPathFromUrl(url);
+  if (server._fsDenyGlob(file)) return false;
+  if (server.moduleGraph.safeModulesPath.has(file)) return true;
+  if (server.config.server.fs.allow.some(
+    (uri) => isSameFileUri(uri, file) || isParentDirectory(uri, file)
+  ))
+    return true;
+  return false;
+}
+
+var main$1 = {exports: {}};
+
+var name = "dotenv";
+var version$1 = "16.4.5";
+var description = "Loads environment variables from .env file";
+var main = "lib/main.js";
+var types = "lib/main.d.ts";
+var exports$1 = {
+	".": {
+		types: "./lib/main.d.ts",
+		require: "./lib/main.js",
+		"default": "./lib/main.js"
+	},
+	"./config": "./config.js",
+	"./config.js": "./config.js",
+	"./lib/env-options": "./lib/env-options.js",
+	"./lib/env-options.js": "./lib/env-options.js",
+	"./lib/cli-options": "./lib/cli-options.js",
+	"./lib/cli-options.js": "./lib/cli-options.js",
+	"./package.json": "./package.json"
+};
+var scripts = {
+	"dts-check": "tsc --project tests/types/tsconfig.json",
+	lint: "standard",
+	"lint-readme": "standard-markdown",
+	pretest: "npm run lint && npm run dts-check",
+	test: "tap tests/*.js --100 -Rspec",
+	"test:coverage": "tap --coverage-report=lcov",
+	prerelease: "npm test",
+	release: "standard-version"
+};
+var repository = {
+	type: "git",
+	url: "git://github.com/motdotla/dotenv.git"
+};
+var funding = "https://dotenvx.com";
+var keywords = [
+	"dotenv",
+	"env",
+	".env",
+	"environment",
+	"variables",
+	"config",
+	"settings"
+];
+var readmeFilename = "README.md";
+var license = "BSD-2-Clause";
+var devDependencies = {
+	"@definitelytyped/dtslint": "^0.0.133",
+	"@types/node": "^18.11.3",
+	decache: "^4.6.1",
+	sinon: "^14.0.1",
+	standard: "^17.0.0",
+	"standard-markdown": "^7.1.0",
+	"standard-version": "^9.5.0",
+	tap: "^16.3.0",
+	tar: "^6.1.11",
+	typescript: "^4.8.4"
+};
+var engines = {
+	node: ">=12"
+};
+var browser = {
+	fs: false
+};
+var require$$4 = {
+	name: name,
+	version: version$1,
+	description: description,
+	main: main,
+	types: types,
+	exports: exports$1,
+	scripts: scripts,
+	repository: repository,
+	funding: funding,
+	keywords: keywords,
+	readmeFilename: readmeFilename,
+	license: license,
+	devDependencies: devDependencies,
+	engines: engines,
+	browser: browser
+};
+
+const fs = fs$2;
+const path = require$$0$1;
+const os = require$$2;
+const crypto = require$$0$2;
+const packageJson = require$$4;
+
+const version = packageJson.version;
+
+const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+// Parse src into an Object
+function parse (src) {
+  const obj = {};
+
+  // Convert buffer to string
+  let lines = src.toString();
+
+  // Convert line breaks to same format
+  lines = lines.replace(/\r\n?/mg, '\n');
+
+  let match;
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1];
+
+    // Default undefined or null to empty string
+    let value = (match[2] || '');
+
+    // Remove whitespace
+    value = value.trim();
+
+    // Check if double quoted
+    const maybeQuote = value[0];
+
+    // Remove surrounding quotes
+    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+    // Expand newlines if double quoted
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, '\n');
+      value = value.replace(/\\r/g, '\r');
+    }
+
+    // Add to object
+    obj[key] = value;
+  }
+
+  return obj
+}
+
+function _parseVault (options) {
+  const vaultPath = _vaultPath(options);
+
+  // Parse .env.vault
+  const result = DotenvModule.configDotenv({ path: vaultPath });
+  if (!result.parsed) {
+    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+    err.code = 'MISSING_DATA';
+    throw err
+  }
+
+  // handle scenario for comma separated keys - for use with key rotation
+  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+  const keys = _dotenvKey(options).split(',');
+  const length = keys.length;
+
+  let decrypted;
+  for (let i = 0; i < length; i++) {
+    try {
+      // Get full key
+      const key = keys[i].trim();
+
+      // Get instructions for decrypt
+      const attrs = _instructions(result, key);
+
+      // Decrypt
+      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+
+      break
+    } catch (error) {
+      // last key
+      if (i + 1 >= length) {
+        throw error
+      }
+      // try next key
+    }
+  }
+
+  // Parse decrypted .env string
+  return DotenvModule.parse(decrypted)
+}
+
+function _log (message) {
+  console.log(`[dotenv@${version}][INFO] ${message}`);
+}
+
+function _warn (message) {
+  console.log(`[dotenv@${version}][WARN] ${message}`);
+}
+
+function _debug (message) {
+  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+}
+
+function _dotenvKey (options) {
+  // prioritize developer directly setting options.DOTENV_KEY
+  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+    return options.DOTENV_KEY
+  }
+
+  // secondary infra already contains a DOTENV_KEY environment variable
+  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+    return process.env.DOTENV_KEY
+  }
+
+  // fallback to empty string
+  return ''
+}
+
+function _instructions (result, dotenvKey) {
+  // Parse DOTENV_KEY. Format is a URI
+  let uri;
+  try {
+    uri = new URL(dotenvKey);
+  } catch (error) {
+    if (error.code === 'ERR_INVALID_URL') {
+      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err
+    }
+
+    throw error
+  }
+
+  // Get decrypt key
+  const key = uri.password;
+  if (!key) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+    err.code = 'INVALID_DOTENV_KEY';
+    throw err
+  }
+
+  // Get environment
+  const environment = uri.searchParams.get('environment');
+  if (!environment) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+    err.code = 'INVALID_DOTENV_KEY';
+    throw err
+  }
+
+  // Get ciphertext payload
+  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+  const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+  if (!ciphertext) {
+    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+    throw err
+  }
+
+  return { ciphertext, key }
+}
+
+function _vaultPath (options) {
+  let possibleVaultPath = null;
+
+  if (options && options.path && options.path.length > 0) {
+    if (Array.isArray(options.path)) {
+      for (const filepath of options.path) {
+        if (fs.existsSync(filepath)) {
+          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+        }
+      }
+    } else {
+      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+    }
+  } else {
+    possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
+  }
+
+  if (fs.existsSync(possibleVaultPath)) {
+    return possibleVaultPath
+  }
+
+  return null
+}
+
+function _resolveHome (envPath) {
+  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+}
+
+function _configVault (options) {
+  _log('Loading env from encrypted .env.vault');
+
+  const parsed = DotenvModule._parseVault(options);
+
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  DotenvModule.populate(processEnv, parsed, options);
+
+  return { parsed }
+}
+
+function configDotenv (options) {
+  const dotenvPath = path.resolve(process.cwd(), '.env');
+  let encoding = 'utf8';
+  const debug = Boolean(options && options.debug);
+
+  if (options && options.encoding) {
+    encoding = options.encoding;
+  } else {
+    if (debug) {
+      _debug('No encoding is specified. UTF-8 is used by default');
+    }
+  }
+
+  let optionPaths = [dotenvPath]; // default, look for .env
+  if (options && options.path) {
+    if (!Array.isArray(options.path)) {
+      optionPaths = [_resolveHome(options.path)];
+    } else {
+      optionPaths = []; // reset default
+      for (const filepath of options.path) {
+        optionPaths.push(_resolveHome(filepath));
+      }
+    }
+  }
+
+  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+  let lastError;
+  const parsedAll = {};
+  for (const path of optionPaths) {
+    try {
+      // Specifying an encoding returns a string instead of a buffer
+      const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }));
+
+      DotenvModule.populate(parsedAll, parsed, options);
+    } catch (e) {
+      if (debug) {
+        _debug(`Failed to load ${path} ${e.message}`);
+      }
+      lastError = e;
+    }
+  }
+
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  DotenvModule.populate(processEnv, parsedAll, options);
+
+  if (lastError) {
+    return { parsed: parsedAll, error: lastError }
+  } else {
+    return { parsed: parsedAll }
+  }
+}
+
+// Populates process.env from .env file
+function config (options) {
+  // fallback to original dotenv if DOTENV_KEY is not set
+  if (_dotenvKey(options).length === 0) {
+    return DotenvModule.configDotenv(options)
+  }
+
+  const vaultPath = _vaultPath(options);
+
+  // dotenvKey exists but .env.vault file does not exist
+  if (!vaultPath) {
+    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+
+    return DotenvModule.configDotenv(options)
+  }
+
+  return DotenvModule._configVault(options)
+}
+
+function decrypt (encrypted, keyStr) {
+  const key = Buffer.from(keyStr.slice(-64), 'hex');
+  let ciphertext = Buffer.from(encrypted, 'base64');
+
+  const nonce = ciphertext.subarray(0, 12);
+  const authTag = ciphertext.subarray(-16);
+  ciphertext = ciphertext.subarray(12, -16);
+
+  try {
+    const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+    aesgcm.setAuthTag(authTag);
+    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+  } catch (error) {
+    const isRange = error instanceof RangeError;
+    const invalidKeyLength = error.message === 'Invalid key length';
+    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
+
+    if (isRange || invalidKeyLength) {
+      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err
+    } else if (decryptionFailed) {
+      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
+      err.code = 'DECRYPTION_FAILED';
+      throw err
+    } else {
+      throw error
+    }
+  }
+}
+
+// Populate process.env with parsed values
+function populate (processEnv, parsed, options = {}) {
+  const debug = Boolean(options && options.debug);
+  const override = Boolean(options && options.override);
+
+  if (typeof parsed !== 'object') {
+    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
+    err.code = 'OBJECT_REQUIRED';
+    throw err
+  }
+
+  // Set process.env
+  for (const key of Object.keys(parsed)) {
+    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+      if (override === true) {
+        processEnv[key] = parsed[key];
+      }
+
+      if (debug) {
+        if (override === true) {
+          _debug(`"${key}" is already defined and WAS overwritten`);
+        } else {
+          _debug(`"${key}" is already defined and was NOT overwritten`);
+        }
+      }
+    } else {
+      processEnv[key] = parsed[key];
+    }
+  }
+}
+
+const DotenvModule = {
+  configDotenv,
+  _configVault,
+  _parseVault,
+  config,
+  decrypt,
+  parse,
+  populate
+};
+
+main$1.exports.configDotenv = DotenvModule.configDotenv;
+main$1.exports._configVault = DotenvModule._configVault;
+main$1.exports._parseVault = DotenvModule._parseVault;
+main$1.exports.config = DotenvModule.config;
+main$1.exports.decrypt = DotenvModule.decrypt;
+var parse_1 = main$1.exports.parse = DotenvModule.parse;
+main$1.exports.populate = DotenvModule.populate;
+
+main$1.exports = DotenvModule;
+
+// * /
+// *   (\\)?            # is it escaped with a backslash?
+// *   (\$)             # literal $
+// *   (?!\()           # shouldnt be followed by parenthesis
+// *   (\{?)            # first brace wrap opening
+// *   ([\w.]+)         # key
+// *   (?::-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))? # optional default nested 3 times
+// *   (\}?)            # last brace warp closing
+// * /xi
+
+const DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+
+function _resolveEscapeSequences (value) {
+  return value.replace(/\\\$/g, '$')
+}
+
+function interpolate (value, processEnv, parsed) {
+  return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
+    if (escaped === '\\') {
+      return match.slice(1)
+    } else {
+      if (processEnv[key]) {
+        if (processEnv[key] === parsed[key]) {
+          return processEnv[key]
+        } else {
+          // scenario: PASSWORD_EXPAND_NESTED=${PASSWORD_EXPAND}
+          return interpolate(processEnv[key], processEnv, parsed)
+        }
+      }
+
+      if (parsed[key]) {
+        // avoid recursion from EXPAND_SELF=$EXPAND_SELF
+        if (parsed[key] === value) {
+          return parsed[key]
+        } else {
+          return interpolate(parsed[key], processEnv, parsed)
+        }
+      }
+
+      if (defaultValue) {
+        if (defaultValue.startsWith('$')) {
+          return interpolate(defaultValue, processEnv, parsed)
+        } else {
+          return defaultValue
+        }
+      }
+
+      return ''
+    }
+  })
+}
+
+function expand (options) {
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  for (const key in options.parsed) {
+    let value = options.parsed[key];
+
+    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key);
+    if (inProcessEnv) {
+      if (processEnv[key] === options.parsed[key]) {
+        // assume was set to processEnv from the .env file if the values match and therefore interpolate
+        value = interpolate(value, processEnv, options.parsed);
+      } else {
+        // do not interpolate - assume processEnv had the intended value even if containing a $.
+        value = processEnv[key];
+      }
+    } else {
+      // not inProcessEnv so assume interpolation for this .env key
+      value = interpolate(value, processEnv, options.parsed);
+    }
+
+    options.parsed[key] = _resolveEscapeSequences(value);
+  }
+
+  for (const processKey in options.parsed) {
+    processEnv[processKey] = options.parsed[processKey];
+  }
+
+  return options
+}
+
+var expand_1 = expand;
+
+function getEnvFilesForMode(mode, envDir) {
+  return [
+    /** default file */
+    `.env`,
+    /** local file */
+    `.env.local`,
+    /** mode file */
+    `.env.${mode}`,
+    /** mode local file */
+    `.env.${mode}.local`
+  ].map((file) => normalizePath(path$3.join(envDir, file)));
+}
+function loadEnv(mode, envDir, prefixes = "VITE_") {
+  if (mode === "local") {
+    throw new Error(
+      `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
+    );
+  }
+  prefixes = arraify(prefixes);
+  const env = {};
+  const envFiles = getEnvFilesForMode(mode, envDir);
+  const parsed = Object.fromEntries(
+    envFiles.flatMap((filePath) => {
+      if (!tryStatSync(filePath)?.isFile()) return [];
+      return Object.entries(parse_1(fs$1.readFileSync(filePath)));
+    })
+  );
+  if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
+    process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
+  }
+  if (parsed.BROWSER && process.env.BROWSER === void 0) {
+    process.env.BROWSER = parsed.BROWSER;
+  }
+  if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) {
+    process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
+  }
+  const processEnv = { ...process.env };
+  expand_1({ parsed, processEnv });
+  for (const [key, value] of Object.entries(parsed)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = value;
+    }
+  }
+  for (const key in process.env) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = process.env[key];
+    }
+  }
+  return env;
+}
+function resolveEnvPrefix({
+  envPrefix = "VITE_"
+}) {
+  envPrefix = arraify(envPrefix);
+  if (envPrefix.includes("")) {
+    throw new Error(
+      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
+    );
+  }
+  return envPrefix;
+}
+
+exports.esbuildVersion = esbuild.version;
+exports.createFilter = createFilter;
+exports.createLogger = createLogger;
+exports.isCSSRequest = isCSSRequest;
+exports.isFileServingAllowed = isFileServingAllowed;
+exports.loadEnv = loadEnv;
+exports.mergeAlias = mergeAlias;
+exports.mergeConfig = mergeConfig;
+exports.normalizePath = normalizePath;
+exports.resolveEnvPrefix = resolveEnvPrefix;
+exports.rollupVersion = rollupVersion;
+exports.searchForWorkspaceRoot = searchForWorkspaceRoot;
+exports.send = send;
+exports.splitVendorChunk = splitVendorChunk;
+exports.splitVendorChunkPlugin = splitVendorChunkPlugin;
+exports.version = VERSION;
diff --git a/node_modules/vite/dist/node/chunks/dep-B7_zXWZq.js b/node_modules/vite/dist/node/chunks/dep-B7_zXWZq.js
new file mode 100644
index 0000000..84c7e79
--- /dev/null
+++ b/node_modules/vite/dist/node/chunks/dep-B7_zXWZq.js
@@ -0,0 +1,993 @@
+import { B as getDefaultExportFromCjs } from './dep-CDnG8rE7.js';
+import require$$0 from 'path';
+import require$$0__default from 'fs';
+import { l as lib } from './dep-IQS-Za7F.js';
+
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    var e = m[i];
+    if (typeof e !== 'string' && !Array.isArray(e)) { for (var k in e) {
+      if (k !== 'default' && !(k in n)) {
+        n[k] = e[k];
+      }
+    } }
+  }
+  return n;
+}
+
+var formatImportPrelude$2 = function formatImportPrelude(layer, media, supports) {
+  const parts = [];
+
+  if (typeof layer !== "undefined") {
+    let layerParams = "layer";
+    if (layer) {
+      layerParams = `layer(${layer})`;
+    }
+
+    parts.push(layerParams);
+  }
+
+  if (typeof supports !== "undefined") {
+    parts.push(`supports(${supports})`);
+  }
+
+  if (typeof media !== "undefined") {
+    parts.push(media);
+  }
+
+  return parts.join(" ")
+};
+
+const formatImportPrelude$1 = formatImportPrelude$2;
+
+// Base64 encode an import with conditions
+// The order of conditions is important and is interleaved with cascade layer declarations
+// Each group of conditions and cascade layers needs to be interpreted in order
+// To achieve this we create a list of base64 encoded imports, where each import contains a stylesheet with another import.
+// Each import can define a single group of conditions and a single cascade layer.
+var base64EncodedImport = function base64EncodedConditionalImport(prelude, conditions) {
+  conditions.reverse();
+  const first = conditions.pop();
+  let params = `${prelude} ${formatImportPrelude$1(
+    first.layer,
+    first.media,
+    first.supports,
+  )}`;
+
+  for (const condition of conditions) {
+    params = `'data:text/css;base64,${Buffer.from(`@import ${params}`).toString(
+      "base64",
+    )}' ${formatImportPrelude$1(
+      condition.layer,
+      condition.media,
+      condition.supports,
+    )}`;
+  }
+
+  return params
+};
+
+const base64EncodedConditionalImport = base64EncodedImport;
+
+var applyConditions$1 = function applyConditions(bundle, atRule) {
+  bundle.forEach(stmt => {
+    if (
+      stmt.type === "charset" ||
+      stmt.type === "warning" ||
+      !stmt.conditions?.length
+    ) {
+      return
+    }
+
+    if (stmt.type === "import") {
+      stmt.node.params = base64EncodedConditionalImport(
+        stmt.fullUri,
+        stmt.conditions,
+      );
+      return
+    }
+
+    const { nodes } = stmt;
+    const { parent } = nodes[0];
+
+    const atRules = [];
+
+    // Convert conditions to at-rules
+    for (const condition of stmt.conditions) {
+      if (typeof condition.media !== "undefined") {
+        const mediaNode = atRule({
+          name: "media",
+          params: condition.media,
+          source: parent.source,
+        });
+
+        atRules.push(mediaNode);
+      }
+
+      if (typeof condition.supports !== "undefined") {
+        const supportsNode = atRule({
+          name: "supports",
+          params: `(${condition.supports})`,
+          source: parent.source,
+        });
+
+        atRules.push(supportsNode);
+      }
+
+      if (typeof condition.layer !== "undefined") {
+        const layerNode = atRule({
+          name: "layer",
+          params: condition.layer,
+          source: parent.source,
+        });
+
+        atRules.push(layerNode);
+      }
+    }
+
+    // Add nodes to AST
+    const outerAtRule = atRules.shift();
+    const innerAtRule = atRules.reduce((previous, next) => {
+      previous.append(next);
+      return next
+    }, outerAtRule);
+
+    parent.insertBefore(nodes[0], outerAtRule);
+
+    // remove nodes
+    nodes.forEach(node => {
+      node.parent = undefined;
+    });
+
+    // better output
+    nodes[0].raws.before = nodes[0].raws.before || "\n";
+
+    // wrap new rules with media query and/or layer at rule
+    innerAtRule.append(nodes);
+
+    stmt.type = "nodes";
+    stmt.nodes = [outerAtRule];
+    delete stmt.node;
+  });
+};
+
+var applyRaws$1 = function applyRaws(bundle) {
+  bundle.forEach((stmt, index) => {
+    if (index === 0) return
+
+    if (stmt.parent) {
+      const { before } = stmt.parent.node.raws;
+      if (stmt.type === "nodes") stmt.nodes[0].raws.before = before;
+      else stmt.node.raws.before = before;
+    } else if (stmt.type === "nodes") {
+      stmt.nodes[0].raws.before = stmt.nodes[0].raws.before || "\n";
+    }
+  });
+};
+
+var applyStyles$1 = function applyStyles(bundle, styles) {
+  styles.nodes = [];
+
+  // Strip additional statements.
+  bundle.forEach(stmt => {
+    if (["charset", "import"].includes(stmt.type)) {
+      stmt.node.parent = undefined;
+      styles.append(stmt.node);
+    } else if (stmt.type === "nodes") {
+      stmt.nodes.forEach(node => {
+        node.parent = undefined;
+        styles.append(node);
+      });
+    }
+  });
+};
+
+var readCache$1 = {exports: {}};
+
+var pify$2 = {exports: {}};
+
+var processFn = function (fn, P, opts) {
+	return function () {
+		var that = this;
+		var args = new Array(arguments.length);
+
+		for (var i = 0; i < arguments.length; i++) {
+			args[i] = arguments[i];
+		}
+
+		return new P(function (resolve, reject) {
+			args.push(function (err, result) {
+				if (err) {
+					reject(err);
+				} else if (opts.multiArgs) {
+					var results = new Array(arguments.length - 1);
+
+					for (var i = 1; i < arguments.length; i++) {
+						results[i - 1] = arguments[i];
+					}
+
+					resolve(results);
+				} else {
+					resolve(result);
+				}
+			});
+
+			fn.apply(that, args);
+		});
+	};
+};
+
+var pify$1 = pify$2.exports = function (obj, P, opts) {
+	if (typeof P !== 'function') {
+		opts = P;
+		P = Promise;
+	}
+
+	opts = opts || {};
+	opts.exclude = opts.exclude || [/.+Sync$/];
+
+	var filter = function (key) {
+		var match = function (pattern) {
+			return typeof pattern === 'string' ? key === pattern : pattern.test(key);
+		};
+
+		return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
+	};
+
+	var ret = typeof obj === 'function' ? function () {
+		if (opts.excludeMain) {
+			return obj.apply(this, arguments);
+		}
+
+		return processFn(obj, P, opts).apply(this, arguments);
+	} : {};
+
+	return Object.keys(obj).reduce(function (ret, key) {
+		var x = obj[key];
+
+		ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x;
+
+		return ret;
+	}, ret);
+};
+
+pify$1.all = pify$1;
+
+var pifyExports = pify$2.exports;
+
+var fs = require$$0__default;
+var path$3 = require$$0;
+var pify = pifyExports;
+
+var stat = pify(fs.stat);
+var readFile = pify(fs.readFile);
+var resolve = path$3.resolve;
+
+var cache = Object.create(null);
+
+function convert(content, encoding) {
+	if (Buffer.isEncoding(encoding)) {
+		return content.toString(encoding);
+	}
+	return content;
+}
+
+readCache$1.exports = function (path, encoding) {
+	path = resolve(path);
+
+	return stat(path).then(function (stats) {
+		var item = cache[path];
+
+		if (item && item.mtime.getTime() === stats.mtime.getTime()) {
+			return convert(item.content, encoding);
+		}
+
+		return readFile(path).then(function (data) {
+			cache[path] = {
+				mtime: stats.mtime,
+				content: data
+			};
+
+			return convert(data, encoding);
+		});
+	}).catch(function (err) {
+		cache[path] = null;
+		return Promise.reject(err);
+	});
+};
+
+readCache$1.exports.sync = function (path, encoding) {
+	path = resolve(path);
+
+	try {
+		var stats = fs.statSync(path);
+		var item = cache[path];
+
+		if (item && item.mtime.getTime() === stats.mtime.getTime()) {
+			return convert(item.content, encoding);
+		}
+
+		var data = fs.readFileSync(path);
+
+		cache[path] = {
+			mtime: stats.mtime,
+			content: data
+		};
+
+		return convert(data, encoding);
+	} catch (err) {
+		cache[path] = null;
+		throw err;
+	}
+
+};
+
+readCache$1.exports.get = function (path, encoding) {
+	path = resolve(path);
+	if (cache[path]) {
+		return convert(cache[path].content, encoding);
+	}
+	return null;
+};
+
+readCache$1.exports.clear = function () {
+	cache = Object.create(null);
+};
+
+var readCacheExports = readCache$1.exports;
+
+const anyDataURLRegexp = /^data:text\/css(?:;(base64|plain))?,/i;
+const base64DataURLRegexp = /^data:text\/css;base64,/i;
+const plainDataURLRegexp = /^data:text\/css;plain,/i;
+
+function isValid(url) {
+  return anyDataURLRegexp.test(url)
+}
+
+function contents(url) {
+  if (base64DataURLRegexp.test(url)) {
+    // "data:text/css;base64,".length === 21
+    return Buffer.from(url.slice(21), "base64").toString()
+  }
+
+  if (plainDataURLRegexp.test(url)) {
+    // "data:text/css;plain,".length === 20
+    return decodeURIComponent(url.slice(20))
+  }
+
+  // "data:text/css,".length === 14
+  return decodeURIComponent(url.slice(14))
+}
+
+var dataUrl = {
+  isValid,
+  contents,
+};
+
+const readCache = readCacheExports;
+const dataURL$1 = dataUrl;
+
+var loadContent$1 = function loadContent(filename) {
+  if (dataURL$1.isValid(filename)) {
+    return dataURL$1.contents(filename)
+  }
+
+  return readCache(filename, "utf-8")
+};
+
+// external tooling
+const valueParser = lib;
+
+// extended tooling
+const { stringify } = valueParser;
+
+var parseStatements$1 = function parseStatements(result, styles, conditions, from) {
+  const statements = [];
+  let nodes = [];
+
+  styles.each(node => {
+    let stmt;
+    if (node.type === "atrule") {
+      if (node.name === "import")
+        stmt = parseImport(result, node, conditions, from);
+      else if (node.name === "charset")
+        stmt = parseCharset(result, node, conditions, from);
+    }
+
+    if (stmt) {
+      if (nodes.length) {
+        statements.push({
+          type: "nodes",
+          nodes,
+          conditions: [...conditions],
+          from,
+        });
+        nodes = [];
+      }
+      statements.push(stmt);
+    } else nodes.push(node);
+  });
+
+  if (nodes.length) {
+    statements.push({
+      type: "nodes",
+      nodes,
+      conditions: [...conditions],
+      from,
+    });
+  }
+
+  return statements
+};
+
+function parseCharset(result, atRule, conditions, from) {
+  if (atRule.prev()) {
+    return result.warn("@charset must precede all other statements", {
+      node: atRule,
+    })
+  }
+  return {
+    type: "charset",
+    node: atRule,
+    conditions: [...conditions],
+    from,
+  }
+}
+
+function parseImport(result, atRule, conditions, from) {
+  let prev = atRule.prev();
+
+  // `@import` statements may follow other `@import` statements.
+  if (prev) {
+    do {
+      if (
+        prev.type === "comment" ||
+        (prev.type === "atrule" && prev.name === "import")
+      ) {
+        prev = prev.prev();
+        continue
+      }
+
+      break
+    } while (prev)
+  }
+
+  // All `@import` statements may be preceded by `@charset` or `@layer` statements.
+  // But the `@import` statements must be consecutive.
+  if (prev) {
+    do {
+      if (
+        prev.type === "comment" ||
+        (prev.type === "atrule" &&
+          (prev.name === "charset" || (prev.name === "layer" && !prev.nodes)))
+      ) {
+        prev = prev.prev();
+        continue
+      }
+
+      return result.warn(
+        "@import must precede all other statements (besides @charset or empty @layer)",
+        { node: atRule },
+      )
+    } while (prev)
+  }
+
+  if (atRule.nodes) {
+    return result.warn(
+      "It looks like you didn't end your @import statement correctly. " +
+        "Child nodes are attached to it.",
+      { node: atRule },
+    )
+  }
+
+  const params = valueParser(atRule.params).nodes;
+  const stmt = {
+    type: "import",
+    uri: "",
+    fullUri: "",
+    node: atRule,
+    conditions: [...conditions],
+    from,
+  };
+
+  let layer;
+  let media;
+  let supports;
+
+  for (let i = 0; i < params.length; i++) {
+    const node = params[i];
+
+    if (node.type === "space" || node.type === "comment") continue
+
+    if (node.type === "string") {
+      if (stmt.uri) {
+        return result.warn(`Multiple url's in '${atRule.toString()}'`, {
+          node: atRule,
+        })
+      }
+
+      if (!node.value) {
+        return result.warn(`Unable to find uri in '${atRule.toString()}'`, {
+          node: atRule,
+        })
+      }
+
+      stmt.uri = node.value;
+      stmt.fullUri = stringify(node);
+      continue
+    }
+
+    if (node.type === "function" && /^url$/i.test(node.value)) {
+      if (stmt.uri) {
+        return result.warn(`Multiple url's in '${atRule.toString()}'`, {
+          node: atRule,
+        })
+      }
+
+      if (!node.nodes?.[0]?.value) {
+        return result.warn(`Unable to find uri in '${atRule.toString()}'`, {
+          node: atRule,
+        })
+      }
+
+      stmt.uri = node.nodes[0].value;
+      stmt.fullUri = stringify(node);
+      continue
+    }
+
+    if (!stmt.uri) {
+      return result.warn(`Unable to find uri in '${atRule.toString()}'`, {
+        node: atRule,
+      })
+    }
+
+    if (
+      (node.type === "word" || node.type === "function") &&
+      /^layer$/i.test(node.value)
+    ) {
+      if (typeof layer !== "undefined") {
+        return result.warn(`Multiple layers in '${atRule.toString()}'`, {
+          node: atRule,
+        })
+      }
+
+      if (typeof supports !== "undefined") {
+        return result.warn(
+          `layers must be defined before support conditions in '${atRule.toString()}'`,
+          {
+            node: atRule,
+          },
+        )
+      }
+
+      if (node.nodes) {
+        layer = stringify(node.nodes);
+      } else {
+        layer = "";
+      }
+
+      continue
+    }
+
+    if (node.type === "function" && /^supports$/i.test(node.value)) {
+      if (typeof supports !== "undefined") {
+        return result.warn(
+          `Multiple support conditions in '${atRule.toString()}'`,
+          {
+            node: atRule,
+          },
+        )
+      }
+
+      supports = stringify(node.nodes);
+
+      continue
+    }
+
+    media = stringify(params.slice(i));
+    break
+  }
+
+  if (!stmt.uri) {
+    return result.warn(`Unable to find uri in '${atRule.toString()}'`, {
+      node: atRule,
+    })
+  }
+
+  if (
+    typeof media !== "undefined" ||
+    typeof layer !== "undefined" ||
+    typeof supports !== "undefined"
+  ) {
+    stmt.conditions.push({
+      layer,
+      media,
+      supports,
+    });
+  }
+
+  return stmt
+}
+
+// builtin tooling
+const path$2 = require$$0;
+
+// placeholder tooling
+let sugarss;
+
+var processContent$1 = function processContent(
+  result,
+  content,
+  filename,
+  options,
+  postcss,
+) {
+  const { plugins } = options;
+  const ext = path$2.extname(filename);
+
+  const parserList = [];
+
+  // SugarSS support:
+  if (ext === ".sss") {
+    if (!sugarss) {
+      /* c8 ignore next 3 */
+      try {
+        sugarss = __require('sugarss');
+      } catch {} // Ignore
+    }
+    if (sugarss)
+      return runPostcss(postcss, content, filename, plugins, [sugarss])
+  }
+
+  // Syntax support:
+  if (result.opts.syntax?.parse) {
+    parserList.push(result.opts.syntax.parse);
+  }
+
+  // Parser support:
+  if (result.opts.parser) parserList.push(result.opts.parser);
+  // Try the default as a last resort:
+  parserList.push(null);
+
+  return runPostcss(postcss, content, filename, plugins, parserList)
+};
+
+function runPostcss(postcss, content, filename, plugins, parsers, index) {
+  if (!index) index = 0;
+  return postcss(plugins)
+    .process(content, {
+      from: filename,
+      parser: parsers[index],
+    })
+    .catch(err => {
+      // If there's an error, try the next parser
+      index++;
+      // If there are no parsers left, throw it
+      if (index === parsers.length) throw err
+      return runPostcss(postcss, content, filename, plugins, parsers, index)
+    })
+}
+
+const path$1 = require$$0;
+
+const dataURL = dataUrl;
+const parseStatements = parseStatements$1;
+const processContent = processContent$1;
+const resolveId$1 = (id) => id;
+const formatImportPrelude = formatImportPrelude$2;
+
+async function parseStyles$1(
+  result,
+  styles,
+  options,
+  state,
+  conditions,
+  from,
+  postcss,
+) {
+  const statements = parseStatements(result, styles, conditions, from);
+
+  for (const stmt of statements) {
+    if (stmt.type !== "import" || !isProcessableURL(stmt.uri)) {
+      continue
+    }
+
+    if (options.filter && !options.filter(stmt.uri)) {
+      // rejected by filter
+      continue
+    }
+
+    await resolveImportId(result, stmt, options, state, postcss);
+  }
+
+  let charset;
+  const imports = [];
+  const bundle = [];
+
+  function handleCharset(stmt) {
+    if (!charset) charset = stmt;
+    // charsets aren't case-sensitive, so convert to lower case to compare
+    else if (
+      stmt.node.params.toLowerCase() !== charset.node.params.toLowerCase()
+    ) {
+      throw stmt.node.error(
+        `Incompatible @charset statements:
+  ${stmt.node.params} specified in ${stmt.node.source.input.file}
+  ${charset.node.params} specified in ${charset.node.source.input.file}`,
+      )
+    }
+  }
+
+  // squash statements and their children
+  statements.forEach(stmt => {
+    if (stmt.type === "charset") handleCharset(stmt);
+    else if (stmt.type === "import") {
+      if (stmt.children) {
+        stmt.children.forEach((child, index) => {
+          if (child.type === "import") imports.push(child);
+          else if (child.type === "charset") handleCharset(child);
+          else bundle.push(child);
+          // For better output
+          if (index === 0) child.parent = stmt;
+        });
+      } else imports.push(stmt);
+    } else if (stmt.type === "nodes") {
+      bundle.push(stmt);
+    }
+  });
+
+  return charset ? [charset, ...imports.concat(bundle)] : imports.concat(bundle)
+}
+
+async function resolveImportId(result, stmt, options, state, postcss) {
+  if (dataURL.isValid(stmt.uri)) {
+    // eslint-disable-next-line require-atomic-updates
+    stmt.children = await loadImportContent(
+      result,
+      stmt,
+      stmt.uri,
+      options,
+      state,
+      postcss,
+    );
+
+    return
+  } else if (dataURL.isValid(stmt.from.slice(-1))) {
+    // Data urls can't be used as a base url to resolve imports.
+    throw stmt.node.error(
+      `Unable to import '${stmt.uri}' from a stylesheet that is embedded in a data url`,
+    )
+  }
+
+  const atRule = stmt.node;
+  let sourceFile;
+  if (atRule.source?.input?.file) {
+    sourceFile = atRule.source.input.file;
+  }
+  const base = sourceFile
+    ? path$1.dirname(atRule.source.input.file)
+    : options.root;
+
+  const paths = [await options.resolve(stmt.uri, base, options, atRule)].flat();
+
+  // Ensure that each path is absolute:
+  const resolved = await Promise.all(
+    paths.map(file => {
+      return !path$1.isAbsolute(file)
+        ? resolveId$1(file)
+        : file
+    }),
+  );
+
+  // Add dependency messages:
+  resolved.forEach(file => {
+    result.messages.push({
+      type: "dependency",
+      plugin: "postcss-import",
+      file,
+      parent: sourceFile,
+    });
+  });
+
+  const importedContent = await Promise.all(
+    resolved.map(file => {
+      return loadImportContent(result, stmt, file, options, state, postcss)
+    }),
+  );
+
+  // Merge loaded statements
+  // eslint-disable-next-line require-atomic-updates
+  stmt.children = importedContent.flat().filter(x => !!x);
+}
+
+async function loadImportContent(
+  result,
+  stmt,
+  filename,
+  options,
+  state,
+  postcss,
+) {
+  const atRule = stmt.node;
+  const { conditions, from } = stmt;
+  const stmtDuplicateCheckKey = conditions
+    .map(condition =>
+      formatImportPrelude(condition.layer, condition.media, condition.supports),
+    )
+    .join(":");
+
+  if (options.skipDuplicates) {
+    // skip files already imported at the same scope
+    if (state.importedFiles[filename]?.[stmtDuplicateCheckKey]) {
+      return
+    }
+
+    // save imported files to skip them next time
+    if (!state.importedFiles[filename]) {
+      state.importedFiles[filename] = {};
+    }
+    state.importedFiles[filename][stmtDuplicateCheckKey] = true;
+  }
+
+  if (from.includes(filename)) {
+    return
+  }
+
+  const content = await options.load(filename, options);
+
+  if (content.trim() === "" && options.warnOnEmpty) {
+    result.warn(`${filename} is empty`, { node: atRule });
+    return
+  }
+
+  // skip previous imported files not containing @import rules
+  if (
+    options.skipDuplicates &&
+    state.hashFiles[content]?.[stmtDuplicateCheckKey]
+  ) {
+    return
+  }
+
+  const importedResult = await processContent(
+    result,
+    content,
+    filename,
+    options,
+    postcss,
+  );
+
+  const styles = importedResult.root;
+  result.messages = result.messages.concat(importedResult.messages);
+
+  if (options.skipDuplicates) {
+    const hasImport = styles.some(child => {
+      return child.type === "atrule" && child.name === "import"
+    });
+    if (!hasImport) {
+      // save hash files to skip them next time
+      if (!state.hashFiles[content]) {
+        state.hashFiles[content] = {};
+      }
+
+      state.hashFiles[content][stmtDuplicateCheckKey] = true;
+    }
+  }
+
+  // recursion: import @import from imported file
+  return parseStyles$1(
+    result,
+    styles,
+    options,
+    state,
+    conditions,
+    [...from, filename],
+    postcss,
+  )
+}
+
+function isProcessableURL(uri) {
+  // skip protocol base uri (protocol://url) or protocol-relative
+  if (/^(?:[a-z]+:)?\/\//i.test(uri)) {
+    return false
+  }
+
+  // check for fragment or query
+  try {
+    // needs a base to parse properly
+    const url = new URL(uri, "https://example.com");
+    if (url.search) {
+      return false
+    }
+  } catch {} // Ignore
+
+  return true
+}
+
+var parseStyles_1 = parseStyles$1;
+
+// builtin tooling
+const path = require$$0;
+
+// internal tooling
+const applyConditions = applyConditions$1;
+const applyRaws = applyRaws$1;
+const applyStyles = applyStyles$1;
+const loadContent = loadContent$1;
+const parseStyles = parseStyles_1;
+const resolveId = (id) => id;
+
+function AtImport(options) {
+  options = {
+    root: process.cwd(),
+    path: [],
+    skipDuplicates: true,
+    resolve: resolveId,
+    load: loadContent,
+    plugins: [],
+    addModulesDirectories: [],
+    warnOnEmpty: true,
+    ...options,
+  };
+
+  options.root = path.resolve(options.root);
+
+  // convert string to an array of a single element
+  if (typeof options.path === "string") options.path = [options.path];
+
+  if (!Array.isArray(options.path)) options.path = [];
+
+  options.path = options.path.map(p => path.resolve(options.root, p));
+
+  return {
+    postcssPlugin: "postcss-import",
+    async Once(styles, { result, atRule, postcss }) {
+      const state = {
+        importedFiles: {},
+        hashFiles: {},
+      };
+
+      if (styles.source?.input?.file) {
+        state.importedFiles[styles.source.input.file] = {};
+      }
+
+      if (options.plugins && !Array.isArray(options.plugins)) {
+        throw new Error("plugins option must be an array")
+      }
+
+      const bundle = await parseStyles(
+        result,
+        styles,
+        options,
+        state,
+        [],
+        [],
+        postcss,
+      );
+
+      applyRaws(bundle);
+      applyConditions(bundle, atRule);
+      applyStyles(bundle, styles);
+    },
+  }
+}
+
+AtImport.postcss = true;
+
+var postcssImport = AtImport;
+
+var index = /*@__PURE__*/getDefaultExportFromCjs(postcssImport);
+
+var index$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [postcssImport]);
+
+export { index$1 as i };
diff --git a/node_modules/vite/dist/node/chunks/dep-BaJt-LTH.js b/node_modules/vite/dist/node/chunks/dep-BaJt-LTH.js
new file mode 100644
index 0000000..a933b0a
--- /dev/null
+++ b/node_modules/vite/dist/node/chunks/dep-BaJt-LTH.js
@@ -0,0 +1,6843 @@
+import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-CDnG8rE7.js';
+import require$$0__default from 'fs';
+import require$$0 from 'postcss';
+import require$$0$1 from 'path';
+import require$$3 from 'crypto';
+import require$$0$2 from 'util';
+import { l as lib } from './dep-IQS-Za7F.js';
+
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    var e = m[i];
+    if (typeof e !== 'string' && !Array.isArray(e)) { for (var k in e) {
+      if (k !== 'default' && !(k in n)) {
+        n[k] = e[k];
+      }
+    } }
+  }
+  return n;
+}
+
+var build = {exports: {}};
+
+var fs = {};
+
+Object.defineProperty(fs, "__esModule", {
+  value: true
+});
+fs.getFileSystem = getFileSystem;
+fs.setFileSystem = setFileSystem;
+let fileSystem = {
+  readFile: () => {
+    throw Error("readFile not implemented");
+  },
+  writeFile: () => {
+    throw Error("writeFile not implemented");
+  }
+};
+
+function setFileSystem(fs) {
+  fileSystem.readFile = fs.readFile;
+  fileSystem.writeFile = fs.writeFile;
+}
+
+function getFileSystem() {
+  return fileSystem;
+}
+
+var pluginFactory = {};
+
+var unquote$1 = {};
+
+Object.defineProperty(unquote$1, "__esModule", {
+  value: true
+});
+unquote$1.default = unquote;
+// copied from https://github.com/lakenen/node-unquote
+const reg = /['"]/;
+
+function unquote(str) {
+  if (!str) {
+    return "";
+  }
+
+  if (reg.test(str.charAt(0))) {
+    str = str.substr(1);
+  }
+
+  if (reg.test(str.charAt(str.length - 1))) {
+    str = str.substr(0, str.length - 1);
+  }
+
+  return str;
+}
+
+var Parser$1 = {};
+
+const matchValueName = /[$]?[\w-]+/g;
+
+const replaceValueSymbols$2 = (value, replacements) => {
+  let matches;
+
+  while ((matches = matchValueName.exec(value))) {
+    const replacement = replacements[matches[0]];
+
+    if (replacement) {
+      value =
+        value.slice(0, matches.index) +
+        replacement +
+        value.slice(matchValueName.lastIndex);
+
+      matchValueName.lastIndex -= matches[0].length - replacement.length;
+    }
+  }
+
+  return value;
+};
+
+var replaceValueSymbols_1 = replaceValueSymbols$2;
+
+const replaceValueSymbols$1 = replaceValueSymbols_1;
+
+const replaceSymbols$1 = (css, replacements) => {
+  css.walk((node) => {
+    if (node.type === "decl" && node.value) {
+      node.value = replaceValueSymbols$1(node.value.toString(), replacements);
+    } else if (node.type === "rule" && node.selector) {
+      node.selector = replaceValueSymbols$1(
+        node.selector.toString(),
+        replacements
+      );
+    } else if (node.type === "atrule" && node.params) {
+      node.params = replaceValueSymbols$1(node.params.toString(), replacements);
+    }
+  });
+};
+
+var replaceSymbols_1 = replaceSymbols$1;
+
+const importPattern = /^:import\(("[^"]*"|'[^']*'|[^"']+)\)$/;
+const balancedQuotes = /^("[^"]*"|'[^']*'|[^"']+)$/;
+
+const getDeclsObject = (rule) => {
+  const object = {};
+
+  rule.walkDecls((decl) => {
+    const before = decl.raws.before ? decl.raws.before.trim() : "";
+
+    object[before + decl.prop] = decl.value;
+  });
+
+  return object;
+};
+/**
+ *
+ * @param {string} css
+ * @param {boolean} removeRules
+ * @param {'auto' | 'rule' | 'at-rule'} mode
+ */
+const extractICSS$2 = (css, removeRules = true, mode = "auto") => {
+  const icssImports = {};
+  const icssExports = {};
+
+  function addImports(node, path) {
+    const unquoted = path.replace(/'|"/g, "");
+    icssImports[unquoted] = Object.assign(
+      icssImports[unquoted] || {},
+      getDeclsObject(node)
+    );
+
+    if (removeRules) {
+      node.remove();
+    }
+  }
+
+  function addExports(node) {
+    Object.assign(icssExports, getDeclsObject(node));
+    if (removeRules) {
+      node.remove();
+    }
+  }
+
+  css.each((node) => {
+    if (node.type === "rule" && mode !== "at-rule") {
+      if (node.selector.slice(0, 7) === ":import") {
+        const matches = importPattern.exec(node.selector);
+
+        if (matches) {
+          addImports(node, matches[1]);
+        }
+      }
+
+      if (node.selector === ":export") {
+        addExports(node);
+      }
+    }
+
+    if (node.type === "atrule" && mode !== "rule") {
+      if (node.name === "icss-import") {
+        const matches = balancedQuotes.exec(node.params);
+
+        if (matches) {
+          addImports(node, matches[1]);
+        }
+      }
+      if (node.name === "icss-export") {
+        addExports(node);
+      }
+    }
+  });
+
+  return { icssImports, icssExports };
+};
+
+var extractICSS_1 = extractICSS$2;
+
+const createImports = (imports, postcss, mode = "rule") => {
+  return Object.keys(imports).map((path) => {
+    const aliases = imports[path];
+    const declarations = Object.keys(aliases).map((key) =>
+      postcss.decl({
+        prop: key,
+        value: aliases[key],
+        raws: { before: "\n  " },
+      })
+    );
+
+    const hasDeclarations = declarations.length > 0;
+
+    const rule =
+      mode === "rule"
+        ? postcss.rule({
+            selector: `:import('${path}')`,
+            raws: { after: hasDeclarations ? "\n" : "" },
+          })
+        : postcss.atRule({
+            name: "icss-import",
+            params: `'${path}'`,
+            raws: { after: hasDeclarations ? "\n" : "" },
+          });
+
+    if (hasDeclarations) {
+      rule.append(declarations);
+    }
+
+    return rule;
+  });
+};
+
+const createExports = (exports, postcss, mode = "rule") => {
+  const declarations = Object.keys(exports).map((key) =>
+    postcss.decl({
+      prop: key,
+      value: exports[key],
+      raws: { before: "\n  " },
+    })
+  );
+
+  if (declarations.length === 0) {
+    return [];
+  }
+  const rule =
+    mode === "rule"
+      ? postcss.rule({
+          selector: `:export`,
+          raws: { after: "\n" },
+        })
+      : postcss.atRule({
+          name: "icss-export",
+          raws: { after: "\n" },
+        });
+
+  rule.append(declarations);
+
+  return [rule];
+};
+
+const createICSSRules$1 = (imports, exports, postcss, mode) => [
+  ...createImports(imports, postcss, mode),
+  ...createExports(exports, postcss, mode),
+];
+
+var createICSSRules_1 = createICSSRules$1;
+
+const replaceValueSymbols = replaceValueSymbols_1;
+const replaceSymbols = replaceSymbols_1;
+const extractICSS$1 = extractICSS_1;
+const createICSSRules = createICSSRules_1;
+
+var src$4 = {
+  replaceValueSymbols,
+  replaceSymbols,
+  extractICSS: extractICSS$1,
+  createICSSRules,
+};
+
+Object.defineProperty(Parser$1, "__esModule", {
+  value: true
+});
+Parser$1.default = void 0;
+
+var _icssUtils = src$4;
+
+// Initially copied from https://github.com/css-modules/css-modules-loader-core
+const importRegexp = /^:import\((.+)\)$/;
+
+class Parser {
+  constructor(pathFetcher, trace) {
+    this.pathFetcher = pathFetcher;
+    this.plugin = this.plugin.bind(this);
+    this.exportTokens = {};
+    this.translations = {};
+    this.trace = trace;
+  }
+
+  plugin() {
+    const parser = this;
+    return {
+      postcssPlugin: "css-modules-parser",
+
+      async OnceExit(css) {
+        await Promise.all(parser.fetchAllImports(css));
+        parser.linkImportedSymbols(css);
+        return parser.extractExports(css);
+      }
+
+    };
+  }
+
+  fetchAllImports(css) {
+    let imports = [];
+    css.each(node => {
+      if (node.type == "rule" && node.selector.match(importRegexp)) {
+        imports.push(this.fetchImport(node, css.source.input.from, imports.length));
+      }
+    });
+    return imports;
+  }
+
+  linkImportedSymbols(css) {
+    (0, _icssUtils.replaceSymbols)(css, this.translations);
+  }
+
+  extractExports(css) {
+    css.each(node => {
+      if (node.type == "rule" && node.selector == ":export") this.handleExport(node);
+    });
+  }
+
+  handleExport(exportNode) {
+    exportNode.each(decl => {
+      if (decl.type == "decl") {
+        Object.keys(this.translations).forEach(translation => {
+          decl.value = decl.value.replace(translation, this.translations[translation]);
+        });
+        this.exportTokens[decl.prop] = decl.value;
+      }
+    });
+    exportNode.remove();
+  }
+
+  async fetchImport(importNode, relativeTo, depNr) {
+    const file = importNode.selector.match(importRegexp)[1];
+    const depTrace = this.trace + String.fromCharCode(depNr);
+    const exports = await this.pathFetcher(file, relativeTo, depTrace);
+
+    try {
+      importNode.each(decl => {
+        if (decl.type == "decl") {
+          this.translations[decl.prop] = exports[decl.value];
+        }
+      });
+      importNode.remove();
+    } catch (err) {
+      console.log(err);
+    }
+  }
+
+}
+
+Parser$1.default = Parser;
+
+var saveJSON$1 = {};
+
+Object.defineProperty(saveJSON$1, "__esModule", {
+  value: true
+});
+saveJSON$1.default = saveJSON;
+
+var _fs$2 = fs;
+
+function saveJSON(cssFile, json) {
+  return new Promise((resolve, reject) => {
+    const {
+      writeFile
+    } = (0, _fs$2.getFileSystem)();
+    writeFile(`${cssFile}.json`, JSON.stringify(json), e => e ? reject(e) : resolve(json));
+  });
+}
+
+var localsConvention = {};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used to match words composed of alphanumeric characters. */
+var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+/** Used to match Latin Unicode letters (excluding mathematical operators). */
+var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+
+/** Used to compose unicode character classes. */
+var rsAstralRange = '\\ud800-\\udfff',
+    rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
+    rsComboSymbolsRange = '\\u20d0-\\u20f0',
+    rsDingbatRange = '\\u2700-\\u27bf',
+    rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
+    rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
+    rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
+    rsPunctuationRange = '\\u2000-\\u206f',
+    rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
+    rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
+    rsVarRange = '\\ufe0e\\ufe0f',
+    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+
+/** Used to compose unicode capture groups. */
+var rsApos = "['\u2019]",
+    rsAstral = '[' + rsAstralRange + ']',
+    rsBreak = '[' + rsBreakRange + ']',
+    rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
+    rsDigits = '\\d+',
+    rsDingbat = '[' + rsDingbatRange + ']',
+    rsLower = '[' + rsLowerRange + ']',
+    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
+    rsFitz = '\\ud83c[\\udffb-\\udfff]',
+    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
+    rsNonAstral = '[^' + rsAstralRange + ']',
+    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
+    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+    rsUpper = '[' + rsUpperRange + ']',
+    rsZWJ = '\\u200d';
+
+/** Used to compose unicode regexes. */
+var rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')',
+    rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')',
+    rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
+    rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
+    reOptMod = rsModifier + '?',
+    rsOptVar = '[' + rsVarRange + ']?',
+    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+    rsSeq = rsOptVar + reOptMod + rsOptJoin,
+    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
+    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+
+/** Used to match apostrophes. */
+var reApos = RegExp(rsApos, 'g');
+
+/**
+ * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+ * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+ */
+var reComboMark = RegExp(rsCombo, 'g');
+
+/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
+
+/** Used to match complex or compound words. */
+var reUnicodeWord = RegExp([
+  rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
+  rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')',
+  rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr,
+  rsUpper + '+' + rsOptUpperContr,
+  rsDigits,
+  rsEmoji
+].join('|'), 'g');
+
+/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
+
+/** Used to detect strings that need a more robust regexp to match words. */
+var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+
+/** Used to map Latin Unicode letters to basic Latin letters. */
+var deburredLetters = {
+  // Latin-1 Supplement block.
+  '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
+  '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
+  '\xc7': 'C',  '\xe7': 'c',
+  '\xd0': 'D',  '\xf0': 'd',
+  '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
+  '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
+  '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
+  '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
+  '\xd1': 'N',  '\xf1': 'n',
+  '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
+  '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
+  '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
+  '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
+  '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
+  '\xc6': 'Ae', '\xe6': 'ae',
+  '\xde': 'Th', '\xfe': 'th',
+  '\xdf': 'ss',
+  // Latin Extended-A block.
+  '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
+  '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
+  '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+  '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+  '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+  '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+  '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+  '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+  '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+  '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+  '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+  '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+  '\u0134': 'J',  '\u0135': 'j',
+  '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
+  '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+  '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+  '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+  '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+  '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
+  '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
+  '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
+  '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
+  '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+  '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
+  '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
+  '\u0163': 't',  '\u0165': 't', '\u0167': 't',
+  '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+  '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+  '\u0174': 'W',  '\u0175': 'w',
+  '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
+  '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
+  '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
+  '\u0132': 'IJ', '\u0133': 'ij',
+  '\u0152': 'Oe', '\u0153': 'oe',
+  '\u0149': "'n", '\u017f': 'ss'
+};
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$2 = freeGlobal || freeSelf || Function('return this')();
+
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1,
+      length = array ? array.length : 0;
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+
+/**
+ * Converts an ASCII `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+function asciiToArray(string) {
+  return string.split('');
+}
+
+/**
+ * Splits an ASCII `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function asciiWords(string) {
+  return string.match(reAsciiWord) || [];
+}
+
+/**
+ * The base implementation of `_.propertyOf` without support for deep paths.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyOf(object) {
+  return function(key) {
+    return object == null ? undefined : object[key];
+  };
+}
+
+/**
+ * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+ * letters to basic Latin letters.
+ *
+ * @private
+ * @param {string} letter The matched letter to deburr.
+ * @returns {string} Returns the deburred letter.
+ */
+var deburrLetter = basePropertyOf(deburredLetters);
+
+/**
+ * Checks if `string` contains Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a symbol is found, else `false`.
+ */
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+
+/**
+ * Checks if `string` contains a word composed of Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a word is found, else `false`.
+ */
+function hasUnicodeWord(string) {
+  return reHasUnicodeWord.test(string);
+}
+
+/**
+ * Converts `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+function stringToArray(string) {
+  return hasUnicode(string)
+    ? unicodeToArray(string)
+    : asciiToArray(string);
+}
+
+/**
+ * Converts a Unicode `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+function unicodeToArray(string) {
+  return string.match(reUnicode) || [];
+}
+
+/**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function unicodeWords(string) {
+  return string.match(reUnicodeWord) || [];
+}
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Built-in value references. */
+var Symbol$1 = root$2.Symbol;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
+    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+function baseSlice(array, start, end) {
+  var index = -1,
+      length = array.length;
+
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : ((end - start) >>> 0);
+  start >>>= 0;
+
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array[index + start];
+  }
+  return result;
+}
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = (value + '');
+  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/**
+ * Casts `array` to a slice if it's needed.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {number} start The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the cast slice.
+ */
+function castSlice(array, start, end) {
+  var length = array.length;
+  end = end === undefined ? length : end;
+  return (!start && end >= length) ? array : baseSlice(array, start, end);
+}
+
+/**
+ * Creates a function like `_.lowerFirst`.
+ *
+ * @private
+ * @param {string} methodName The name of the `String` case method to use.
+ * @returns {Function} Returns the new case function.
+ */
+function createCaseFirst(methodName) {
+  return function(string) {
+    string = toString(string);
+
+    var strSymbols = hasUnicode(string)
+      ? stringToArray(string)
+      : undefined;
+
+    var chr = strSymbols
+      ? strSymbols[0]
+      : string.charAt(0);
+
+    var trailing = strSymbols
+      ? castSlice(strSymbols, 1).join('')
+      : string.slice(1);
+
+    return chr[methodName]() + trailing;
+  };
+}
+
+/**
+ * Creates a function like `_.camelCase`.
+ *
+ * @private
+ * @param {Function} callback The function to combine each word.
+ * @returns {Function} Returns the new compounder function.
+ */
+function createCompounder(callback) {
+  return function(string) {
+    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
+  };
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString(value) {
+  return value == null ? '' : baseToString(value);
+}
+
+/**
+ * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the camel cased string.
+ * @example
+ *
+ * _.camelCase('Foo Bar');
+ * // => 'fooBar'
+ *
+ * _.camelCase('--foo-bar--');
+ * // => 'fooBar'
+ *
+ * _.camelCase('__FOO_BAR__');
+ * // => 'fooBar'
+ */
+var camelCase = createCompounder(function(result, word, index) {
+  word = word.toLowerCase();
+  return result + (index ? capitalize(word) : word);
+});
+
+/**
+ * Converts the first character of `string` to upper case and the remaining
+ * to lower case.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to capitalize.
+ * @returns {string} Returns the capitalized string.
+ * @example
+ *
+ * _.capitalize('FRED');
+ * // => 'Fred'
+ */
+function capitalize(string) {
+  return upperFirst(toString(string).toLowerCase());
+}
+
+/**
+ * Deburrs `string` by converting
+ * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+ * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+ * letters to basic Latin letters and removing
+ * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to deburr.
+ * @returns {string} Returns the deburred string.
+ * @example
+ *
+ * _.deburr('déjà vu');
+ * // => 'deja vu'
+ */
+function deburr(string) {
+  string = toString(string);
+  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
+}
+
+/**
+ * Converts the first character of `string` to upper case.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.upperFirst('fred');
+ * // => 'Fred'
+ *
+ * _.upperFirst('FRED');
+ * // => 'FRED'
+ */
+var upperFirst = createCaseFirst('toUpperCase');
+
+/**
+ * Splits `string` into an array of its words.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {RegExp|string} [pattern] The pattern to match words.
+ * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
+ * @returns {Array} Returns the words of `string`.
+ * @example
+ *
+ * _.words('fred, barney, & pebbles');
+ * // => ['fred', 'barney', 'pebbles']
+ *
+ * _.words('fred, barney, & pebbles', /[^, ]+/g);
+ * // => ['fred', 'barney', '&', 'pebbles']
+ */
+function words(string, pattern, guard) {
+  string = toString(string);
+  pattern = pattern;
+
+  if (pattern === undefined) {
+    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+  }
+  return string.match(pattern) || [];
+}
+
+var lodash_camelcase = camelCase;
+
+Object.defineProperty(localsConvention, "__esModule", {
+  value: true
+});
+localsConvention.makeLocalsConventionReducer = makeLocalsConventionReducer;
+
+var _lodash = _interopRequireDefault$5(lodash_camelcase);
+
+function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function dashesCamelCase(string) {
+  return string.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase());
+}
+
+function makeLocalsConventionReducer(localsConvention, inputFile) {
+  const isFunc = typeof localsConvention === "function";
+  return (tokens, [className, value]) => {
+    if (isFunc) {
+      const convention = localsConvention(className, value, inputFile);
+      tokens[convention] = value;
+      return tokens;
+    }
+
+    switch (localsConvention) {
+      case "camelCase":
+        tokens[className] = value;
+        tokens[(0, _lodash.default)(className)] = value;
+        break;
+
+      case "camelCaseOnly":
+        tokens[(0, _lodash.default)(className)] = value;
+        break;
+
+      case "dashes":
+        tokens[className] = value;
+        tokens[dashesCamelCase(className)] = value;
+        break;
+
+      case "dashesOnly":
+        tokens[dashesCamelCase(className)] = value;
+        break;
+    }
+
+    return tokens;
+  };
+}
+
+var FileSystemLoader$1 = {};
+
+Object.defineProperty(FileSystemLoader$1, "__esModule", {
+  value: true
+});
+FileSystemLoader$1.default = void 0;
+
+var _postcss$1 = _interopRequireDefault$4(require$$0);
+
+var _path = _interopRequireDefault$4(require$$0$1);
+
+var _Parser$1 = _interopRequireDefault$4(Parser$1);
+
+var _fs$1 = fs;
+
+function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Initially copied from https://github.com/css-modules/css-modules-loader-core
+class Core {
+  constructor(plugins) {
+    this.plugins = plugins || Core.defaultPlugins;
+  }
+
+  async load(sourceString, sourcePath, trace, pathFetcher) {
+    const parser = new _Parser$1.default(pathFetcher, trace);
+    const plugins = this.plugins.concat([parser.plugin()]);
+    const result = await (0, _postcss$1.default)(plugins).process(sourceString, {
+      from: sourcePath
+    });
+    return {
+      injectableSource: result.css,
+      exportTokens: parser.exportTokens
+    };
+  }
+
+} // Sorts dependencies in the following way:
+// AAA comes before AA and A
+// AB comes after AA and before A
+// All Bs come after all As
+// This ensures that the files are always returned in the following order:
+// - In the order they were required, except
+// - After all their dependencies
+
+
+const traceKeySorter = (a, b) => {
+  if (a.length < b.length) {
+    return a < b.substring(0, a.length) ? -1 : 1;
+  }
+
+  if (a.length > b.length) {
+    return a.substring(0, b.length) <= b ? -1 : 1;
+  }
+
+  return a < b ? -1 : 1;
+};
+
+class FileSystemLoader {
+  constructor(root, plugins, fileResolve) {
+    if (root === "/" && process.platform === "win32") {
+      const cwdDrive = process.cwd().slice(0, 3);
+
+      if (!/^[A-Za-z]:\\$/.test(cwdDrive)) {
+        throw new Error(`Failed to obtain root from "${process.cwd()}".`);
+      }
+
+      root = cwdDrive;
+    }
+
+    this.root = root;
+    this.fileResolve = fileResolve;
+    this.sources = {};
+    this.traces = {};
+    this.importNr = 0;
+    this.core = new Core(plugins);
+    this.tokensByFile = {};
+    this.fs = (0, _fs$1.getFileSystem)();
+  }
+
+  async fetch(_newPath, relativeTo, _trace) {
+    const newPath = _newPath.replace(/^["']|["']$/g, "");
+
+    const trace = _trace || String.fromCharCode(this.importNr++);
+
+    const useFileResolve = typeof this.fileResolve === "function";
+    const fileResolvedPath = useFileResolve ? await this.fileResolve(newPath, relativeTo) : await Promise.resolve();
+
+    if (fileResolvedPath && !_path.default.isAbsolute(fileResolvedPath)) {
+      throw new Error('The returned path from the "fileResolve" option must be absolute.');
+    }
+
+    const relativeDir = _path.default.dirname(relativeTo);
+
+    const rootRelativePath = fileResolvedPath || _path.default.resolve(relativeDir, newPath);
+
+    let fileRelativePath = fileResolvedPath || _path.default.resolve(_path.default.resolve(this.root, relativeDir), newPath); // if the path is not relative or absolute, try to resolve it in node_modules
+
+
+    if (!useFileResolve && newPath[0] !== "." && !_path.default.isAbsolute(newPath)) {
+      try {
+        fileRelativePath = require.resolve(newPath);
+      } catch (e) {// noop
+      }
+    }
+
+    const tokens = this.tokensByFile[fileRelativePath];
+    if (tokens) return tokens;
+    return new Promise((resolve, reject) => {
+      this.fs.readFile(fileRelativePath, "utf-8", async (err, source) => {
+        if (err) reject(err);
+        const {
+          injectableSource,
+          exportTokens
+        } = await this.core.load(source, rootRelativePath, trace, this.fetch.bind(this));
+        this.sources[fileRelativePath] = injectableSource;
+        this.traces[trace] = fileRelativePath;
+        this.tokensByFile[fileRelativePath] = exportTokens;
+        resolve(exportTokens);
+      });
+    });
+  }
+
+  get finalSource() {
+    const traces = this.traces;
+    const sources = this.sources;
+    let written = new Set();
+    return Object.keys(traces).sort(traceKeySorter).map(key => {
+      const filename = traces[key];
+
+      if (written.has(filename)) {
+        return null;
+      }
+
+      written.add(filename);
+      return sources[filename];
+    }).join("");
+  }
+
+}
+
+FileSystemLoader$1.default = FileSystemLoader;
+
+var scoping = {};
+
+var src$3 = {exports: {}};
+
+const PERMANENT_MARKER = 2;
+const TEMPORARY_MARKER = 1;
+
+function createError(node, graph) {
+  const er = new Error("Nondeterministic import's order");
+
+  const related = graph[node];
+  const relatedNode = related.find(
+    (relatedNode) => graph[relatedNode].indexOf(node) > -1
+  );
+
+  er.nodes = [node, relatedNode];
+
+  return er;
+}
+
+function walkGraph(node, graph, state, result, strict) {
+  if (state[node] === PERMANENT_MARKER) {
+    return;
+  }
+
+  if (state[node] === TEMPORARY_MARKER) {
+    if (strict) {
+      return createError(node, graph);
+    }
+
+    return;
+  }
+
+  state[node] = TEMPORARY_MARKER;
+
+  const children = graph[node];
+  const length = children.length;
+
+  for (let i = 0; i < length; ++i) {
+    const error = walkGraph(children[i], graph, state, result, strict);
+
+    if (error instanceof Error) {
+      return error;
+    }
+  }
+
+  state[node] = PERMANENT_MARKER;
+
+  result.push(node);
+}
+
+function topologicalSort$1(graph, strict) {
+  const result = [];
+  const state = {};
+
+  const nodes = Object.keys(graph);
+  const length = nodes.length;
+
+  for (let i = 0; i < length; ++i) {
+    const er = walkGraph(nodes[i], graph, state, result, strict);
+
+    if (er instanceof Error) {
+      return er;
+    }
+  }
+
+  return result;
+}
+
+var topologicalSort_1 = topologicalSort$1;
+
+const topologicalSort = topologicalSort_1;
+
+const matchImports$1 = /^(.+?)\s+from\s+(?:"([^"]+)"|'([^']+)'|(global))$/;
+const icssImport = /^:import\((?:"([^"]+)"|'([^']+)')\)/;
+
+const VISITED_MARKER = 1;
+
+/**
+ * :import('G') {}
+ *
+ * Rule
+ *   composes: ... from 'A'
+ *   composes: ... from 'B'
+
+ * Rule
+ *   composes: ... from 'A'
+ *   composes: ... from 'A'
+ *   composes: ... from 'C'
+ *
+ * Results in:
+ *
+ * graph: {
+ *   G: [],
+ *   A: [],
+ *   B: ['A'],
+ *   C: ['A'],
+ * }
+ */
+function addImportToGraph(importId, parentId, graph, visited) {
+  const siblingsId = parentId + "_" + "siblings";
+  const visitedId = parentId + "_" + importId;
+
+  if (visited[visitedId] !== VISITED_MARKER) {
+    if (!Array.isArray(visited[siblingsId])) {
+      visited[siblingsId] = [];
+    }
+
+    const siblings = visited[siblingsId];
+
+    if (Array.isArray(graph[importId])) {
+      graph[importId] = graph[importId].concat(siblings);
+    } else {
+      graph[importId] = siblings.slice();
+    }
+
+    visited[visitedId] = VISITED_MARKER;
+
+    siblings.push(importId);
+  }
+}
+
+src$3.exports = (options = {}) => {
+  let importIndex = 0;
+  const createImportedName =
+    typeof options.createImportedName !== "function"
+      ? (importName /*, path*/) =>
+          `i__imported_${importName.replace(/\W/g, "_")}_${importIndex++}`
+      : options.createImportedName;
+  const failOnWrongOrder = options.failOnWrongOrder;
+
+  return {
+    postcssPlugin: "postcss-modules-extract-imports",
+    prepare() {
+      const graph = {};
+      const visited = {};
+      const existingImports = {};
+      const importDecls = {};
+      const imports = {};
+
+      return {
+        Once(root, postcss) {
+          // Check the existing imports order and save refs
+          root.walkRules((rule) => {
+            const matches = icssImport.exec(rule.selector);
+
+            if (matches) {
+              const [, /*match*/ doubleQuotePath, singleQuotePath] = matches;
+              const importPath = doubleQuotePath || singleQuotePath;
+
+              addImportToGraph(importPath, "root", graph, visited);
+
+              existingImports[importPath] = rule;
+            }
+          });
+
+          root.walkDecls(/^composes$/, (declaration) => {
+            const matches = declaration.value.match(matchImports$1);
+
+            if (!matches) {
+              return;
+            }
+
+            let tmpSymbols;
+            let [
+              ,
+              /*match*/ symbols,
+              doubleQuotePath,
+              singleQuotePath,
+              global,
+            ] = matches;
+
+            if (global) {
+              // Composing globals simply means changing these classes to wrap them in global(name)
+              tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
+            } else {
+              const importPath = doubleQuotePath || singleQuotePath;
+
+              let parent = declaration.parent;
+              let parentIndexes = "";
+
+              while (parent.type !== "root") {
+                parentIndexes =
+                  parent.parent.index(parent) + "_" + parentIndexes;
+                parent = parent.parent;
+              }
+
+              const { selector } = declaration.parent;
+              const parentRule = `_${parentIndexes}${selector}`;
+
+              addImportToGraph(importPath, parentRule, graph, visited);
+
+              importDecls[importPath] = declaration;
+              imports[importPath] = imports[importPath] || {};
+
+              tmpSymbols = symbols.split(/\s+/).map((s) => {
+                if (!imports[importPath][s]) {
+                  imports[importPath][s] = createImportedName(s, importPath);
+                }
+
+                return imports[importPath][s];
+              });
+            }
+
+            declaration.value = tmpSymbols.join(" ");
+          });
+
+          const importsOrder = topologicalSort(graph, failOnWrongOrder);
+
+          if (importsOrder instanceof Error) {
+            const importPath = importsOrder.nodes.find((importPath) =>
+              // eslint-disable-next-line no-prototype-builtins
+              importDecls.hasOwnProperty(importPath)
+            );
+            const decl = importDecls[importPath];
+
+            throw decl.error(
+              "Failed to resolve order of composed modules " +
+                importsOrder.nodes
+                  .map((importPath) => "`" + importPath + "`")
+                  .join(", ") +
+                ".",
+              {
+                plugin: "postcss-modules-extract-imports",
+                word: "composes",
+              }
+            );
+          }
+
+          let lastImportRule;
+
+          importsOrder.forEach((path) => {
+            const importedSymbols = imports[path];
+            let rule = existingImports[path];
+
+            if (!rule && importedSymbols) {
+              rule = postcss.rule({
+                selector: `:import("${path}")`,
+                raws: { after: "\n" },
+              });
+
+              if (lastImportRule) {
+                root.insertAfter(lastImportRule, rule);
+              } else {
+                root.prepend(rule);
+              }
+            }
+
+            lastImportRule = rule;
+
+            if (!importedSymbols) {
+              return;
+            }
+
+            Object.keys(importedSymbols).forEach((importedSymbol) => {
+              rule.append(
+                postcss.decl({
+                  value: importedSymbol,
+                  prop: importedSymbols[importedSymbol],
+                  raws: { before: "\n  " },
+                })
+              );
+            });
+          });
+        },
+      };
+    },
+  };
+};
+
+src$3.exports.postcss = true;
+
+var srcExports$2 = src$3.exports;
+
+var wasmHash = {exports: {}};
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var hasRequiredWasmHash;
+
+function requireWasmHash () {
+	if (hasRequiredWasmHash) return wasmHash.exports;
+	hasRequiredWasmHash = 1;
+
+	// 65536 is the size of a wasm memory page
+	// 64 is the maximum chunk size for every possible wasm hash implementation
+	// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+	// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+	const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+
+	class WasmHash {
+	  /**
+	   * @param {WebAssembly.Instance} instance wasm instance
+	   * @param {WebAssembly.Instance[]} instancesPool pool of instances
+	   * @param {number} chunkSize size of data chunks passed to wasm
+	   * @param {number} digestSize size of digest returned by wasm
+	   */
+	  constructor(instance, instancesPool, chunkSize, digestSize) {
+	    const exports = /** @type {any} */ (instance.exports);
+
+	    exports.init();
+
+	    this.exports = exports;
+	    this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+	    this.buffered = 0;
+	    this.instancesPool = instancesPool;
+	    this.chunkSize = chunkSize;
+	    this.digestSize = digestSize;
+	  }
+
+	  reset() {
+	    this.buffered = 0;
+	    this.exports.init();
+	  }
+
+	  /**
+	   * @param {Buffer | string} data data
+	   * @param {BufferEncoding=} encoding encoding
+	   * @returns {this} itself
+	   */
+	  update(data, encoding) {
+	    if (typeof data === "string") {
+	      while (data.length > MAX_SHORT_STRING) {
+	        this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+	        data = data.slice(MAX_SHORT_STRING);
+	      }
+
+	      this._updateWithShortString(data, encoding);
+
+	      return this;
+	    }
+
+	    this._updateWithBuffer(data);
+
+	    return this;
+	  }
+
+	  /**
+	   * @param {string} data data
+	   * @param {BufferEncoding=} encoding encoding
+	   * @returns {void}
+	   */
+	  _updateWithShortString(data, encoding) {
+	    const { exports, buffered, mem, chunkSize } = this;
+
+	    let endPos;
+
+	    if (data.length < 70) {
+	      if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+	        endPos = buffered;
+	        for (let i = 0; i < data.length; i++) {
+	          const cc = data.charCodeAt(i);
+
+	          if (cc < 0x80) {
+	            mem[endPos++] = cc;
+	          } else if (cc < 0x800) {
+	            mem[endPos] = (cc >> 6) | 0xc0;
+	            mem[endPos + 1] = (cc & 0x3f) | 0x80;
+	            endPos += 2;
+	          } else {
+	            // bail-out for weird chars
+	            endPos += mem.write(data.slice(i), endPos, encoding);
+	            break;
+	          }
+	        }
+	      } else if (encoding === "latin1") {
+	        endPos = buffered;
+
+	        for (let i = 0; i < data.length; i++) {
+	          const cc = data.charCodeAt(i);
+
+	          mem[endPos++] = cc;
+	        }
+	      } else {
+	        endPos = buffered + mem.write(data, buffered, encoding);
+	      }
+	    } else {
+	      endPos = buffered + mem.write(data, buffered, encoding);
+	    }
+
+	    if (endPos < chunkSize) {
+	      this.buffered = endPos;
+	    } else {
+	      const l = endPos & ~(this.chunkSize - 1);
+
+	      exports.update(l);
+
+	      const newBuffered = endPos - l;
+
+	      this.buffered = newBuffered;
+
+	      if (newBuffered > 0) {
+	        mem.copyWithin(0, l, endPos);
+	      }
+	    }
+	  }
+
+	  /**
+	   * @param {Buffer} data data
+	   * @returns {void}
+	   */
+	  _updateWithBuffer(data) {
+	    const { exports, buffered, mem } = this;
+	    const length = data.length;
+
+	    if (buffered + length < this.chunkSize) {
+	      data.copy(mem, buffered, 0, length);
+
+	      this.buffered += length;
+	    } else {
+	      const l = (buffered + length) & ~(this.chunkSize - 1);
+
+	      if (l > 65536) {
+	        let i = 65536 - buffered;
+
+	        data.copy(mem, buffered, 0, i);
+	        exports.update(65536);
+
+	        const stop = l - buffered - 65536;
+
+	        while (i < stop) {
+	          data.copy(mem, 0, i, i + 65536);
+	          exports.update(65536);
+	          i += 65536;
+	        }
+
+	        data.copy(mem, 0, i, l - buffered);
+
+	        exports.update(l - buffered - i);
+	      } else {
+	        data.copy(mem, buffered, 0, l - buffered);
+
+	        exports.update(l);
+	      }
+
+	      const newBuffered = length + buffered - l;
+
+	      this.buffered = newBuffered;
+
+	      if (newBuffered > 0) {
+	        data.copy(mem, 0, length - newBuffered, length);
+	      }
+	    }
+	  }
+
+	  digest(type) {
+	    const { exports, buffered, mem, digestSize } = this;
+
+	    exports.final(buffered);
+
+	    this.instancesPool.push(this);
+
+	    const hex = mem.toString("latin1", 0, digestSize);
+
+	    if (type === "hex") {
+	      return hex;
+	    }
+
+	    if (type === "binary" || !type) {
+	      return Buffer.from(hex, "hex");
+	    }
+
+	    return Buffer.from(hex, "hex").toString(type);
+	  }
+	}
+
+	const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+	  if (instancesPool.length > 0) {
+	    const old = instancesPool.pop();
+
+	    old.reset();
+
+	    return old;
+	  } else {
+	    return new WasmHash(
+	      new WebAssembly.Instance(wasmModule),
+	      instancesPool,
+	      chunkSize,
+	      digestSize
+	    );
+	  }
+	};
+
+	wasmHash.exports = create;
+	wasmHash.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+	return wasmHash.exports;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var xxhash64_1;
+var hasRequiredXxhash64;
+
+function requireXxhash64 () {
+	if (hasRequiredXxhash64) return xxhash64_1;
+	hasRequiredXxhash64 = 1;
+
+	const create = requireWasmHash();
+
+	//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+	const xxhash64 = new WebAssembly.Module(
+	  Buffer.from(
+	    // 1173 bytes
+	    "AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
+	    "base64"
+	  )
+	);
+	//#endregion
+
+	xxhash64_1 = create.bind(null, xxhash64, [], 32, 16);
+	return xxhash64_1;
+}
+
+var BatchedHash_1;
+var hasRequiredBatchedHash;
+
+function requireBatchedHash () {
+	if (hasRequiredBatchedHash) return BatchedHash_1;
+	hasRequiredBatchedHash = 1;
+	const MAX_SHORT_STRING = requireWasmHash().MAX_SHORT_STRING;
+
+	class BatchedHash {
+	  constructor(hash) {
+	    this.string = undefined;
+	    this.encoding = undefined;
+	    this.hash = hash;
+	  }
+
+	  /**
+	   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	   * @param {string|Buffer} data data
+	   * @param {string=} inputEncoding data encoding
+	   * @returns {this} updated hash
+	   */
+	  update(data, inputEncoding) {
+	    if (this.string !== undefined) {
+	      if (
+	        typeof data === "string" &&
+	        inputEncoding === this.encoding &&
+	        this.string.length + data.length < MAX_SHORT_STRING
+	      ) {
+	        this.string += data;
+
+	        return this;
+	      }
+
+	      this.hash.update(this.string, this.encoding);
+	      this.string = undefined;
+	    }
+
+	    if (typeof data === "string") {
+	      if (
+	        data.length < MAX_SHORT_STRING &&
+	        // base64 encoding is not valid since it may contain padding chars
+	        (!inputEncoding || !inputEncoding.startsWith("ba"))
+	      ) {
+	        this.string = data;
+	        this.encoding = inputEncoding;
+	      } else {
+	        this.hash.update(data, inputEncoding);
+	      }
+	    } else {
+	      this.hash.update(data);
+	    }
+
+	    return this;
+	  }
+
+	  /**
+	   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	   * @param {string=} encoding encoding of the return value
+	   * @returns {string|Buffer} digest
+	   */
+	  digest(encoding) {
+	    if (this.string !== undefined) {
+	      this.hash.update(this.string, this.encoding);
+	    }
+
+	    return this.hash.digest(encoding);
+	  }
+	}
+
+	BatchedHash_1 = BatchedHash;
+	return BatchedHash_1;
+}
+
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+var md4_1;
+var hasRequiredMd4;
+
+function requireMd4 () {
+	if (hasRequiredMd4) return md4_1;
+	hasRequiredMd4 = 1;
+
+	const create = requireWasmHash();
+
+	//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+	const md4 = new WebAssembly.Module(
+	  Buffer.from(
+	    // 2150 bytes
+	    "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",
+	    "base64"
+	  )
+	);
+	//#endregion
+
+	md4_1 = create.bind(null, md4, [], 64, 32);
+	return md4_1;
+}
+
+var BulkUpdateDecorator_1;
+var hasRequiredBulkUpdateDecorator;
+
+function requireBulkUpdateDecorator () {
+	if (hasRequiredBulkUpdateDecorator) return BulkUpdateDecorator_1;
+	hasRequiredBulkUpdateDecorator = 1;
+	const BULK_SIZE = 2000;
+
+	// We are using an object instead of a Map as this will stay static during the runtime
+	// so access to it can be optimized by v8
+	const digestCaches = {};
+
+	class BulkUpdateDecorator {
+	  /**
+	   * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	   * @param {string=} hashKey key for caching
+	   */
+	  constructor(hashOrFactory, hashKey) {
+	    this.hashKey = hashKey;
+
+	    if (typeof hashOrFactory === "function") {
+	      this.hashFactory = hashOrFactory;
+	      this.hash = undefined;
+	    } else {
+	      this.hashFactory = undefined;
+	      this.hash = hashOrFactory;
+	    }
+
+	    this.buffer = "";
+	  }
+
+	  /**
+	   * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	   * @param {string|Buffer} data data
+	   * @param {string=} inputEncoding data encoding
+	   * @returns {this} updated hash
+	   */
+	  update(data, inputEncoding) {
+	    if (
+	      inputEncoding !== undefined ||
+	      typeof data !== "string" ||
+	      data.length > BULK_SIZE
+	    ) {
+	      if (this.hash === undefined) {
+	        this.hash = this.hashFactory();
+	      }
+
+	      if (this.buffer.length > 0) {
+	        this.hash.update(this.buffer);
+	        this.buffer = "";
+	      }
+
+	      this.hash.update(data, inputEncoding);
+	    } else {
+	      this.buffer += data;
+
+	      if (this.buffer.length > BULK_SIZE) {
+	        if (this.hash === undefined) {
+	          this.hash = this.hashFactory();
+	        }
+
+	        this.hash.update(this.buffer);
+	        this.buffer = "";
+	      }
+	    }
+
+	    return this;
+	  }
+
+	  /**
+	   * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	   * @param {string=} encoding encoding of the return value
+	   * @returns {string|Buffer} digest
+	   */
+	  digest(encoding) {
+	    let digestCache;
+
+	    const buffer = this.buffer;
+
+	    if (this.hash === undefined) {
+	      // short data for hash, we can use caching
+	      const cacheKey = `${this.hashKey}-${encoding}`;
+
+	      digestCache = digestCaches[cacheKey];
+
+	      if (digestCache === undefined) {
+	        digestCache = digestCaches[cacheKey] = new Map();
+	      }
+
+	      const cacheEntry = digestCache.get(buffer);
+
+	      if (cacheEntry !== undefined) {
+	        return cacheEntry;
+	      }
+
+	      this.hash = this.hashFactory();
+	    }
+
+	    if (buffer.length > 0) {
+	      this.hash.update(buffer);
+	    }
+
+	    const digestResult = this.hash.digest(encoding);
+
+	    if (digestCache !== undefined) {
+	      digestCache.set(buffer, digestResult);
+	    }
+
+	    return digestResult;
+	  }
+	}
+
+	BulkUpdateDecorator_1 = BulkUpdateDecorator;
+	return BulkUpdateDecorator_1;
+}
+
+const baseEncodeTables = {
+  26: "abcdefghijklmnopqrstuvwxyz",
+  32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio
+  36: "0123456789abcdefghijklmnopqrstuvwxyz",
+  49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO
+  52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO
+  62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_",
+};
+
+/**
+ * @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian
+ * @param {number} divisor The divisor
+ * @return {number} Modulo (remainder) of the division
+ */
+function divmod32(uint32Array, divisor) {
+  let carry = 0;
+  for (let i = uint32Array.length - 1; i >= 0; i--) {
+    const value = carry * 0x100000000 + uint32Array[i];
+    carry = value % divisor;
+    uint32Array[i] = Math.floor(value / divisor);
+  }
+  return carry;
+}
+
+function encodeBufferToBase(buffer, base, length) {
+  const encodeTable = baseEncodeTables[base];
+
+  if (!encodeTable) {
+    throw new Error("Unknown encoding base" + base);
+  }
+
+  // Input bits are only enough to generate this many characters
+  const limit = Math.ceil((buffer.length * 8) / Math.log2(base));
+  length = Math.min(length, limit);
+
+  // Most of the crypto digests (if not all) has length a multiple of 4 bytes.
+  // Fewer numbers in the array means faster math.
+  const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4));
+
+  // Make sure the input buffer data is copied and is not mutated by reference.
+  // divmod32() would corrupt the BulkUpdateDecorator cache otherwise.
+  buffer.copy(Buffer.from(uint32Array.buffer));
+
+  let output = "";
+
+  for (let i = 0; i < length; i++) {
+    output = encodeTable[divmod32(uint32Array, base)] + output;
+  }
+
+  return output;
+}
+
+let crypto = undefined;
+let createXXHash64 = undefined;
+let createMd4 = undefined;
+let BatchedHash = undefined;
+let BulkUpdateDecorator = undefined;
+
+function getHashDigest$1(buffer, algorithm, digestType, maxLength) {
+  algorithm = algorithm || "xxhash64";
+  maxLength = maxLength || 9999;
+
+  let hash;
+
+  if (algorithm === "xxhash64") {
+    if (createXXHash64 === undefined) {
+      createXXHash64 = requireXxhash64();
+
+      if (BatchedHash === undefined) {
+        BatchedHash = requireBatchedHash();
+      }
+    }
+
+    hash = new BatchedHash(createXXHash64());
+  } else if (algorithm === "md4") {
+    if (createMd4 === undefined) {
+      createMd4 = requireMd4();
+
+      if (BatchedHash === undefined) {
+        BatchedHash = requireBatchedHash();
+      }
+    }
+
+    hash = new BatchedHash(createMd4());
+  } else if (algorithm === "native-md4") {
+    if (typeof crypto === "undefined") {
+      crypto = require$$3;
+
+      if (BulkUpdateDecorator === undefined) {
+        BulkUpdateDecorator = requireBulkUpdateDecorator();
+      }
+    }
+
+    hash = new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+  } else {
+    if (typeof crypto === "undefined") {
+      crypto = require$$3;
+
+      if (BulkUpdateDecorator === undefined) {
+        BulkUpdateDecorator = requireBulkUpdateDecorator();
+      }
+    }
+
+    hash = new BulkUpdateDecorator(
+      () => crypto.createHash(algorithm),
+      algorithm
+    );
+  }
+
+  hash.update(buffer);
+
+  if (
+    digestType === "base26" ||
+    digestType === "base32" ||
+    digestType === "base36" ||
+    digestType === "base49" ||
+    digestType === "base52" ||
+    digestType === "base58" ||
+    digestType === "base62"
+  ) {
+    return encodeBufferToBase(hash.digest(), digestType.substr(4), maxLength);
+  } else {
+    return hash.digest(digestType || "hex").substr(0, maxLength);
+  }
+}
+
+var getHashDigest_1 = getHashDigest$1;
+
+const path$1 = require$$0$1;
+const getHashDigest = getHashDigest_1;
+
+function interpolateName$1(loaderContext, name, options = {}) {
+  let filename;
+
+  const hasQuery =
+    loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
+
+  if (typeof name === "function") {
+    filename = name(
+      loaderContext.resourcePath,
+      hasQuery ? loaderContext.resourceQuery : undefined
+    );
+  } else {
+    filename = name || "[hash].[ext]";
+  }
+
+  const context = options.context;
+  const content = options.content;
+  const regExp = options.regExp;
+
+  let ext = "bin";
+  let basename = "file";
+  let directory = "";
+  let folder = "";
+  let query = "";
+
+  if (loaderContext.resourcePath) {
+    const parsed = path$1.parse(loaderContext.resourcePath);
+    let resourcePath = loaderContext.resourcePath;
+
+    if (parsed.ext) {
+      ext = parsed.ext.substr(1);
+    }
+
+    if (parsed.dir) {
+      basename = parsed.name;
+      resourcePath = parsed.dir + path$1.sep;
+    }
+
+    if (typeof context !== "undefined") {
+      directory = path$1
+        .relative(context, resourcePath + "_")
+        .replace(/\\/g, "/")
+        .replace(/\.\.(\/)?/g, "_$1");
+      directory = directory.substr(0, directory.length - 1);
+    } else {
+      directory = resourcePath.replace(/\\/g, "/").replace(/\.\.(\/)?/g, "_$1");
+    }
+
+    if (directory.length === 1) {
+      directory = "";
+    } else if (directory.length > 1) {
+      folder = path$1.basename(directory);
+    }
+  }
+
+  if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
+    query = loaderContext.resourceQuery;
+
+    const hashIdx = query.indexOf("#");
+
+    if (hashIdx >= 0) {
+      query = query.substr(0, hashIdx);
+    }
+  }
+
+  let url = filename;
+
+  if (content) {
+    // Match hash template
+    url = url
+      // `hash` and `contenthash` are same in `loader-utils` context
+      // let's keep `hash` for backward compatibility
+      .replace(
+        /\[(?:([^[:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi,
+        (all, hashType, digestType, maxLength) =>
+          getHashDigest(content, hashType, digestType, parseInt(maxLength, 10))
+      );
+  }
+
+  url = url
+    .replace(/\[ext\]/gi, () => ext)
+    .replace(/\[name\]/gi, () => basename)
+    .replace(/\[path\]/gi, () => directory)
+    .replace(/\[folder\]/gi, () => folder)
+    .replace(/\[query\]/gi, () => query);
+
+  if (regExp && loaderContext.resourcePath) {
+    const match = loaderContext.resourcePath.match(new RegExp(regExp));
+
+    match &&
+      match.forEach((matched, i) => {
+        url = url.replace(new RegExp("\\[" + i + "\\]", "ig"), matched);
+      });
+  }
+
+  if (
+    typeof loaderContext.options === "object" &&
+    typeof loaderContext.options.customInterpolateName === "function"
+  ) {
+    url = loaderContext.options.customInterpolateName.call(
+      loaderContext,
+      url,
+      name,
+      options
+    );
+  }
+
+  return url;
+}
+
+var interpolateName_1 = interpolateName$1;
+
+var interpolateName = interpolateName_1;
+var path = require$$0$1;
+
+/**
+ * @param  {string} pattern
+ * @param  {object} options
+ * @param  {string} options.context
+ * @param  {string} options.hashPrefix
+ * @return {function}
+ */
+var genericNames = function createGenerator(pattern, options) {
+  options = options || {};
+  var context =
+    options && typeof options.context === "string"
+      ? options.context
+      : process.cwd();
+  var hashPrefix =
+    options && typeof options.hashPrefix === "string" ? options.hashPrefix : "";
+
+  /**
+   * @param  {string} localName Usually a class name
+   * @param  {string} filepath  Absolute path
+   * @return {string}
+   */
+  return function generate(localName, filepath) {
+    var name = pattern.replace(/\[local\]/gi, localName);
+    var loaderContext = {
+      resourcePath: filepath,
+    };
+
+    var loaderOptions = {
+      content:
+        hashPrefix +
+        path.relative(context, filepath).replace(/\\/g, "/") +
+        "\x00" +
+        localName,
+      context: context,
+    };
+
+    var genericName = interpolateName(loaderContext, name, loaderOptions);
+    return genericName
+      .replace(new RegExp("[^a-zA-Z0-9\\-_\u00A0-\uFFFF]", "g"), "-")
+      .replace(/^((-?[0-9])|--)/, "_$1");
+  };
+};
+
+var src$2 = {exports: {}};
+
+var dist = {exports: {}};
+
+var processor = {exports: {}};
+
+var parser = {exports: {}};
+
+var root$1 = {exports: {}};
+
+var container = {exports: {}};
+
+var node$1 = {exports: {}};
+
+var util = {};
+
+var unesc = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = unesc;
+	// Many thanks for this post which made this migration much easier.
+	// https://mathiasbynens.be/notes/css-escapes
+
+	/**
+	 * 
+	 * @param {string} str 
+	 * @returns {[string, number]|undefined}
+	 */
+	function gobbleHex(str) {
+	  var lower = str.toLowerCase();
+	  var hex = '';
+	  var spaceTerminated = false;
+	  for (var i = 0; i < 6 && lower[i] !== undefined; i++) {
+	    var code = lower.charCodeAt(i);
+	    // check to see if we are dealing with a valid hex char [a-f|0-9]
+	    var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
+	    // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+	    spaceTerminated = code === 32;
+	    if (!valid) {
+	      break;
+	    }
+	    hex += lower[i];
+	  }
+	  if (hex.length === 0) {
+	    return undefined;
+	  }
+	  var codePoint = parseInt(hex, 16);
+	  var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF;
+	  // Add special case for
+	  // "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
+	  // https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
+	  if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10FFFF) {
+	    return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
+	  }
+	  return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
+	}
+	var CONTAINS_ESCAPE = /\\/;
+	function unesc(str) {
+	  var needToProcess = CONTAINS_ESCAPE.test(str);
+	  if (!needToProcess) {
+	    return str;
+	  }
+	  var ret = "";
+	  for (var i = 0; i < str.length; i++) {
+	    if (str[i] === "\\") {
+	      var gobbled = gobbleHex(str.slice(i + 1, i + 7));
+	      if (gobbled !== undefined) {
+	        ret += gobbled[0];
+	        i += gobbled[1];
+	        continue;
+	      }
+
+	      // Retain a pair of \\ if double escaped `\\\\`
+	      // https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
+	      if (str[i + 1] === "\\") {
+	        ret += "\\";
+	        i++;
+	        continue;
+	      }
+
+	      // if \\ is at the end of the string retain it
+	      // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
+	      if (str.length === i + 1) {
+	        ret += str[i];
+	      }
+	      continue;
+	    }
+	    ret += str[i];
+	  }
+	  return ret;
+	}
+	module.exports = exports.default; 
+} (unesc, unesc.exports));
+
+var unescExports = unesc.exports;
+
+var getProp = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = getProp;
+	function getProp(obj) {
+	  for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	    props[_key - 1] = arguments[_key];
+	  }
+	  while (props.length > 0) {
+	    var prop = props.shift();
+	    if (!obj[prop]) {
+	      return undefined;
+	    }
+	    obj = obj[prop];
+	  }
+	  return obj;
+	}
+	module.exports = exports.default; 
+} (getProp, getProp.exports));
+
+var getPropExports = getProp.exports;
+
+var ensureObject = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = ensureObject;
+	function ensureObject(obj) {
+	  for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+	    props[_key - 1] = arguments[_key];
+	  }
+	  while (props.length > 0) {
+	    var prop = props.shift();
+	    if (!obj[prop]) {
+	      obj[prop] = {};
+	    }
+	    obj = obj[prop];
+	  }
+	}
+	module.exports = exports.default; 
+} (ensureObject, ensureObject.exports));
+
+var ensureObjectExports = ensureObject.exports;
+
+var stripComments = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = stripComments;
+	function stripComments(str) {
+	  var s = "";
+	  var commentStart = str.indexOf("/*");
+	  var lastEnd = 0;
+	  while (commentStart >= 0) {
+	    s = s + str.slice(lastEnd, commentStart);
+	    var commentEnd = str.indexOf("*/", commentStart + 2);
+	    if (commentEnd < 0) {
+	      return s;
+	    }
+	    lastEnd = commentEnd + 2;
+	    commentStart = str.indexOf("/*", lastEnd);
+	  }
+	  s = s + str.slice(lastEnd);
+	  return s;
+	}
+	module.exports = exports.default; 
+} (stripComments, stripComments.exports));
+
+var stripCommentsExports = stripComments.exports;
+
+util.__esModule = true;
+util.unesc = util.stripComments = util.getProp = util.ensureObject = void 0;
+var _unesc = _interopRequireDefault$3(unescExports);
+util.unesc = _unesc["default"];
+var _getProp = _interopRequireDefault$3(getPropExports);
+util.getProp = _getProp["default"];
+var _ensureObject = _interopRequireDefault$3(ensureObjectExports);
+util.ensureObject = _ensureObject["default"];
+var _stripComments = _interopRequireDefault$3(stripCommentsExports);
+util.stripComments = _stripComments["default"];
+function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _util = util;
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	var cloneNode = function cloneNode(obj, parent) {
+	  if (typeof obj !== 'object' || obj === null) {
+	    return obj;
+	  }
+	  var cloned = new obj.constructor();
+	  for (var i in obj) {
+	    if (!obj.hasOwnProperty(i)) {
+	      continue;
+	    }
+	    var value = obj[i];
+	    var type = typeof value;
+	    if (i === 'parent' && type === 'object') {
+	      if (parent) {
+	        cloned[i] = parent;
+	      }
+	    } else if (value instanceof Array) {
+	      cloned[i] = value.map(function (j) {
+	        return cloneNode(j, cloned);
+	      });
+	    } else {
+	      cloned[i] = cloneNode(value, cloned);
+	    }
+	  }
+	  return cloned;
+	};
+	var Node = /*#__PURE__*/function () {
+	  function Node(opts) {
+	    if (opts === void 0) {
+	      opts = {};
+	    }
+	    Object.assign(this, opts);
+	    this.spaces = this.spaces || {};
+	    this.spaces.before = this.spaces.before || '';
+	    this.spaces.after = this.spaces.after || '';
+	  }
+	  var _proto = Node.prototype;
+	  _proto.remove = function remove() {
+	    if (this.parent) {
+	      this.parent.removeChild(this);
+	    }
+	    this.parent = undefined;
+	    return this;
+	  };
+	  _proto.replaceWith = function replaceWith() {
+	    if (this.parent) {
+	      for (var index in arguments) {
+	        this.parent.insertBefore(this, arguments[index]);
+	      }
+	      this.remove();
+	    }
+	    return this;
+	  };
+	  _proto.next = function next() {
+	    return this.parent.at(this.parent.index(this) + 1);
+	  };
+	  _proto.prev = function prev() {
+	    return this.parent.at(this.parent.index(this) - 1);
+	  };
+	  _proto.clone = function clone(overrides) {
+	    if (overrides === void 0) {
+	      overrides = {};
+	    }
+	    var cloned = cloneNode(this);
+	    for (var name in overrides) {
+	      cloned[name] = overrides[name];
+	    }
+	    return cloned;
+	  }
+
+	  /**
+	   * Some non-standard syntax doesn't follow normal escaping rules for css.
+	   * This allows non standard syntax to be appended to an existing property
+	   * by specifying the escaped value. By specifying the escaped value,
+	   * illegal characters are allowed to be directly inserted into css output.
+	   * @param {string} name the property to set
+	   * @param {any} value the unescaped value of the property
+	   * @param {string} valueEscaped optional. the escaped value of the property.
+	   */;
+	  _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
+	    if (!this.raws) {
+	      this.raws = {};
+	    }
+	    var originalValue = this[name];
+	    var originalEscaped = this.raws[name];
+	    this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
+	    if (originalEscaped || valueEscaped !== value) {
+	      this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
+	    } else {
+	      delete this.raws[name]; // delete any escaped value that was created by the setter.
+	    }
+	  }
+
+	  /**
+	   * Some non-standard syntax doesn't follow normal escaping rules for css.
+	   * This allows the escaped value to be specified directly, allowing illegal
+	   * characters to be directly inserted into css output.
+	   * @param {string} name the property to set
+	   * @param {any} value the unescaped value of the property
+	   * @param {string} valueEscaped the escaped value of the property.
+	   */;
+	  _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
+	    if (!this.raws) {
+	      this.raws = {};
+	    }
+	    this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+	    this.raws[name] = valueEscaped;
+	  }
+
+	  /**
+	   * When you want a value to passed through to CSS directly. This method
+	   * deletes the corresponding raw value causing the stringifier to fallback
+	   * to the unescaped value.
+	   * @param {string} name the property to set.
+	   * @param {any} value The value that is both escaped and unescaped.
+	   */;
+	  _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
+	    this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
+	    if (this.raws) {
+	      delete this.raws[name];
+	    }
+	  }
+
+	  /**
+	   *
+	   * @param {number} line The number (starting with 1)
+	   * @param {number} column The column number (starting with 1)
+	   */;
+	  _proto.isAtPosition = function isAtPosition(line, column) {
+	    if (this.source && this.source.start && this.source.end) {
+	      if (this.source.start.line > line) {
+	        return false;
+	      }
+	      if (this.source.end.line < line) {
+	        return false;
+	      }
+	      if (this.source.start.line === line && this.source.start.column > column) {
+	        return false;
+	      }
+	      if (this.source.end.line === line && this.source.end.column < column) {
+	        return false;
+	      }
+	      return true;
+	    }
+	    return undefined;
+	  };
+	  _proto.stringifyProperty = function stringifyProperty(name) {
+	    return this.raws && this.raws[name] || this[name];
+	  };
+	  _proto.valueToString = function valueToString() {
+	    return String(this.stringifyProperty("value"));
+	  };
+	  _proto.toString = function toString() {
+	    return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
+	  };
+	  _createClass(Node, [{
+	    key: "rawSpaceBefore",
+	    get: function get() {
+	      var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
+	      if (rawSpace === undefined) {
+	        rawSpace = this.spaces && this.spaces.before;
+	      }
+	      return rawSpace || "";
+	    },
+	    set: function set(raw) {
+	      (0, _util.ensureObject)(this, "raws", "spaces");
+	      this.raws.spaces.before = raw;
+	    }
+	  }, {
+	    key: "rawSpaceAfter",
+	    get: function get() {
+	      var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
+	      if (rawSpace === undefined) {
+	        rawSpace = this.spaces.after;
+	      }
+	      return rawSpace || "";
+	    },
+	    set: function set(raw) {
+	      (0, _util.ensureObject)(this, "raws", "spaces");
+	      this.raws.spaces.after = raw;
+	    }
+	  }]);
+	  return Node;
+	}();
+	exports["default"] = Node;
+	module.exports = exports.default; 
+} (node$1, node$1.exports));
+
+var nodeExports = node$1.exports;
+
+var types = {};
+
+types.__esModule = true;
+types.UNIVERSAL = types.TAG = types.STRING = types.SELECTOR = types.ROOT = types.PSEUDO = types.NESTING = types.ID = types.COMMENT = types.COMBINATOR = types.CLASS = types.ATTRIBUTE = void 0;
+var TAG = 'tag';
+types.TAG = TAG;
+var STRING = 'string';
+types.STRING = STRING;
+var SELECTOR = 'selector';
+types.SELECTOR = SELECTOR;
+var ROOT = 'root';
+types.ROOT = ROOT;
+var PSEUDO = 'pseudo';
+types.PSEUDO = PSEUDO;
+var NESTING = 'nesting';
+types.NESTING = NESTING;
+var ID = 'id';
+types.ID = ID;
+var COMMENT = 'comment';
+types.COMMENT = COMMENT;
+var COMBINATOR = 'combinator';
+types.COMBINATOR = COMBINATOR;
+var CLASS = 'class';
+types.CLASS = CLASS;
+var ATTRIBUTE = 'attribute';
+types.ATTRIBUTE = ATTRIBUTE;
+var UNIVERSAL = 'universal';
+types.UNIVERSAL = UNIVERSAL;
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var types$1 = _interopRequireWildcard(types);
+	function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+	function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+	function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+	function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Container = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(Container, _Node);
+	  function Container(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    if (!_this.nodes) {
+	      _this.nodes = [];
+	    }
+	    return _this;
+	  }
+	  var _proto = Container.prototype;
+	  _proto.append = function append(selector) {
+	    selector.parent = this;
+	    this.nodes.push(selector);
+	    return this;
+	  };
+	  _proto.prepend = function prepend(selector) {
+	    selector.parent = this;
+	    this.nodes.unshift(selector);
+	    return this;
+	  };
+	  _proto.at = function at(index) {
+	    return this.nodes[index];
+	  };
+	  _proto.index = function index(child) {
+	    if (typeof child === 'number') {
+	      return child;
+	    }
+	    return this.nodes.indexOf(child);
+	  };
+	  _proto.removeChild = function removeChild(child) {
+	    child = this.index(child);
+	    this.at(child).parent = undefined;
+	    this.nodes.splice(child, 1);
+	    var index;
+	    for (var id in this.indexes) {
+	      index = this.indexes[id];
+	      if (index >= child) {
+	        this.indexes[id] = index - 1;
+	      }
+	    }
+	    return this;
+	  };
+	  _proto.removeAll = function removeAll() {
+	    for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
+	      var node = _step.value;
+	      node.parent = undefined;
+	    }
+	    this.nodes = [];
+	    return this;
+	  };
+	  _proto.empty = function empty() {
+	    return this.removeAll();
+	  };
+	  _proto.insertAfter = function insertAfter(oldNode, newNode) {
+	    newNode.parent = this;
+	    var oldIndex = this.index(oldNode);
+	    this.nodes.splice(oldIndex + 1, 0, newNode);
+	    newNode.parent = this;
+	    var index;
+	    for (var id in this.indexes) {
+	      index = this.indexes[id];
+	      if (oldIndex <= index) {
+	        this.indexes[id] = index + 1;
+	      }
+	    }
+	    return this;
+	  };
+	  _proto.insertBefore = function insertBefore(oldNode, newNode) {
+	    newNode.parent = this;
+	    var oldIndex = this.index(oldNode);
+	    this.nodes.splice(oldIndex, 0, newNode);
+	    newNode.parent = this;
+	    var index;
+	    for (var id in this.indexes) {
+	      index = this.indexes[id];
+	      if (index <= oldIndex) {
+	        this.indexes[id] = index + 1;
+	      }
+	    }
+	    return this;
+	  };
+	  _proto._findChildAtPosition = function _findChildAtPosition(line, col) {
+	    var found = undefined;
+	    this.each(function (node) {
+	      if (node.atPosition) {
+	        var foundChild = node.atPosition(line, col);
+	        if (foundChild) {
+	          found = foundChild;
+	          return false;
+	        }
+	      } else if (node.isAtPosition(line, col)) {
+	        found = node;
+	        return false;
+	      }
+	    });
+	    return found;
+	  }
+
+	  /**
+	   * Return the most specific node at the line and column number given.
+	   * The source location is based on the original parsed location, locations aren't
+	   * updated as selector nodes are mutated.
+	   * 
+	   * Note that this location is relative to the location of the first character
+	   * of the selector, and not the location of the selector in the overall document
+	   * when used in conjunction with postcss.
+	   *
+	   * If not found, returns undefined.
+	   * @param {number} line The line number of the node to find. (1-based index)
+	   * @param {number} col  The column number of the node to find. (1-based index)
+	   */;
+	  _proto.atPosition = function atPosition(line, col) {
+	    if (this.isAtPosition(line, col)) {
+	      return this._findChildAtPosition(line, col) || this;
+	    } else {
+	      return undefined;
+	    }
+	  };
+	  _proto._inferEndPosition = function _inferEndPosition() {
+	    if (this.last && this.last.source && this.last.source.end) {
+	      this.source = this.source || {};
+	      this.source.end = this.source.end || {};
+	      Object.assign(this.source.end, this.last.source.end);
+	    }
+	  };
+	  _proto.each = function each(callback) {
+	    if (!this.lastEach) {
+	      this.lastEach = 0;
+	    }
+	    if (!this.indexes) {
+	      this.indexes = {};
+	    }
+	    this.lastEach++;
+	    var id = this.lastEach;
+	    this.indexes[id] = 0;
+	    if (!this.length) {
+	      return undefined;
+	    }
+	    var index, result;
+	    while (this.indexes[id] < this.length) {
+	      index = this.indexes[id];
+	      result = callback(this.at(index), index);
+	      if (result === false) {
+	        break;
+	      }
+	      this.indexes[id] += 1;
+	    }
+	    delete this.indexes[id];
+	    if (result === false) {
+	      return false;
+	    }
+	  };
+	  _proto.walk = function walk(callback) {
+	    return this.each(function (node, i) {
+	      var result = callback(node, i);
+	      if (result !== false && node.length) {
+	        result = node.walk(callback);
+	      }
+	      if (result === false) {
+	        return false;
+	      }
+	    });
+	  };
+	  _proto.walkAttributes = function walkAttributes(callback) {
+	    var _this2 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.ATTRIBUTE) {
+	        return callback.call(_this2, selector);
+	      }
+	    });
+	  };
+	  _proto.walkClasses = function walkClasses(callback) {
+	    var _this3 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.CLASS) {
+	        return callback.call(_this3, selector);
+	      }
+	    });
+	  };
+	  _proto.walkCombinators = function walkCombinators(callback) {
+	    var _this4 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.COMBINATOR) {
+	        return callback.call(_this4, selector);
+	      }
+	    });
+	  };
+	  _proto.walkComments = function walkComments(callback) {
+	    var _this5 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.COMMENT) {
+	        return callback.call(_this5, selector);
+	      }
+	    });
+	  };
+	  _proto.walkIds = function walkIds(callback) {
+	    var _this6 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.ID) {
+	        return callback.call(_this6, selector);
+	      }
+	    });
+	  };
+	  _proto.walkNesting = function walkNesting(callback) {
+	    var _this7 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.NESTING) {
+	        return callback.call(_this7, selector);
+	      }
+	    });
+	  };
+	  _proto.walkPseudos = function walkPseudos(callback) {
+	    var _this8 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.PSEUDO) {
+	        return callback.call(_this8, selector);
+	      }
+	    });
+	  };
+	  _proto.walkTags = function walkTags(callback) {
+	    var _this9 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.TAG) {
+	        return callback.call(_this9, selector);
+	      }
+	    });
+	  };
+	  _proto.walkUniversals = function walkUniversals(callback) {
+	    var _this10 = this;
+	    return this.walk(function (selector) {
+	      if (selector.type === types$1.UNIVERSAL) {
+	        return callback.call(_this10, selector);
+	      }
+	    });
+	  };
+	  _proto.split = function split(callback) {
+	    var _this11 = this;
+	    var current = [];
+	    return this.reduce(function (memo, node, index) {
+	      var split = callback.call(_this11, node);
+	      current.push(node);
+	      if (split) {
+	        memo.push(current);
+	        current = [];
+	      } else if (index === _this11.length - 1) {
+	        memo.push(current);
+	      }
+	      return memo;
+	    }, []);
+	  };
+	  _proto.map = function map(callback) {
+	    return this.nodes.map(callback);
+	  };
+	  _proto.reduce = function reduce(callback, memo) {
+	    return this.nodes.reduce(callback, memo);
+	  };
+	  _proto.every = function every(callback) {
+	    return this.nodes.every(callback);
+	  };
+	  _proto.some = function some(callback) {
+	    return this.nodes.some(callback);
+	  };
+	  _proto.filter = function filter(callback) {
+	    return this.nodes.filter(callback);
+	  };
+	  _proto.sort = function sort(callback) {
+	    return this.nodes.sort(callback);
+	  };
+	  _proto.toString = function toString() {
+	    return this.map(String).join('');
+	  };
+	  _createClass(Container, [{
+	    key: "first",
+	    get: function get() {
+	      return this.at(0);
+	    }
+	  }, {
+	    key: "last",
+	    get: function get() {
+	      return this.at(this.length - 1);
+	    }
+	  }, {
+	    key: "length",
+	    get: function get() {
+	      return this.nodes.length;
+	    }
+	  }]);
+	  return Container;
+	}(_node["default"]);
+	exports["default"] = Container;
+	module.exports = exports.default; 
+} (container, container.exports));
+
+var containerExports = container.exports;
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(containerExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Root = /*#__PURE__*/function (_Container) {
+	  _inheritsLoose(Root, _Container);
+	  function Root(opts) {
+	    var _this;
+	    _this = _Container.call(this, opts) || this;
+	    _this.type = _types.ROOT;
+	    return _this;
+	  }
+	  var _proto = Root.prototype;
+	  _proto.toString = function toString() {
+	    var str = this.reduce(function (memo, selector) {
+	      memo.push(String(selector));
+	      return memo;
+	    }, []).join(',');
+	    return this.trailingComma ? str + ',' : str;
+	  };
+	  _proto.error = function error(message, options) {
+	    if (this._error) {
+	      return this._error(message, options);
+	    } else {
+	      return new Error(message);
+	    }
+	  };
+	  _createClass(Root, [{
+	    key: "errorGenerator",
+	    set: function set(handler) {
+	      this._error = handler;
+	    }
+	  }]);
+	  return Root;
+	}(_container["default"]);
+	exports["default"] = Root;
+	module.exports = exports.default; 
+} (root$1, root$1.exports));
+
+var rootExports = root$1.exports;
+
+var selector$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(containerExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Selector = /*#__PURE__*/function (_Container) {
+	  _inheritsLoose(Selector, _Container);
+	  function Selector(opts) {
+	    var _this;
+	    _this = _Container.call(this, opts) || this;
+	    _this.type = _types.SELECTOR;
+	    return _this;
+	  }
+	  return Selector;
+	}(_container["default"]);
+	exports["default"] = Selector;
+	module.exports = exports.default; 
+} (selector$1, selector$1.exports));
+
+var selectorExports = selector$1.exports;
+
+var className$1 = {exports: {}};
+
+/*! https://mths.be/cssesc v3.0.0 by @mathias */
+
+var object = {};
+var hasOwnProperty$1 = object.hasOwnProperty;
+var merge = function merge(options, defaults) {
+	if (!options) {
+		return defaults;
+	}
+	var result = {};
+	for (var key in defaults) {
+		// `if (defaults.hasOwnProperty(key) { … }` is not needed here, since
+		// only recognized option names are used.
+		result[key] = hasOwnProperty$1.call(options, key) ? options[key] : defaults[key];
+	}
+	return result;
+};
+
+var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
+var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
+var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+
+// https://mathiasbynens.be/notes/css-escapes#css
+var cssesc = function cssesc(string, options) {
+	options = merge(options, cssesc.options);
+	if (options.quotes != 'single' && options.quotes != 'double') {
+		options.quotes = 'single';
+	}
+	var quote = options.quotes == 'double' ? '"' : '\'';
+	var isIdentifier = options.isIdentifier;
+
+	var firstChar = string.charAt(0);
+	var output = '';
+	var counter = 0;
+	var length = string.length;
+	while (counter < length) {
+		var character = string.charAt(counter++);
+		var codePoint = character.charCodeAt();
+		var value = void 0;
+		// If it’s not a printable ASCII character…
+		if (codePoint < 0x20 || codePoint > 0x7E) {
+			if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) {
+				// It’s a high surrogate, and there is a next character.
+				var extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) {
+					// next character is low surrogate
+					codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+				} else {
+					// It’s an unmatched surrogate; only append this code unit, in case
+					// the next code unit is the high surrogate of a surrogate pair.
+					counter--;
+				}
+			}
+			value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+		} else {
+			if (options.escapeEverything) {
+				if (regexAnySingleEscape.test(character)) {
+					value = '\\' + character;
+				} else {
+					value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+				}
+			} else if (/[\t\n\f\r\x0B]/.test(character)) {
+				value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+			} else if (character == '\\' || !isIdentifier && (character == '"' && quote == character || character == '\'' && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
+				value = '\\' + character;
+			} else {
+				value = character;
+			}
+		}
+		output += value;
+	}
+
+	if (isIdentifier) {
+		if (/^-[-\d]/.test(output)) {
+			output = '\\-' + output.slice(1);
+		} else if (/\d/.test(firstChar)) {
+			output = '\\3' + firstChar + ' ' + output.slice(1);
+		}
+	}
+
+	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+	// since they’re redundant. Note that this is only possible if the escape
+	// sequence isn’t preceded by an odd number of backslashes.
+	output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
+		if ($1 && $1.length % 2) {
+			// It’s not safe to remove the space, so don’t.
+			return $0;
+		}
+		// Strip the space.
+		return ($1 || '') + $2;
+	});
+
+	if (!isIdentifier && options.wrap) {
+		return quote + output + quote;
+	}
+	return output;
+};
+
+// Expose default options (so they can be overridden globally).
+cssesc.options = {
+	'escapeEverything': false,
+	'isIdentifier': false,
+	'quotes': 'single',
+	'wrap': false
+};
+
+cssesc.version = '3.0.0';
+
+var cssesc_1 = cssesc;
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc = _interopRequireDefault(cssesc_1);
+	var _util = util;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var ClassName = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(ClassName, _Node);
+	  function ClassName(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.CLASS;
+	    _this._constructed = true;
+	    return _this;
+	  }
+	  var _proto = ClassName.prototype;
+	  _proto.valueToString = function valueToString() {
+	    return '.' + _Node.prototype.valueToString.call(this);
+	  };
+	  _createClass(ClassName, [{
+	    key: "value",
+	    get: function get() {
+	      return this._value;
+	    },
+	    set: function set(v) {
+	      if (this._constructed) {
+	        var escaped = (0, _cssesc["default"])(v, {
+	          isIdentifier: true
+	        });
+	        if (escaped !== v) {
+	          (0, _util.ensureObject)(this, "raws");
+	          this.raws.value = escaped;
+	        } else if (this.raws) {
+	          delete this.raws.value;
+	        }
+	      }
+	      this._value = v;
+	    }
+	  }]);
+	  return ClassName;
+	}(_node["default"]);
+	exports["default"] = ClassName;
+	module.exports = exports.default; 
+} (className$1, className$1.exports));
+
+var classNameExports = className$1.exports;
+
+var comment$2 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Comment = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(Comment, _Node);
+	  function Comment(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.COMMENT;
+	    return _this;
+	  }
+	  return Comment;
+	}(_node["default"]);
+	exports["default"] = Comment;
+	module.exports = exports.default; 
+} (comment$2, comment$2.exports));
+
+var commentExports = comment$2.exports;
+
+var id$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var ID = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(ID, _Node);
+	  function ID(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.ID;
+	    return _this;
+	  }
+	  var _proto = ID.prototype;
+	  _proto.valueToString = function valueToString() {
+	    return '#' + _Node.prototype.valueToString.call(this);
+	  };
+	  return ID;
+	}(_node["default"]);
+	exports["default"] = ID;
+	module.exports = exports.default; 
+} (id$1, id$1.exports));
+
+var idExports = id$1.exports;
+
+var tag$1 = {exports: {}};
+
+var namespace = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _cssesc = _interopRequireDefault(cssesc_1);
+	var _util = util;
+	var _node = _interopRequireDefault(nodeExports);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Namespace = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(Namespace, _Node);
+	  function Namespace() {
+	    return _Node.apply(this, arguments) || this;
+	  }
+	  var _proto = Namespace.prototype;
+	  _proto.qualifiedName = function qualifiedName(value) {
+	    if (this.namespace) {
+	      return this.namespaceString + "|" + value;
+	    } else {
+	      return value;
+	    }
+	  };
+	  _proto.valueToString = function valueToString() {
+	    return this.qualifiedName(_Node.prototype.valueToString.call(this));
+	  };
+	  _createClass(Namespace, [{
+	    key: "namespace",
+	    get: function get() {
+	      return this._namespace;
+	    },
+	    set: function set(namespace) {
+	      if (namespace === true || namespace === "*" || namespace === "&") {
+	        this._namespace = namespace;
+	        if (this.raws) {
+	          delete this.raws.namespace;
+	        }
+	        return;
+	      }
+	      var escaped = (0, _cssesc["default"])(namespace, {
+	        isIdentifier: true
+	      });
+	      this._namespace = namespace;
+	      if (escaped !== namespace) {
+	        (0, _util.ensureObject)(this, "raws");
+	        this.raws.namespace = escaped;
+	      } else if (this.raws) {
+	        delete this.raws.namespace;
+	      }
+	    }
+	  }, {
+	    key: "ns",
+	    get: function get() {
+	      return this._namespace;
+	    },
+	    set: function set(namespace) {
+	      this.namespace = namespace;
+	    }
+	  }, {
+	    key: "namespaceString",
+	    get: function get() {
+	      if (this.namespace) {
+	        var ns = this.stringifyProperty("namespace");
+	        if (ns === true) {
+	          return '';
+	        } else {
+	          return ns;
+	        }
+	      } else {
+	        return '';
+	      }
+	    }
+	  }]);
+	  return Namespace;
+	}(_node["default"]);
+	exports["default"] = Namespace;
+	module.exports = exports.default; 
+} (namespace, namespace.exports));
+
+var namespaceExports = namespace.exports;
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace = _interopRequireDefault(namespaceExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Tag = /*#__PURE__*/function (_Namespace) {
+	  _inheritsLoose(Tag, _Namespace);
+	  function Tag(opts) {
+	    var _this;
+	    _this = _Namespace.call(this, opts) || this;
+	    _this.type = _types.TAG;
+	    return _this;
+	  }
+	  return Tag;
+	}(_namespace["default"]);
+	exports["default"] = Tag;
+	module.exports = exports.default; 
+} (tag$1, tag$1.exports));
+
+var tagExports = tag$1.exports;
+
+var string$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var String = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(String, _Node);
+	  function String(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.STRING;
+	    return _this;
+	  }
+	  return String;
+	}(_node["default"]);
+	exports["default"] = String;
+	module.exports = exports.default; 
+} (string$1, string$1.exports));
+
+var stringExports = string$1.exports;
+
+var pseudo$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _container = _interopRequireDefault(containerExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Pseudo = /*#__PURE__*/function (_Container) {
+	  _inheritsLoose(Pseudo, _Container);
+	  function Pseudo(opts) {
+	    var _this;
+	    _this = _Container.call(this, opts) || this;
+	    _this.type = _types.PSEUDO;
+	    return _this;
+	  }
+	  var _proto = Pseudo.prototype;
+	  _proto.toString = function toString() {
+	    var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
+	    return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
+	  };
+	  return Pseudo;
+	}(_container["default"]);
+	exports["default"] = Pseudo;
+	module.exports = exports.default; 
+} (pseudo$1, pseudo$1.exports));
+
+var pseudoExports = pseudo$1.exports;
+
+var attribute$1 = {};
+
+/**
+ * For Node.js, simply re-export the core `util.deprecate` function.
+ */
+
+var node = require$$0$2.deprecate;
+
+(function (exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	exports.unescapeValue = unescapeValue;
+	var _cssesc = _interopRequireDefault(cssesc_1);
+	var _unesc = _interopRequireDefault(unescExports);
+	var _namespace = _interopRequireDefault(namespaceExports);
+	var _types = types;
+	var _CSSESC_QUOTE_OPTIONS;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var deprecate = node;
+	var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
+	var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
+	var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
+	var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+	function unescapeValue(value) {
+	  var deprecatedUsage = false;
+	  var quoteMark = null;
+	  var unescaped = value;
+	  var m = unescaped.match(WRAPPED_IN_QUOTES);
+	  if (m) {
+	    quoteMark = m[1];
+	    unescaped = m[2];
+	  }
+	  unescaped = (0, _unesc["default"])(unescaped);
+	  if (unescaped !== value) {
+	    deprecatedUsage = true;
+	  }
+	  return {
+	    deprecatedUsage: deprecatedUsage,
+	    unescaped: unescaped,
+	    quoteMark: quoteMark
+	  };
+	}
+	function handleDeprecatedContructorOpts(opts) {
+	  if (opts.quoteMark !== undefined) {
+	    return opts;
+	  }
+	  if (opts.value === undefined) {
+	    return opts;
+	  }
+	  warnOfDeprecatedConstructor();
+	  var _unescapeValue = unescapeValue(opts.value),
+	    quoteMark = _unescapeValue.quoteMark,
+	    unescaped = _unescapeValue.unescaped;
+	  if (!opts.raws) {
+	    opts.raws = {};
+	  }
+	  if (opts.raws.value === undefined) {
+	    opts.raws.value = opts.value;
+	  }
+	  opts.value = unescaped;
+	  opts.quoteMark = quoteMark;
+	  return opts;
+	}
+	var Attribute = /*#__PURE__*/function (_Namespace) {
+	  _inheritsLoose(Attribute, _Namespace);
+	  function Attribute(opts) {
+	    var _this;
+	    if (opts === void 0) {
+	      opts = {};
+	    }
+	    _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
+	    _this.type = _types.ATTRIBUTE;
+	    _this.raws = _this.raws || {};
+	    Object.defineProperty(_this.raws, 'unquoted', {
+	      get: deprecate(function () {
+	        return _this.value;
+	      }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+	      set: deprecate(function () {
+	        return _this.value;
+	      }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+	    });
+	    _this._constructed = true;
+	    return _this;
+	  }
+
+	  /**
+	   * Returns the Attribute's value quoted such that it would be legal to use
+	   * in the value of a css file. The original value's quotation setting
+	   * used for stringification is left unchanged. See `setValue(value, options)`
+	   * if you want to control the quote settings of a new value for the attribute.
+	   *
+	   * You can also change the quotation used for the current value by setting quoteMark.
+	   *
+	   * Options:
+	   *   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
+	   *     option is not set, the original value for quoteMark will be used. If
+	   *     indeterminate, a double quote is used. The legal values are:
+	   *     * `null` - the value will be unquoted and characters will be escaped as necessary.
+	   *     * `'` - the value will be quoted with a single quote and single quotes are escaped.
+	   *     * `"` - the value will be quoted with a double quote and double quotes are escaped.
+	   *   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
+	   *     over the quoteMark option value.
+	   *   * smart {boolean} - if true, will select a quote mark based on the value
+	   *     and the other options specified here. See the `smartQuoteMark()`
+	   *     method.
+	   **/
+	  var _proto = Attribute.prototype;
+	  _proto.getQuotedValue = function getQuotedValue(options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    var quoteMark = this._determineQuoteMark(options);
+	    var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
+	    var escaped = (0, _cssesc["default"])(this._value, cssescopts);
+	    return escaped;
+	  };
+	  _proto._determineQuoteMark = function _determineQuoteMark(options) {
+	    return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
+	  }
+
+	  /**
+	   * Set the unescaped value with the specified quotation options. The value
+	   * provided must not include any wrapping quote marks -- those quotes will
+	   * be interpreted as part of the value and escaped accordingly.
+	   */;
+	  _proto.setValue = function setValue(value, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    this._value = value;
+	    this._quoteMark = this._determineQuoteMark(options);
+	    this._syncRawValue();
+	  }
+
+	  /**
+	   * Intelligently select a quoteMark value based on the value's contents. If
+	   * the value is a legal CSS ident, it will not be quoted. Otherwise a quote
+	   * mark will be picked that minimizes the number of escapes.
+	   *
+	   * If there's no clear winner, the quote mark from these options is used,
+	   * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
+	   * true). If the quoteMark is unspecified, a double quote is used.
+	   *
+	   * @param options This takes the quoteMark and preferCurrentQuoteMark options
+	   * from the quoteValue method.
+	   */;
+	  _proto.smartQuoteMark = function smartQuoteMark(options) {
+	    var v = this.value;
+	    var numSingleQuotes = v.replace(/[^']/g, '').length;
+	    var numDoubleQuotes = v.replace(/[^"]/g, '').length;
+	    if (numSingleQuotes + numDoubleQuotes === 0) {
+	      var escaped = (0, _cssesc["default"])(v, {
+	        isIdentifier: true
+	      });
+	      if (escaped === v) {
+	        return Attribute.NO_QUOTE;
+	      } else {
+	        var pref = this.preferredQuoteMark(options);
+	        if (pref === Attribute.NO_QUOTE) {
+	          // pick a quote mark that isn't none and see if it's smaller
+	          var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+	          var opts = CSSESC_QUOTE_OPTIONS[quote];
+	          var quoteValue = (0, _cssesc["default"])(v, opts);
+	          if (quoteValue.length < escaped.length) {
+	            return quote;
+	          }
+	        }
+	        return pref;
+	      }
+	    } else if (numDoubleQuotes === numSingleQuotes) {
+	      return this.preferredQuoteMark(options);
+	    } else if (numDoubleQuotes < numSingleQuotes) {
+	      return Attribute.DOUBLE_QUOTE;
+	    } else {
+	      return Attribute.SINGLE_QUOTE;
+	    }
+	  }
+
+	  /**
+	   * Selects the preferred quote mark based on the options and the current quote mark value.
+	   * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
+	   * instead.
+	   */;
+	  _proto.preferredQuoteMark = function preferredQuoteMark(options) {
+	    var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
+	    if (quoteMark === undefined) {
+	      quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
+	    }
+	    if (quoteMark === undefined) {
+	      quoteMark = Attribute.DOUBLE_QUOTE;
+	    }
+	    return quoteMark;
+	  };
+	  _proto._syncRawValue = function _syncRawValue() {
+	    var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+	    if (rawValue === this._value) {
+	      if (this.raws) {
+	        delete this.raws.value;
+	      }
+	    } else {
+	      this.raws.value = rawValue;
+	    }
+	  };
+	  _proto._handleEscapes = function _handleEscapes(prop, value) {
+	    if (this._constructed) {
+	      var escaped = (0, _cssesc["default"])(value, {
+	        isIdentifier: true
+	      });
+	      if (escaped !== value) {
+	        this.raws[prop] = escaped;
+	      } else {
+	        delete this.raws[prop];
+	      }
+	    }
+	  };
+	  _proto._spacesFor = function _spacesFor(name) {
+	    var attrSpaces = {
+	      before: '',
+	      after: ''
+	    };
+	    var spaces = this.spaces[name] || {};
+	    var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
+	    return Object.assign(attrSpaces, spaces, rawSpaces);
+	  };
+	  _proto._stringFor = function _stringFor(name, spaceName, concat) {
+	    if (spaceName === void 0) {
+	      spaceName = name;
+	    }
+	    if (concat === void 0) {
+	      concat = defaultAttrConcat;
+	    }
+	    var attrSpaces = this._spacesFor(spaceName);
+	    return concat(this.stringifyProperty(name), attrSpaces);
+	  }
+
+	  /**
+	   * returns the offset of the attribute part specified relative to the
+	   * start of the node of the output string.
+	   *
+	   * * "ns" - alias for "namespace"
+	   * * "namespace" - the namespace if it exists.
+	   * * "attribute" - the attribute name
+	   * * "attributeNS" - the start of the attribute or its namespace
+	   * * "operator" - the match operator of the attribute
+	   * * "value" - The value (string or identifier)
+	   * * "insensitive" - the case insensitivity flag;
+	   * @param part One of the possible values inside an attribute.
+	   * @returns -1 if the name is invalid or the value doesn't exist in this attribute.
+	   */;
+	  _proto.offsetOf = function offsetOf(name) {
+	    var count = 1;
+	    var attributeSpaces = this._spacesFor("attribute");
+	    count += attributeSpaces.before.length;
+	    if (name === "namespace" || name === "ns") {
+	      return this.namespace ? count : -1;
+	    }
+	    if (name === "attributeNS") {
+	      return count;
+	    }
+	    count += this.namespaceString.length;
+	    if (this.namespace) {
+	      count += 1;
+	    }
+	    if (name === "attribute") {
+	      return count;
+	    }
+	    count += this.stringifyProperty("attribute").length;
+	    count += attributeSpaces.after.length;
+	    var operatorSpaces = this._spacesFor("operator");
+	    count += operatorSpaces.before.length;
+	    var operator = this.stringifyProperty("operator");
+	    if (name === "operator") {
+	      return operator ? count : -1;
+	    }
+	    count += operator.length;
+	    count += operatorSpaces.after.length;
+	    var valueSpaces = this._spacesFor("value");
+	    count += valueSpaces.before.length;
+	    var value = this.stringifyProperty("value");
+	    if (name === "value") {
+	      return value ? count : -1;
+	    }
+	    count += value.length;
+	    count += valueSpaces.after.length;
+	    var insensitiveSpaces = this._spacesFor("insensitive");
+	    count += insensitiveSpaces.before.length;
+	    if (name === "insensitive") {
+	      return this.insensitive ? count : -1;
+	    }
+	    return -1;
+	  };
+	  _proto.toString = function toString() {
+	    var _this2 = this;
+	    var selector = [this.rawSpaceBefore, '['];
+	    selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
+	    if (this.operator && (this.value || this.value === '')) {
+	      selector.push(this._stringFor('operator'));
+	      selector.push(this._stringFor('value'));
+	      selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) {
+	        if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
+	          attrSpaces.before = " ";
+	        }
+	        return defaultAttrConcat(attrValue, attrSpaces);
+	      }));
+	    }
+	    selector.push(']');
+	    selector.push(this.rawSpaceAfter);
+	    return selector.join('');
+	  };
+	  _createClass(Attribute, [{
+	    key: "quoted",
+	    get: function get() {
+	      var qm = this.quoteMark;
+	      return qm === "'" || qm === '"';
+	    },
+	    set: function set(value) {
+	      warnOfDeprecatedQuotedAssignment();
+	    }
+
+	    /**
+	     * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+	     * returns `null` if the value is not quoted.
+	     * returns `undefined` if the quotation state is unknown (this can happen when
+	     * the attribute is constructed without specifying a quote mark.)
+	     */
+	  }, {
+	    key: "quoteMark",
+	    get: function get() {
+	      return this._quoteMark;
+	    }
+
+	    /**
+	     * Set the quote mark to be used by this attribute's value.
+	     * If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
+	     * value is updated accordingly.
+	     *
+	     * @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
+	     */,
+	    set: function set(quoteMark) {
+	      if (!this._constructed) {
+	        this._quoteMark = quoteMark;
+	        return;
+	      }
+	      if (this._quoteMark !== quoteMark) {
+	        this._quoteMark = quoteMark;
+	        this._syncRawValue();
+	      }
+	    }
+	  }, {
+	    key: "qualifiedAttribute",
+	    get: function get() {
+	      return this.qualifiedName(this.raws.attribute || this.attribute);
+	    }
+	  }, {
+	    key: "insensitiveFlag",
+	    get: function get() {
+	      return this.insensitive ? 'i' : '';
+	    }
+	  }, {
+	    key: "value",
+	    get: function get() {
+	      return this._value;
+	    },
+	    set:
+	    /**
+	     * Before 3.0, the value had to be set to an escaped value including any wrapped
+	     * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+	     * is unescaped during parsing and any quote marks are removed.
+	     *
+	     * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+	     * a deprecation warning is raised when the new value contains any characters that would
+	     * require escaping (including if it contains wrapped quotes).
+	     *
+	     * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+	     * how the new value is quoted.
+	     */
+	    function set(v) {
+	      if (this._constructed) {
+	        var _unescapeValue2 = unescapeValue(v),
+	          deprecatedUsage = _unescapeValue2.deprecatedUsage,
+	          unescaped = _unescapeValue2.unescaped,
+	          quoteMark = _unescapeValue2.quoteMark;
+	        if (deprecatedUsage) {
+	          warnOfDeprecatedValueAssignment();
+	        }
+	        if (unescaped === this._value && quoteMark === this._quoteMark) {
+	          return;
+	        }
+	        this._value = unescaped;
+	        this._quoteMark = quoteMark;
+	        this._syncRawValue();
+	      } else {
+	        this._value = v;
+	      }
+	    }
+	  }, {
+	    key: "insensitive",
+	    get: function get() {
+	      return this._insensitive;
+	    }
+
+	    /**
+	     * Set the case insensitive flag.
+	     * If the case insensitive flag changes, the raw (escaped) value at `attr.raws.insensitiveFlag`
+	     * of the attribute is updated accordingly.
+	     *
+	     * @param {true | false} insensitive true if the attribute should match case-insensitively.
+	     */,
+	    set: function set(insensitive) {
+	      if (!insensitive) {
+	        this._insensitive = false;
+
+	        // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
+	        // When setting `attr.insensitive = false` both should be erased to ensure correct serialization.
+	        if (this.raws && (this.raws.insensitiveFlag === 'I' || this.raws.insensitiveFlag === 'i')) {
+	          this.raws.insensitiveFlag = undefined;
+	        }
+	      }
+	      this._insensitive = insensitive;
+	    }
+	  }, {
+	    key: "attribute",
+	    get: function get() {
+	      return this._attribute;
+	    },
+	    set: function set(name) {
+	      this._handleEscapes("attribute", name);
+	      this._attribute = name;
+	    }
+	  }]);
+	  return Attribute;
+	}(_namespace["default"]);
+	exports["default"] = Attribute;
+	Attribute.NO_QUOTE = null;
+	Attribute.SINGLE_QUOTE = "'";
+	Attribute.DOUBLE_QUOTE = '"';
+	var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
+	  "'": {
+	    quotes: 'single',
+	    wrap: true
+	  },
+	  '"': {
+	    quotes: 'double',
+	    wrap: true
+	  }
+	}, _CSSESC_QUOTE_OPTIONS[null] = {
+	  isIdentifier: true
+	}, _CSSESC_QUOTE_OPTIONS);
+	function defaultAttrConcat(attrValue, attrSpaces) {
+	  return "" + attrSpaces.before + attrValue + attrSpaces.after;
+	} 
+} (attribute$1));
+
+var universal$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _namespace = _interopRequireDefault(namespaceExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Universal = /*#__PURE__*/function (_Namespace) {
+	  _inheritsLoose(Universal, _Namespace);
+	  function Universal(opts) {
+	    var _this;
+	    _this = _Namespace.call(this, opts) || this;
+	    _this.type = _types.UNIVERSAL;
+	    _this.value = '*';
+	    return _this;
+	  }
+	  return Universal;
+	}(_namespace["default"]);
+	exports["default"] = Universal;
+	module.exports = exports.default; 
+} (universal$1, universal$1.exports));
+
+var universalExports = universal$1.exports;
+
+var combinator$2 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Combinator = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(Combinator, _Node);
+	  function Combinator(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.COMBINATOR;
+	    return _this;
+	  }
+	  return Combinator;
+	}(_node["default"]);
+	exports["default"] = Combinator;
+	module.exports = exports.default; 
+} (combinator$2, combinator$2.exports));
+
+var combinatorExports = combinator$2.exports;
+
+var nesting$1 = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _node = _interopRequireDefault(nodeExports);
+	var _types = types;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
+	function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+	var Nesting = /*#__PURE__*/function (_Node) {
+	  _inheritsLoose(Nesting, _Node);
+	  function Nesting(opts) {
+	    var _this;
+	    _this = _Node.call(this, opts) || this;
+	    _this.type = _types.NESTING;
+	    _this.value = '&';
+	    return _this;
+	  }
+	  return Nesting;
+	}(_node["default"]);
+	exports["default"] = Nesting;
+	module.exports = exports.default; 
+} (nesting$1, nesting$1.exports));
+
+var nestingExports = nesting$1.exports;
+
+var sortAscending = {exports: {}};
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = sortAscending;
+	function sortAscending(list) {
+	  return list.sort(function (a, b) {
+	    return a - b;
+	  });
+	}
+	module.exports = exports.default; 
+} (sortAscending, sortAscending.exports));
+
+var sortAscendingExports = sortAscending.exports;
+
+var tokenize = {};
+
+var tokenTypes = {};
+
+tokenTypes.__esModule = true;
+tokenTypes.word = tokenTypes.tilde = tokenTypes.tab = tokenTypes.str = tokenTypes.space = tokenTypes.slash = tokenTypes.singleQuote = tokenTypes.semicolon = tokenTypes.plus = tokenTypes.pipe = tokenTypes.openSquare = tokenTypes.openParenthesis = tokenTypes.newline = tokenTypes.greaterThan = tokenTypes.feed = tokenTypes.equals = tokenTypes.doubleQuote = tokenTypes.dollar = tokenTypes.cr = tokenTypes.comment = tokenTypes.comma = tokenTypes.combinator = tokenTypes.colon = tokenTypes.closeSquare = tokenTypes.closeParenthesis = tokenTypes.caret = tokenTypes.bang = tokenTypes.backslash = tokenTypes.at = tokenTypes.asterisk = tokenTypes.ampersand = void 0;
+var ampersand = 38; // `&`.charCodeAt(0);
+tokenTypes.ampersand = ampersand;
+var asterisk = 42; // `*`.charCodeAt(0);
+tokenTypes.asterisk = asterisk;
+var at = 64; // `@`.charCodeAt(0);
+tokenTypes.at = at;
+var comma = 44; // `,`.charCodeAt(0);
+tokenTypes.comma = comma;
+var colon = 58; // `:`.charCodeAt(0);
+tokenTypes.colon = colon;
+var semicolon = 59; // `;`.charCodeAt(0);
+tokenTypes.semicolon = semicolon;
+var openParenthesis = 40; // `(`.charCodeAt(0);
+tokenTypes.openParenthesis = openParenthesis;
+var closeParenthesis = 41; // `)`.charCodeAt(0);
+tokenTypes.closeParenthesis = closeParenthesis;
+var openSquare = 91; // `[`.charCodeAt(0);
+tokenTypes.openSquare = openSquare;
+var closeSquare = 93; // `]`.charCodeAt(0);
+tokenTypes.closeSquare = closeSquare;
+var dollar = 36; // `$`.charCodeAt(0);
+tokenTypes.dollar = dollar;
+var tilde = 126; // `~`.charCodeAt(0);
+tokenTypes.tilde = tilde;
+var caret = 94; // `^`.charCodeAt(0);
+tokenTypes.caret = caret;
+var plus = 43; // `+`.charCodeAt(0);
+tokenTypes.plus = plus;
+var equals = 61; // `=`.charCodeAt(0);
+tokenTypes.equals = equals;
+var pipe = 124; // `|`.charCodeAt(0);
+tokenTypes.pipe = pipe;
+var greaterThan = 62; // `>`.charCodeAt(0);
+tokenTypes.greaterThan = greaterThan;
+var space = 32; // ` `.charCodeAt(0);
+tokenTypes.space = space;
+var singleQuote = 39; // `'`.charCodeAt(0);
+tokenTypes.singleQuote = singleQuote;
+var doubleQuote = 34; // `"`.charCodeAt(0);
+tokenTypes.doubleQuote = doubleQuote;
+var slash = 47; // `/`.charCodeAt(0);
+tokenTypes.slash = slash;
+var bang = 33; // `!`.charCodeAt(0);
+tokenTypes.bang = bang;
+var backslash = 92; // '\\'.charCodeAt(0);
+tokenTypes.backslash = backslash;
+var cr = 13; // '\r'.charCodeAt(0);
+tokenTypes.cr = cr;
+var feed = 12; // '\f'.charCodeAt(0);
+tokenTypes.feed = feed;
+var newline = 10; // '\n'.charCodeAt(0);
+tokenTypes.newline = newline;
+var tab = 9; // '\t'.charCodeAt(0);
+
+// Expose aliases primarily for readability.
+tokenTypes.tab = tab;
+var str = singleQuote;
+
+// No good single character representation!
+tokenTypes.str = str;
+var comment$1 = -1;
+tokenTypes.comment = comment$1;
+var word = -2;
+tokenTypes.word = word;
+var combinator$1 = -3;
+tokenTypes.combinator = combinator$1;
+
+(function (exports) {
+
+	exports.__esModule = true;
+	exports.FIELDS = void 0;
+	exports["default"] = tokenize;
+	var t = _interopRequireWildcard(tokenTypes);
+	var _unescapable, _wordDelimiters;
+	function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+	function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+	var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
+	var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
+	var hex = {};
+	var hexChars = "0123456789abcdefABCDEF";
+	for (var i = 0; i < hexChars.length; i++) {
+	  hex[hexChars.charCodeAt(i)] = true;
+	}
+
+	/**
+	 *  Returns the last index of the bar css word
+	 * @param {string} css The string in which the word begins
+	 * @param {number} start The index into the string where word's first letter occurs
+	 */
+	function consumeWord(css, start) {
+	  var next = start;
+	  var code;
+	  do {
+	    code = css.charCodeAt(next);
+	    if (wordDelimiters[code]) {
+	      return next - 1;
+	    } else if (code === t.backslash) {
+	      next = consumeEscape(css, next) + 1;
+	    } else {
+	      // All other characters are part of the word
+	      next++;
+	    }
+	  } while (next < css.length);
+	  return next - 1;
+	}
+
+	/**
+	 *  Returns the last index of the escape sequence
+	 * @param {string} css The string in which the sequence begins
+	 * @param {number} start The index into the string where escape character (`\`) occurs.
+	 */
+	function consumeEscape(css, start) {
+	  var next = start;
+	  var code = css.charCodeAt(next + 1);
+	  if (unescapable[code]) ; else if (hex[code]) {
+	    var hexDigits = 0;
+	    // consume up to 6 hex chars
+	    do {
+	      next++;
+	      hexDigits++;
+	      code = css.charCodeAt(next + 1);
+	    } while (hex[code] && hexDigits < 6);
+	    // if fewer than 6 hex chars, a trailing space ends the escape
+	    if (hexDigits < 6 && code === t.space) {
+	      next++;
+	    }
+	  } else {
+	    // the next char is part of the current word
+	    next++;
+	  }
+	  return next;
+	}
+	var FIELDS = {
+	  TYPE: 0,
+	  START_LINE: 1,
+	  START_COL: 2,
+	  END_LINE: 3,
+	  END_COL: 4,
+	  START_POS: 5,
+	  END_POS: 6
+	};
+	exports.FIELDS = FIELDS;
+	function tokenize(input) {
+	  var tokens = [];
+	  var css = input.css.valueOf();
+	  var _css = css,
+	    length = _css.length;
+	  var offset = -1;
+	  var line = 1;
+	  var start = 0;
+	  var end = 0;
+	  var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
+	  function unclosed(what, fix) {
+	    if (input.safe) {
+	      // fyi: this is never set to true.
+	      css += fix;
+	      next = css.length - 1;
+	    } else {
+	      throw input.error('Unclosed ' + what, line, start - offset, start);
+	    }
+	  }
+	  while (start < length) {
+	    code = css.charCodeAt(start);
+	    if (code === t.newline) {
+	      offset = start;
+	      line += 1;
+	    }
+	    switch (code) {
+	      case t.space:
+	      case t.tab:
+	      case t.newline:
+	      case t.cr:
+	      case t.feed:
+	        next = start;
+	        do {
+	          next += 1;
+	          code = css.charCodeAt(next);
+	          if (code === t.newline) {
+	            offset = next;
+	            line += 1;
+	          }
+	        } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
+	        tokenType = t.space;
+	        endLine = line;
+	        endColumn = next - offset - 1;
+	        end = next;
+	        break;
+	      case t.plus:
+	      case t.greaterThan:
+	      case t.tilde:
+	      case t.pipe:
+	        next = start;
+	        do {
+	          next += 1;
+	          code = css.charCodeAt(next);
+	        } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
+	        tokenType = t.combinator;
+	        endLine = line;
+	        endColumn = start - offset;
+	        end = next;
+	        break;
+
+	      // Consume these characters as single tokens.
+	      case t.asterisk:
+	      case t.ampersand:
+	      case t.bang:
+	      case t.comma:
+	      case t.equals:
+	      case t.dollar:
+	      case t.caret:
+	      case t.openSquare:
+	      case t.closeSquare:
+	      case t.colon:
+	      case t.semicolon:
+	      case t.openParenthesis:
+	      case t.closeParenthesis:
+	        next = start;
+	        tokenType = code;
+	        endLine = line;
+	        endColumn = start - offset;
+	        end = next + 1;
+	        break;
+	      case t.singleQuote:
+	      case t.doubleQuote:
+	        quote = code === t.singleQuote ? "'" : '"';
+	        next = start;
+	        do {
+	          escaped = false;
+	          next = css.indexOf(quote, next + 1);
+	          if (next === -1) {
+	            unclosed('quote', quote);
+	          }
+	          escapePos = next;
+	          while (css.charCodeAt(escapePos - 1) === t.backslash) {
+	            escapePos -= 1;
+	            escaped = !escaped;
+	          }
+	        } while (escaped);
+	        tokenType = t.str;
+	        endLine = line;
+	        endColumn = start - offset;
+	        end = next + 1;
+	        break;
+	      default:
+	        if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
+	          next = css.indexOf('*/', start + 2) + 1;
+	          if (next === 0) {
+	            unclosed('comment', '*/');
+	          }
+	          content = css.slice(start, next + 1);
+	          lines = content.split('\n');
+	          last = lines.length - 1;
+	          if (last > 0) {
+	            nextLine = line + last;
+	            nextOffset = next - lines[last].length;
+	          } else {
+	            nextLine = line;
+	            nextOffset = offset;
+	          }
+	          tokenType = t.comment;
+	          line = nextLine;
+	          endLine = nextLine;
+	          endColumn = next - nextOffset;
+	        } else if (code === t.slash) {
+	          next = start;
+	          tokenType = code;
+	          endLine = line;
+	          endColumn = start - offset;
+	          end = next + 1;
+	        } else {
+	          next = consumeWord(css, start);
+	          tokenType = t.word;
+	          endLine = line;
+	          endColumn = next - offset;
+	        }
+	        end = next + 1;
+	        break;
+	    }
+
+	    // Ensure that the token structure remains consistent
+	    tokens.push([tokenType,
+	    // [0] Token type
+	    line,
+	    // [1] Starting line
+	    start - offset,
+	    // [2] Starting column
+	    endLine,
+	    // [3] Ending line
+	    endColumn,
+	    // [4] Ending column
+	    start,
+	    // [5] Start position / Source index
+	    end // [6] End position
+	    ]);
+
+	    // Reset offset for the next token
+	    if (nextOffset) {
+	      offset = nextOffset;
+	      nextOffset = null;
+	    }
+	    start = end;
+	  }
+	  return tokens;
+	} 
+} (tokenize));
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _root = _interopRequireDefault(rootExports);
+	var _selector = _interopRequireDefault(selectorExports);
+	var _className = _interopRequireDefault(classNameExports);
+	var _comment = _interopRequireDefault(commentExports);
+	var _id = _interopRequireDefault(idExports);
+	var _tag = _interopRequireDefault(tagExports);
+	var _string = _interopRequireDefault(stringExports);
+	var _pseudo = _interopRequireDefault(pseudoExports);
+	var _attribute = _interopRequireWildcard(attribute$1);
+	var _universal = _interopRequireDefault(universalExports);
+	var _combinator = _interopRequireDefault(combinatorExports);
+	var _nesting = _interopRequireDefault(nestingExports);
+	var _sortAscending = _interopRequireDefault(sortAscendingExports);
+	var _tokenize = _interopRequireWildcard(tokenize);
+	var tokens = _interopRequireWildcard(tokenTypes);
+	var types$1 = _interopRequireWildcard(types);
+	var _util = util;
+	var _WHITESPACE_TOKENS, _Object$assign;
+	function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+	function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+	var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
+	var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
+	function tokenStart(token) {
+	  return {
+	    line: token[_tokenize.FIELDS.START_LINE],
+	    column: token[_tokenize.FIELDS.START_COL]
+	  };
+	}
+	function tokenEnd(token) {
+	  return {
+	    line: token[_tokenize.FIELDS.END_LINE],
+	    column: token[_tokenize.FIELDS.END_COL]
+	  };
+	}
+	function getSource(startLine, startColumn, endLine, endColumn) {
+	  return {
+	    start: {
+	      line: startLine,
+	      column: startColumn
+	    },
+	    end: {
+	      line: endLine,
+	      column: endColumn
+	    }
+	  };
+	}
+	function getTokenSource(token) {
+	  return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
+	}
+	function getTokenSourceSpan(startToken, endToken) {
+	  if (!startToken) {
+	    return undefined;
+	  }
+	  return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
+	}
+	function unescapeProp(node, prop) {
+	  var value = node[prop];
+	  if (typeof value !== "string") {
+	    return;
+	  }
+	  if (value.indexOf("\\") !== -1) {
+	    (0, _util.ensureObject)(node, 'raws');
+	    node[prop] = (0, _util.unesc)(value);
+	    if (node.raws[prop] === undefined) {
+	      node.raws[prop] = value;
+	    }
+	  }
+	  return node;
+	}
+	function indexesOf(array, item) {
+	  var i = -1;
+	  var indexes = [];
+	  while ((i = array.indexOf(item, i + 1)) !== -1) {
+	    indexes.push(i);
+	  }
+	  return indexes;
+	}
+	function uniqs() {
+	  var list = Array.prototype.concat.apply([], arguments);
+	  return list.filter(function (item, i) {
+	    return i === list.indexOf(item);
+	  });
+	}
+	var Parser = /*#__PURE__*/function () {
+	  function Parser(rule, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    this.rule = rule;
+	    this.options = Object.assign({
+	      lossy: false,
+	      safe: false
+	    }, options);
+	    this.position = 0;
+	    this.css = typeof this.rule === 'string' ? this.rule : this.rule.selector;
+	    this.tokens = (0, _tokenize["default"])({
+	      css: this.css,
+	      error: this._errorGenerator(),
+	      safe: this.options.safe
+	    });
+	    var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
+	    this.root = new _root["default"]({
+	      source: rootSource
+	    });
+	    this.root.errorGenerator = this._errorGenerator();
+	    var selector = new _selector["default"]({
+	      source: {
+	        start: {
+	          line: 1,
+	          column: 1
+	        }
+	      },
+	      sourceIndex: 0
+	    });
+	    this.root.append(selector);
+	    this.current = selector;
+	    this.loop();
+	  }
+	  var _proto = Parser.prototype;
+	  _proto._errorGenerator = function _errorGenerator() {
+	    var _this = this;
+	    return function (message, errorOptions) {
+	      if (typeof _this.rule === 'string') {
+	        return new Error(message);
+	      }
+	      return _this.rule.error(message, errorOptions);
+	    };
+	  };
+	  _proto.attribute = function attribute() {
+	    var attr = [];
+	    var startingToken = this.currToken;
+	    this.position++;
+	    while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+	      attr.push(this.currToken);
+	      this.position++;
+	    }
+	    if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
+	      return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+	    }
+	    var len = attr.length;
+	    var node = {
+	      source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
+	      sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+	    };
+	    if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
+	      return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
+	    }
+	    var pos = 0;
+	    var spaceBefore = '';
+	    var commentBefore = '';
+	    var lastAdded = null;
+	    var spaceAfterMeaningfulToken = false;
+	    while (pos < len) {
+	      var token = attr[pos];
+	      var content = this.content(token);
+	      var next = attr[pos + 1];
+	      switch (token[_tokenize.FIELDS.TYPE]) {
+	        case tokens.space:
+	          // if (
+	          //     len === 1 ||
+	          //     pos === 0 && this.content(next) === '|'
+	          // ) {
+	          //     return this.expected('attribute', token[TOKEN.START_POS], content);
+	          // }
+	          spaceAfterMeaningfulToken = true;
+	          if (this.options.lossy) {
+	            break;
+	          }
+	          if (lastAdded) {
+	            (0, _util.ensureObject)(node, 'spaces', lastAdded);
+	            var prevContent = node.spaces[lastAdded].after || '';
+	            node.spaces[lastAdded].after = prevContent + content;
+	            var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
+	            if (existingComment) {
+	              node.raws.spaces[lastAdded].after = existingComment + content;
+	            }
+	          } else {
+	            spaceBefore = spaceBefore + content;
+	            commentBefore = commentBefore + content;
+	          }
+	          break;
+	        case tokens.asterisk:
+	          if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+	            node.operator = content;
+	            lastAdded = 'operator';
+	          } else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
+	            if (spaceBefore) {
+	              (0, _util.ensureObject)(node, 'spaces', 'attribute');
+	              node.spaces.attribute.before = spaceBefore;
+	              spaceBefore = '';
+	            }
+	            if (commentBefore) {
+	              (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+	              node.raws.spaces.attribute.before = spaceBefore;
+	              commentBefore = '';
+	            }
+	            node.namespace = (node.namespace || "") + content;
+	            var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
+	            if (rawValue) {
+	              node.raws.namespace += content;
+	            }
+	            lastAdded = 'namespace';
+	          }
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.dollar:
+	          if (lastAdded === "value") {
+	            var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
+	            node.value += "$";
+	            if (oldRawValue) {
+	              node.raws.value = oldRawValue + "$";
+	            }
+	            break;
+	          }
+	        // Falls through
+	        case tokens.caret:
+	          if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+	            node.operator = content;
+	            lastAdded = 'operator';
+	          }
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.combinator:
+	          if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+	            node.operator = content;
+	            lastAdded = 'operator';
+	          }
+	          if (content !== '|') {
+	            spaceAfterMeaningfulToken = false;
+	            break;
+	          }
+	          if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
+	            node.operator = content;
+	            lastAdded = 'operator';
+	          } else if (!node.namespace && !node.attribute) {
+	            node.namespace = true;
+	          }
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.word:
+	          if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals &&
+	          // this look-ahead probably fails with comment nodes involved.
+	          !node.operator && !node.namespace) {
+	            node.namespace = content;
+	            lastAdded = 'namespace';
+	          } else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
+	            if (spaceBefore) {
+	              (0, _util.ensureObject)(node, 'spaces', 'attribute');
+	              node.spaces.attribute.before = spaceBefore;
+	              spaceBefore = '';
+	            }
+	            if (commentBefore) {
+	              (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
+	              node.raws.spaces.attribute.before = commentBefore;
+	              commentBefore = '';
+	            }
+	            node.attribute = (node.attribute || "") + content;
+	            var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
+	            if (_rawValue) {
+	              node.raws.attribute += content;
+	            }
+	            lastAdded = 'attribute';
+	          } else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
+	            var _unescaped = (0, _util.unesc)(content);
+	            var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
+	            var oldValue = node.value || '';
+	            node.value = oldValue + _unescaped;
+	            node.quoteMark = null;
+	            if (_unescaped !== content || _oldRawValue) {
+	              (0, _util.ensureObject)(node, 'raws');
+	              node.raws.value = (_oldRawValue || oldValue) + content;
+	            }
+	            lastAdded = 'value';
+	          } else {
+	            var insensitive = content === 'i' || content === "I";
+	            if ((node.value || node.value === '') && (node.quoteMark || spaceAfterMeaningfulToken)) {
+	              node.insensitive = insensitive;
+	              if (!insensitive || content === "I") {
+	                (0, _util.ensureObject)(node, 'raws');
+	                node.raws.insensitiveFlag = content;
+	              }
+	              lastAdded = 'insensitive';
+	              if (spaceBefore) {
+	                (0, _util.ensureObject)(node, 'spaces', 'insensitive');
+	                node.spaces.insensitive.before = spaceBefore;
+	                spaceBefore = '';
+	              }
+	              if (commentBefore) {
+	                (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
+	                node.raws.spaces.insensitive.before = commentBefore;
+	                commentBefore = '';
+	              }
+	            } else if (node.value || node.value === '') {
+	              lastAdded = 'value';
+	              node.value += content;
+	              if (node.raws.value) {
+	                node.raws.value += content;
+	              }
+	            }
+	          }
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.str:
+	          if (!node.attribute || !node.operator) {
+	            return this.error("Expected an attribute followed by an operator preceding the string.", {
+	              index: token[_tokenize.FIELDS.START_POS]
+	            });
+	          }
+	          var _unescapeValue = (0, _attribute.unescapeValue)(content),
+	            unescaped = _unescapeValue.unescaped,
+	            quoteMark = _unescapeValue.quoteMark;
+	          node.value = unescaped;
+	          node.quoteMark = quoteMark;
+	          lastAdded = 'value';
+	          (0, _util.ensureObject)(node, 'raws');
+	          node.raws.value = content;
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.equals:
+	          if (!node.attribute) {
+	            return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
+	          }
+	          if (node.value) {
+	            return this.error('Unexpected "=" found; an operator was already defined.', {
+	              index: token[_tokenize.FIELDS.START_POS]
+	            });
+	          }
+	          node.operator = node.operator ? node.operator + content : content;
+	          lastAdded = 'operator';
+	          spaceAfterMeaningfulToken = false;
+	          break;
+	        case tokens.comment:
+	          if (lastAdded) {
+	            if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === 'insensitive') {
+	              var lastComment = (0, _util.getProp)(node, 'spaces', lastAdded, 'after') || '';
+	              var rawLastComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || lastComment;
+	              (0, _util.ensureObject)(node, 'raws', 'spaces', lastAdded);
+	              node.raws.spaces[lastAdded].after = rawLastComment + content;
+	            } else {
+	              var lastValue = node[lastAdded] || '';
+	              var rawLastValue = (0, _util.getProp)(node, 'raws', lastAdded) || lastValue;
+	              (0, _util.ensureObject)(node, 'raws');
+	              node.raws[lastAdded] = rawLastValue + content;
+	            }
+	          } else {
+	            commentBefore = commentBefore + content;
+	          }
+	          break;
+	        default:
+	          return this.error("Unexpected \"" + content + "\" found.", {
+	            index: token[_tokenize.FIELDS.START_POS]
+	          });
+	      }
+	      pos++;
+	    }
+	    unescapeProp(node, "attribute");
+	    unescapeProp(node, "namespace");
+	    this.newNode(new _attribute["default"](node));
+	    this.position++;
+	  }
+
+	  /**
+	   * return a node containing meaningless garbage up to (but not including) the specified token position.
+	   * if the token position is negative, all remaining tokens are consumed.
+	   *
+	   * This returns an array containing a single string node if all whitespace,
+	   * otherwise an array of comment nodes with space before and after.
+	   *
+	   * These tokens are not added to the current selector, the caller can add them or use them to amend
+	   * a previous node's space metadata.
+	   *
+	   * In lossy mode, this returns only comments.
+	   */;
+	  _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
+	    if (stopPosition < 0) {
+	      stopPosition = this.tokens.length;
+	    }
+	    var startPosition = this.position;
+	    var nodes = [];
+	    var space = "";
+	    var lastComment = undefined;
+	    do {
+	      if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
+	        if (!this.options.lossy) {
+	          space += this.content();
+	        }
+	      } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
+	        var spaces = {};
+	        if (space) {
+	          spaces.before = space;
+	          space = "";
+	        }
+	        lastComment = new _comment["default"]({
+	          value: this.content(),
+	          source: getTokenSource(this.currToken),
+	          sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+	          spaces: spaces
+	        });
+	        nodes.push(lastComment);
+	      }
+	    } while (++this.position < stopPosition);
+	    if (space) {
+	      if (lastComment) {
+	        lastComment.spaces.after = space;
+	      } else if (!this.options.lossy) {
+	        var firstToken = this.tokens[startPosition];
+	        var lastToken = this.tokens[this.position - 1];
+	        nodes.push(new _string["default"]({
+	          value: '',
+	          source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
+	          sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+	          spaces: {
+	            before: space,
+	            after: ''
+	          }
+	        }));
+	      }
+	    }
+	    return nodes;
+	  }
+
+	  /**
+	   *
+	   * @param {*} nodes
+	   */;
+	  _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
+	    var _this2 = this;
+	    if (requiredSpace === void 0) {
+	      requiredSpace = false;
+	    }
+	    var space = "";
+	    var rawSpace = "";
+	    nodes.forEach(function (n) {
+	      var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
+	      var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
+	      space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
+	      rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
+	    });
+	    if (rawSpace === space) {
+	      rawSpace = undefined;
+	    }
+	    var result = {
+	      space: space,
+	      rawSpace: rawSpace
+	    };
+	    return result;
+	  };
+	  _proto.isNamedCombinator = function isNamedCombinator(position) {
+	    if (position === void 0) {
+	      position = this.position;
+	    }
+	    return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
+	  };
+	  _proto.namedCombinator = function namedCombinator() {
+	    if (this.isNamedCombinator()) {
+	      var nameRaw = this.content(this.tokens[this.position + 1]);
+	      var name = (0, _util.unesc)(nameRaw).toLowerCase();
+	      var raws = {};
+	      if (name !== nameRaw) {
+	        raws.value = "/" + nameRaw + "/";
+	      }
+	      var node = new _combinator["default"]({
+	        value: "/" + name + "/",
+	        source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
+	        sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
+	        raws: raws
+	      });
+	      this.position = this.position + 3;
+	      return node;
+	    } else {
+	      this.unexpected();
+	    }
+	  };
+	  _proto.combinator = function combinator() {
+	    var _this3 = this;
+	    if (this.content() === '|') {
+	      return this.namespace();
+	    }
+	    // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
+	    var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
+	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+	      var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+	      if (nodes.length > 0) {
+	        var last = this.current.last;
+	        if (last) {
+	          var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes),
+	            space = _this$convertWhitespa.space,
+	            rawSpace = _this$convertWhitespa.rawSpace;
+	          if (rawSpace !== undefined) {
+	            last.rawSpaceAfter += rawSpace;
+	          }
+	          last.spaces.after += space;
+	        } else {
+	          nodes.forEach(function (n) {
+	            return _this3.newNode(n);
+	          });
+	        }
+	      }
+	      return;
+	    }
+	    var firstToken = this.currToken;
+	    var spaceOrDescendantSelectorNodes = undefined;
+	    if (nextSigTokenPos > this.position) {
+	      spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
+	    }
+	    var node;
+	    if (this.isNamedCombinator()) {
+	      node = this.namedCombinator();
+	    } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
+	      node = new _combinator["default"]({
+	        value: this.content(),
+	        source: getTokenSource(this.currToken),
+	        sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
+	      });
+	      this.position++;
+	    } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) ; else if (!spaceOrDescendantSelectorNodes) {
+	      this.unexpected();
+	    }
+	    if (node) {
+	      if (spaceOrDescendantSelectorNodes) {
+	        var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
+	          _space = _this$convertWhitespa2.space,
+	          _rawSpace = _this$convertWhitespa2.rawSpace;
+	        node.spaces.before = _space;
+	        node.rawSpaceBefore = _rawSpace;
+	      }
+	    } else {
+	      // descendant combinator
+	      var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
+	        _space2 = _this$convertWhitespa3.space,
+	        _rawSpace2 = _this$convertWhitespa3.rawSpace;
+	      if (!_rawSpace2) {
+	        _rawSpace2 = _space2;
+	      }
+	      var spaces = {};
+	      var raws = {
+	        spaces: {}
+	      };
+	      if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
+	        spaces.before = _space2.slice(0, _space2.length - 1);
+	        raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
+	      } else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) {
+	        spaces.after = _space2.slice(1);
+	        raws.spaces.after = _rawSpace2.slice(1);
+	      } else {
+	        raws.value = _rawSpace2;
+	      }
+	      node = new _combinator["default"]({
+	        value: ' ',
+	        source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
+	        sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
+	        spaces: spaces,
+	        raws: raws
+	      });
+	    }
+	    if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
+	      node.spaces.after = this.optionalSpace(this.content());
+	      this.position++;
+	    }
+	    return this.newNode(node);
+	  };
+	  _proto.comma = function comma() {
+	    if (this.position === this.tokens.length - 1) {
+	      this.root.trailingComma = true;
+	      this.position++;
+	      return;
+	    }
+	    this.current._inferEndPosition();
+	    var selector = new _selector["default"]({
+	      source: {
+	        start: tokenStart(this.tokens[this.position + 1])
+	      },
+	      sourceIndex: this.tokens[this.position + 1][_tokenize.FIELDS.START_POS]
+	    });
+	    this.current.parent.append(selector);
+	    this.current = selector;
+	    this.position++;
+	  };
+	  _proto.comment = function comment() {
+	    var current = this.currToken;
+	    this.newNode(new _comment["default"]({
+	      value: this.content(),
+	      source: getTokenSource(current),
+	      sourceIndex: current[_tokenize.FIELDS.START_POS]
+	    }));
+	    this.position++;
+	  };
+	  _proto.error = function error(message, opts) {
+	    throw this.root.error(message, opts);
+	  };
+	  _proto.missingBackslash = function missingBackslash() {
+	    return this.error('Expected a backslash preceding the semicolon.', {
+	      index: this.currToken[_tokenize.FIELDS.START_POS]
+	    });
+	  };
+	  _proto.missingParenthesis = function missingParenthesis() {
+	    return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+	  };
+	  _proto.missingSquareBracket = function missingSquareBracket() {
+	    return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
+	  };
+	  _proto.unexpected = function unexpected() {
+	    return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
+	  };
+	  _proto.unexpectedPipe = function unexpectedPipe() {
+	    return this.error("Unexpected '|'.", this.currToken[_tokenize.FIELDS.START_POS]);
+	  };
+	  _proto.namespace = function namespace() {
+	    var before = this.prevToken && this.content(this.prevToken) || true;
+	    if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+	      this.position++;
+	      return this.word(before);
+	    } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
+	      this.position++;
+	      return this.universal(before);
+	    }
+	    this.unexpectedPipe();
+	  };
+	  _proto.nesting = function nesting() {
+	    if (this.nextToken) {
+	      var nextContent = this.content(this.nextToken);
+	      if (nextContent === "|") {
+	        this.position++;
+	        return;
+	      }
+	    }
+	    var current = this.currToken;
+	    this.newNode(new _nesting["default"]({
+	      value: this.content(),
+	      source: getTokenSource(current),
+	      sourceIndex: current[_tokenize.FIELDS.START_POS]
+	    }));
+	    this.position++;
+	  };
+	  _proto.parentheses = function parentheses() {
+	    var last = this.current.last;
+	    var unbalanced = 1;
+	    this.position++;
+	    if (last && last.type === types$1.PSEUDO) {
+	      var selector = new _selector["default"]({
+	        source: {
+	          start: tokenStart(this.tokens[this.position])
+	        },
+	        sourceIndex: this.tokens[this.position][_tokenize.FIELDS.START_POS]
+	      });
+	      var cache = this.current;
+	      last.append(selector);
+	      this.current = selector;
+	      while (this.position < this.tokens.length && unbalanced) {
+	        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+	          unbalanced++;
+	        }
+	        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+	          unbalanced--;
+	        }
+	        if (unbalanced) {
+	          this.parse();
+	        } else {
+	          this.current.source.end = tokenEnd(this.currToken);
+	          this.current.parent.source.end = tokenEnd(this.currToken);
+	          this.position++;
+	        }
+	      }
+	      this.current = cache;
+	    } else {
+	      // I think this case should be an error. It's used to implement a basic parse of media queries
+	      // but I don't think it's a good idea.
+	      var parenStart = this.currToken;
+	      var parenValue = "(";
+	      var parenEnd;
+	      while (this.position < this.tokens.length && unbalanced) {
+	        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+	          unbalanced++;
+	        }
+	        if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+	          unbalanced--;
+	        }
+	        parenEnd = this.currToken;
+	        parenValue += this.parseParenthesisToken(this.currToken);
+	        this.position++;
+	      }
+	      if (last) {
+	        last.appendToPropertyAndEscape("value", parenValue, parenValue);
+	      } else {
+	        this.newNode(new _string["default"]({
+	          value: parenValue,
+	          source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
+	          sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
+	        }));
+	      }
+	    }
+	    if (unbalanced) {
+	      return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
+	    }
+	  };
+	  _proto.pseudo = function pseudo() {
+	    var _this4 = this;
+	    var pseudoStr = '';
+	    var startingToken = this.currToken;
+	    while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
+	      pseudoStr += this.content();
+	      this.position++;
+	    }
+	    if (!this.currToken) {
+	      return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
+	    }
+	    if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
+	      this.splitWord(false, function (first, length) {
+	        pseudoStr += first;
+	        _this4.newNode(new _pseudo["default"]({
+	          value: pseudoStr,
+	          source: getTokenSourceSpan(startingToken, _this4.currToken),
+	          sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
+	        }));
+	        if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
+	          _this4.error('Misplaced parenthesis.', {
+	            index: _this4.nextToken[_tokenize.FIELDS.START_POS]
+	          });
+	        }
+	      });
+	    } else {
+	      return this.expected(['pseudo-class', 'pseudo-element'], this.currToken[_tokenize.FIELDS.START_POS]);
+	    }
+	  };
+	  _proto.space = function space() {
+	    var content = this.content();
+	    // Handle space before and after the selector
+	    if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function (node) {
+	      return node.type === 'comment';
+	    })) {
+	      this.spaces = this.optionalSpace(content);
+	      this.position++;
+	    } else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
+	      this.current.last.spaces.after = this.optionalSpace(content);
+	      this.position++;
+	    } else {
+	      this.combinator();
+	    }
+	  };
+	  _proto.string = function string() {
+	    var current = this.currToken;
+	    this.newNode(new _string["default"]({
+	      value: this.content(),
+	      source: getTokenSource(current),
+	      sourceIndex: current[_tokenize.FIELDS.START_POS]
+	    }));
+	    this.position++;
+	  };
+	  _proto.universal = function universal(namespace) {
+	    var nextToken = this.nextToken;
+	    if (nextToken && this.content(nextToken) === '|') {
+	      this.position++;
+	      return this.namespace();
+	    }
+	    var current = this.currToken;
+	    this.newNode(new _universal["default"]({
+	      value: this.content(),
+	      source: getTokenSource(current),
+	      sourceIndex: current[_tokenize.FIELDS.START_POS]
+	    }), namespace);
+	    this.position++;
+	  };
+	  _proto.splitWord = function splitWord(namespace, firstCallback) {
+	    var _this5 = this;
+	    var nextToken = this.nextToken;
+	    var word = this.content();
+	    while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
+	      this.position++;
+	      var current = this.content();
+	      word += current;
+	      if (current.lastIndexOf('\\') === current.length - 1) {
+	        var next = this.nextToken;
+	        if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
+	          word += this.requiredSpace(this.content(next));
+	          this.position++;
+	        }
+	      }
+	      nextToken = this.nextToken;
+	    }
+	    var hasClass = indexesOf(word, '.').filter(function (i) {
+	      // Allow escaped dot within class name
+	      var escapedDot = word[i - 1] === '\\';
+	      // Allow decimal numbers percent in @keyframes
+	      var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
+	      return !escapedDot && !isKeyframesPercent;
+	    });
+	    var hasId = indexesOf(word, '#').filter(function (i) {
+	      return word[i - 1] !== '\\';
+	    });
+	    // Eliminate Sass interpolations from the list of id indexes
+	    var interpolations = indexesOf(word, '#{');
+	    if (interpolations.length) {
+	      hasId = hasId.filter(function (hashIndex) {
+	        return !~interpolations.indexOf(hashIndex);
+	      });
+	    }
+	    var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
+	    indices.forEach(function (ind, i) {
+	      var index = indices[i + 1] || word.length;
+	      var value = word.slice(ind, index);
+	      if (i === 0 && firstCallback) {
+	        return firstCallback.call(_this5, value, indices.length);
+	      }
+	      var node;
+	      var current = _this5.currToken;
+	      var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
+	      var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
+	      if (~hasClass.indexOf(ind)) {
+	        var classNameOpts = {
+	          value: value.slice(1),
+	          source: source,
+	          sourceIndex: sourceIndex
+	        };
+	        node = new _className["default"](unescapeProp(classNameOpts, "value"));
+	      } else if (~hasId.indexOf(ind)) {
+	        var idOpts = {
+	          value: value.slice(1),
+	          source: source,
+	          sourceIndex: sourceIndex
+	        };
+	        node = new _id["default"](unescapeProp(idOpts, "value"));
+	      } else {
+	        var tagOpts = {
+	          value: value,
+	          source: source,
+	          sourceIndex: sourceIndex
+	        };
+	        unescapeProp(tagOpts, "value");
+	        node = new _tag["default"](tagOpts);
+	      }
+	      _this5.newNode(node, namespace);
+	      // Ensure that the namespace is used only once
+	      namespace = null;
+	    });
+	    this.position++;
+	  };
+	  _proto.word = function word(namespace) {
+	    var nextToken = this.nextToken;
+	    if (nextToken && this.content(nextToken) === '|') {
+	      this.position++;
+	      return this.namespace();
+	    }
+	    return this.splitWord(namespace);
+	  };
+	  _proto.loop = function loop() {
+	    while (this.position < this.tokens.length) {
+	      this.parse(true);
+	    }
+	    this.current._inferEndPosition();
+	    return this.root;
+	  };
+	  _proto.parse = function parse(throwOnParenthesis) {
+	    switch (this.currToken[_tokenize.FIELDS.TYPE]) {
+	      case tokens.space:
+	        this.space();
+	        break;
+	      case tokens.comment:
+	        this.comment();
+	        break;
+	      case tokens.openParenthesis:
+	        this.parentheses();
+	        break;
+	      case tokens.closeParenthesis:
+	        if (throwOnParenthesis) {
+	          this.missingParenthesis();
+	        }
+	        break;
+	      case tokens.openSquare:
+	        this.attribute();
+	        break;
+	      case tokens.dollar:
+	      case tokens.caret:
+	      case tokens.equals:
+	      case tokens.word:
+	        this.word();
+	        break;
+	      case tokens.colon:
+	        this.pseudo();
+	        break;
+	      case tokens.comma:
+	        this.comma();
+	        break;
+	      case tokens.asterisk:
+	        this.universal();
+	        break;
+	      case tokens.ampersand:
+	        this.nesting();
+	        break;
+	      case tokens.slash:
+	      case tokens.combinator:
+	        this.combinator();
+	        break;
+	      case tokens.str:
+	        this.string();
+	        break;
+	      // These cases throw; no break needed.
+	      case tokens.closeSquare:
+	        this.missingSquareBracket();
+	      case tokens.semicolon:
+	        this.missingBackslash();
+	      default:
+	        this.unexpected();
+	    }
+	  }
+
+	  /**
+	   * Helpers
+	   */;
+	  _proto.expected = function expected(description, index, found) {
+	    if (Array.isArray(description)) {
+	      var last = description.pop();
+	      description = description.join(', ') + " or " + last;
+	    }
+	    var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
+	    if (!found) {
+	      return this.error("Expected " + an + " " + description + ".", {
+	        index: index
+	      });
+	    }
+	    return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", {
+	      index: index
+	    });
+	  };
+	  _proto.requiredSpace = function requiredSpace(space) {
+	    return this.options.lossy ? ' ' : space;
+	  };
+	  _proto.optionalSpace = function optionalSpace(space) {
+	    return this.options.lossy ? '' : space;
+	  };
+	  _proto.lossySpace = function lossySpace(space, required) {
+	    if (this.options.lossy) {
+	      return required ? ' ' : '';
+	    } else {
+	      return space;
+	    }
+	  };
+	  _proto.parseParenthesisToken = function parseParenthesisToken(token) {
+	    var content = this.content(token);
+	    if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
+	      return this.requiredSpace(content);
+	    } else {
+	      return content;
+	    }
+	  };
+	  _proto.newNode = function newNode(node, namespace) {
+	    if (namespace) {
+	      if (/^ +$/.test(namespace)) {
+	        if (!this.options.lossy) {
+	          this.spaces = (this.spaces || '') + namespace;
+	        }
+	        namespace = true;
+	      }
+	      node.namespace = namespace;
+	      unescapeProp(node, "namespace");
+	    }
+	    if (this.spaces) {
+	      node.spaces.before = this.spaces;
+	      this.spaces = '';
+	    }
+	    return this.current.append(node);
+	  };
+	  _proto.content = function content(token) {
+	    if (token === void 0) {
+	      token = this.currToken;
+	    }
+	    return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
+	  };
+	  /**
+	   * returns the index of the next non-whitespace, non-comment token.
+	   * returns -1 if no meaningful token is found.
+	   */
+	  _proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
+	    if (startPosition === void 0) {
+	      startPosition = this.position + 1;
+	    }
+	    var searchPosition = startPosition;
+	    while (searchPosition < this.tokens.length) {
+	      if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
+	        searchPosition++;
+	        continue;
+	      } else {
+	        return searchPosition;
+	      }
+	    }
+	    return -1;
+	  };
+	  _createClass(Parser, [{
+	    key: "currToken",
+	    get: function get() {
+	      return this.tokens[this.position];
+	    }
+	  }, {
+	    key: "nextToken",
+	    get: function get() {
+	      return this.tokens[this.position + 1];
+	    }
+	  }, {
+	    key: "prevToken",
+	    get: function get() {
+	      return this.tokens[this.position - 1];
+	    }
+	  }]);
+	  return Parser;
+	}();
+	exports["default"] = Parser;
+	module.exports = exports.default; 
+} (parser, parser.exports));
+
+var parserExports = parser.exports;
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _parser = _interopRequireDefault(parserExports);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	var Processor = /*#__PURE__*/function () {
+	  function Processor(func, options) {
+	    this.func = func || function noop() {};
+	    this.funcRes = null;
+	    this.options = options;
+	  }
+	  var _proto = Processor.prototype;
+	  _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    var merged = Object.assign({}, this.options, options);
+	    if (merged.updateSelector === false) {
+	      return false;
+	    } else {
+	      return typeof rule !== "string";
+	    }
+	  };
+	  _proto._isLossy = function _isLossy(options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    var merged = Object.assign({}, this.options, options);
+	    if (merged.lossless === false) {
+	      return true;
+	    } else {
+	      return false;
+	    }
+	  };
+	  _proto._root = function _root(rule, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    var parser = new _parser["default"](rule, this._parseOptions(options));
+	    return parser.root;
+	  };
+	  _proto._parseOptions = function _parseOptions(options) {
+	    return {
+	      lossy: this._isLossy(options)
+	    };
+	  };
+	  _proto._run = function _run(rule, options) {
+	    var _this = this;
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    return new Promise(function (resolve, reject) {
+	      try {
+	        var root = _this._root(rule, options);
+	        Promise.resolve(_this.func(root)).then(function (transform) {
+	          var string = undefined;
+	          if (_this._shouldUpdateSelector(rule, options)) {
+	            string = root.toString();
+	            rule.selector = string;
+	          }
+	          return {
+	            transform: transform,
+	            root: root,
+	            string: string
+	          };
+	        }).then(resolve, reject);
+	      } catch (e) {
+	        reject(e);
+	        return;
+	      }
+	    });
+	  };
+	  _proto._runSync = function _runSync(rule, options) {
+	    if (options === void 0) {
+	      options = {};
+	    }
+	    var root = this._root(rule, options);
+	    var transform = this.func(root);
+	    if (transform && typeof transform.then === "function") {
+	      throw new Error("Selector processor returned a promise to a synchronous call.");
+	    }
+	    var string = undefined;
+	    if (options.updateSelector && typeof rule !== "string") {
+	      string = root.toString();
+	      rule.selector = string;
+	    }
+	    return {
+	      transform: transform,
+	      root: root,
+	      string: string
+	    };
+	  }
+
+	  /**
+	   * Process rule into a selector AST.
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {Promise<parser.Root>} The AST of the selector after processing it.
+	   */;
+	  _proto.ast = function ast(rule, options) {
+	    return this._run(rule, options).then(function (result) {
+	      return result.root;
+	    });
+	  }
+
+	  /**
+	   * Process rule into a selector AST synchronously.
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {parser.Root} The AST of the selector after processing it.
+	   */;
+	  _proto.astSync = function astSync(rule, options) {
+	    return this._runSync(rule, options).root;
+	  }
+
+	  /**
+	   * Process a selector into a transformed value asynchronously
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {Promise<any>} The value returned by the processor.
+	   */;
+	  _proto.transform = function transform(rule, options) {
+	    return this._run(rule, options).then(function (result) {
+	      return result.transform;
+	    });
+	  }
+
+	  /**
+	   * Process a selector into a transformed value synchronously.
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {any} The value returned by the processor.
+	   */;
+	  _proto.transformSync = function transformSync(rule, options) {
+	    return this._runSync(rule, options).transform;
+	  }
+
+	  /**
+	   * Process a selector into a new selector string asynchronously.
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {string} the selector after processing.
+	   */;
+	  _proto.process = function process(rule, options) {
+	    return this._run(rule, options).then(function (result) {
+	      return result.string || result.root.toString();
+	    });
+	  }
+
+	  /**
+	   * Process a selector into a new selector string synchronously.
+	   *
+	   * @param rule {postcss.Rule | string} The css selector to be processed
+	   * @param options The options for processing
+	   * @returns {string} the selector after processing.
+	   */;
+	  _proto.processSync = function processSync(rule, options) {
+	    var result = this._runSync(rule, options);
+	    return result.string || result.root.toString();
+	  };
+	  return Processor;
+	}();
+	exports["default"] = Processor;
+	module.exports = exports.default; 
+} (processor, processor.exports));
+
+var processorExports = processor.exports;
+
+var selectors = {};
+
+var constructors = {};
+
+constructors.__esModule = true;
+constructors.universal = constructors.tag = constructors.string = constructors.selector = constructors.root = constructors.pseudo = constructors.nesting = constructors.id = constructors.comment = constructors.combinator = constructors.className = constructors.attribute = void 0;
+var _attribute = _interopRequireDefault$2(attribute$1);
+var _className = _interopRequireDefault$2(classNameExports);
+var _combinator = _interopRequireDefault$2(combinatorExports);
+var _comment = _interopRequireDefault$2(commentExports);
+var _id = _interopRequireDefault$2(idExports);
+var _nesting = _interopRequireDefault$2(nestingExports);
+var _pseudo = _interopRequireDefault$2(pseudoExports);
+var _root = _interopRequireDefault$2(rootExports);
+var _selector = _interopRequireDefault$2(selectorExports);
+var _string = _interopRequireDefault$2(stringExports);
+var _tag = _interopRequireDefault$2(tagExports);
+var _universal = _interopRequireDefault$2(universalExports);
+function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var attribute = function attribute(opts) {
+  return new _attribute["default"](opts);
+};
+constructors.attribute = attribute;
+var className = function className(opts) {
+  return new _className["default"](opts);
+};
+constructors.className = className;
+var combinator = function combinator(opts) {
+  return new _combinator["default"](opts);
+};
+constructors.combinator = combinator;
+var comment = function comment(opts) {
+  return new _comment["default"](opts);
+};
+constructors.comment = comment;
+var id = function id(opts) {
+  return new _id["default"](opts);
+};
+constructors.id = id;
+var nesting = function nesting(opts) {
+  return new _nesting["default"](opts);
+};
+constructors.nesting = nesting;
+var pseudo = function pseudo(opts) {
+  return new _pseudo["default"](opts);
+};
+constructors.pseudo = pseudo;
+var root = function root(opts) {
+  return new _root["default"](opts);
+};
+constructors.root = root;
+var selector = function selector(opts) {
+  return new _selector["default"](opts);
+};
+constructors.selector = selector;
+var string = function string(opts) {
+  return new _string["default"](opts);
+};
+constructors.string = string;
+var tag = function tag(opts) {
+  return new _tag["default"](opts);
+};
+constructors.tag = tag;
+var universal = function universal(opts) {
+  return new _universal["default"](opts);
+};
+constructors.universal = universal;
+
+var guards = {};
+
+guards.__esModule = true;
+guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0;
+guards.isContainer = isContainer;
+guards.isIdentifier = void 0;
+guards.isNamespace = isNamespace;
+guards.isNesting = void 0;
+guards.isNode = isNode;
+guards.isPseudo = void 0;
+guards.isPseudoClass = isPseudoClass;
+guards.isPseudoElement = isPseudoElement;
+guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = void 0;
+var _types = types;
+var _IS_TYPE;
+var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
+function isNode(node) {
+  return typeof node === "object" && IS_TYPE[node.type];
+}
+function isNodeType(type, node) {
+  return isNode(node) && node.type === type;
+}
+var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
+guards.isAttribute = isAttribute;
+var isClassName = isNodeType.bind(null, _types.CLASS);
+guards.isClassName = isClassName;
+var isCombinator = isNodeType.bind(null, _types.COMBINATOR);
+guards.isCombinator = isCombinator;
+var isComment = isNodeType.bind(null, _types.COMMENT);
+guards.isComment = isComment;
+var isIdentifier = isNodeType.bind(null, _types.ID);
+guards.isIdentifier = isIdentifier;
+var isNesting = isNodeType.bind(null, _types.NESTING);
+guards.isNesting = isNesting;
+var isPseudo = isNodeType.bind(null, _types.PSEUDO);
+guards.isPseudo = isPseudo;
+var isRoot = isNodeType.bind(null, _types.ROOT);
+guards.isRoot = isRoot;
+var isSelector = isNodeType.bind(null, _types.SELECTOR);
+guards.isSelector = isSelector;
+var isString = isNodeType.bind(null, _types.STRING);
+guards.isString = isString;
+var isTag = isNodeType.bind(null, _types.TAG);
+guards.isTag = isTag;
+var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
+guards.isUniversal = isUniversal;
+function isPseudoElement(node) {
+  return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
+}
+function isPseudoClass(node) {
+  return isPseudo(node) && !isPseudoElement(node);
+}
+function isContainer(node) {
+  return !!(isNode(node) && node.walk);
+}
+function isNamespace(node) {
+  return isAttribute(node) || isTag(node);
+}
+
+(function (exports) {
+
+	exports.__esModule = true;
+	var _types = types;
+	Object.keys(_types).forEach(function (key) {
+	  if (key === "default" || key === "__esModule") return;
+	  if (key in exports && exports[key] === _types[key]) return;
+	  exports[key] = _types[key];
+	});
+	var _constructors = constructors;
+	Object.keys(_constructors).forEach(function (key) {
+	  if (key === "default" || key === "__esModule") return;
+	  if (key in exports && exports[key] === _constructors[key]) return;
+	  exports[key] = _constructors[key];
+	});
+	var _guards = guards;
+	Object.keys(_guards).forEach(function (key) {
+	  if (key === "default" || key === "__esModule") return;
+	  if (key in exports && exports[key] === _guards[key]) return;
+	  exports[key] = _guards[key];
+	}); 
+} (selectors));
+
+(function (module, exports) {
+
+	exports.__esModule = true;
+	exports["default"] = void 0;
+	var _processor = _interopRequireDefault(processorExports);
+	var selectors$1 = _interopRequireWildcard(selectors);
+	function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+	function _interopRequireWildcard(obj, nodeInterop) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+	var parser = function parser(processor) {
+	  return new _processor["default"](processor);
+	};
+	Object.assign(parser, selectors$1);
+	delete parser.__esModule;
+	var _default = parser;
+	exports["default"] = _default;
+	module.exports = exports.default; 
+} (dist, dist.exports));
+
+var distExports = dist.exports;
+
+const selectorParser$1 = distExports;
+const valueParser = lib;
+const { extractICSS } = src$4;
+
+const isSpacing = (node) => node.type === "combinator" && node.value === " ";
+
+function normalizeNodeArray(nodes) {
+  const array = [];
+
+  nodes.forEach((x) => {
+    if (Array.isArray(x)) {
+      normalizeNodeArray(x).forEach((item) => {
+        array.push(item);
+      });
+    } else if (x) {
+      array.push(x);
+    }
+  });
+
+  if (array.length > 0 && isSpacing(array[array.length - 1])) {
+    array.pop();
+  }
+  return array;
+}
+
+function localizeNode(rule, mode, localAliasMap) {
+  const transform = (node, context) => {
+    if (context.ignoreNextSpacing && !isSpacing(node)) {
+      throw new Error("Missing whitespace after " + context.ignoreNextSpacing);
+    }
+
+    if (context.enforceNoSpacing && isSpacing(node)) {
+      throw new Error("Missing whitespace before " + context.enforceNoSpacing);
+    }
+
+    let newNodes;
+
+    switch (node.type) {
+      case "root": {
+        let resultingGlobal;
+
+        context.hasPureGlobals = false;
+
+        newNodes = node.nodes.map((n) => {
+          const nContext = {
+            global: context.global,
+            lastWasSpacing: true,
+            hasLocals: false,
+            explicit: false,
+          };
+
+          n = transform(n, nContext);
+
+          if (typeof resultingGlobal === "undefined") {
+            resultingGlobal = nContext.global;
+          } else if (resultingGlobal !== nContext.global) {
+            throw new Error(
+              'Inconsistent rule global/local result in rule "' +
+                node +
+                '" (multiple selectors must result in the same mode for the rule)'
+            );
+          }
+
+          if (!nContext.hasLocals) {
+            context.hasPureGlobals = true;
+          }
+
+          return n;
+        });
+
+        context.global = resultingGlobal;
+
+        node.nodes = normalizeNodeArray(newNodes);
+        break;
+      }
+      case "selector": {
+        newNodes = node.map((childNode) => transform(childNode, context));
+
+        node = node.clone();
+        node.nodes = normalizeNodeArray(newNodes);
+        break;
+      }
+      case "combinator": {
+        if (isSpacing(node)) {
+          if (context.ignoreNextSpacing) {
+            context.ignoreNextSpacing = false;
+            context.lastWasSpacing = false;
+            context.enforceNoSpacing = false;
+            return null;
+          }
+          context.lastWasSpacing = true;
+          return node;
+        }
+        break;
+      }
+      case "pseudo": {
+        let childContext;
+        const isNested = !!node.length;
+        const isScoped = node.value === ":local" || node.value === ":global";
+        const isImportExport =
+          node.value === ":import" || node.value === ":export";
+
+        if (isImportExport) {
+          context.hasLocals = true;
+          // :local(.foo)
+        } else if (isNested) {
+          if (isScoped) {
+            if (node.nodes.length === 0) {
+              throw new Error(`${node.value}() can't be empty`);
+            }
+
+            if (context.inside) {
+              throw new Error(
+                `A ${node.value} is not allowed inside of a ${context.inside}(...)`
+              );
+            }
+
+            childContext = {
+              global: node.value === ":global",
+              inside: node.value,
+              hasLocals: false,
+              explicit: true,
+            };
+
+            newNodes = node
+              .map((childNode) => transform(childNode, childContext))
+              .reduce((acc, next) => acc.concat(next.nodes), []);
+
+            if (newNodes.length) {
+              const { before, after } = node.spaces;
+
+              const first = newNodes[0];
+              const last = newNodes[newNodes.length - 1];
+
+              first.spaces = { before, after: first.spaces.after };
+              last.spaces = { before: last.spaces.before, after };
+            }
+
+            node = newNodes;
+
+            break;
+          } else {
+            childContext = {
+              global: context.global,
+              inside: context.inside,
+              lastWasSpacing: true,
+              hasLocals: false,
+              explicit: context.explicit,
+            };
+            newNodes = node.map((childNode) =>
+              transform(childNode, childContext)
+            );
+
+            node = node.clone();
+            node.nodes = normalizeNodeArray(newNodes);
+
+            if (childContext.hasLocals) {
+              context.hasLocals = true;
+            }
+          }
+          break;
+
+          //:local .foo .bar
+        } else if (isScoped) {
+          if (context.inside) {
+            throw new Error(
+              `A ${node.value} is not allowed inside of a ${context.inside}(...)`
+            );
+          }
+
+          const addBackSpacing = !!node.spaces.before;
+
+          context.ignoreNextSpacing = context.lastWasSpacing
+            ? node.value
+            : false;
+
+          context.enforceNoSpacing = context.lastWasSpacing
+            ? false
+            : node.value;
+
+          context.global = node.value === ":global";
+          context.explicit = true;
+
+          // because this node has spacing that is lost when we remove it
+          // we make up for it by adding an extra combinator in since adding
+          // spacing on the parent selector doesn't work
+          return addBackSpacing
+            ? selectorParser$1.combinator({ value: " " })
+            : null;
+        }
+        break;
+      }
+      case "id":
+      case "class": {
+        if (!node.value) {
+          throw new Error("Invalid class or id selector syntax");
+        }
+
+        if (context.global) {
+          break;
+        }
+
+        const isImportedValue = localAliasMap.has(node.value);
+        const isImportedWithExplicitScope = isImportedValue && context.explicit;
+
+        if (!isImportedValue || isImportedWithExplicitScope) {
+          const innerNode = node.clone();
+          innerNode.spaces = { before: "", after: "" };
+
+          node = selectorParser$1.pseudo({
+            value: ":local",
+            nodes: [innerNode],
+            spaces: node.spaces,
+          });
+
+          context.hasLocals = true;
+        }
+
+        break;
+      }
+    }
+
+    context.lastWasSpacing = false;
+    context.ignoreNextSpacing = false;
+    context.enforceNoSpacing = false;
+
+    return node;
+  };
+
+  const rootContext = {
+    global: mode === "global",
+    hasPureGlobals: false,
+  };
+
+  rootContext.selector = selectorParser$1((root) => {
+    transform(root, rootContext);
+  }).processSync(rule, { updateSelector: false, lossless: true });
+
+  return rootContext;
+}
+
+function localizeDeclNode(node, context) {
+  switch (node.type) {
+    case "word":
+      if (context.localizeNextItem) {
+        if (!context.localAliasMap.has(node.value)) {
+          node.value = ":local(" + node.value + ")";
+          context.localizeNextItem = false;
+        }
+      }
+      break;
+
+    case "function":
+      if (
+        context.options &&
+        context.options.rewriteUrl &&
+        node.value.toLowerCase() === "url"
+      ) {
+        node.nodes.map((nestedNode) => {
+          if (nestedNode.type !== "string" && nestedNode.type !== "word") {
+            return;
+          }
+
+          let newUrl = context.options.rewriteUrl(
+            context.global,
+            nestedNode.value
+          );
+
+          switch (nestedNode.type) {
+            case "string":
+              if (nestedNode.quote === "'") {
+                newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/'/g, "\\'");
+              }
+
+              if (nestedNode.quote === '"') {
+                newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/"/g, '\\"');
+              }
+
+              break;
+            case "word":
+              newUrl = newUrl.replace(/("|'|\)|\\)/g, "\\$1");
+              break;
+          }
+
+          nestedNode.value = newUrl;
+        });
+      }
+      break;
+  }
+  return node;
+}
+
+function isWordAFunctionArgument(wordNode, functionNode) {
+  return functionNode
+    ? functionNode.nodes.some(
+        (functionNodeChild) =>
+          functionNodeChild.sourceIndex === wordNode.sourceIndex
+      )
+    : false;
+}
+
+function localizeDeclarationValues(localize, declaration, context) {
+  const valueNodes = valueParser(declaration.value);
+
+  valueNodes.walk((node, index, nodes) => {
+    const subContext = {
+      options: context.options,
+      global: context.global,
+      localizeNextItem: localize && !context.global,
+      localAliasMap: context.localAliasMap,
+    };
+    nodes[index] = localizeDeclNode(node, subContext);
+  });
+
+  declaration.value = valueNodes.toString();
+}
+
+function localizeDeclaration(declaration, context) {
+  const isAnimation = /animation$/i.test(declaration.prop);
+
+  if (isAnimation) {
+    const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;
+
+    /*
+    The spec defines some keywords that you can use to describe properties such as the timing
+    function. These are still valid animation names, so as long as there is a property that accepts
+    a keyword, it is given priority. Only when all the properties that can take a keyword are
+    exhausted can the animation name be set to the keyword. I.e.
+  
+    animation: infinite infinite;
+  
+    The animation will repeat an infinite number of times from the first argument, and will have an
+    animation name of infinite from the second.
+    */
+    const animationKeywords = {
+      $alternate: 1,
+      "$alternate-reverse": 1,
+      $backwards: 1,
+      $both: 1,
+      $ease: 1,
+      "$ease-in": 1,
+      "$ease-in-out": 1,
+      "$ease-out": 1,
+      $forwards: 1,
+      $infinite: 1,
+      $linear: 1,
+      $none: Infinity, // No matter how many times you write none, it will never be an animation name
+      $normal: 1,
+      $paused: 1,
+      $reverse: 1,
+      $running: 1,
+      "$step-end": 1,
+      "$step-start": 1,
+      $initial: Infinity,
+      $inherit: Infinity,
+      $unset: Infinity,
+    };
+    let parsedAnimationKeywords = {};
+    let stepsFunctionNode = null;
+    const valueNodes = valueParser(declaration.value).walk((node) => {
+      /* If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh. */
+      if (node.type === "div") {
+        parsedAnimationKeywords = {};
+      }
+      if (node.type === "function" && node.value.toLowerCase() === "steps") {
+        stepsFunctionNode = node;
+      }
+      const value =
+        node.type === "word" &&
+        !isWordAFunctionArgument(node, stepsFunctionNode)
+          ? node.value.toLowerCase()
+          : null;
+
+      let shouldParseAnimationName = false;
+
+      if (value && validIdent.test(value)) {
+        if ("$" + value in animationKeywords) {
+          parsedAnimationKeywords["$" + value] =
+            "$" + value in parsedAnimationKeywords
+              ? parsedAnimationKeywords["$" + value] + 1
+              : 0;
+
+          shouldParseAnimationName =
+            parsedAnimationKeywords["$" + value] >=
+            animationKeywords["$" + value];
+        } else {
+          shouldParseAnimationName = true;
+        }
+      }
+
+      const subContext = {
+        options: context.options,
+        global: context.global,
+        localizeNextItem: shouldParseAnimationName && !context.global,
+        localAliasMap: context.localAliasMap,
+      };
+      return localizeDeclNode(node, subContext);
+    });
+
+    declaration.value = valueNodes.toString();
+
+    return;
+  }
+
+  const isAnimationName = /animation(-name)?$/i.test(declaration.prop);
+
+  if (isAnimationName) {
+    return localizeDeclarationValues(true, declaration, context);
+  }
+
+  const hasUrl = /url\(/i.test(declaration.value);
+
+  if (hasUrl) {
+    return localizeDeclarationValues(false, declaration, context);
+  }
+}
+
+src$2.exports = (options = {}) => {
+  if (
+    options &&
+    options.mode &&
+    options.mode !== "global" &&
+    options.mode !== "local" &&
+    options.mode !== "pure"
+  ) {
+    throw new Error(
+      'options.mode must be either "global", "local" or "pure" (default "local")'
+    );
+  }
+
+  const pureMode = options && options.mode === "pure";
+  const globalMode = options && options.mode === "global";
+
+  return {
+    postcssPlugin: "postcss-modules-local-by-default",
+    prepare() {
+      const localAliasMap = new Map();
+
+      return {
+        Once(root) {
+          const { icssImports } = extractICSS(root, false);
+
+          Object.keys(icssImports).forEach((key) => {
+            Object.keys(icssImports[key]).forEach((prop) => {
+              localAliasMap.set(prop, icssImports[key][prop]);
+            });
+          });
+
+          root.walkAtRules((atRule) => {
+            if (/keyframes$/i.test(atRule.name)) {
+              const globalMatch = /^\s*:global\s*\((.+)\)\s*$/.exec(
+                atRule.params
+              );
+              const localMatch = /^\s*:local\s*\((.+)\)\s*$/.exec(
+                atRule.params
+              );
+
+              let globalKeyframes = globalMode;
+
+              if (globalMatch) {
+                if (pureMode) {
+                  throw atRule.error(
+                    "@keyframes :global(...) is not allowed in pure mode"
+                  );
+                }
+                atRule.params = globalMatch[1];
+                globalKeyframes = true;
+              } else if (localMatch) {
+                atRule.params = localMatch[0];
+                globalKeyframes = false;
+              } else if (!globalMode) {
+                if (atRule.params && !localAliasMap.has(atRule.params)) {
+                  atRule.params = ":local(" + atRule.params + ")";
+                }
+              }
+
+              atRule.walkDecls((declaration) => {
+                localizeDeclaration(declaration, {
+                  localAliasMap,
+                  options: options,
+                  global: globalKeyframes,
+                });
+              });
+            } else if (atRule.nodes) {
+              atRule.nodes.forEach((declaration) => {
+                if (declaration.type === "decl") {
+                  localizeDeclaration(declaration, {
+                    localAliasMap,
+                    options: options,
+                    global: globalMode,
+                  });
+                }
+              });
+            }
+          });
+
+          root.walkRules((rule) => {
+            if (
+              rule.parent &&
+              rule.parent.type === "atrule" &&
+              /keyframes$/i.test(rule.parent.name)
+            ) {
+              // ignore keyframe rules
+              return;
+            }
+
+            const context = localizeNode(rule, options.mode, localAliasMap);
+
+            context.options = options;
+            context.localAliasMap = localAliasMap;
+
+            if (pureMode && context.hasPureGlobals) {
+              throw rule.error(
+                'Selector "' +
+                  rule.selector +
+                  '" is not pure ' +
+                  "(pure selectors must contain at least one local class or id)"
+              );
+            }
+
+            rule.selector = context.selector;
+
+            // Less-syntax mixins parse as rules with no nodes
+            if (rule.nodes) {
+              rule.nodes.forEach((declaration) =>
+                localizeDeclaration(declaration, context)
+              );
+            }
+          });
+        },
+      };
+    },
+  };
+};
+src$2.exports.postcss = true;
+
+var srcExports$1 = src$2.exports;
+
+const selectorParser = distExports;
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function getSingleLocalNamesForComposes(root) {
+  return root.nodes.map((node) => {
+    if (node.type !== "selector" || node.nodes.length !== 1) {
+      throw new Error(
+        `composition is only allowed when selector is single :local class name not in "${root}"`
+      );
+    }
+
+    node = node.nodes[0];
+
+    if (
+      node.type !== "pseudo" ||
+      node.value !== ":local" ||
+      node.nodes.length !== 1
+    ) {
+      throw new Error(
+        'composition is only allowed when selector is single :local class name not in "' +
+          root +
+          '", "' +
+          node +
+          '" is weird'
+      );
+    }
+
+    node = node.first;
+
+    if (node.type !== "selector" || node.length !== 1) {
+      throw new Error(
+        'composition is only allowed when selector is single :local class name not in "' +
+          root +
+          '", "' +
+          node +
+          '" is weird'
+      );
+    }
+
+    node = node.first;
+
+    if (node.type !== "class") {
+      // 'id' is not possible, because you can't compose ids
+      throw new Error(
+        'composition is only allowed when selector is single :local class name not in "' +
+          root +
+          '", "' +
+          node +
+          '" is weird'
+      );
+    }
+
+    return node.value;
+  });
+}
+
+const whitespace = "[\\x20\\t\\r\\n\\f]";
+const unescapeRegExp = new RegExp(
+  "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)",
+  "ig"
+);
+
+function unescape(str) {
+  return str.replace(unescapeRegExp, (_, escaped, escapedWhitespace) => {
+    const high = "0x" + escaped - 0x10000;
+
+    // NaN means non-codepoint
+    // Workaround erroneous numeric interpretation of +"0x"
+    return high !== high || escapedWhitespace
+      ? escaped
+      : high < 0
+      ? // BMP codepoint
+        String.fromCharCode(high + 0x10000)
+      : // Supplemental Plane codepoint (surrogate pair)
+        String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
+  });
+}
+
+const plugin = (options = {}) => {
+  const generateScopedName =
+    (options && options.generateScopedName) || plugin.generateScopedName;
+  const generateExportEntry =
+    (options && options.generateExportEntry) || plugin.generateExportEntry;
+  const exportGlobals = options && options.exportGlobals;
+
+  return {
+    postcssPlugin: "postcss-modules-scope",
+    Once(root, { rule }) {
+      const exports = Object.create(null);
+
+      function exportScopedName(name, rawName) {
+        const scopedName = generateScopedName(
+          rawName ? rawName : name,
+          root.source.input.from,
+          root.source.input.css
+        );
+        const exportEntry = generateExportEntry(
+          rawName ? rawName : name,
+          scopedName,
+          root.source.input.from,
+          root.source.input.css
+        );
+        const { key, value } = exportEntry;
+
+        exports[key] = exports[key] || [];
+
+        if (exports[key].indexOf(value) < 0) {
+          exports[key].push(value);
+        }
+
+        return scopedName;
+      }
+
+      function localizeNode(node) {
+        switch (node.type) {
+          case "selector":
+            node.nodes = node.map(localizeNode);
+            return node;
+          case "class":
+            return selectorParser.className({
+              value: exportScopedName(
+                node.value,
+                node.raws && node.raws.value ? node.raws.value : null
+              ),
+            });
+          case "id": {
+            return selectorParser.id({
+              value: exportScopedName(
+                node.value,
+                node.raws && node.raws.value ? node.raws.value : null
+              ),
+            });
+          }
+        }
+
+        throw new Error(
+          `${node.type} ("${node}") is not allowed in a :local block`
+        );
+      }
+
+      function traverseNode(node) {
+        switch (node.type) {
+          case "pseudo":
+            if (node.value === ":local") {
+              if (node.nodes.length !== 1) {
+                throw new Error('Unexpected comma (",") in :local block');
+              }
+
+              const selector = localizeNode(node.first);
+              // move the spaces that were around the psuedo selector to the first
+              // non-container node
+              selector.first.spaces = node.spaces;
+
+              const nextNode = node.next();
+
+              if (
+                nextNode &&
+                nextNode.type === "combinator" &&
+                nextNode.value === " " &&
+                /\\[A-F0-9]{1,6}$/.test(selector.last.value)
+              ) {
+                selector.last.spaces.after = " ";
+              }
+
+              node.replaceWith(selector);
+
+              return;
+            }
+          /* falls through */
+          case "root":
+          case "selector": {
+            node.each(traverseNode);
+            break;
+          }
+          case "id":
+          case "class":
+            if (exportGlobals) {
+              exports[node.value] = [node.value];
+            }
+            break;
+        }
+        return node;
+      }
+
+      // Find any :import and remember imported names
+      const importedNames = {};
+
+      root.walkRules(/^:import\(.+\)$/, (rule) => {
+        rule.walkDecls((decl) => {
+          importedNames[decl.prop] = true;
+        });
+      });
+
+      // Find any :local selectors
+      root.walkRules((rule) => {
+        let parsedSelector = selectorParser().astSync(rule);
+
+        rule.selector = traverseNode(parsedSelector.clone()).toString();
+
+        rule.walkDecls(/composes|compose-with/i, (decl) => {
+          const localNames = getSingleLocalNamesForComposes(parsedSelector);
+          const classes = decl.value.split(/\s+/);
+
+          classes.forEach((className) => {
+            const global = /^global\(([^)]+)\)$/.exec(className);
+
+            if (global) {
+              localNames.forEach((exportedName) => {
+                exports[exportedName].push(global[1]);
+              });
+            } else if (hasOwnProperty.call(importedNames, className)) {
+              localNames.forEach((exportedName) => {
+                exports[exportedName].push(className);
+              });
+            } else if (hasOwnProperty.call(exports, className)) {
+              localNames.forEach((exportedName) => {
+                exports[className].forEach((item) => {
+                  exports[exportedName].push(item);
+                });
+              });
+            } else {
+              throw decl.error(
+                `referenced class name "${className}" in ${decl.prop} not found`
+              );
+            }
+          });
+
+          decl.remove();
+        });
+
+        // Find any :local values
+        rule.walkDecls((decl) => {
+          if (!/:local\s*\((.+?)\)/.test(decl.value)) {
+            return;
+          }
+
+          let tokens = decl.value.split(/(,|'[^']*'|"[^"]*")/);
+
+          tokens = tokens.map((token, idx) => {
+            if (idx === 0 || tokens[idx - 1] === ",") {
+              let result = token;
+
+              const localMatch = /:local\s*\((.+?)\)/.exec(token);
+
+              if (localMatch) {
+                const input = localMatch.input;
+                const matchPattern = localMatch[0];
+                const matchVal = localMatch[1];
+                const newVal = exportScopedName(matchVal);
+
+                result = input.replace(matchPattern, newVal);
+              } else {
+                return token;
+              }
+
+              return result;
+            } else {
+              return token;
+            }
+          });
+
+          decl.value = tokens.join("");
+        });
+      });
+
+      // Find any :local keyframes
+      root.walkAtRules(/keyframes$/i, (atRule) => {
+        const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(atRule.params);
+
+        if (!localMatch) {
+          return;
+        }
+
+        atRule.params = exportScopedName(localMatch[1]);
+      });
+
+      // If we found any :locals, insert an :export rule
+      const exportedNames = Object.keys(exports);
+
+      if (exportedNames.length > 0) {
+        const exportRule = rule({ selector: ":export" });
+
+        exportedNames.forEach((exportedName) =>
+          exportRule.append({
+            prop: exportedName,
+            value: exports[exportedName].join(" "),
+            raws: { before: "\n  " },
+          })
+        );
+
+        root.append(exportRule);
+      }
+    },
+  };
+};
+
+plugin.postcss = true;
+
+plugin.generateScopedName = function (name, path) {
+  const sanitisedPath = path
+    .replace(/\.[^./\\]+$/, "")
+    .replace(/[\W_]+/g, "_")
+    .replace(/^_|_$/g, "");
+
+  return `_${sanitisedPath}__${name}`.trim();
+};
+
+plugin.generateExportEntry = function (name, scopedName) {
+  return {
+    key: unescape(name),
+    value: unescape(scopedName),
+  };
+};
+
+var src$1 = plugin;
+
+function hash(str) {
+  var hash = 5381,
+      i    = str.length;
+
+  while(i) {
+    hash = (hash * 33) ^ str.charCodeAt(--i);
+  }
+
+  /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
+   * integers. Since we want the results to be always positive, convert the
+   * signed int to an unsigned by doing an unsigned bitshift. */
+  return hash >>> 0;
+}
+
+var stringHash = hash;
+
+var src = {exports: {}};
+
+const ICSSUtils = src$4;
+
+const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
+const matchValueDefinition = /(?:\s+|^)([\w-]+):?(.*?)$/;
+const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
+
+src.exports = (options) => {
+  let importIndex = 0;
+  const createImportedName =
+    (options && options.createImportedName) ||
+    ((importName /*, path*/) =>
+      `i__const_${importName.replace(/\W/g, "_")}_${importIndex++}`);
+
+  return {
+    postcssPlugin: "postcss-modules-values",
+    prepare(result) {
+      const importAliases = [];
+      const definitions = {};
+
+      return {
+        Once(root, postcss) {
+          root.walkAtRules(/value/i, (atRule) => {
+            const matches = atRule.params.match(matchImports);
+
+            if (matches) {
+              let [, /*match*/ aliases, path] = matches;
+
+              // We can use constants for path names
+              if (definitions[path]) {
+                path = definitions[path];
+              }
+
+              const imports = aliases
+                .replace(/^\(\s*([\s\S]+)\s*\)$/, "$1")
+                .split(/\s*,\s*/)
+                .map((alias) => {
+                  const tokens = matchImport.exec(alias);
+
+                  if (tokens) {
+                    const [, /*match*/ theirName, myName = theirName] = tokens;
+                    const importedName = createImportedName(myName);
+                    definitions[myName] = importedName;
+                    return { theirName, importedName };
+                  } else {
+                    throw new Error(`@import statement "${alias}" is invalid!`);
+                  }
+                });
+
+              importAliases.push({ path, imports });
+
+              atRule.remove();
+
+              return;
+            }
+
+            if (atRule.params.indexOf("@value") !== -1) {
+              result.warn("Invalid value definition: " + atRule.params);
+            }
+
+            let [, key, value] = `${atRule.params}${atRule.raws.between}`.match(
+              matchValueDefinition
+            );
+
+            const normalizedValue = value.replace(/\/\*((?!\*\/).*?)\*\//g, "");
+
+            if (normalizedValue.length === 0) {
+              result.warn("Invalid value definition: " + atRule.params);
+              atRule.remove();
+
+              return;
+            }
+
+            let isOnlySpace = /^\s+$/.test(normalizedValue);
+
+            if (!isOnlySpace) {
+              value = value.trim();
+            }
+
+            // Add to the definitions, knowing that values can refer to each other
+            definitions[key] = ICSSUtils.replaceValueSymbols(
+              value,
+              definitions
+            );
+
+            atRule.remove();
+          });
+
+          /* If we have no definitions, don't continue */
+          if (!Object.keys(definitions).length) {
+            return;
+          }
+
+          /* Perform replacements */
+          ICSSUtils.replaceSymbols(root, definitions);
+
+          /* We want to export anything defined by now, but don't add it to the CSS yet or it well get picked up by the replacement stuff */
+          const exportDeclarations = Object.keys(definitions).map((key) =>
+            postcss.decl({
+              value: definitions[key],
+              prop: key,
+              raws: { before: "\n  " },
+            })
+          );
+
+          /* Add export rules if any */
+          if (exportDeclarations.length > 0) {
+            const exportRule = postcss.rule({
+              selector: ":export",
+              raws: { after: "\n" },
+            });
+
+            exportRule.append(exportDeclarations);
+
+            root.prepend(exportRule);
+          }
+
+          /* Add import rules */
+          importAliases.reverse().forEach(({ path, imports }) => {
+            const importRule = postcss.rule({
+              selector: `:import(${path})`,
+              raws: { after: "\n" },
+            });
+
+            imports.forEach(({ theirName, importedName }) => {
+              importRule.append({
+                value: theirName,
+                prop: importedName,
+                raws: { before: "\n  " },
+              });
+            });
+
+            root.prepend(importRule);
+          });
+        },
+      };
+    },
+  };
+};
+
+src.exports.postcss = true;
+
+var srcExports = src.exports;
+
+Object.defineProperty(scoping, "__esModule", {
+  value: true
+});
+scoping.behaviours = void 0;
+scoping.getDefaultPlugins = getDefaultPlugins;
+scoping.getDefaultScopeBehaviour = getDefaultScopeBehaviour;
+scoping.getScopedNameGenerator = getScopedNameGenerator;
+
+var _postcssModulesExtractImports = _interopRequireDefault$1(srcExports$2);
+
+var _genericNames = _interopRequireDefault$1(genericNames);
+
+var _postcssModulesLocalByDefault = _interopRequireDefault$1(srcExports$1);
+
+var _postcssModulesScope = _interopRequireDefault$1(src$1);
+
+var _stringHash = _interopRequireDefault$1(stringHash);
+
+var _postcssModulesValues = _interopRequireDefault$1(srcExports);
+
+function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const behaviours = {
+  LOCAL: "local",
+  GLOBAL: "global"
+};
+scoping.behaviours = behaviours;
+
+function getDefaultPlugins({
+  behaviour,
+  generateScopedName,
+  exportGlobals
+}) {
+  const scope = (0, _postcssModulesScope.default)({
+    generateScopedName,
+    exportGlobals
+  });
+  const plugins = {
+    [behaviours.LOCAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({
+      mode: "local"
+    }), _postcssModulesExtractImports.default, scope],
+    [behaviours.GLOBAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({
+      mode: "global"
+    }), _postcssModulesExtractImports.default, scope]
+  };
+  return plugins[behaviour];
+}
+
+function isValidBehaviour(behaviour) {
+  return Object.keys(behaviours).map(key => behaviours[key]).indexOf(behaviour) > -1;
+}
+
+function getDefaultScopeBehaviour(scopeBehaviour) {
+  return scopeBehaviour && isValidBehaviour(scopeBehaviour) ? scopeBehaviour : behaviours.LOCAL;
+}
+
+function generateScopedNameDefault(name, filename, css) {
+  const i = css.indexOf(`.${name}`);
+  const lineNumber = css.substr(0, i).split(/[\r\n]/).length;
+  const hash = (0, _stringHash.default)(css).toString(36).substr(0, 5);
+  return `_${name}_${hash}_${lineNumber}`;
+}
+
+function getScopedNameGenerator(generateScopedName, hashPrefix) {
+  const scopedNameGenerator = generateScopedName || generateScopedNameDefault;
+
+  if (typeof scopedNameGenerator === "function") {
+    return scopedNameGenerator;
+  }
+
+  return (0, _genericNames.default)(scopedNameGenerator, {
+    context: process.cwd(),
+    hashPrefix: hashPrefix
+  });
+}
+
+Object.defineProperty(pluginFactory, "__esModule", {
+  value: true
+});
+pluginFactory.makePlugin = makePlugin;
+
+var _postcss = _interopRequireDefault(require$$0);
+
+var _unquote = _interopRequireDefault(unquote$1);
+
+var _Parser = _interopRequireDefault(Parser$1);
+
+var _saveJSON = _interopRequireDefault(saveJSON$1);
+
+var _localsConvention = localsConvention;
+
+var _FileSystemLoader = _interopRequireDefault(FileSystemLoader$1);
+
+var _scoping = scoping;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const PLUGIN_NAME = "postcss-modules";
+
+function isGlobalModule(globalModules, inputFile) {
+  return globalModules.some(regex => inputFile.match(regex));
+}
+
+function getDefaultPluginsList(opts, inputFile) {
+  const globalModulesList = opts.globalModulePaths || null;
+  const exportGlobals = opts.exportGlobals || false;
+  const defaultBehaviour = (0, _scoping.getDefaultScopeBehaviour)(opts.scopeBehaviour);
+  const generateScopedName = (0, _scoping.getScopedNameGenerator)(opts.generateScopedName, opts.hashPrefix);
+
+  if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) {
+    return (0, _scoping.getDefaultPlugins)({
+      behaviour: _scoping.behaviours.GLOBAL,
+      generateScopedName,
+      exportGlobals
+    });
+  }
+
+  return (0, _scoping.getDefaultPlugins)({
+    behaviour: defaultBehaviour,
+    generateScopedName,
+    exportGlobals
+  });
+}
+
+function getLoader(opts, plugins) {
+  const root = typeof opts.root === "undefined" ? "/" : opts.root;
+  return typeof opts.Loader === "function" ? new opts.Loader(root, plugins, opts.resolve) : new _FileSystemLoader.default(root, plugins, opts.resolve);
+}
+
+function isOurPlugin(plugin) {
+  return plugin.postcssPlugin === PLUGIN_NAME;
+}
+
+function makePlugin(opts) {
+  return {
+    postcssPlugin: PLUGIN_NAME,
+
+    async OnceExit(css, {
+      result
+    }) {
+      const getJSON = opts.getJSON || _saveJSON.default;
+      const inputFile = css.source.input.file;
+      const pluginList = getDefaultPluginsList(opts, inputFile);
+      const resultPluginIndex = result.processor.plugins.findIndex(plugin => isOurPlugin(plugin));
+
+      if (resultPluginIndex === -1) {
+        throw new Error("Plugin missing from options.");
+      }
+
+      const earlierPlugins = result.processor.plugins.slice(0, resultPluginIndex);
+      const loaderPlugins = [...earlierPlugins, ...pluginList];
+      const loader = getLoader(opts, loaderPlugins);
+
+      const fetcher = async (file, relativeTo, depTrace) => {
+        const unquoteFile = (0, _unquote.default)(file);
+        return loader.fetch.call(loader, unquoteFile, relativeTo, depTrace);
+      };
+
+      const parser = new _Parser.default(fetcher);
+      await (0, _postcss.default)([...pluginList, parser.plugin()]).process(css, {
+        from: inputFile
+      });
+      const out = loader.finalSource;
+      if (out) css.prepend(out);
+
+      if (opts.localsConvention) {
+        const reducer = (0, _localsConvention.makeLocalsConventionReducer)(opts.localsConvention, inputFile);
+        parser.exportTokens = Object.entries(parser.exportTokens).reduce(reducer, {});
+      }
+
+      result.messages.push({
+        type: "export",
+        plugin: "postcss-modules",
+        exportTokens: parser.exportTokens
+      }); // getJSON may return a promise
+
+      return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
+    }
+
+  };
+}
+
+var _fs = require$$0__default;
+
+var _fs2 = fs;
+
+var _pluginFactory = pluginFactory;
+
+(0, _fs2.setFileSystem)({
+  readFile: _fs.readFile,
+  writeFile: _fs.writeFile
+});
+
+build.exports = (opts = {}) => (0, _pluginFactory.makePlugin)(opts);
+
+var postcss = build.exports.postcss = true;
+
+var buildExports = build.exports;
+var index = /*@__PURE__*/getDefaultExportFromCjs(buildExports);
+
+var index$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: index,
+  postcss: postcss
+}, [buildExports]);
+
+export { index$1 as i };
diff --git a/node_modules/vite/dist/node/chunks/dep-CDnG8rE7.js b/node_modules/vite/dist/node/chunks/dep-CDnG8rE7.js
new file mode 100644
index 0000000..e853064
--- /dev/null
+++ b/node_modules/vite/dist/node/chunks/dep-CDnG8rE7.js
@@ -0,0 +1,66707 @@
+import * as fs$j from 'node:fs';
+import fs__default, { promises as promises$1 } from 'node:fs';
+import fsp, { lstat as lstat$3, readdir as readdir$5, readlink, realpath as realpath$2 } from 'node:fs/promises';
+import path$n, { win32 as win32$1, posix as posix$1, isAbsolute as isAbsolute$1, join as join$2, extname as extname$1, dirname as dirname$2, relative as relative$2, basename as basename$2 } from 'node:path';
+import { fileURLToPath, URL as URL$3, parse as parse$h, pathToFileURL } from 'node:url';
+import { promisify as promisify$4, format as format$2, inspect } from 'node:util';
+import { performance as performance$1 } from 'node:perf_hooks';
+import { createRequire as createRequire$1, builtinModules } from 'node:module';
+import require$$0$3 from 'tty';
+import require$$0$4, { win32, posix, isAbsolute, resolve as resolve$3, relative as relative$1, basename as basename$1, extname, dirname as dirname$1, join as join$1, sep as sep$1, normalize as normalize$1 } from 'path';
+import esbuild, { transform as transform$1, formatMessages, build as build$3 } from 'esbuild';
+import { CLIENT_ENTRY, OPTIMIZABLE_ENTRY_RE, wildcardHosts, loopbackHosts, FS_PREFIX, CLIENT_PUBLIC_PATH, ENV_PUBLIC_PATH, DEFAULT_ASSETS_INLINE_LIMIT, CSS_LANGS_RE, ESBUILD_MODULES_TARGET, SPECIAL_QUERY_RE, ENV_ENTRY, DEP_VERSION_RE, DEFAULT_MAIN_FIELDS, DEFAULT_EXTENSIONS, KNOWN_ASSET_TYPES, JS_TYPES_RE, METADATA_FILENAME, VITE_PACKAGE_DIR, DEFAULT_DEV_PORT, CLIENT_DIR, VERSION, DEFAULT_PREVIEW_PORT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES } from '../constants.js';
+import * as require$$0$2 from 'fs';
+import require$$0__default, { lstatSync, readdir as readdir$4, readdirSync, readlinkSync, realpathSync as realpathSync$1, existsSync, readFileSync, statSync as statSync$1 } from 'fs';
+import { EventEmitter as EventEmitter$4 } from 'node:events';
+import Stream$1 from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+import { exec, execSync } from 'node:child_process';
+import { createServer as createServer$3, STATUS_CODES, get as get$2 } from 'node:http';
+import { createServer as createServer$2, get as get$1 } from 'node:https';
+import require$$0$5 from 'util';
+import require$$4$1 from 'net';
+import require$$0$7 from 'events';
+import require$$0$9 from 'url';
+import require$$1 from 'http';
+import require$$0$6 from 'stream';
+import require$$2 from 'os';
+import require$$2$1 from 'child_process';
+import os$5 from 'node:os';
+import { createHash as createHash$2 } from 'node:crypto';
+import { promises } from 'node:dns';
+import require$$3$1 from 'crypto';
+import require$$0$8, { createRequire as createRequire$2 } from 'module';
+import assert$1 from 'node:assert';
+import v8 from 'node:v8';
+import { Worker as Worker$1 } from 'node:worker_threads';
+import { Buffer as Buffer$1 } from 'node:buffer';
+import { parseAstAsync, parseAst } from 'rollup/parseAst';
+import * as qs from 'querystring';
+import readline from 'node:readline';
+import zlib$1 from 'zlib';
+import require$$0$a from 'buffer';
+import require$$1$1 from 'https';
+import require$$4$2 from 'tls';
+import require$$4$3 from 'assert';
+import { gzip } from 'node:zlib';
+
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var picocolors = {exports: {}};
+
+let argv = process.argv || [],
+	env$1 = process.env;
+let isColorSupported =
+	!("NO_COLOR" in env$1 || argv.includes("--no-color")) &&
+	("FORCE_COLOR" in env$1 ||
+		argv.includes("--color") ||
+		process.platform === "win32" ||
+		(commonjsRequire != null && require$$0$3.isatty(1) && env$1.TERM !== "dumb") ||
+		"CI" in env$1);
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input;
+		let index = string.indexOf(close, open.length);
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	};
+
+let replaceClose = (string, close, replace, index) => {
+	let result = "";
+	let cursor = 0;
+	do {
+		result += string.substring(cursor, index) + replace;
+		cursor = index + close.length;
+		index = string.indexOf(close, cursor);
+	} while (~index)
+	return result + string.substring(cursor)
+};
+
+let createColors = (enabled = isColorSupported) => {
+	let init = enabled ? formatter : () => String;
+	return {
+		isColorSupported: enabled,
+		reset: init("\x1b[0m", "\x1b[0m"),
+		bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+		dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+		italic: init("\x1b[3m", "\x1b[23m"),
+		underline: init("\x1b[4m", "\x1b[24m"),
+		inverse: init("\x1b[7m", "\x1b[27m"),
+		hidden: init("\x1b[8m", "\x1b[28m"),
+		strikethrough: init("\x1b[9m", "\x1b[29m"),
+		black: init("\x1b[30m", "\x1b[39m"),
+		red: init("\x1b[31m", "\x1b[39m"),
+		green: init("\x1b[32m", "\x1b[39m"),
+		yellow: init("\x1b[33m", "\x1b[39m"),
+		blue: init("\x1b[34m", "\x1b[39m"),
+		magenta: init("\x1b[35m", "\x1b[39m"),
+		cyan: init("\x1b[36m", "\x1b[39m"),
+		white: init("\x1b[37m", "\x1b[39m"),
+		gray: init("\x1b[90m", "\x1b[39m"),
+		bgBlack: init("\x1b[40m", "\x1b[49m"),
+		bgRed: init("\x1b[41m", "\x1b[49m"),
+		bgGreen: init("\x1b[42m", "\x1b[49m"),
+		bgYellow: init("\x1b[43m", "\x1b[49m"),
+		bgBlue: init("\x1b[44m", "\x1b[49m"),
+		bgMagenta: init("\x1b[45m", "\x1b[49m"),
+		bgCyan: init("\x1b[46m", "\x1b[49m"),
+		bgWhite: init("\x1b[47m", "\x1b[49m"),
+	}
+};
+
+picocolors.exports = createColors();
+picocolors.exports.createColors = createColors;
+
+var picocolorsExports = picocolors.exports;
+var colors$1 = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+
+function matches$1(pattern, importee) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(importee);
+    }
+    if (importee.length < pattern.length) {
+        return false;
+    }
+    if (importee === pattern) {
+        return true;
+    }
+    // eslint-disable-next-line prefer-template
+    return importee.startsWith(pattern + '/');
+}
+function getEntries({ entries, customResolver }) {
+    if (!entries) {
+        return [];
+    }
+    const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+    if (Array.isArray(entries)) {
+        return entries.map((entry) => {
+            return {
+                find: entry.find,
+                replacement: entry.replacement,
+                resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+            };
+        });
+    }
+    return Object.entries(entries).map(([key, value]) => {
+        return { find: key, replacement: value, resolverFunction: resolverFunctionFromOptions };
+    });
+}
+function getHookFunction(hook) {
+    if (typeof hook === 'function') {
+        return hook;
+    }
+    if (hook && 'handler' in hook && typeof hook.handler === 'function') {
+        return hook.handler;
+    }
+    return null;
+}
+function resolveCustomResolver(customResolver) {
+    if (typeof customResolver === 'function') {
+        return customResolver;
+    }
+    if (customResolver) {
+        return getHookFunction(customResolver.resolveId);
+    }
+    return null;
+}
+function alias$1(options = {}) {
+    const entries = getEntries(options);
+    if (entries.length === 0) {
+        return {
+            name: 'alias',
+            resolveId: () => null
+        };
+    }
+    return {
+        name: 'alias',
+        async buildStart(inputOptions) {
+            await Promise.all([...(Array.isArray(options.entries) ? options.entries : []), options].map(({ customResolver }) => { var _a; return customResolver && ((_a = getHookFunction(customResolver.buildStart)) === null || _a === void 0 ? void 0 : _a.call(this, inputOptions)); }));
+        },
+        resolveId(importee, importer, resolveOptions) {
+            // First match is supposed to be the correct one
+            const matchedEntry = entries.find((entry) => matches$1(entry.find, importee));
+            if (!matchedEntry) {
+                return null;
+            }
+            const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+            if (matchedEntry.resolverFunction) {
+                return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+            }
+            return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
+                if (resolved)
+                    return resolved;
+                if (!require$$0$4.isAbsolute(updatedId)) {
+                    this.warn(`rewrote ${importee} to ${updatedId} but was not an abolute path and was not handled by other plugins. ` +
+                        `This will lead to duplicated modules for the same path. ` +
+                        `To avoid duplicating modules, you should resolve to an absolute path.`);
+                }
+                return { id: updatedId };
+            });
+        }
+    };
+}
+
+const VALID_ID_PREFIX = `/@id/`;
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+const VITE_RUNTIME_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-runtime";
+
+const isWindows$3 = typeof process !== "undefined" && process.platform === "win32";
+function wrapId$1(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId$1(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+const windowsSlashRE = /\\/g;
+function slash$1(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function withTrailingSlash(path) {
+  if (path[path.length - 1] !== "/") {
+    return `${path}/`;
+  }
+  return path;
+}
+const AsyncFunction = async function() {
+}.constructor;
+const asyncFunctionDeclarationPaddingLineCount = /* @__PURE__ */ (() => {
+  const body = "/*code*/";
+  const source = new AsyncFunction("a", "b", body).toString();
+  return source.slice(0, source.indexOf(body)).split("\n").length - 1;
+})();
+
+// @ts-check
+/** @typedef { import('estree').BaseNode} BaseNode */
+
+/** @typedef {{
+	skip: () => void;
+	remove: () => void;
+	replace: (node: BaseNode) => void;
+}} WalkerContext */
+
+let WalkerBase$1 = class WalkerBase {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+
+		/** @type {boolean} */
+		this.should_remove = false;
+
+		/** @type {BaseNode | null} */
+		this.replacement = null;
+
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => (this.should_skip = true),
+			remove: () => (this.should_remove = true),
+			replace: (node) => (this.replacement = node)
+		};
+	}
+
+	/**
+	 *
+	 * @param {any} parent
+	 * @param {string} prop
+	 * @param {number} index
+	 * @param {BaseNode} node
+	 */
+	replace(parent, prop, index, node) {
+		if (parent) {
+			if (index !== null) {
+				parent[prop][index] = node;
+			} else {
+				parent[prop] = node;
+			}
+		}
+	}
+
+	/**
+	 *
+	 * @param {any} parent
+	 * @param {string} prop
+	 * @param {number} index
+	 */
+	remove(parent, prop, index) {
+		if (parent) {
+			if (index !== null) {
+				parent[prop].splice(index, 1);
+			} else {
+				delete parent[prop];
+			}
+		}
+	}
+};
+
+// @ts-check
+
+/** @typedef { import('estree').BaseNode} BaseNode */
+/** @typedef { import('./walker.js').WalkerContext} WalkerContext */
+
+/** @typedef {(
+ *    this: WalkerContext,
+ *    node: BaseNode,
+ *    parent: BaseNode,
+ *    key: string,
+ *    index: number
+ * ) => void} SyncHandler */
+
+let SyncWalker$1 = class SyncWalker extends WalkerBase$1 {
+	/**
+	 *
+	 * @param {SyncHandler} enter
+	 * @param {SyncHandler} leave
+	 */
+	constructor(enter, leave) {
+		super();
+
+		/** @type {SyncHandler} */
+		this.enter = enter;
+
+		/** @type {SyncHandler} */
+		this.leave = leave;
+	}
+
+	/**
+	 *
+	 * @param {BaseNode} node
+	 * @param {BaseNode} parent
+	 * @param {string} [prop]
+	 * @param {number} [index]
+	 * @returns {BaseNode}
+	 */
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+
+				this.enter.call(this.context, node, parent, prop, index);
+
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+
+				if (this.should_remove) {
+					this.remove(parent, prop, index);
+				}
+
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+
+				if (skipped) return node;
+				if (removed) return null;
+			}
+
+			for (const key in node) {
+				const value = node[key];
+
+				if (typeof value !== "object") {
+					continue;
+				} else if (Array.isArray(value)) {
+					for (let i = 0; i < value.length; i += 1) {
+						if (value[i] !== null && typeof value[i].type === 'string') {
+							if (!this.visit(value[i], node, key, i)) {
+								// removed
+								i--;
+							}
+						}
+					}
+				} else if (value !== null && typeof value.type === "string") {
+					this.visit(value, node, key, null);
+				}
+			}
+
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+
+				this.leave.call(this.context, node, parent, prop, index);
+
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+
+				if (this.should_remove) {
+					this.remove(parent, prop, index);
+				}
+
+				const removed = this.should_remove;
+
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+
+				if (removed) return null;
+			}
+		}
+
+		return node;
+	}
+};
+
+// @ts-check
+
+/** @typedef { import('estree').BaseNode} BaseNode */
+/** @typedef { import('./sync.js').SyncHandler} SyncHandler */
+/** @typedef { import('./async.js').AsyncHandler} AsyncHandler */
+
+/**
+ *
+ * @param {BaseNode} ast
+ * @param {{
+ *   enter?: SyncHandler
+ *   leave?: SyncHandler
+ * }} walker
+ * @returns {BaseNode}
+ */
+function walk$3(ast, { enter, leave }) {
+	const instance = new SyncWalker$1(enter, leave);
+	return instance.visit(ast, null);
+}
+
+var utils$k = {};
+
+const path$m = require$$0$4;
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR$1 = `${QMARK}*?`;
+
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR: STAR$1,
+  START_ANCHOR
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+  ...POSIX_CHARS,
+
+  SLASH_LITERAL: `[${WIN_SLASH}]`,
+  QMARK: WIN_NO_SLASH,
+  STAR: `${WIN_NO_SLASH}*?`,
+  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+  NO_DOT: `(?!${DOT_LITERAL})`,
+  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE$1 = {
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  ascii: '\\x00-\\x7F',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E ',
+  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word: 'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9'
+};
+
+var constants$6 = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    '***': '*',
+    '**/**': '**',
+    '**/**/**': '**'
+  },
+
+  // Digits
+  CHAR_0: 48, /* 0 */
+  CHAR_9: 57, /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65, /* A */
+  CHAR_LOWERCASE_A: 97, /* a */
+  CHAR_UPPERCASE_Z: 90, /* Z */
+  CHAR_LOWERCASE_Z: 122, /* z */
+
+  CHAR_LEFT_PARENTHESES: 40, /* ( */
+  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+  CHAR_ASTERISK: 42, /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38, /* & */
+  CHAR_AT: 64, /* @ */
+  CHAR_BACKWARD_SLASH: 92, /* \ */
+  CHAR_CARRIAGE_RETURN: 13, /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+  CHAR_COLON: 58, /* : */
+  CHAR_COMMA: 44, /* , */
+  CHAR_DOT: 46, /* . */
+  CHAR_DOUBLE_QUOTE: 34, /* " */
+  CHAR_EQUAL: 61, /* = */
+  CHAR_EXCLAMATION_MARK: 33, /* ! */
+  CHAR_FORM_FEED: 12, /* \f */
+  CHAR_FORWARD_SLASH: 47, /* / */
+  CHAR_GRAVE_ACCENT: 96, /* ` */
+  CHAR_HASH: 35, /* # */
+  CHAR_HYPHEN_MINUS: 45, /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+  CHAR_LINE_FEED: 10, /* \n */
+  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+  CHAR_PERCENT: 37, /* % */
+  CHAR_PLUS: 43, /* + */
+  CHAR_QUESTION_MARK: 63, /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+  CHAR_SEMICOLON: 59, /* ; */
+  CHAR_SINGLE_QUOTE: 39, /* ' */
+  CHAR_SPACE: 32, /*   */
+  CHAR_TAB: 9, /* \t */
+  CHAR_UNDERSCORE: 95, /* _ */
+  CHAR_VERTICAL_LINE: 124, /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+  SEP: path$m.sep,
+
+  /**
+   * Create EXTGLOB_CHARS
+   */
+
+  extglobChars(chars) {
+    return {
+      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+      '?': { type: 'qmark', open: '(?:', close: ')?' },
+      '+': { type: 'plus', open: '(?:', close: ')+' },
+      '*': { type: 'star', open: '(?:', close: ')*' },
+      '@': { type: 'at', open: '(?:', close: ')' }
+    };
+  },
+
+  /**
+   * Create GLOB_CHARS
+   */
+
+  globChars(win32) {
+    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
+};
+
+(function (exports) {
+
+	const path = require$$0$4;
+	const win32 = process.platform === 'win32';
+	const {
+	  REGEX_BACKSLASH,
+	  REGEX_REMOVE_BACKSLASH,
+	  REGEX_SPECIAL_CHARS,
+	  REGEX_SPECIAL_CHARS_GLOBAL
+	} = constants$6;
+
+	exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+	exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+	exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+	exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+	exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+	exports.removeBackslashes = str => {
+	  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+	    return match === '\\' ? '' : match;
+	  });
+	};
+
+	exports.supportsLookbehinds = () => {
+	  const segs = process.version.slice(1).split('.').map(Number);
+	  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
+	    return true;
+	  }
+	  return false;
+	};
+
+	exports.isWindows = options => {
+	  if (options && typeof options.windows === 'boolean') {
+	    return options.windows;
+	  }
+	  return win32 === true || path.sep === '\\';
+	};
+
+	exports.escapeLast = (input, char, lastIdx) => {
+	  const idx = input.lastIndexOf(char, lastIdx);
+	  if (idx === -1) return input;
+	  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+	  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+	};
+
+	exports.removePrefix = (input, state = {}) => {
+	  let output = input;
+	  if (output.startsWith('./')) {
+	    output = output.slice(2);
+	    state.prefix = './';
+	  }
+	  return output;
+	};
+
+	exports.wrapOutput = (input, state = {}, options = {}) => {
+	  const prepend = options.contains ? '' : '^';
+	  const append = options.contains ? '' : '$';
+
+	  let output = `${prepend}(?:${input})${append}`;
+	  if (state.negated === true) {
+	    output = `(?:^(?!${output}).*$)`;
+	  }
+	  return output;
+	}; 
+} (utils$k));
+
+const utils$j = utils$k;
+const {
+  CHAR_ASTERISK,             /* * */
+  CHAR_AT,                   /* @ */
+  CHAR_BACKWARD_SLASH,       /* \ */
+  CHAR_COMMA: CHAR_COMMA$1,                /* , */
+  CHAR_DOT: CHAR_DOT$1,                  /* . */
+  CHAR_EXCLAMATION_MARK,     /* ! */
+  CHAR_FORWARD_SLASH,        /* / */
+  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1,     /* { */
+  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1,  /* [ */
+  CHAR_PLUS,                 /* + */
+  CHAR_QUESTION_MARK,        /* ? */
+  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1,    /* } */
+  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1  /* ] */
+} = constants$6;
+
+const isPathSeparator = code => {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+const depth = token => {
+  if (token.isPrefix !== true) {
+    token.depth = token.isGlobstar ? Infinity : 1;
+  }
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+const scan$2 = (input, options) => {
+  const opts = options || {};
+
+  const length = input.length - 1;
+  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+  const slashes = [];
+  const tokens = [];
+  const parts = [];
+
+  let str = input;
+  let index = -1;
+  let start = 0;
+  let lastIndex = 0;
+  let isBrace = false;
+  let isBracket = false;
+  let isGlob = false;
+  let isExtglob = false;
+  let isGlobstar = false;
+  let braceEscaped = false;
+  let backslashes = false;
+  let negated = false;
+  let negatedExtglob = false;
+  let finished = false;
+  let braces = 0;
+  let prev;
+  let code;
+  let token = { value: '', depth: 0, isGlob: false };
+
+  const eos = () => index >= length;
+  const peek = () => str.charCodeAt(index + 1);
+  const advance = () => {
+    prev = code;
+    return str.charCodeAt(++index);
+  };
+
+  while (index < length) {
+    code = advance();
+    let next;
+
+    if (code === CHAR_BACKWARD_SLASH) {
+      backslashes = token.backslashes = true;
+      code = advance();
+
+      if (code === CHAR_LEFT_CURLY_BRACE$1) {
+        braceEscaped = true;
+      }
+      continue;
+    }
+
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {
+      braces++;
+
+      while (eos() !== true && (code = advance())) {
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (code === CHAR_LEFT_CURLY_BRACE$1) {
+          braces++;
+          continue;
+        }
+
+        if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (braceEscaped !== true && code === CHAR_COMMA$1) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (code === CHAR_RIGHT_CURLY_BRACE$1) {
+          braces--;
+
+          if (braces === 0) {
+            braceEscaped = false;
+            isBrace = token.isBrace = true;
+            finished = true;
+            break;
+          }
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (code === CHAR_FORWARD_SLASH) {
+      slashes.push(index);
+      tokens.push(token);
+      token = { value: '', depth: 0, isGlob: false };
+
+      if (finished === true) continue;
+      if (prev === CHAR_DOT$1 && index === (start + 1)) {
+        start += 2;
+        continue;
+      }
+
+      lastIndex = index + 1;
+      continue;
+    }
+
+    if (opts.noext !== true) {
+      const isExtglobChar = code === CHAR_PLUS
+        || code === CHAR_AT
+        || code === CHAR_ASTERISK
+        || code === CHAR_QUESTION_MARK
+        || code === CHAR_EXCLAMATION_MARK;
+
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {
+        isGlob = token.isGlob = true;
+        isExtglob = token.isExtglob = true;
+        finished = true;
+        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+          negatedExtglob = true;
+        }
+
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
+
+            if (code === CHAR_RIGHT_PARENTHESES$1) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+    }
+
+    if (code === CHAR_ASTERISK) {
+      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_QUESTION_MARK) {
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_LEFT_SQUARE_BRACKET$1) {
+      while (eos() !== true && (next = advance())) {
+        if (next === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
+          isBracket = token.isBracket = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          break;
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+      negated = token.negated = true;
+      start++;
+      continue;
+    }
+
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {
+      isGlob = token.isGlob = true;
+
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES$1) {
+            backslashes = token.backslashes = true;
+            code = advance();
+            continue;
+          }
+
+          if (code === CHAR_RIGHT_PARENTHESES$1) {
+            finished = true;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+
+    if (isGlob === true) {
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  if (opts.noext === true) {
+    isExtglob = false;
+    isGlob = false;
+  }
+
+  let base = str;
+  let prefix = '';
+  let glob = '';
+
+  if (start > 0) {
+    prefix = str.slice(0, start);
+    str = str.slice(start);
+    lastIndex -= start;
+  }
+
+  if (base && isGlob === true && lastIndex > 0) {
+    base = str.slice(0, lastIndex);
+    glob = str.slice(lastIndex);
+  } else if (isGlob === true) {
+    base = '';
+    glob = str;
+  } else {
+    base = str;
+  }
+
+  if (base && base !== '' && base !== '/' && base !== str) {
+    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+      base = base.slice(0, -1);
+    }
+  }
+
+  if (opts.unescape === true) {
+    if (glob) glob = utils$j.removeBackslashes(glob);
+
+    if (base && backslashes === true) {
+      base = utils$j.removeBackslashes(base);
+    }
+  }
+
+  const state = {
+    prefix,
+    input,
+    start,
+    base,
+    glob,
+    isBrace,
+    isBracket,
+    isGlob,
+    isExtglob,
+    isGlobstar,
+    negated,
+    negatedExtglob
+  };
+
+  if (opts.tokens === true) {
+    state.maxDepth = 0;
+    if (!isPathSeparator(code)) {
+      tokens.push(token);
+    }
+    state.tokens = tokens;
+  }
+
+  if (opts.parts === true || opts.tokens === true) {
+    let prevIndex;
+
+    for (let idx = 0; idx < slashes.length; idx++) {
+      const n = prevIndex ? prevIndex + 1 : start;
+      const i = slashes[idx];
+      const value = input.slice(n, i);
+      if (opts.tokens) {
+        if (idx === 0 && start !== 0) {
+          tokens[idx].isPrefix = true;
+          tokens[idx].value = prefix;
+        } else {
+          tokens[idx].value = value;
+        }
+        depth(tokens[idx]);
+        state.maxDepth += tokens[idx].depth;
+      }
+      if (idx !== 0 || value !== '') {
+        parts.push(value);
+      }
+      prevIndex = i;
+    }
+
+    if (prevIndex && prevIndex + 1 < input.length) {
+      const value = input.slice(prevIndex + 1);
+      parts.push(value);
+
+      if (opts.tokens) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
+    }
+
+    state.slashes = slashes;
+    state.parts = parts;
+  }
+
+  return state;
+};
+
+var scan_1 = scan$2;
+
+const constants$5 = constants$6;
+const utils$i = utils$k;
+
+/**
+ * Constants
+ */
+
+const {
+  MAX_LENGTH: MAX_LENGTH$1,
+  POSIX_REGEX_SOURCE,
+  REGEX_NON_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_BACKREF,
+  REPLACEMENTS
+} = constants$5;
+
+/**
+ * Helpers
+ */
+
+const expandRange = (args, options) => {
+  if (typeof options.expandRange === 'function') {
+    return options.expandRange(...args, options);
+  }
+
+  args.sort();
+  const value = `[${args.join('-')}]`;
+
+  return value;
+};
+
+/**
+ * Create the message for a syntax error
+ */
+
+const syntaxError = (type, char) => {
+  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+};
+
+/**
+ * Parse the given input string.
+ * @param {String} input
+ * @param {Object} options
+ * @return {Object}
+ */
+
+const parse$g = (input, options) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  input = REPLACEMENTS[input] || input;
+
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+
+  let len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
+  const tokens = [bos];
+
+  const capture = opts.capture ? '' : '?:';
+  const win32 = utils$i.isWindows(options);
+
+  // create constants based on platform, for windows or posix
+  const PLATFORM_CHARS = constants$5.globChars(win32);
+  const EXTGLOB_CHARS = constants$5.extglobChars(PLATFORM_CHARS);
+
+  const {
+    DOT_LITERAL,
+    PLUS_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOT_SLASH,
+    NO_DOTS_SLASH,
+    QMARK,
+    QMARK_NO_DOT,
+    STAR,
+    START_ANCHOR
+  } = PLATFORM_CHARS;
+
+  const globstar = opts => {
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const nodot = opts.dot ? '' : NO_DOT;
+  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+  let star = opts.bash === true ? globstar(opts) : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  // minimatch options support
+  if (typeof opts.noext === 'boolean') {
+    opts.noextglob = opts.noext;
+  }
+
+  const state = {
+    input,
+    index: -1,
+    start: 0,
+    dot: opts.dot === true,
+    consumed: '',
+    output: '',
+    prefix: '',
+    backtrack: false,
+    negated: false,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: false,
+    tokens
+  };
+
+  input = utils$i.removePrefix(input, state);
+  len = input.length;
+
+  const extglobs = [];
+  const braces = [];
+  const stack = [];
+  let prev = bos;
+  let value;
+
+  /**
+   * Tokenizing helpers
+   */
+
+  const eos = () => state.index === len - 1;
+  const peek = state.peek = (n = 1) => input[state.index + n];
+  const advance = state.advance = () => input[++state.index] || '';
+  const remaining = () => input.slice(state.index + 1);
+  const consume = (value = '', num = 0) => {
+    state.consumed += value;
+    state.index += num;
+  };
+
+  const append = token => {
+    state.output += token.output != null ? token.output : token.value;
+    consume(token.value);
+  };
+
+  const negate = () => {
+    let count = 1;
+
+    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
+      advance();
+      state.start++;
+      count++;
+    }
+
+    if (count % 2 === 0) {
+      return false;
+    }
+
+    state.negated = true;
+    state.start++;
+    return true;
+  };
+
+  const increment = type => {
+    state[type]++;
+    stack.push(type);
+  };
+
+  const decrement = type => {
+    state[type]--;
+    stack.pop();
+  };
+
+  /**
+   * Push tokens onto the tokens array. This helper speeds up
+   * tokenizing by 1) helping us avoid backtracking as much as possible,
+   * and 2) helping us avoid creating extra tokens when consecutive
+   * characters are plain text. This improves performance and simplifies
+   * lookbehinds.
+   */
+
+  const push = tok => {
+    if (prev.type === 'globstar') {
+      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));
+
+      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+        state.output = state.output.slice(0, -prev.output.length);
+        prev.type = 'star';
+        prev.value = '*';
+        prev.output = star;
+        state.output += prev.output;
+      }
+    }
+
+    if (extglobs.length && tok.type !== 'paren') {
+      extglobs[extglobs.length - 1].inner += tok.value;
+    }
+
+    if (tok.value || tok.output) append(tok);
+    if (prev && prev.type === 'text' && tok.type === 'text') {
+      prev.value += tok.value;
+      prev.output = (prev.output || '') + tok.value;
+      return;
+    }
+
+    tok.prev = prev;
+    tokens.push(tok);
+    prev = tok;
+  };
+
+  const extglobOpen = (type, value) => {
+    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+    token.prev = prev;
+    token.parens = state.parens;
+    token.output = state.output;
+    const output = (opts.capture ? '(' : '') + token.open;
+
+    increment('parens');
+    push({ type, value, output: state.output ? '' : ONE_CHAR });
+    push({ type: 'paren', extglob: true, value: advance(), output });
+    extglobs.push(token);
+  };
+
+  const extglobClose = token => {
+    let output = token.close + (opts.capture ? ')' : '');
+    let rest;
+
+    if (token.type === 'negate') {
+      let extglobStar = star;
+
+      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+        extglobStar = globstar(opts);
+      }
+
+      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+        output = token.close = `)$))${extglobStar}`;
+      }
+
+      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+        // Any non-magical string (`.ts`) or even nested expression (`.{ts,tsx}`) can follow after the closing parenthesis.
+        // In this case, we need to parse the string and use it in the output of the original pattern.
+        // Suitable patterns: `/!(*.d).ts`, `/!(*.d).{ts,tsx}`, `**/!(*-dbg).@(js)`.
+        //
+        // Disabling the `fastpaths` option due to a problem with parsing strings as `.ts` in the pattern like `**/!(*.d).ts`.
+        const expression = parse$g(rest, { ...options, fastpaths: false }).output;
+
+        output = token.close = `)${expression})${extglobStar})`;
+      }
+
+      if (token.prev.type === 'bos') {
+        state.negatedExtglob = true;
+      }
+    }
+
+    push({ type: 'paren', extglob: true, value, output });
+    decrement('parens');
+  };
+
+  /**
+   * Fast paths
+   */
+
+  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+    let backslashes = false;
+
+    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+      if (first === '\\') {
+        backslashes = true;
+        return m;
+      }
+
+      if (first === '?') {
+        if (esc) {
+          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        if (index === 0) {
+          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+        }
+        return QMARK.repeat(chars.length);
+      }
+
+      if (first === '.') {
+        return DOT_LITERAL.repeat(chars.length);
+      }
+
+      if (first === '*') {
+        if (esc) {
+          return esc + first + (rest ? star : '');
+        }
+        return star;
+      }
+      return esc ? m : `\\${m}`;
+    });
+
+    if (backslashes === true) {
+      if (opts.unescape === true) {
+        output = output.replace(/\\/g, '');
+      } else {
+        output = output.replace(/\\+/g, m => {
+          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+        });
+      }
+    }
+
+    if (output === input && opts.contains === true) {
+      state.output = input;
+      return state;
+    }
+
+    state.output = utils$i.wrapOutput(output, state, options);
+    return state;
+  }
+
+  /**
+   * Tokenize input until we reach end-of-string
+   */
+
+  while (!eos()) {
+    value = advance();
+
+    if (value === '\u0000') {
+      continue;
+    }
+
+    /**
+     * Escaped characters
+     */
+
+    if (value === '\\') {
+      const next = peek();
+
+      if (next === '/' && opts.bash !== true) {
+        continue;
+      }
+
+      if (next === '.' || next === ';') {
+        continue;
+      }
+
+      if (!next) {
+        value += '\\';
+        push({ type: 'text', value });
+        continue;
+      }
+
+      // collapse slashes to reduce potential for exploits
+      const match = /^\\+/.exec(remaining());
+      let slashes = 0;
+
+      if (match && match[0].length > 2) {
+        slashes = match[0].length;
+        state.index += slashes;
+        if (slashes % 2 !== 0) {
+          value += '\\';
+        }
+      }
+
+      if (opts.unescape === true) {
+        value = advance();
+      } else {
+        value += advance();
+      }
+
+      if (state.brackets === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
+    }
+
+    /**
+     * If we're inside a regex character class, continue
+     * until we reach the closing bracket.
+     */
+
+    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+      if (opts.posix !== false && value === ':') {
+        const inner = prev.value.slice(1);
+        if (inner.includes('[')) {
+          prev.posix = true;
+
+          if (inner.includes(':')) {
+            const idx = prev.value.lastIndexOf('[');
+            const pre = prev.value.slice(0, idx);
+            const rest = prev.value.slice(idx + 2);
+            const posix = POSIX_REGEX_SOURCE[rest];
+            if (posix) {
+              prev.value = pre + posix;
+              state.backtrack = true;
+              advance();
+
+              if (!bos.output && tokens.indexOf(prev) === 1) {
+                bos.output = ONE_CHAR;
+              }
+              continue;
+            }
+          }
+        }
+      }
+
+      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+        value = `\\${value}`;
+      }
+
+      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+        value = `\\${value}`;
+      }
+
+      if (opts.posix === true && value === '!' && prev.value === '[') {
+        value = '^';
+      }
+
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * If we're inside a quoted string, continue
+     * until we reach the closing double quote.
+     */
+
+    if (state.quotes === 1 && value !== '"') {
+      value = utils$i.escapeRegex(value);
+      prev.value += value;
+      append({ value });
+      continue;
+    }
+
+    /**
+     * Double quotes
+     */
+
+    if (value === '"') {
+      state.quotes = state.quotes === 1 ? 0 : 1;
+      if (opts.keepQuotes === true) {
+        push({ type: 'text', value });
+      }
+      continue;
+    }
+
+    /**
+     * Parentheses
+     */
+
+    if (value === '(') {
+      increment('parens');
+      push({ type: 'paren', value });
+      continue;
+    }
+
+    if (value === ')') {
+      if (state.parens === 0 && opts.strictBrackets === true) {
+        throw new SyntaxError(syntaxError('opening', '('));
+      }
+
+      const extglob = extglobs[extglobs.length - 1];
+      if (extglob && state.parens === extglob.parens + 1) {
+        extglobClose(extglobs.pop());
+        continue;
+      }
+
+      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+      decrement('parens');
+      continue;
+    }
+
+    /**
+     * Square brackets
+     */
+
+    if (value === '[') {
+      if (opts.nobracket === true || !remaining().includes(']')) {
+        if (opts.nobracket !== true && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('closing', ']'));
+        }
+
+        value = `\\${value}`;
+      } else {
+        increment('brackets');
+      }
+
+      push({ type: 'bracket', value });
+      continue;
+    }
+
+    if (value === ']') {
+      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      if (state.brackets === 0) {
+        if (opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError('opening', '['));
+        }
+
+        push({ type: 'text', value, output: `\\${value}` });
+        continue;
+      }
+
+      decrement('brackets');
+
+      const prevValue = prev.value.slice(1);
+      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+        value = `/${value}`;
+      }
+
+      prev.value += value;
+      append({ value });
+
+      // when literal brackets are explicitly disabled
+      // assume we should match with a regex character class
+      if (opts.literalBrackets === false || utils$i.hasRegexChars(prevValue)) {
+        continue;
+      }
+
+      const escaped = utils$i.escapeRegex(prev.value);
+      state.output = state.output.slice(0, -prev.value.length);
+
+      // when literal brackets are explicitly enabled
+      // assume we should escape the brackets to match literal characters
+      if (opts.literalBrackets === true) {
+        state.output += escaped;
+        prev.value = escaped;
+        continue;
+      }
+
+      // when the user specifies nothing, try to match both
+      prev.value = `(${capture}${escaped}|${prev.value})`;
+      state.output += prev.value;
+      continue;
+    }
+
+    /**
+     * Braces
+     */
+
+    if (value === '{' && opts.nobrace !== true) {
+      increment('braces');
+
+      const open = {
+        type: 'brace',
+        value,
+        output: '(',
+        outputIndex: state.output.length,
+        tokensIndex: state.tokens.length
+      };
+
+      braces.push(open);
+      push(open);
+      continue;
+    }
+
+    if (value === '}') {
+      const brace = braces[braces.length - 1];
+
+      if (opts.nobrace === true || !brace) {
+        push({ type: 'text', value, output: value });
+        continue;
+      }
+
+      let output = ')';
+
+      if (brace.dots === true) {
+        const arr = tokens.slice();
+        const range = [];
+
+        for (let i = arr.length - 1; i >= 0; i--) {
+          tokens.pop();
+          if (arr[i].type === 'brace') {
+            break;
+          }
+          if (arr[i].type !== 'dots') {
+            range.unshift(arr[i].value);
+          }
+        }
+
+        output = expandRange(range, opts);
+        state.backtrack = true;
+      }
+
+      if (brace.comma !== true && brace.dots !== true) {
+        const out = state.output.slice(0, brace.outputIndex);
+        const toks = state.tokens.slice(brace.tokensIndex);
+        brace.value = brace.output = '\\{';
+        value = output = '\\}';
+        state.output = out;
+        for (const t of toks) {
+          state.output += (t.output || t.value);
+        }
+      }
+
+      push({ type: 'brace', value, output });
+      decrement('braces');
+      braces.pop();
+      continue;
+    }
+
+    /**
+     * Pipes
+     */
+
+    if (value === '|') {
+      if (extglobs.length > 0) {
+        extglobs[extglobs.length - 1].conditions++;
+      }
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Commas
+     */
+
+    if (value === ',') {
+      let output = value;
+
+      const brace = braces[braces.length - 1];
+      if (brace && stack[stack.length - 1] === 'braces') {
+        brace.comma = true;
+        output = '|';
+      }
+
+      push({ type: 'comma', value, output });
+      continue;
+    }
+
+    /**
+     * Slashes
+     */
+
+    if (value === '/') {
+      // if the beginning of the glob is "./", advance the start
+      // to the current index, and don't add the "./" characters
+      // to the state. This greatly simplifies lookbehinds when
+      // checking for BOS characters like "!" and "." (not "./")
+      if (prev.type === 'dot' && state.index === state.start + 1) {
+        state.start = state.index + 1;
+        state.consumed = '';
+        state.output = '';
+        tokens.pop();
+        prev = bos; // reset "prev" to the first token
+        continue;
+      }
+
+      push({ type: 'slash', value, output: SLASH_LITERAL });
+      continue;
+    }
+
+    /**
+     * Dots
+     */
+
+    if (value === '.') {
+      if (state.braces > 0 && prev.type === 'dot') {
+        if (prev.value === '.') prev.output = DOT_LITERAL;
+        const brace = braces[braces.length - 1];
+        prev.type = 'dots';
+        prev.output += value;
+        prev.value += value;
+        brace.dots = true;
+        continue;
+      }
+
+      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
+        push({ type: 'text', value, output: DOT_LITERAL });
+        continue;
+      }
+
+      push({ type: 'dot', value, output: DOT_LITERAL });
+      continue;
+    }
+
+    /**
+     * Question marks
+     */
+
+    if (value === '?') {
+      const isGroup = prev && prev.value === '(';
+      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('qmark', value);
+        continue;
+      }
+
+      if (prev && prev.type === 'paren') {
+        const next = peek();
+        let output = value;
+
+        if (next === '<' && !utils$i.supportsLookbehinds()) {
+          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+        }
+
+        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
+          output = `\\${value}`;
+        }
+
+        push({ type: 'text', value, output });
+        continue;
+      }
+
+      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+        push({ type: 'qmark', value, output: QMARK_NO_DOT });
+        continue;
+      }
+
+      push({ type: 'qmark', value, output: QMARK });
+      continue;
+    }
+
+    /**
+     * Exclamation
+     */
+
+    if (value === '!') {
+      if (opts.noextglob !== true && peek() === '(') {
+        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+          extglobOpen('negate', value);
+          continue;
+        }
+      }
+
+      if (opts.nonegate !== true && state.index === 0) {
+        negate();
+        continue;
+      }
+    }
+
+    /**
+     * Plus
+     */
+
+    if (value === '+') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        extglobOpen('plus', value);
+        continue;
+      }
+
+      if ((prev && prev.value === '(') || opts.regex === false) {
+        push({ type: 'plus', value, output: PLUS_LITERAL });
+        continue;
+      }
+
+      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
+        push({ type: 'plus', value });
+        continue;
+      }
+
+      push({ type: 'plus', value: PLUS_LITERAL });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value === '@') {
+      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+        push({ type: 'at', extglob: true, value, output: '' });
+        continue;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Plain text
+     */
+
+    if (value !== '*') {
+      if (value === '$' || value === '^') {
+        value = `\\${value}`;
+      }
+
+      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+      if (match) {
+        value += match[0];
+        state.index += match[0].length;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Stars
+     */
+
+    if (prev && (prev.type === 'globstar' || prev.star === true)) {
+      prev.type = 'star';
+      prev.star = true;
+      prev.value += value;
+      prev.output = star;
+      state.backtrack = true;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    let rest = remaining();
+    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+      extglobOpen('star', value);
+      continue;
+    }
+
+    if (prev.type === 'star') {
+      if (opts.noglobstar === true) {
+        consume(value);
+        continue;
+      }
+
+      const prior = prev.prev;
+      const before = prior.prev;
+      const isStart = prior.type === 'slash' || prior.type === 'bos';
+      const afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+        push({ type: 'star', value, output: '' });
+        continue;
+      }
+
+      // strip consecutive `/**/`
+      while (rest.slice(0, 3) === '/**') {
+        const after = input[state.index + 4];
+        if (after && after !== '/') {
+          break;
+        }
+        rest = rest.slice(3);
+        consume('/**', 3);
+      }
+
+      if (prior.type === 'bos' && eos()) {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = globstar(opts);
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
+        prev.value += value;
+        state.globstar = true;
+        state.output += prior.output + prev.output;
+        consume(value);
+        continue;
+      }
+
+      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
+        const end = rest[1] !== void 0 ? '|$' : '';
+
+        state.output = state.output.slice(0, -(prior.output + prev.output).length);
+        prior.output = `(?:${prior.output}`;
+
+        prev.type = 'globstar';
+        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+        prev.value += value;
+
+        state.output += prior.output + prev.output;
+        state.globstar = true;
+
+        consume(value + advance());
+
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      if (prior.type === 'bos' && rest[0] === '/') {
+        prev.type = 'globstar';
+        prev.value += value;
+        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+        state.output = prev.output;
+        state.globstar = true;
+        consume(value + advance());
+        push({ type: 'slash', value: '/', output: '' });
+        continue;
+      }
+
+      // remove single star from output
+      state.output = state.output.slice(0, -prev.output.length);
+
+      // reset previous token to globstar
+      prev.type = 'globstar';
+      prev.output = globstar(opts);
+      prev.value += value;
+
+      // reset output with globstar
+      state.output += prev.output;
+      state.globstar = true;
+      consume(value);
+      continue;
+    }
+
+    const token = { type: 'star', value, output: star };
+
+    if (opts.bash === true) {
+      token.output = '.*?';
+      if (prev.type === 'bos' || prev.type === 'slash') {
+        token.output = nodot + token.output;
+      }
+      push(token);
+      continue;
+    }
+
+    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+      token.output = value;
+      push(token);
+      continue;
+    }
+
+    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+      if (prev.type === 'dot') {
+        state.output += NO_DOT_SLASH;
+        prev.output += NO_DOT_SLASH;
+
+      } else if (opts.dot === true) {
+        state.output += NO_DOTS_SLASH;
+        prev.output += NO_DOTS_SLASH;
+
+      } else {
+        state.output += nodot;
+        prev.output += nodot;
+      }
+
+      if (peek() !== '*') {
+        state.output += ONE_CHAR;
+        prev.output += ONE_CHAR;
+      }
+    }
+
+    push(token);
+  }
+
+  while (state.brackets > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+    state.output = utils$i.escapeLast(state.output, '[');
+    decrement('brackets');
+  }
+
+  while (state.parens > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+    state.output = utils$i.escapeLast(state.output, '(');
+    decrement('parens');
+  }
+
+  while (state.braces > 0) {
+    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+    state.output = utils$i.escapeLast(state.output, '{');
+    decrement('braces');
+  }
+
+  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+  }
+
+  // rebuild the output if we had to backtrack at any point
+  if (state.backtrack === true) {
+    state.output = '';
+
+    for (const token of state.tokens) {
+      state.output += token.output != null ? token.output : token.value;
+
+      if (token.suffix) {
+        state.output += token.suffix;
+      }
+    }
+  }
+
+  return state;
+};
+
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse$g.fastpaths = (input, options) => {
+  const opts = { ...options };
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const len = input.length;
+  if (len > max) {
+    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+  }
+
+  input = REPLACEMENTS[input] || input;
+  const win32 = utils$i.isWindows(options);
+
+  // create constants based on platform, for windows or posix
+  const {
+    DOT_LITERAL,
+    SLASH_LITERAL,
+    ONE_CHAR,
+    DOTS_SLASH,
+    NO_DOT,
+    NO_DOTS,
+    NO_DOTS_SLASH,
+    STAR,
+    START_ANCHOR
+  } = constants$5.globChars(win32);
+
+  const nodot = opts.dot ? NO_DOTS : NO_DOT;
+  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+  const capture = opts.capture ? '' : '?:';
+  const state = { negated: false, prefix: '' };
+  let star = opts.bash === true ? '.*?' : STAR;
+
+  if (opts.capture) {
+    star = `(${star})`;
+  }
+
+  const globstar = opts => {
+    if (opts.noglobstar === true) return star;
+    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+  };
+
+  const create = str => {
+    switch (str) {
+      case '*':
+        return `${nodot}${ONE_CHAR}${star}`;
+
+      case '.*':
+        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*.*':
+        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '*/*':
+        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+      case '**':
+        return nodot + globstar(opts);
+
+      case '**/*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+
+      case '**/*.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      case '**/.*':
+        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+      default: {
+        const match = /^(.*?)\.(\w+)$/.exec(str);
+        if (!match) return;
+
+        const source = create(match[1]);
+        if (!source) return;
+
+        return source + DOT_LITERAL + match[2];
+      }
+    }
+  };
+
+  const output = utils$i.removePrefix(input, state);
+  let source = create(output);
+
+  if (source && opts.strictSlashes !== true) {
+    source += `${SLASH_LITERAL}?`;
+  }
+
+  return source;
+};
+
+var parse_1$3 = parse$g;
+
+const path$l = require$$0$4;
+const scan$1 = scan_1;
+const parse$f = parse_1$3;
+const utils$h = utils$k;
+const constants$4 = constants$6;
+const isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch$5 = (glob, options, returnState = false) => {
+  if (Array.isArray(glob)) {
+    const fns = glob.map(input => picomatch$5(input, options, returnState));
+    const arrayMatcher = str => {
+      for (const isMatch of fns) {
+        const state = isMatch(str);
+        if (state) return state;
+      }
+      return false;
+    };
+    return arrayMatcher;
+  }
+
+  const isState = isObject$3(glob) && glob.tokens && glob.input;
+
+  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+    throw new TypeError('Expected pattern to be a non-empty string');
+  }
+
+  const opts = options || {};
+  const posix = utils$h.isWindows(options);
+  const regex = isState
+    ? picomatch$5.compileRe(glob, options)
+    : picomatch$5.makeRe(glob, options, false, true);
+
+  const state = regex.state;
+  delete regex.state;
+
+  let isIgnored = () => false;
+  if (opts.ignore) {
+    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    isIgnored = picomatch$5(opts.ignore, ignoreOpts, returnState);
+  }
+
+  const matcher = (input, returnObject = false) => {
+    const { isMatch, match, output } = picomatch$5.test(input, regex, options, { glob, posix });
+    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+    if (typeof opts.onResult === 'function') {
+      opts.onResult(result);
+    }
+
+    if (isMatch === false) {
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (isIgnored(input)) {
+      if (typeof opts.onIgnore === 'function') {
+        opts.onIgnore(result);
+      }
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (typeof opts.onMatch === 'function') {
+      opts.onMatch(result);
+    }
+    return returnObject ? result : true;
+  };
+
+  if (returnState) {
+    matcher.state = state;
+  }
+
+  return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch$5.test = (input, regex, options, { glob, posix } = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
+
+  if (input === '') {
+    return { isMatch: false, output: '' };
+  }
+
+  const opts = options || {};
+  const format = opts.format || (posix ? utils$h.toPosixSlashes : null);
+  let match = input === glob;
+  let output = (match && format) ? format(input) : input;
+
+  if (match === false) {
+    output = format ? format(input) : input;
+    match = output === glob;
+  }
+
+  if (match === false || opts.capture === true) {
+    if (opts.matchBase === true || opts.basename === true) {
+      match = picomatch$5.matchBase(input, regex, options, posix);
+    } else {
+      match = regex.exec(output);
+    }
+  }
+
+  return { isMatch: Boolean(match), match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch$5.matchBase = (input, glob, options, posix = utils$h.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$5.makeRe(glob, options);
+  return regex.test(path$l.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch$5.isMatch = (str, patterns, options) => picomatch$5(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch$5.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$5.parse(p, options));
+  return parse$f(pattern, { ...options, fastpaths: false });
+};
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch$5.scan = (input, options) => scan$1(input, options);
+
+/**
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
+ *
+ * @param {Object} `state`
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch$5.compileRe = (state, options, returnOutput = false, returnState = false) => {
+  if (returnOutput === true) {
+    return state.output;
+  }
+
+  const opts = options || {};
+  const prepend = opts.contains ? '' : '^';
+  const append = opts.contains ? '' : '$';
+
+  let source = `${prepend}(?:${state.output})${append}`;
+  if (state && state.negated === true) {
+    source = `^(?!${source}).*$`;
+  }
+
+  const regex = picomatch$5.toRegex(source, options);
+  if (returnState === true) {
+    regex.state = state;
+  }
+
+  return regex;
+};
+
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch$5.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+  if (!input || typeof input !== 'string') {
+    throw new TypeError('Expected a non-empty string');
+  }
+
+  let parsed = { negated: false, fastpaths: true };
+
+  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    parsed.output = parse$f.fastpaths(input, options);
+  }
+
+  if (!parsed.output) {
+    parsed = parse$f(input, options);
+  }
+
+  return picomatch$5.compileRe(parsed, options, returnOutput, returnState);
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch$5.toRegex = (source, options) => {
+  try {
+    const opts = options || {};
+    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+  } catch (err) {
+    if (options && options.debug === true) throw err;
+    return /$^/;
+  }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch$5.constants = constants$4;
+
+/**
+ * Expose "picomatch"
+ */
+
+var picomatch_1 = picomatch$5;
+
+var picomatch$3 = picomatch_1;
+
+var picomatch$4 = /*@__PURE__*/getDefaultExportFromCjs(picomatch$3);
+
+const extractors = {
+    ArrayPattern(names, param) {
+        for (const element of param.elements) {
+            if (element)
+                extractors[element.type](names, element);
+        }
+    },
+    AssignmentPattern(names, param) {
+        extractors[param.left.type](names, param.left);
+    },
+    Identifier(names, param) {
+        names.push(param.name);
+    },
+    MemberExpression() { },
+    ObjectPattern(names, param) {
+        for (const prop of param.properties) {
+            // @ts-ignore Typescript reports that this is not a valid type
+            if (prop.type === 'RestElement') {
+                extractors.RestElement(names, prop);
+            }
+            else {
+                extractors[prop.value.type](names, prop.value);
+            }
+        }
+    },
+    RestElement(names, param) {
+        extractors[param.argument.type](names, param.argument);
+    }
+};
+const extractAssignedNames = function extractAssignedNames(param) {
+    const names = [];
+    extractors[param.type](names, param);
+    return names;
+};
+
+const blockDeclarations = {
+    const: true,
+    let: true
+};
+class Scope {
+    constructor(options = {}) {
+        this.parent = options.parent;
+        this.isBlockScope = !!options.block;
+        this.declarations = Object.create(null);
+        if (options.params) {
+            options.params.forEach((param) => {
+                extractAssignedNames(param).forEach((name) => {
+                    this.declarations[name] = true;
+                });
+            });
+        }
+    }
+    addDeclaration(node, isBlockDeclaration, isVar) {
+        if (!isBlockDeclaration && this.isBlockScope) {
+            // it's a `var` or function node, and this
+            // is a block scope, so we need to go up
+            this.parent.addDeclaration(node, isBlockDeclaration, isVar);
+        }
+        else if (node.id) {
+            extractAssignedNames(node.id).forEach((name) => {
+                this.declarations[name] = true;
+            });
+        }
+    }
+    contains(name) {
+        return this.declarations[name] || (this.parent ? this.parent.contains(name) : false);
+    }
+}
+const attachScopes = function attachScopes(ast, propertyName = 'scope') {
+    let scope = new Scope();
+    walk$3(ast, {
+        enter(n, parent) {
+            const node = n;
+            // function foo () {...}
+            // class Foo {...}
+            if (/(Function|Class)Declaration/.test(node.type)) {
+                scope.addDeclaration(node, false, false);
+            }
+            // var foo = 1
+            if (node.type === 'VariableDeclaration') {
+                const { kind } = node;
+                const isBlockDeclaration = blockDeclarations[kind];
+                node.declarations.forEach((declaration) => {
+                    scope.addDeclaration(declaration, isBlockDeclaration, true);
+                });
+            }
+            let newScope;
+            // create new function scope
+            if (/Function/.test(node.type)) {
+                const func = node;
+                newScope = new Scope({
+                    parent: scope,
+                    block: false,
+                    params: func.params
+                });
+                // named function expressions - the name is considered
+                // part of the function's scope
+                if (func.type === 'FunctionExpression' && func.id) {
+                    newScope.addDeclaration(func, false, false);
+                }
+            }
+            // create new for scope
+            if (/For(In|Of)?Statement/.test(node.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // create new block scope
+            if (node.type === 'BlockStatement' && !/Function/.test(parent.type)) {
+                newScope = new Scope({
+                    parent: scope,
+                    block: true
+                });
+            }
+            // catch clause has its own block scope
+            if (node.type === 'CatchClause') {
+                newScope = new Scope({
+                    parent: scope,
+                    params: node.param ? [node.param] : [],
+                    block: true
+                });
+            }
+            if (newScope) {
+                Object.defineProperty(node, propertyName, {
+                    value: newScope,
+                    configurable: true
+                });
+                scope = newScope;
+            }
+        },
+        leave(n) {
+            const node = n;
+            if (node[propertyName])
+                scope = scope.parent;
+        }
+    });
+    return scope;
+};
+
+// Helper since Typescript can't detect readonly arrays with Array.isArray
+function isArray(arg) {
+    return Array.isArray(arg);
+}
+function ensureArray(thing) {
+    if (isArray(thing))
+        return thing;
+    if (thing == null)
+        return [];
+    return [thing];
+}
+
+const normalizePath$5 = function normalizePath(filename) {
+    return filename.split(win32.sep).join(posix.sep);
+};
+
+function getMatcherString(id, resolutionBase) {
+    if (resolutionBase === false || isAbsolute(id) || id.startsWith('**')) {
+        return normalizePath$5(id);
+    }
+    // resolve('') is valid and will default to process.cwd()
+    const basePath = normalizePath$5(resolve$3(resolutionBase || ''))
+        // escape all possible (posix + win) path characters that might interfere with regex
+        .replace(/[-^$*+?.()|[\]{}]/g, '\\$&');
+    // Note that we use posix.join because:
+    // 1. the basePath has been normalized to use /
+    // 2. the incoming glob (id) matcher, also uses /
+    // otherwise Node will force backslash (\) on windows
+    return posix.join(basePath, normalizePath$5(id));
+}
+const createFilter$1 = function createFilter(include, exclude, options) {
+    const resolutionBase = options && options.resolve;
+    const getMatcher = (id) => id instanceof RegExp
+        ? id
+        : {
+            test: (what) => {
+                // this refactor is a tad overly verbose but makes for easy debugging
+                const pattern = getMatcherString(id, resolutionBase);
+                const fn = picomatch$4(pattern, { dot: true });
+                const result = fn(what);
+                return result;
+            }
+        };
+    const includeMatchers = ensureArray(include).map(getMatcher);
+    const excludeMatchers = ensureArray(exclude).map(getMatcher);
+    return function result(id) {
+        if (typeof id !== 'string')
+            return false;
+        if (/\0/.test(id))
+            return false;
+        const pathId = normalizePath$5(id);
+        for (let i = 0; i < excludeMatchers.length; ++i) {
+            const matcher = excludeMatchers[i];
+            if (matcher.test(pathId))
+                return false;
+        }
+        for (let i = 0; i < includeMatchers.length; ++i) {
+            const matcher = includeMatchers[i];
+            if (matcher.test(pathId))
+                return true;
+        }
+        return !includeMatchers.length;
+    };
+};
+
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbiddenIdentifiers = new Set(`${reservedWords} ${builtins}`.split(' '));
+forbiddenIdentifiers.add('');
+const makeLegalIdentifier = function makeLegalIdentifier(str) {
+    let identifier = str
+        .replace(/-(\w)/g, (_, letter) => letter.toUpperCase())
+        .replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+    }
+    return identifier || '_';
+};
+
+function stringify$8(obj) {
+    return (JSON.stringify(obj) || 'undefined').replace(/[\u2028\u2029]/g, (char) => `\\u${`000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+}
+function serializeArray(arr, indent, baseIndent) {
+    let output = '[';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    for (let i = 0; i < arr.length; i++) {
+        const key = arr[i];
+        output += `${i > 0 ? ',' : ''}${separator}${serialize(key, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}]`;
+}
+function serializeObject(obj, indent, baseIndent) {
+    let output = '{';
+    const separator = indent ? `\n${baseIndent}${indent}` : '';
+    const entries = Object.entries(obj);
+    for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        const stringKey = makeLegalIdentifier(key) === key ? key : stringify$8(key);
+        output += `${i > 0 ? ',' : ''}${separator}${stringKey}:${indent ? ' ' : ''}${serialize(value, indent, baseIndent + indent)}`;
+    }
+    return `${output}${indent ? `\n${baseIndent}` : ''}}`;
+}
+function serialize(obj, indent, baseIndent) {
+    if (typeof obj === 'object' && obj !== null) {
+        if (Array.isArray(obj))
+            return serializeArray(obj, indent, baseIndent);
+        if (obj instanceof Date)
+            return `new Date(${obj.getTime()})`;
+        if (obj instanceof RegExp)
+            return obj.toString();
+        return serializeObject(obj, indent, baseIndent);
+    }
+    if (typeof obj === 'number') {
+        if (obj === Infinity)
+            return 'Infinity';
+        if (obj === -Infinity)
+            return '-Infinity';
+        if (obj === 0)
+            return 1 / obj === Infinity ? '0' : '-0';
+        if (obj !== obj)
+            return 'NaN'; // eslint-disable-line no-self-compare
+    }
+    if (typeof obj === 'symbol') {
+        const key = Symbol.keyFor(obj);
+        // eslint-disable-next-line no-undefined
+        if (key !== undefined)
+            return `Symbol.for(${stringify$8(key)})`;
+    }
+    if (typeof obj === 'bigint')
+        return `${obj}n`;
+    return stringify$8(obj);
+}
+// isWellFormed exists from Node.js 20
+const hasStringIsWellFormed = 'isWellFormed' in String.prototype;
+function isWellFormedString(input) {
+    // @ts-expect-error String::isWellFormed exists from ES2024. tsconfig lib is set to ES6
+    if (hasStringIsWellFormed)
+        return input.isWellFormed();
+    // https://github.com/tc39/proposal-is-usv-string/blob/main/README.md#algorithm
+    return !/\p{Surrogate}/u.test(input);
+}
+const dataToEsm = function dataToEsm(data, options = {}) {
+    var _a, _b;
+    const t = options.compact ? '' : 'indent' in options ? options.indent : '\t';
+    const _ = options.compact ? '' : ' ';
+    const n = options.compact ? '' : '\n';
+    const declarationType = options.preferConst ? 'const' : 'var';
+    if (options.namedExports === false ||
+        typeof data !== 'object' ||
+        Array.isArray(data) ||
+        data instanceof Date ||
+        data instanceof RegExp ||
+        data === null) {
+        const code = serialize(data, options.compact ? null : t, '');
+        const magic = _ || (/^[{[\-\/]/.test(code) ? '' : ' '); // eslint-disable-line no-useless-escape
+        return `export default${magic}${code};`;
+    }
+    let maxUnderbarPrefixLength = 0;
+    for (const key of Object.keys(data)) {
+        const underbarPrefixLength = (_b = (_a = key.match(/^(_+)/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+        if (underbarPrefixLength > maxUnderbarPrefixLength) {
+            maxUnderbarPrefixLength = underbarPrefixLength;
+        }
+    }
+    const arbitraryNamePrefix = `${'_'.repeat(maxUnderbarPrefixLength + 1)}arbitrary`;
+    let namedExportCode = '';
+    const defaultExportRows = [];
+    const arbitraryNameExportRows = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (key === makeLegalIdentifier(key)) {
+            if (options.objectShorthand)
+                defaultExportRows.push(key);
+            else
+                defaultExportRows.push(`${key}:${_}${key}`);
+            namedExportCode += `export ${declarationType} ${key}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+        }
+        else {
+            defaultExportRows.push(`${stringify$8(key)}:${_}${serialize(value, options.compact ? null : t, '')}`);
+            if (options.includeArbitraryNames && isWellFormedString(key)) {
+                const variableName = `${arbitraryNamePrefix}${arbitraryNameExportRows.length}`;
+                namedExportCode += `${declarationType} ${variableName}${_}=${_}${serialize(value, options.compact ? null : t, '')};${n}`;
+                arbitraryNameExportRows.push(`${variableName} as ${JSON.stringify(key)}`);
+            }
+        }
+    }
+    const arbitraryExportCode = arbitraryNameExportRows.length > 0
+        ? `export${_}{${n}${t}${arbitraryNameExportRows.join(`,${n}${t}`)}${n}};${n}`
+        : '';
+    const defaultExportCode = `export default${_}{${n}${t}${defaultExportRows.join(`,${n}${t}`)}${n}};${n}`;
+    return `${namedExportCode}${arbitraryExportCode}${defaultExportCode}`;
+};
+
+var path$k = require$$0$4;
+
+var commondir = function (basedir, relfiles) {
+    if (relfiles) {
+        var files = relfiles.map(function (r) {
+            return path$k.resolve(basedir, r);
+        });
+    }
+    else {
+        var files = basedir;
+    }
+    
+    var res = files.slice(1).reduce(function (ps, file) {
+        if (!file.match(/^([A-Za-z]:)?\/|\\/)) {
+            throw new Error('relative path without a basedir');
+        }
+        
+        var xs = file.split(/\/+|\\+/);
+        for (
+            var i = 0;
+            ps[i] === xs[i] && i < Math.min(ps.length, xs.length);
+            i++
+        );
+        return ps.slice(0, i);
+    }, files[0].split(/\/+|\\+/));
+    
+    // Windows correctly handles paths with forward-slashes
+    return res.length > 1 ? res.join('/') : '/'
+};
+
+var getCommonDir = /*@__PURE__*/getDefaultExportFromCjs(commondir);
+
+var balancedMatch = balanced$1;
+function balanced$1(a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str);
+  if (b instanceof RegExp) b = maybeMatch(b, str);
+
+  var r = range$1(a, b, str);
+
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + a.length, r[1]),
+    post: str.slice(r[1] + b.length)
+  };
+}
+
+function maybeMatch(reg, str) {
+  var m = str.match(reg);
+  return m ? m[0] : null;
+}
+
+balanced$1.range = range$1;
+function range$1(a, b, str) {
+  var begs, beg, left, right, result;
+  var ai = str.indexOf(a);
+  var bi = str.indexOf(b, ai + 1);
+  var i = ai;
+
+  if (ai >= 0 && bi > 0) {
+    if(a===b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+
+    while (i >= 0 && !result) {
+      if (i == ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length == 1) {
+        result = [ begs.pop(), bi ];
+      } else {
+        beg = begs.pop();
+        if (beg < left) {
+          left = beg;
+          right = bi;
+        }
+
+        bi = str.indexOf(b, i + 1);
+      }
+
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+
+    if (begs.length) {
+      result = [ left, right ];
+    }
+  }
+
+  return result;
+}
+
+var balanced = balancedMatch;
+
+var braceExpansion = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
+
+  var parts = [];
+  var m = balanced('{', '}', str);
+
+  if (!m)
+    return str.split(',');
+
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+
+  parts.push.apply(parts, p);
+
+  return parts;
+}
+
+function expandTop(str) {
+  if (!str)
+    return [];
+
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
+
+  return expand$3(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+
+function expand$3(str, isTop) {
+  var expansions = [];
+
+  var m = balanced('{', '}', str);
+  if (!m) return [str];
+
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand$3(m.post, false)
+    : [''];
+
+  if (/\$$/.test(m.pre)) {    
+    for (var k = 0; k < post.length; k++) {
+      var expansion = pre+ '{' + m.body + '}' + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    var isSequence = isNumericSequence || isAlphaSequence;
+    var isOptions = m.body.indexOf(',') >= 0;
+    if (!isSequence && !isOptions) {
+      // {a},b}
+      if (m.post.match(/,.*\}/)) {
+        str = m.pre + '{' + m.body + escClose + m.post;
+        return expand$3(str);
+      }
+      return [str];
+    }
+
+    var n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1) {
+        // x{{a,b}}y ==> x{a}y x{b}y
+        n = expand$3(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map(function(p) {
+            return m.pre + n[0] + p;
+          });
+        }
+      }
+    }
+
+    // at this point, n is the parts, and we know it's not a comma set
+    // with a single entry.
+    var N;
+
+    if (isSequence) {
+      var x = numeric(n[0]);
+      var y = numeric(n[1]);
+      var width = Math.max(n[0].length, n[1].length);
+      var incr = n.length == 3
+        ? Math.abs(numeric(n[2]))
+        : 1;
+      var test = lte;
+      var reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      var pad = n.some(isPadded);
+
+      N = [];
+
+      for (var i = x; test(i, y); i += incr) {
+        var c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === '\\')
+            c = '';
+        } else {
+          c = String(i);
+          if (pad) {
+            var need = width - c.length;
+            if (need > 0) {
+              var z = new Array(need + 1).join('0');
+              if (i < 0)
+                c = '-' + z + c.slice(1);
+              else
+                c = z + c;
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+
+      for (var j = 0; j < n.length; j++) {
+        N.push.apply(N, expand$3(n[j], false));
+      }
+    }
+
+    for (var j = 0; j < N.length; j++) {
+      for (var k = 0; k < post.length; k++) {
+        var expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion)
+          expansions.push(expansion);
+      }
+    }
+  }
+
+  return expansions;
+}
+
+var expand$4 = /*@__PURE__*/getDefaultExportFromCjs(braceExpansion);
+
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+    if (typeof pattern !== 'string') {
+        throw new TypeError('invalid pattern');
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError('pattern is too long');
+    }
+};
+
+// translate the various posix character classes into unicode properties
+// this works across all unicode locales
+// { <posix class>: [<translation>, /u flag required, negated]
+const posixClasses = {
+    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
+    '[:alpha:]': ['\\p{L}\\p{Nl}', true],
+    '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
+    '[:blank:]': ['\\p{Zs}\\t', true],
+    '[:cntrl:]': ['\\p{Cc}', true],
+    '[:digit:]': ['\\p{Nd}', true],
+    '[:graph:]': ['\\p{Z}\\p{C}', true, true],
+    '[:lower:]': ['\\p{Ll}', true],
+    '[:print:]': ['\\p{C}', true],
+    '[:punct:]': ['\\p{P}', true],
+    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
+    '[:upper:]': ['\\p{Lu}', true],
+    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
+    '[:xdigit:]': ['A-Fa-f0-9', false],
+};
+// only need to escape a few things inside of brace expressions
+// escapes: [ \ ] -
+const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
+// escape all regexp magic characters
+const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+// everything has already been escaped, we just have to join
+const rangesToString = (ranges) => ranges.join('');
+// takes a glob string at a posix brace expression, and returns
+// an equivalent regular expression source, and boolean indicating
+// whether the /u flag needs to be applied, and the number of chars
+// consumed to parse the character class.
+// This also removes out of order ranges, and returns ($.) if the
+// entire class just no good.
+const parseClass = (glob, position) => {
+    const pos = position;
+    /* c8 ignore start */
+    if (glob.charAt(pos) !== '[') {
+        throw new Error('not in a brace expression');
+    }
+    /* c8 ignore stop */
+    const ranges = [];
+    const negs = [];
+    let i = pos + 1;
+    let sawStart = false;
+    let uflag = false;
+    let escaping = false;
+    let negate = false;
+    let endPos = pos;
+    let rangeStart = '';
+    WHILE: while (i < glob.length) {
+        const c = glob.charAt(i);
+        if ((c === '!' || c === '^') && i === pos + 1) {
+            negate = true;
+            i++;
+            continue;
+        }
+        if (c === ']' && sawStart && !escaping) {
+            endPos = i + 1;
+            break;
+        }
+        sawStart = true;
+        if (c === '\\') {
+            if (!escaping) {
+                escaping = true;
+                i++;
+                continue;
+            }
+            // escaped \ char, fall through and treat like normal char
+        }
+        if (c === '[' && !escaping) {
+            // either a posix class, a collation equivalent, or just a [
+            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+                if (glob.startsWith(cls, i)) {
+                    // invalid, [a-[] is fine, but not [a-[:alpha]]
+                    if (rangeStart) {
+                        return ['$.', false, glob.length - pos, true];
+                    }
+                    i += cls.length;
+                    if (neg)
+                        negs.push(unip);
+                    else
+                        ranges.push(unip);
+                    uflag = uflag || u;
+                    continue WHILE;
+                }
+            }
+        }
+        // now it's just a normal character, effectively
+        escaping = false;
+        if (rangeStart) {
+            // throw this range away if it's not valid, but others
+            // can still match.
+            if (c > rangeStart) {
+                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
+            }
+            else if (c === rangeStart) {
+                ranges.push(braceEscape(c));
+            }
+            rangeStart = '';
+            i++;
+            continue;
+        }
+        // now might be the start of a range.
+        // can be either c-d or c-] or c<more...>] or c] at this point
+        if (glob.startsWith('-]', i + 1)) {
+            ranges.push(braceEscape(c + '-'));
+            i += 2;
+            continue;
+        }
+        if (glob.startsWith('-', i + 1)) {
+            rangeStart = c;
+            i += 2;
+            continue;
+        }
+        // not the start of a range, just a single character
+        ranges.push(braceEscape(c));
+        i++;
+    }
+    if (endPos < i) {
+        // didn't see the end of the class, not a valid class,
+        // but might still be valid as a literal match.
+        return ['', false, 0, false];
+    }
+    // if we got no ranges and no negates, then we have a range that
+    // cannot possibly match anything, and that poisons the whole glob
+    if (!ranges.length && !negs.length) {
+        return ['$.', false, glob.length - pos, true];
+    }
+    // if we got one positive range, and it's a single character, then that's
+    // not actually a magic pattern, it's just that one literal character.
+    // we should not treat that as "magic", we should just return the literal
+    // character. [_] is a perfectly valid way to escape glob magic chars.
+    if (negs.length === 0 &&
+        ranges.length === 1 &&
+        /^\\?.$/.test(ranges[0]) &&
+        !negate) {
+        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+        return [regexpEscape(r), false, endPos - pos, false];
+    }
+    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
+    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
+    const comb = ranges.length && negs.length
+        ? '(' + sranges + '|' + snegs + ')'
+        : ranges.length
+            ? sranges
+            : snegs;
+    return [comb, uflag, endPos - pos, true];
+};
+
+/**
+ * Un-escape a string that has been escaped with {@link escape}.
+ *
+ * If the {@link windowsPathsNoEscape} option is used, then square-brace
+ * escapes are removed, but not backslash escapes.  For example, it will turn
+ * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
+ * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
+ *
+ * When `windowsPathsNoEscape` is not set, then both brace escapes and
+ * backslash escapes are removed.
+ *
+ * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
+ * or unescaped.
+ */
+const unescape$1 = (s, { windowsPathsNoEscape = false, } = {}) => {
+    return windowsPathsNoEscape
+        ? s.replace(/\[([^\/\\])\]/g, '$1')
+        : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+};
+
+// parse a single path portion
+const types$1 = new Set(['!', '?', '+', '*', '@']);
+const isExtglobType = (c) => types$1.has(c);
+// Patterns that get prepended to bind to the start of either the
+// entire string, or just a single path portion, to prevent dots
+// and/or traversal patterns, when needed.
+// Exts don't need the ^ or / bit, because the root binds that already.
+const startNoTraversal = '(?!(?:^|/)\\.\\.?(?:$|/))';
+const startNoDot = '(?!\\.)';
+// characters that indicate a start of pattern needs the "no dots" bit,
+// because a dot *might* be matched. ( is not in the list, because in
+// the case of a child extglob, it will handle the prevention itself.
+const addPatternStart = new Set(['[', '.']);
+// cases where traversal is A-OK, no dot prevention needed
+const justDots = new Set(['..', '.']);
+const reSpecials = new Set('().*{}+?[]^$\\!');
+const regExpEscape$1 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+// any single thing other than /
+const qmark$1 = '[^/]';
+// * => any number of characters
+const star$1 = qmark$1 + '*?';
+// use + when we need to ensure that *something* matches, because the * is
+// the only thing in the path portion.
+const starNoEmpty = qmark$1 + '+?';
+// remove the \ chars that we added if we end up doing a nonmagic compare
+// const deslash = (s: string) => s.replace(/\\(.)/g, '$1')
+class AST {
+    type;
+    #root;
+    #hasMagic;
+    #uflag = false;
+    #parts = [];
+    #parent;
+    #parentIndex;
+    #negs;
+    #filledNegs = false;
+    #options;
+    #toString;
+    // set to true if it's an extglob with no children
+    // (which really means one child of '')
+    #emptyExt = false;
+    constructor(type, parent, options = {}) {
+        this.type = type;
+        // extglobs are inherently magical
+        if (type)
+            this.#hasMagic = true;
+        this.#parent = parent;
+        this.#root = this.#parent ? this.#parent.#root : this;
+        this.#options = this.#root === this ? options : this.#root.#options;
+        this.#negs = this.#root === this ? [] : this.#root.#negs;
+        if (type === '!' && !this.#root.#filledNegs)
+            this.#negs.push(this);
+        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+    }
+    get hasMagic() {
+        /* c8 ignore start */
+        if (this.#hasMagic !== undefined)
+            return this.#hasMagic;
+        /* c8 ignore stop */
+        for (const p of this.#parts) {
+            if (typeof p === 'string')
+                continue;
+            if (p.type || p.hasMagic)
+                return (this.#hasMagic = true);
+        }
+        // note: will be undefined until we generate the regexp src and find out
+        return this.#hasMagic;
+    }
+    // reconstructs the pattern
+    toString() {
+        if (this.#toString !== undefined)
+            return this.#toString;
+        if (!this.type) {
+            return (this.#toString = this.#parts.map(p => String(p)).join(''));
+        }
+        else {
+            return (this.#toString =
+                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');
+        }
+    }
+    #fillNegs() {
+        /* c8 ignore start */
+        if (this !== this.#root)
+            throw new Error('should only call on root');
+        if (this.#filledNegs)
+            return this;
+        /* c8 ignore stop */
+        // call toString() once to fill this out
+        this.toString();
+        this.#filledNegs = true;
+        let n;
+        while ((n = this.#negs.pop())) {
+            if (n.type !== '!')
+                continue;
+            // walk up the tree, appending everthing that comes AFTER parentIndex
+            let p = n;
+            let pp = p.#parent;
+            while (pp) {
+                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+                    for (const part of n.#parts) {
+                        /* c8 ignore start */
+                        if (typeof part === 'string') {
+                            throw new Error('string part in extglob AST??');
+                        }
+                        /* c8 ignore stop */
+                        part.copyIn(pp.#parts[i]);
+                    }
+                }
+                p = pp;
+                pp = p.#parent;
+            }
+        }
+        return this;
+    }
+    push(...parts) {
+        for (const p of parts) {
+            if (p === '')
+                continue;
+            /* c8 ignore start */
+            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {
+                throw new Error('invalid part: ' + p);
+            }
+            /* c8 ignore stop */
+            this.#parts.push(p);
+        }
+    }
+    toJSON() {
+        const ret = this.type === null
+            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))
+            : [this.type, ...this.#parts.map(p => p.toJSON())];
+        if (this.isStart() && !this.type)
+            ret.unshift([]);
+        if (this.isEnd() &&
+            (this === this.#root ||
+                (this.#root.#filledNegs && this.#parent?.type === '!'))) {
+            ret.push({});
+        }
+        return ret;
+    }
+    isStart() {
+        if (this.#root === this)
+            return true;
+        // if (this.type) return !!this.#parent?.isStart()
+        if (!this.#parent?.isStart())
+            return false;
+        if (this.#parentIndex === 0)
+            return true;
+        // if everything AHEAD of this is a negation, then it's still the "start"
+        const p = this.#parent;
+        for (let i = 0; i < this.#parentIndex; i++) {
+            const pp = p.#parts[i];
+            if (!(pp instanceof AST && pp.type === '!')) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isEnd() {
+        if (this.#root === this)
+            return true;
+        if (this.#parent?.type === '!')
+            return true;
+        if (!this.#parent?.isEnd())
+            return false;
+        if (!this.type)
+            return this.#parent?.isEnd();
+        // if not root, it'll always have a parent
+        /* c8 ignore start */
+        const pl = this.#parent ? this.#parent.#parts.length : 0;
+        /* c8 ignore stop */
+        return this.#parentIndex === pl - 1;
+    }
+    copyIn(part) {
+        if (typeof part === 'string')
+            this.push(part);
+        else
+            this.push(part.clone(this));
+    }
+    clone(parent) {
+        const c = new AST(this.type, parent);
+        for (const p of this.#parts) {
+            c.copyIn(p);
+        }
+        return c;
+    }
+    static #parseAST(str, ast, pos, opt) {
+        let escaping = false;
+        let inBrace = false;
+        let braceStart = -1;
+        let braceNeg = false;
+        if (ast.type === null) {
+            // outside of a extglob, append until we find a start
+            let i = pos;
+            let acc = '';
+            while (i < str.length) {
+                const c = str.charAt(i++);
+                // still accumulate escapes at this point, but we do ignore
+                // starts that are escaped
+                if (escaping || c === '\\') {
+                    escaping = !escaping;
+                    acc += c;
+                    continue;
+                }
+                if (inBrace) {
+                    if (i === braceStart + 1) {
+                        if (c === '^' || c === '!') {
+                            braceNeg = true;
+                        }
+                    }
+                    else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
+                        inBrace = false;
+                    }
+                    acc += c;
+                    continue;
+                }
+                else if (c === '[') {
+                    inBrace = true;
+                    braceStart = i;
+                    braceNeg = false;
+                    acc += c;
+                    continue;
+                }
+                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {
+                    ast.push(acc);
+                    acc = '';
+                    const ext = new AST(c, ast);
+                    i = AST.#parseAST(str, ext, i, opt);
+                    ast.push(ext);
+                    continue;
+                }
+                acc += c;
+            }
+            ast.push(acc);
+            return i;
+        }
+        // some kind of extglob, pos is at the (
+        // find the next | or )
+        let i = pos + 1;
+        let part = new AST(null, ast);
+        const parts = [];
+        let acc = '';
+        while (i < str.length) {
+            const c = str.charAt(i++);
+            // still accumulate escapes at this point, but we do ignore
+            // starts that are escaped
+            if (escaping || c === '\\') {
+                escaping = !escaping;
+                acc += c;
+                continue;
+            }
+            if (inBrace) {
+                if (i === braceStart + 1) {
+                    if (c === '^' || c === '!') {
+                        braceNeg = true;
+                    }
+                }
+                else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {
+                    inBrace = false;
+                }
+                acc += c;
+                continue;
+            }
+            else if (c === '[') {
+                inBrace = true;
+                braceStart = i;
+                braceNeg = false;
+                acc += c;
+                continue;
+            }
+            if (isExtglobType(c) && str.charAt(i) === '(') {
+                part.push(acc);
+                acc = '';
+                const ext = new AST(c, part);
+                part.push(ext);
+                i = AST.#parseAST(str, ext, i, opt);
+                continue;
+            }
+            if (c === '|') {
+                part.push(acc);
+                acc = '';
+                parts.push(part);
+                part = new AST(null, ast);
+                continue;
+            }
+            if (c === ')') {
+                if (acc === '' && ast.#parts.length === 0) {
+                    ast.#emptyExt = true;
+                }
+                part.push(acc);
+                acc = '';
+                ast.push(...parts, part);
+                return i;
+            }
+            acc += c;
+        }
+        // unfinished extglob
+        // if we got here, it was a malformed extglob! not an extglob, but
+        // maybe something else in there.
+        ast.type = null;
+        ast.#hasMagic = undefined;
+        ast.#parts = [str.substring(pos - 1)];
+        return i;
+    }
+    static fromGlob(pattern, options = {}) {
+        const ast = new AST(null, undefined, options);
+        AST.#parseAST(pattern, ast, 0, options);
+        return ast;
+    }
+    // returns the regular expression if there's magic, or the unescaped
+    // string if not.
+    toMMPattern() {
+        // should only be called on root
+        /* c8 ignore start */
+        if (this !== this.#root)
+            return this.#root.toMMPattern();
+        /* c8 ignore stop */
+        const glob = this.toString();
+        const [re, body, hasMagic, uflag] = this.toRegExpSource();
+        // if we're in nocase mode, and not nocaseMagicOnly, then we do
+        // still need a regular expression if we have to case-insensitively
+        // match capital/lowercase characters.
+        const anyMagic = hasMagic ||
+            this.#hasMagic ||
+            (this.#options.nocase &&
+                !this.#options.nocaseMagicOnly &&
+                glob.toUpperCase() !== glob.toLowerCase());
+        if (!anyMagic) {
+            return body;
+        }
+        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');
+        return Object.assign(new RegExp(`^${re}$`, flags), {
+            _src: re,
+            _glob: glob,
+        });
+    }
+    get options() {
+        return this.#options;
+    }
+    // returns the string match, the regexp source, whether there's magic
+    // in the regexp (so a regular expression is required) and whether or
+    // not the uflag is needed for the regular expression (for posix classes)
+    // TODO: instead of injecting the start/end at this point, just return
+    // the BODY of the regexp, along with the start/end portions suitable
+    // for binding the start/end in either a joined full-path makeRe context
+    // (where we bind to (^|/), or a standalone matchPart context (where
+    // we bind to ^, and not /).  Otherwise slashes get duped!
+    //
+    // In part-matching mode, the start is:
+    // - if not isStart: nothing
+    // - if traversal possible, but not allowed: ^(?!\.\.?$)
+    // - if dots allowed or not possible: ^
+    // - if dots possible and not allowed: ^(?!\.)
+    // end is:
+    // - if not isEnd(): nothing
+    // - else: $
+    //
+    // In full-path matching mode, we put the slash at the START of the
+    // pattern, so start is:
+    // - if first pattern: same as part-matching mode
+    // - if not isStart(): nothing
+    // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+    // - if dots allowed or not possible: /
+    // - if dots possible and not allowed: /(?!\.)
+    // end is:
+    // - if last pattern, same as part-matching mode
+    // - else nothing
+    //
+    // Always put the (?:$|/) on negated tails, though, because that has to be
+    // there to bind the end of the negated pattern portion, and it's easier to
+    // just stick it in now rather than try to inject it later in the middle of
+    // the pattern.
+    //
+    // We can just always return the same end, and leave it up to the caller
+    // to know whether it's going to be used joined or in parts.
+    // And, if the start is adjusted slightly, can do the same there:
+    // - if not isStart: nothing
+    // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+    // - if dots allowed or not possible: (?:/|^)
+    // - if dots possible and not allowed: (?:/|^)(?!\.)
+    //
+    // But it's better to have a simpler binding without a conditional, for
+    // performance, so probably better to return both start options.
+    //
+    // Then the caller just ignores the end if it's not the first pattern,
+    // and the start always gets applied.
+    //
+    // But that's always going to be $ if it's the ending pattern, or nothing,
+    // so the caller can just attach $ at the end of the pattern when building.
+    //
+    // So the todo is:
+    // - better detect what kind of start is needed
+    // - return both flavors of starting pattern
+    // - attach $ at the end of the pattern when creating the actual RegExp
+    //
+    // Ah, but wait, no, that all only applies to the root when the first pattern
+    // is not an extglob. If the first pattern IS an extglob, then we need all
+    // that dot prevention biz to live in the extglob portions, because eg
+    // +(*|.x*) can match .xy but not .yx.
+    //
+    // So, return the two flavors if it's #root and the first child is not an
+    // AST, otherwise leave it to the child AST to handle it, and there,
+    // use the (?:^|/) style of start binding.
+    //
+    // Even simplified further:
+    // - Since the start for a join is eg /(?!\.) and the start for a part
+    // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+    // or start or whatever) and prepend ^ or / at the Regexp construction.
+    toRegExpSource(allowDot) {
+        const dot = allowDot ?? !!this.#options.dot;
+        if (this.#root === this)
+            this.#fillNegs();
+        if (!this.type) {
+            const noEmpty = this.isStart() && this.isEnd();
+            const src = this.#parts
+                .map(p => {
+                const [re, _, hasMagic, uflag] = typeof p === 'string'
+                    ? AST.#parseGlob(p, this.#hasMagic, noEmpty)
+                    : p.toRegExpSource(allowDot);
+                this.#hasMagic = this.#hasMagic || hasMagic;
+                this.#uflag = this.#uflag || uflag;
+                return re;
+            })
+                .join('');
+            let start = '';
+            if (this.isStart()) {
+                if (typeof this.#parts[0] === 'string') {
+                    // this is the string that will match the start of the pattern,
+                    // so we need to protect against dots and such.
+                    // '.' and '..' cannot match unless the pattern is that exactly,
+                    // even if it starts with . or dot:true is set.
+                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+                    if (!dotTravAllowed) {
+                        const aps = addPatternStart;
+                        // check if we have a possibility of matching . or ..,
+                        // and prevent that.
+                        const needNoTrav = 
+                        // dots are allowed, and the pattern starts with [ or .
+                        (dot && aps.has(src.charAt(0))) ||
+                            // the pattern starts with \., and then [ or .
+                            (src.startsWith('\\.') && aps.has(src.charAt(2))) ||
+                            // the pattern starts with \.\., and then [ or .
+                            (src.startsWith('\\.\\.') && aps.has(src.charAt(4)));
+                        // no need to prevent dots if it can't match a dot, or if a
+                        // sub-pattern will be preventing it anyway.
+                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';
+                    }
+                }
+            }
+            // append the "end of path portion" pattern to negation tails
+            let end = '';
+            if (this.isEnd() &&
+                this.#root.#filledNegs &&
+                this.#parent?.type === '!') {
+                end = '(?:$|\\/)';
+            }
+            const final = start + src + end;
+            return [
+                final,
+                unescape$1(src),
+                (this.#hasMagic = !!this.#hasMagic),
+                this.#uflag,
+            ];
+        }
+        // We need to calculate the body *twice* if it's a repeat pattern
+        // at the start, once in nodot mode, then again in dot mode, so a
+        // pattern like *(?) can match 'x.y'
+        const repeated = this.type === '*' || this.type === '+';
+        // some kind of extglob
+        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';
+        let body = this.#partsToRegExp(dot);
+        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {
+            // invalid extglob, has to at least be *something* present, if it's
+            // the entire path portion.
+            const s = this.toString();
+            this.#parts = [s];
+            this.type = null;
+            this.#hasMagic = undefined;
+            return [s, unescape$1(this.toString()), false, false];
+        }
+        // XXX abstract out this map method
+        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot
+            ? ''
+            : this.#partsToRegExp(true);
+        if (bodyDotAllowed === body) {
+            bodyDotAllowed = '';
+        }
+        if (bodyDotAllowed) {
+            body = `(?:${body})(?:${bodyDotAllowed})*?`;
+        }
+        // an empty !() is exactly equivalent to a starNoEmpty
+        let final = '';
+        if (this.type === '!' && this.#emptyExt) {
+            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;
+        }
+        else {
+            const close = this.type === '!'
+                ? // !() must match something,but !(x) can match ''
+                    '))' +
+                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +
+                        star$1 +
+                        ')'
+                : this.type === '@'
+                    ? ')'
+                    : this.type === '?'
+                        ? ')?'
+                        : this.type === '+' && bodyDotAllowed
+                            ? ')'
+                            : this.type === '*' && bodyDotAllowed
+                                ? `)?`
+                                : `)${this.type}`;
+            final = start + body + close;
+        }
+        return [
+            final,
+            unescape$1(body),
+            (this.#hasMagic = !!this.#hasMagic),
+            this.#uflag,
+        ];
+    }
+    #partsToRegExp(dot) {
+        return this.#parts
+            .map(p => {
+            // extglob ASTs should only contain parent ASTs
+            /* c8 ignore start */
+            if (typeof p === 'string') {
+                throw new Error('string type in extglob ast??');
+            }
+            /* c8 ignore stop */
+            // can ignore hasMagic, because extglobs are already always magic
+            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+            this.#uflag = this.#uflag || uflag;
+            return re;
+        })
+            .filter(p => !(this.isStart() && this.isEnd()) || !!p)
+            .join('|');
+    }
+    static #parseGlob(glob, hasMagic, noEmpty = false) {
+        let escaping = false;
+        let re = '';
+        let uflag = false;
+        for (let i = 0; i < glob.length; i++) {
+            const c = glob.charAt(i);
+            if (escaping) {
+                escaping = false;
+                re += (reSpecials.has(c) ? '\\' : '') + c;
+                continue;
+            }
+            if (c === '\\') {
+                if (i === glob.length - 1) {
+                    re += '\\\\';
+                }
+                else {
+                    escaping = true;
+                }
+                continue;
+            }
+            if (c === '[') {
+                const [src, needUflag, consumed, magic] = parseClass(glob, i);
+                if (consumed) {
+                    re += src;
+                    uflag = uflag || needUflag;
+                    i += consumed - 1;
+                    hasMagic = hasMagic || magic;
+                    continue;
+                }
+            }
+            if (c === '*') {
+                if (noEmpty && glob === '*')
+                    re += starNoEmpty;
+                else
+                    re += star$1;
+                hasMagic = true;
+                continue;
+            }
+            if (c === '?') {
+                re += qmark$1;
+                hasMagic = true;
+                continue;
+            }
+            re += regExpEscape$1(c);
+        }
+        return [re, unescape$1(glob), !!hasMagic, uflag];
+    }
+}
+
+/**
+ * Escape all magic characters in a glob pattern.
+ *
+ * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * option is used, then characters are escaped by wrapping in `[]`, because
+ * a magic character wrapped in a character class can only be satisfied by
+ * that exact character.  In this mode, `\` is _not_ escaped, because it is
+ * not interpreted as a magic character, but instead as a path separator.
+ */
+const escape$2 = (s, { windowsPathsNoEscape = false, } = {}) => {
+    // don't need to escape +@! because we escape the parens
+    // that make those magic, and escaping ! as [!] isn't valid,
+    // because [!]] is a valid glob class meaning not ']'.
+    return windowsPathsNoEscape
+        ? s.replace(/[?*()[\]]/g, '[$&]')
+        : s.replace(/[?*()[\]\\]/g, '\\$&');
+};
+
+const minimatch = (p, pattern, options = {}) => {
+    assertValidPattern(pattern);
+    // shortcut: comments match nothing.
+    if (!options.nocomment && pattern.charAt(0) === '#') {
+        return false;
+    }
+    return new Minimatch(pattern, options).match(p);
+};
+// Optimized checking for the most common glob patterns.
+const starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+const starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);
+const starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
+const starDotExtTestNocase = (ext) => {
+    ext = ext.toLowerCase();
+    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);
+};
+const starDotExtTestNocaseDot = (ext) => {
+    ext = ext.toLowerCase();
+    return (f) => f.toLowerCase().endsWith(ext);
+};
+const starDotStarRE = /^\*+\.\*+$/;
+const starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');
+const starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');
+const dotStarRE = /^\.\*+$/;
+const dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');
+const starRE = /^\*+$/;
+const starTest = (f) => f.length !== 0 && !f.startsWith('.');
+const starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';
+const qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+const qmarksTestNocase = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExt([$0]);
+    if (!ext)
+        return noext;
+    ext = ext.toLowerCase();
+    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestNocaseDot = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExtDot([$0]);
+    if (!ext)
+        return noext;
+    ext = ext.toLowerCase();
+    return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+const qmarksTestDot = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExtDot([$0]);
+    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTest = ([$0, ext = '']) => {
+    const noext = qmarksTestNoExt([$0]);
+    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+const qmarksTestNoExt = ([$0]) => {
+    const len = $0.length;
+    return (f) => f.length === len && !f.startsWith('.');
+};
+const qmarksTestNoExtDot = ([$0]) => {
+    const len = $0.length;
+    return (f) => f.length === len && f !== '.' && f !== '..';
+};
+/* c8 ignore start */
+const defaultPlatform$2 = (typeof process === 'object' && process
+    ? (typeof process.env === 'object' &&
+        process.env &&
+        process.env.__MINIMATCH_TESTING_PLATFORM__) ||
+        process.platform
+    : 'posix');
+const path$j = {
+    win32: { sep: '\\' },
+    posix: { sep: '/' },
+};
+/* c8 ignore stop */
+const sep = defaultPlatform$2 === 'win32' ? path$j.win32.sep : path$j.posix.sep;
+minimatch.sep = sep;
+const GLOBSTAR$2 = Symbol('globstar **');
+minimatch.GLOBSTAR = GLOBSTAR$2;
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+const qmark = '[^/]';
+// * => any number of characters
+const star = qmark + '*?';
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+const twoStarDot = '(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?';
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+const twoStarNoDot = '(?:(?!(?:\\/|^)\\.).)*?';
+const filter$1 = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter$1;
+const ext = (a, b = {}) => Object.assign({}, a, b);
+const defaults = (def) => {
+    if (!def || typeof def !== 'object' || !Object.keys(def).length) {
+        return minimatch;
+    }
+    const orig = minimatch;
+    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+    return Object.assign(m, {
+        Minimatch: class Minimatch extends orig.Minimatch {
+            constructor(pattern, options = {}) {
+                super(pattern, ext(def, options));
+            }
+            static defaults(options) {
+                return orig.defaults(ext(def, options)).Minimatch;
+            }
+        },
+        AST: class AST extends orig.AST {
+            /* c8 ignore start */
+            constructor(type, parent, options = {}) {
+                super(type, parent, ext(def, options));
+            }
+            /* c8 ignore stop */
+            static fromGlob(pattern, options = {}) {
+                return orig.AST.fromGlob(pattern, ext(def, options));
+            }
+        },
+        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+        escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+        defaults: (options) => orig.defaults(ext(def, options)),
+        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+        sep: orig.sep,
+        GLOBSTAR: GLOBSTAR$2,
+    });
+};
+minimatch.defaults = defaults;
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+const braceExpand = (pattern, options = {}) => {
+    assertValidPattern(pattern);
+    // Thanks to Yeting Li <https://github.com/yetingli> for
+    // improving this regexp to avoid a ReDOS vulnerability.
+    if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+        // shortcut. no need to expand.
+        return [pattern];
+    }
+    return expand$4(pattern);
+};
+minimatch.braceExpand = braceExpand;
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+const makeRe$1 = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe$1;
+const match = (list, pattern, options = {}) => {
+    const mm = new Minimatch(pattern, options);
+    list = list.filter(f => mm.match(f));
+    if (mm.options.nonull && !list.length) {
+        list.push(pattern);
+    }
+    return list;
+};
+minimatch.match = match;
+// replace stuff like \* with *
+const globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+const regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+class Minimatch {
+    options;
+    set;
+    pattern;
+    windowsPathsNoEscape;
+    nonegate;
+    negate;
+    comment;
+    empty;
+    preserveMultipleSlashes;
+    partial;
+    globSet;
+    globParts;
+    nocase;
+    isWindows;
+    platform;
+    windowsNoMagicRoot;
+    regexp;
+    constructor(pattern, options = {}) {
+        assertValidPattern(pattern);
+        options = options || {};
+        this.options = options;
+        this.pattern = pattern;
+        this.platform = options.platform || defaultPlatform$2;
+        this.isWindows = this.platform === 'win32';
+        this.windowsPathsNoEscape =
+            !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+        if (this.windowsPathsNoEscape) {
+            this.pattern = this.pattern.replace(/\\/g, '/');
+        }
+        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+        this.regexp = null;
+        this.negate = false;
+        this.nonegate = !!options.nonegate;
+        this.comment = false;
+        this.empty = false;
+        this.partial = !!options.partial;
+        this.nocase = !!this.options.nocase;
+        this.windowsNoMagicRoot =
+            options.windowsNoMagicRoot !== undefined
+                ? options.windowsNoMagicRoot
+                : !!(this.isWindows && this.nocase);
+        this.globSet = [];
+        this.globParts = [];
+        this.set = [];
+        // make the set of regexps etc.
+        this.make();
+    }
+    hasMagic() {
+        if (this.options.magicalBraces && this.set.length > 1) {
+            return true;
+        }
+        for (const pattern of this.set) {
+            for (const part of pattern) {
+                if (typeof part !== 'string')
+                    return true;
+            }
+        }
+        return false;
+    }
+    debug(..._) { }
+    make() {
+        const pattern = this.pattern;
+        const options = this.options;
+        // empty patterns and comments match nothing.
+        if (!options.nocomment && pattern.charAt(0) === '#') {
+            this.comment = true;
+            return;
+        }
+        if (!pattern) {
+            this.empty = true;
+            return;
+        }
+        // step 1: figure out negation, etc.
+        this.parseNegate();
+        // step 2: expand braces
+        this.globSet = [...new Set(this.braceExpand())];
+        if (options.debug) {
+            this.debug = (...args) => console.error(...args);
+        }
+        this.debug(this.pattern, this.globSet);
+        // step 3: now we have a set, so turn each one into a series of
+        // path-portion matching patterns.
+        // These will be regexps, except in the case of "**", which is
+        // set to the GLOBSTAR object for globstar behavior,
+        // and will not contain any / characters
+        //
+        // First, we preprocess to make the glob pattern sets a bit simpler
+        // and deduped.  There are some perf-killing patterns that can cause
+        // problems with a glob walk, but we can simplify them down a bit.
+        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));
+        this.globParts = this.preprocess(rawGlobParts);
+        this.debug(this.pattern, this.globParts);
+        // glob --> regexps
+        let set = this.globParts.map((s, _, __) => {
+            if (this.isWindows && this.windowsNoMagicRoot) {
+                // check if it's a drive or unc path.
+                const isUNC = s[0] === '' &&
+                    s[1] === '' &&
+                    (s[2] === '?' || !globMagic.test(s[2])) &&
+                    !globMagic.test(s[3]);
+                const isDrive = /^[a-z]:/i.test(s[0]);
+                if (isUNC) {
+                    return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];
+                }
+                else if (isDrive) {
+                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];
+                }
+            }
+            return s.map(ss => this.parse(ss));
+        });
+        this.debug(this.pattern, set);
+        // filter out everything that didn't compile properly.
+        this.set = set.filter(s => s.indexOf(false) === -1);
+        // do not treat the ? in UNC paths as magic
+        if (this.isWindows) {
+            for (let i = 0; i < this.set.length; i++) {
+                const p = this.set[i];
+                if (p[0] === '' &&
+                    p[1] === '' &&
+                    this.globParts[i][2] === '?' &&
+                    typeof p[3] === 'string' &&
+                    /^[a-z]:$/i.test(p[3])) {
+                    p[2] = '?';
+                }
+            }
+        }
+        this.debug(this.pattern, this.set);
+    }
+    // various transforms to equivalent pattern sets that are
+    // faster to process in a filesystem walk.  The goal is to
+    // eliminate what we can, and push all ** patterns as far
+    // to the right as possible, even if it increases the number
+    // of patterns that we have to process.
+    preprocess(globParts) {
+        // if we're not in globstar mode, then turn all ** into *
+        if (this.options.noglobstar) {
+            for (let i = 0; i < globParts.length; i++) {
+                for (let j = 0; j < globParts[i].length; j++) {
+                    if (globParts[i][j] === '**') {
+                        globParts[i][j] = '*';
+                    }
+                }
+            }
+        }
+        const { optimizationLevel = 1 } = this.options;
+        if (optimizationLevel >= 2) {
+            // aggressive optimization for the purpose of fs walking
+            globParts = this.firstPhasePreProcess(globParts);
+            globParts = this.secondPhasePreProcess(globParts);
+        }
+        else if (optimizationLevel >= 1) {
+            // just basic optimizations to remove some .. parts
+            globParts = this.levelOneOptimize(globParts);
+        }
+        else {
+            // just collapse multiple ** portions into one
+            globParts = this.adjascentGlobstarOptimize(globParts);
+        }
+        return globParts;
+    }
+    // just get rid of adjascent ** portions
+    adjascentGlobstarOptimize(globParts) {
+        return globParts.map(parts => {
+            let gs = -1;
+            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+                let i = gs;
+                while (parts[i + 1] === '**') {
+                    i++;
+                }
+                if (i !== gs) {
+                    parts.splice(gs, i - gs);
+                }
+            }
+            return parts;
+        });
+    }
+    // get rid of adjascent ** and resolve .. portions
+    levelOneOptimize(globParts) {
+        return globParts.map(parts => {
+            parts = parts.reduce((set, part) => {
+                const prev = set[set.length - 1];
+                if (part === '**' && prev === '**') {
+                    return set;
+                }
+                if (part === '..') {
+                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {
+                        set.pop();
+                        return set;
+                    }
+                }
+                set.push(part);
+                return set;
+            }, []);
+            return parts.length === 0 ? [''] : parts;
+        });
+    }
+    levelTwoFileOptimize(parts) {
+        if (!Array.isArray(parts)) {
+            parts = this.slashSplit(parts);
+        }
+        let didSomething = false;
+        do {
+            didSomething = false;
+            // <pre>/<e>/<rest> -> <pre>/<rest>
+            if (!this.preserveMultipleSlashes) {
+                for (let i = 1; i < parts.length - 1; i++) {
+                    const p = parts[i];
+                    // don't squeeze out UNC patterns
+                    if (i === 1 && p === '' && parts[0] === '')
+                        continue;
+                    if (p === '.' || p === '') {
+                        didSomething = true;
+                        parts.splice(i, 1);
+                        i--;
+                    }
+                }
+                if (parts[0] === '.' &&
+                    parts.length === 2 &&
+                    (parts[1] === '.' || parts[1] === '')) {
+                    didSomething = true;
+                    parts.pop();
+                }
+            }
+            // <pre>/<p>/../<rest> -> <pre>/<rest>
+            let dd = 0;
+            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+                const p = parts[dd - 1];
+                if (p && p !== '.' && p !== '..' && p !== '**') {
+                    didSomething = true;
+                    parts.splice(dd - 1, 2);
+                    dd -= 2;
+                }
+            }
+        } while (didSomething);
+        return parts.length === 0 ? [''] : parts;
+    }
+    // First phase: single-pattern processing
+    // <pre> is 1 or more portions
+    // <rest> is 1 or more portions
+    // <p> is any portion other than ., .., '', or **
+    // <e> is . or ''
+    //
+    // **/.. is *brutal* for filesystem walking performance, because
+    // it effectively resets the recursive walk each time it occurs,
+    // and ** cannot be reduced out by a .. pattern part like a regexp
+    // or most strings (other than .., ., and '') can be.
+    //
+    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+    // <pre>/<e>/<rest> -> <pre>/<rest>
+    // <pre>/<p>/../<rest> -> <pre>/<rest>
+    // **/**/<rest> -> **/<rest>
+    //
+    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+    // this WOULD be allowed if ** did follow symlinks, or * didn't
+    firstPhasePreProcess(globParts) {
+        let didSomething = false;
+        do {
+            didSomething = false;
+            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+            for (let parts of globParts) {
+                let gs = -1;
+                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+                    let gss = gs;
+                    while (parts[gss + 1] === '**') {
+                        // <pre>/**/**/<rest> -> <pre>/**/<rest>
+                        gss++;
+                    }
+                    // eg, if gs is 2 and gss is 4, that means we have 3 **
+                    // parts, and can remove 2 of them.
+                    if (gss > gs) {
+                        parts.splice(gs + 1, gss - gs);
+                    }
+                    let next = parts[gs + 1];
+                    const p = parts[gs + 2];
+                    const p2 = parts[gs + 3];
+                    if (next !== '..')
+                        continue;
+                    if (!p ||
+                        p === '.' ||
+                        p === '..' ||
+                        !p2 ||
+                        p2 === '.' ||
+                        p2 === '..') {
+                        continue;
+                    }
+                    didSomething = true;
+                    // edit parts in place, and push the new one
+                    parts.splice(gs, 1);
+                    const other = parts.slice(0);
+                    other[gs] = '**';
+                    globParts.push(other);
+                    gs--;
+                }
+                // <pre>/<e>/<rest> -> <pre>/<rest>
+                if (!this.preserveMultipleSlashes) {
+                    for (let i = 1; i < parts.length - 1; i++) {
+                        const p = parts[i];
+                        // don't squeeze out UNC patterns
+                        if (i === 1 && p === '' && parts[0] === '')
+                            continue;
+                        if (p === '.' || p === '') {
+                            didSomething = true;
+                            parts.splice(i, 1);
+                            i--;
+                        }
+                    }
+                    if (parts[0] === '.' &&
+                        parts.length === 2 &&
+                        (parts[1] === '.' || parts[1] === '')) {
+                        didSomething = true;
+                        parts.pop();
+                    }
+                }
+                // <pre>/<p>/../<rest> -> <pre>/<rest>
+                let dd = 0;
+                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+                    const p = parts[dd - 1];
+                    if (p && p !== '.' && p !== '..' && p !== '**') {
+                        didSomething = true;
+                        const needDot = dd === 1 && parts[dd + 1] === '**';
+                        const splin = needDot ? ['.'] : [];
+                        parts.splice(dd - 1, 2, ...splin);
+                        if (parts.length === 0)
+                            parts.push('');
+                        dd -= 2;
+                    }
+                }
+            }
+        } while (didSomething);
+        return globParts;
+    }
+    // second phase: multi-pattern dedupes
+    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+    //
+    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+    // ^-- not valid because ** doens't follow symlinks
+    secondPhasePreProcess(globParts) {
+        for (let i = 0; i < globParts.length - 1; i++) {
+            for (let j = i + 1; j < globParts.length; j++) {
+                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+                if (matched) {
+                    globParts[i] = [];
+                    globParts[j] = matched;
+                    break;
+                }
+            }
+        }
+        return globParts.filter(gs => gs.length);
+    }
+    partsMatch(a, b, emptyGSMatch = false) {
+        let ai = 0;
+        let bi = 0;
+        let result = [];
+        let which = '';
+        while (ai < a.length && bi < b.length) {
+            if (a[ai] === b[bi]) {
+                result.push(which === 'b' ? b[bi] : a[ai]);
+                ai++;
+                bi++;
+            }
+            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {
+                result.push(a[ai]);
+                ai++;
+            }
+            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {
+                result.push(b[bi]);
+                bi++;
+            }
+            else if (a[ai] === '*' &&
+                b[bi] &&
+                (this.options.dot || !b[bi].startsWith('.')) &&
+                b[bi] !== '**') {
+                if (which === 'b')
+                    return false;
+                which = 'a';
+                result.push(a[ai]);
+                ai++;
+                bi++;
+            }
+            else if (b[bi] === '*' &&
+                a[ai] &&
+                (this.options.dot || !a[ai].startsWith('.')) &&
+                a[ai] !== '**') {
+                if (which === 'a')
+                    return false;
+                which = 'b';
+                result.push(b[bi]);
+                ai++;
+                bi++;
+            }
+            else {
+                return false;
+            }
+        }
+        // if we fall out of the loop, it means they two are identical
+        // as long as their lengths match
+        return a.length === b.length && result;
+    }
+    parseNegate() {
+        if (this.nonegate)
+            return;
+        const pattern = this.pattern;
+        let negate = false;
+        let negateOffset = 0;
+        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
+            negate = !negate;
+            negateOffset++;
+        }
+        if (negateOffset)
+            this.pattern = pattern.slice(negateOffset);
+        this.negate = negate;
+    }
+    // set partial to true to test if, for example,
+    // "/a/b" matches the start of "/*/b/*/d"
+    // Partial means, if you run out of file before you run
+    // out of pattern, then that's fine, as long as all
+    // the parts match.
+    matchOne(file, pattern, partial = false) {
+        const options = this.options;
+        // UNC paths like //?/X:/... can match X:/... and vice versa
+        // Drive letters in absolute drive or unc paths are always compared
+        // case-insensitively.
+        if (this.isWindows) {
+            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);
+            const fileUNC = !fileDrive &&
+                file[0] === '' &&
+                file[1] === '' &&
+                file[2] === '?' &&
+                /^[a-z]:$/i.test(file[3]);
+            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);
+            const patternUNC = !patternDrive &&
+                pattern[0] === '' &&
+                pattern[1] === '' &&
+                pattern[2] === '?' &&
+                typeof pattern[3] === 'string' &&
+                /^[a-z]:$/i.test(pattern[3]);
+            const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;
+            const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;
+            if (typeof fdi === 'number' && typeof pdi === 'number') {
+                const [fd, pd] = [file[fdi], pattern[pdi]];
+                if (fd.toLowerCase() === pd.toLowerCase()) {
+                    pattern[pdi] = fd;
+                    if (pdi > fdi) {
+                        pattern = pattern.slice(pdi);
+                    }
+                    else if (fdi > pdi) {
+                        file = file.slice(fdi);
+                    }
+                }
+            }
+        }
+        // resolve and reduce . and .. portions in the file as well.
+        // dont' need to do the second phase, because it's only one string[]
+        const { optimizationLevel = 1 } = this.options;
+        if (optimizationLevel >= 2) {
+            file = this.levelTwoFileOptimize(file);
+        }
+        this.debug('matchOne', this, { file, pattern });
+        this.debug('matchOne', file.length, pattern.length);
+        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+            this.debug('matchOne loop');
+            var p = pattern[pi];
+            var f = file[fi];
+            this.debug(pattern, p, f);
+            // should be impossible.
+            // some invalid regexp stuff in the set.
+            /* c8 ignore start */
+            if (p === false) {
+                return false;
+            }
+            /* c8 ignore stop */
+            if (p === GLOBSTAR$2) {
+                this.debug('GLOBSTAR', [pattern, p, f]);
+                // "**"
+                // a/**/b/**/c would match the following:
+                // a/b/x/y/z/c
+                // a/x/y/z/b/c
+                // a/b/x/b/x/c
+                // a/b/c
+                // To do this, take the rest of the pattern after
+                // the **, and see if it would match the file remainder.
+                // If so, return success.
+                // If not, the ** "swallows" a segment, and try again.
+                // This is recursively awful.
+                //
+                // a/**/b/**/c matching a/b/x/y/z/c
+                // - a matches a
+                // - doublestar
+                //   - matchOne(b/x/y/z/c, b/**/c)
+                //     - b matches b
+                //     - doublestar
+                //       - matchOne(x/y/z/c, c) -> no
+                //       - matchOne(y/z/c, c) -> no
+                //       - matchOne(z/c, c) -> no
+                //       - matchOne(c, c) yes, hit
+                var fr = fi;
+                var pr = pi + 1;
+                if (pr === pl) {
+                    this.debug('** at the end');
+                    // a ** at the end will just swallow the rest.
+                    // We have found a match.
+                    // however, it will not swallow /.x, unless
+                    // options.dot is set.
+                    // . and .. are *never* matched by **, for explosively
+                    // exponential reasons.
+                    for (; fi < fl; fi++) {
+                        if (file[fi] === '.' ||
+                            file[fi] === '..' ||
+                            (!options.dot && file[fi].charAt(0) === '.'))
+                            return false;
+                    }
+                    return true;
+                }
+                // ok, let's see if we can swallow whatever we can.
+                while (fr < fl) {
+                    var swallowee = file[fr];
+                    this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
+                    // XXX remove this slice.  Just pass the start index.
+                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+                        this.debug('globstar found match!', fr, fl, swallowee);
+                        // found a match.
+                        return true;
+                    }
+                    else {
+                        // can't swallow "." or ".." ever.
+                        // can only swallow ".foo" when explicitly asked.
+                        if (swallowee === '.' ||
+                            swallowee === '..' ||
+                            (!options.dot && swallowee.charAt(0) === '.')) {
+                            this.debug('dot detected!', file, fr, pattern, pr);
+                            break;
+                        }
+                        // ** swallows a segment, and continue.
+                        this.debug('globstar swallow a segment, and continue');
+                        fr++;
+                    }
+                }
+                // no match was found.
+                // However, in partial mode, we can't say this is necessarily over.
+                /* c8 ignore start */
+                if (partial) {
+                    // ran out of file
+                    this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
+                    if (fr === fl) {
+                        return true;
+                    }
+                }
+                /* c8 ignore stop */
+                return false;
+            }
+            // something other than **
+            // non-magic patterns just have to match exactly
+            // patterns with magic have been turned into regexps.
+            let hit;
+            if (typeof p === 'string') {
+                hit = f === p;
+                this.debug('string match', p, f, hit);
+            }
+            else {
+                hit = p.test(f);
+                this.debug('pattern match', p, f, hit);
+            }
+            if (!hit)
+                return false;
+        }
+        // Note: ending in / means that we'll get a final ""
+        // at the end of the pattern.  This can only match a
+        // corresponding "" at the end of the file.
+        // If the file ends in /, then it can only match a
+        // a pattern that ends in /, unless the pattern just
+        // doesn't have any more for it. But, a/b/ should *not*
+        // match "a/b/*", even though "" matches against the
+        // [^/]*? pattern, except in partial mode, where it might
+        // simply not be reached yet.
+        // However, a/b/ should still satisfy a/*
+        // now either we fell off the end of the pattern, or we're done.
+        if (fi === fl && pi === pl) {
+            // ran out of pattern and filename at the same time.
+            // an exact hit!
+            return true;
+        }
+        else if (fi === fl) {
+            // ran out of file, but still had pattern left.
+            // this is ok if we're doing the match as part of
+            // a glob fs traversal.
+            return partial;
+        }
+        else if (pi === pl) {
+            // ran out of pattern, still have file left.
+            // this is only acceptable if we're on the very last
+            // empty segment of a file with a trailing slash.
+            // a/* should match a/b/
+            return fi === fl - 1 && file[fi] === '';
+            /* c8 ignore start */
+        }
+        else {
+            // should be unreachable.
+            throw new Error('wtf?');
+        }
+        /* c8 ignore stop */
+    }
+    braceExpand() {
+        return braceExpand(this.pattern, this.options);
+    }
+    parse(pattern) {
+        assertValidPattern(pattern);
+        const options = this.options;
+        // shortcuts
+        if (pattern === '**')
+            return GLOBSTAR$2;
+        if (pattern === '')
+            return '';
+        // far and away, the most common glob pattern parts are
+        // *, *.*, and *.<ext>  Add a fast check method for those.
+        let m;
+        let fastTest = null;
+        if ((m = pattern.match(starRE))) {
+            fastTest = options.dot ? starTestDot : starTest;
+        }
+        else if ((m = pattern.match(starDotExtRE))) {
+            fastTest = (options.nocase
+                ? options.dot
+                    ? starDotExtTestNocaseDot
+                    : starDotExtTestNocase
+                : options.dot
+                    ? starDotExtTestDot
+                    : starDotExtTest)(m[1]);
+        }
+        else if ((m = pattern.match(qmarksRE))) {
+            fastTest = (options.nocase
+                ? options.dot
+                    ? qmarksTestNocaseDot
+                    : qmarksTestNocase
+                : options.dot
+                    ? qmarksTestDot
+                    : qmarksTest)(m);
+        }
+        else if ((m = pattern.match(starDotStarRE))) {
+            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+        }
+        else if ((m = pattern.match(dotStarRE))) {
+            fastTest = dotStarTest;
+        }
+        const re = AST.fromGlob(pattern, this.options).toMMPattern();
+        if (fastTest && typeof re === 'object') {
+            // Avoids overriding in frozen environments
+            Reflect.defineProperty(re, 'test', { value: fastTest });
+        }
+        return re;
+    }
+    makeRe() {
+        if (this.regexp || this.regexp === false)
+            return this.regexp;
+        // at this point, this.set is a 2d array of partial
+        // pattern strings, or "**".
+        //
+        // It's better to use .match().  This function shouldn't
+        // be used, really, but it's pretty convenient sometimes,
+        // when you just want to work with a regex.
+        const set = this.set;
+        if (!set.length) {
+            this.regexp = false;
+            return this.regexp;
+        }
+        const options = this.options;
+        const twoStar = options.noglobstar
+            ? star
+            : options.dot
+                ? twoStarDot
+                : twoStarNoDot;
+        const flags = new Set(options.nocase ? ['i'] : []);
+        // regexpify non-globstar patterns
+        // if ** is only item, then we just do one twoStar
+        // if ** is first, and there are more, prepend (\/|twoStar\/)? to next
+        // if ** is last, append (\/twoStar|) to previous
+        // if ** is in the middle, append (\/|\/twoStar\/) to previous
+        // then filter out GLOBSTAR symbols
+        let re = set
+            .map(pattern => {
+            const pp = pattern.map(p => {
+                if (p instanceof RegExp) {
+                    for (const f of p.flags.split(''))
+                        flags.add(f);
+                }
+                return typeof p === 'string'
+                    ? regExpEscape(p)
+                    : p === GLOBSTAR$2
+                        ? GLOBSTAR$2
+                        : p._src;
+            });
+            pp.forEach((p, i) => {
+                const next = pp[i + 1];
+                const prev = pp[i - 1];
+                if (p !== GLOBSTAR$2 || prev === GLOBSTAR$2) {
+                    return;
+                }
+                if (prev === undefined) {
+                    if (next !== undefined && next !== GLOBSTAR$2) {
+                        pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
+                    }
+                    else {
+                        pp[i] = twoStar;
+                    }
+                }
+                else if (next === undefined) {
+                    pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
+                }
+                else if (next !== GLOBSTAR$2) {
+                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
+                    pp[i + 1] = GLOBSTAR$2;
+                }
+            });
+            return pp.filter(p => p !== GLOBSTAR$2).join('/');
+        })
+            .join('|');
+        // need to wrap in parens if we had more than one thing with |,
+        // otherwise only the first will be anchored to ^ and the last to $
+        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];
+        // must match entire pattern
+        // ending in a * or ** will make it less strict.
+        re = '^' + open + re + close + '$';
+        // can match anything, as long as it's not this.
+        if (this.negate)
+            re = '^(?!' + re + ').+$';
+        try {
+            this.regexp = new RegExp(re, [...flags].join(''));
+            /* c8 ignore start */
+        }
+        catch (ex) {
+            // should be impossible
+            this.regexp = false;
+        }
+        /* c8 ignore stop */
+        return this.regexp;
+    }
+    slashSplit(p) {
+        // if p starts with // on windows, we preserve that
+        // so that UNC paths aren't broken.  Otherwise, any number of
+        // / characters are coalesced into one, unless
+        // preserveMultipleSlashes is set to true.
+        if (this.preserveMultipleSlashes) {
+            return p.split('/');
+        }
+        else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+            // add an extra '' for the one we lose
+            return ['', ...p.split(/\/+/)];
+        }
+        else {
+            return p.split(/\/+/);
+        }
+    }
+    match(f, partial = this.partial) {
+        this.debug('match', f, this.pattern);
+        // short-circuit in the case of busted things.
+        // comments, etc.
+        if (this.comment) {
+            return false;
+        }
+        if (this.empty) {
+            return f === '';
+        }
+        if (f === '/' && partial) {
+            return true;
+        }
+        const options = this.options;
+        // windows: need to use /, not \
+        if (this.isWindows) {
+            f = f.split('\\').join('/');
+        }
+        // treat the test path as a set of pathparts.
+        const ff = this.slashSplit(f);
+        this.debug(this.pattern, 'split', ff);
+        // just ONE of the pattern sets in this.set needs to match
+        // in order for it to be valid.  If negating, then just one
+        // match means that we have failed.
+        // Either way, return on the first hit.
+        const set = this.set;
+        this.debug(this.pattern, 'set', set);
+        // Find the basename of the path by looking for the last non-empty segment
+        let filename = ff[ff.length - 1];
+        if (!filename) {
+            for (let i = ff.length - 2; !filename && i >= 0; i--) {
+                filename = ff[i];
+            }
+        }
+        for (let i = 0; i < set.length; i++) {
+            const pattern = set[i];
+            let file = ff;
+            if (options.matchBase && pattern.length === 1) {
+                file = [filename];
+            }
+            const hit = this.matchOne(file, pattern, partial);
+            if (hit) {
+                if (options.flipNegate) {
+                    return true;
+                }
+                return !this.negate;
+            }
+        }
+        // didn't get any hits.  this is success if it's a negative
+        // pattern, failure otherwise.
+        if (options.flipNegate) {
+            return false;
+        }
+        return this.negate;
+    }
+    static defaults(def) {
+        return minimatch.defaults(def).Minimatch;
+    }
+}
+/* c8 ignore stop */
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape$2;
+minimatch.unescape = unescape$1;
+
+/**
+ * @module LRUCache
+ */
+const perf = typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function'
+    ? performance
+    : Date;
+const warned$1 = new Set();
+/* c8 ignore start */
+const PROCESS = (typeof process === 'object' && !!process ? process : {});
+/* c8 ignore start */
+const emitWarning = (msg, type, code, fn) => {
+    typeof PROCESS.emitWarning === 'function'
+        ? PROCESS.emitWarning(msg, type, code, fn)
+        : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+/* c8 ignore start */
+if (typeof AC === 'undefined') {
+    //@ts-ignore
+    AS = class AbortSignal {
+        onabort;
+        _onabort = [];
+        reason;
+        aborted = false;
+        addEventListener(_, fn) {
+            this._onabort.push(fn);
+        }
+    };
+    //@ts-ignore
+    AC = class AbortController {
+        constructor() {
+            warnACPolyfill();
+        }
+        signal = new AS();
+        abort(reason) {
+            if (this.signal.aborted)
+                return;
+            //@ts-ignore
+            this.signal.reason = reason;
+            //@ts-ignore
+            this.signal.aborted = true;
+            //@ts-ignore
+            for (const fn of this.signal._onabort) {
+                fn(reason);
+            }
+            this.signal.onabort?.(reason);
+        }
+    };
+    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
+    const warnACPolyfill = () => {
+        if (!printACPolyfillWarning)
+            return;
+        printACPolyfillWarning = false;
+        emitWarning('AbortController is not defined. If using lru-cache in ' +
+            'node 14, load an AbortController polyfill from the ' +
+            '`node-abort-controller` package. A minimal polyfill is ' +
+            'provided for use by LRUCache.fetch(), but it should not be ' +
+            'relied upon in other contexts (eg, passing it to other APIs that ' +
+            'use AbortController/AbortSignal might have undesirable effects). ' +
+            'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.', 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+    };
+}
+/* c8 ignore stop */
+const shouldWarn = (code) => !warned$1.has(code);
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+/* c8 ignore start */
+// This is a little bit ridiculous, tbh.
+// The maximum array length is 2^32-1 or thereabouts on most JS impls.
+// And well before that point, you're caching the entire world, I mean,
+// that's ~32GB of just integers for the next/prev links, plus whatever
+// else to hold that many keys and values.  Just filling the memory with
+// zeroes at init time is brutal when you get that big.
+// But why not be complete?
+// Maybe in the future, these limits will have expanded.
+const getUintArray = (max) => !isPosInt(max)
+    ? null
+    : max <= Math.pow(2, 8)
+        ? Uint8Array
+        : max <= Math.pow(2, 16)
+            ? Uint16Array
+            : max <= Math.pow(2, 32)
+                ? Uint32Array
+                : max <= Number.MAX_SAFE_INTEGER
+                    ? ZeroArray
+                    : null;
+/* c8 ignore stop */
+class ZeroArray extends Array {
+    constructor(size) {
+        super(size);
+        this.fill(0);
+    }
+}
+class Stack {
+    heap;
+    length;
+    // private constructor
+    static #constructing = false;
+    static create(max) {
+        const HeapCls = getUintArray(max);
+        if (!HeapCls)
+            return [];
+        Stack.#constructing = true;
+        const s = new Stack(max, HeapCls);
+        Stack.#constructing = false;
+        return s;
+    }
+    constructor(max, HeapCls) {
+        /* c8 ignore start */
+        if (!Stack.#constructing) {
+            throw new TypeError('instantiate Stack using Stack.create(n)');
+        }
+        /* c8 ignore stop */
+        this.heap = new HeapCls(max);
+        this.length = 0;
+    }
+    push(n) {
+        this.heap[this.length++] = n;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+/**
+ * Default export, the thing you're using this module to get.
+ *
+ * The `K` and `V` types define the key and value types, respectively. The
+ * optional `FC` type defines the type of the `context` object passed to
+ * `cache.fetch()` and `cache.memo()`.
+ *
+ * Keys and values **must not** be `null` or `undefined`.
+ *
+ * All properties from the options object (with the exception of `max`,
+ * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+ * added as normal public members. (The listed options are read-only getters.)
+ *
+ * Changing any of these will alter the defaults for subsequent method calls.
+ */
+class LRUCache {
+    // options that cannot be changed without disaster
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    #memoMethod;
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    ttl;
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    ttlResolution;
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    ttlAutopurge;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    updateAgeOnGet;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    updateAgeOnHas;
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    allowStale;
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    noDisposeOnSet;
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    noUpdateTTL;
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    maxEntrySize;
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    sizeCalculation;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    noDeleteOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    noDeleteOnStaleGet;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    allowStaleOnFetchAbort;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    allowStaleOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    ignoreFetchAbort;
+    // computed properties
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    /**
+     * Do not call this method unless you need to inspect the
+     * inner workings of the cache.  If anything returned by this
+     * object is modified in any way, strange breakage may occur.
+     *
+     * These fields are private for a reason!
+     *
+     * @internal
+     */
+    static unsafeExposeInternals(c) {
+        return {
+            // properties
+            starts: c.#starts,
+            ttls: c.#ttls,
+            sizes: c.#sizes,
+            keyMap: c.#keyMap,
+            keyList: c.#keyList,
+            valList: c.#valList,
+            next: c.#next,
+            prev: c.#prev,
+            get head() {
+                return c.#head;
+            },
+            get tail() {
+                return c.#tail;
+            },
+            free: c.#free,
+            // methods
+            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+            moveToTail: (index) => c.#moveToTail(index),
+            indexes: (options) => c.#indexes(options),
+            rindexes: (options) => c.#rindexes(options),
+            isStale: (index) => c.#isStale(index),
+        };
+    }
+    // Protected read-only members
+    /**
+     * {@link LRUCache.OptionsBase.max} (read-only)
+     */
+    get max() {
+        return this.#max;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.maxSize} (read-only)
+     */
+    get maxSize() {
+        return this.#maxSize;
+    }
+    /**
+     * The total computed size of items in the cache (read-only)
+     */
+    get calculatedSize() {
+        return this.#calculatedSize;
+    }
+    /**
+     * The number of items stored in the cache (read-only)
+     */
+    get size() {
+        return this.#size;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+     */
+    get fetchMethod() {
+        return this.#fetchMethod;
+    }
+    get memoMethod() {
+        return this.#memoMethod;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.dispose} (read-only)
+     */
+    get dispose() {
+        return this.#dispose;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+     */
+    get disposeAfter() {
+        return this.#disposeAfter;
+    }
+    constructor(options) {
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
+        if (max !== 0 && !isPosInt(max)) {
+            throw new TypeError('max option must be a nonnegative integer');
+        }
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) {
+            throw new Error('invalid max value: ' + max);
+        }
+        this.#max = max;
+        this.#maxSize = maxSize;
+        this.maxEntrySize = maxEntrySize || this.#maxSize;
+        this.sizeCalculation = sizeCalculation;
+        if (this.sizeCalculation) {
+            if (!this.#maxSize && !this.maxEntrySize) {
+                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+            }
+            if (typeof this.sizeCalculation !== 'function') {
+                throw new TypeError('sizeCalculation set to non-function');
+            }
+        }
+        if (memoMethod !== undefined &&
+            typeof memoMethod !== 'function') {
+            throw new TypeError('memoMethod must be a function if defined');
+        }
+        this.#memoMethod = memoMethod;
+        if (fetchMethod !== undefined &&
+            typeof fetchMethod !== 'function') {
+            throw new TypeError('fetchMethod must be a function if specified');
+        }
+        this.#fetchMethod = fetchMethod;
+        this.#hasFetchMethod = !!fetchMethod;
+        this.#keyMap = new Map();
+        this.#keyList = new Array(max).fill(undefined);
+        this.#valList = new Array(max).fill(undefined);
+        this.#next = new UintArray(max);
+        this.#prev = new UintArray(max);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free = Stack.create(max);
+        this.#size = 0;
+        this.#calculatedSize = 0;
+        if (typeof dispose === 'function') {
+            this.#dispose = dispose;
+        }
+        if (typeof disposeAfter === 'function') {
+            this.#disposeAfter = disposeAfter;
+            this.#disposed = [];
+        }
+        else {
+            this.#disposeAfter = undefined;
+            this.#disposed = undefined;
+        }
+        this.#hasDispose = !!this.#dispose;
+        this.#hasDisposeAfter = !!this.#disposeAfter;
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+        this.ignoreFetchAbort = !!ignoreFetchAbort;
+        // NB: maxEntrySize is set to maxSize if it's set
+        if (this.maxEntrySize !== 0) {
+            if (this.#maxSize !== 0) {
+                if (!isPosInt(this.#maxSize)) {
+                    throw new TypeError('maxSize must be a positive integer if specified');
+                }
+            }
+            if (!isPosInt(this.maxEntrySize)) {
+                throw new TypeError('maxEntrySize must be a positive integer if specified');
+            }
+            this.#initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale;
+        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution =
+            isPosInt(ttlResolution) || ttlResolution === 0
+                ? ttlResolution
+                : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || 0;
+        if (this.ttl) {
+            if (!isPosInt(this.ttl)) {
+                throw new TypeError('ttl must be a positive integer if specified');
+            }
+            this.#initializeTTLTracking();
+        }
+        // do not allow completely unbounded caches
+        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+            throw new TypeError('At least one of max, maxSize, or ttl is required');
+        }
+        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+            const code = 'LRU_CACHE_UNBOUNDED';
+            if (shouldWarn(code)) {
+                warned$1.add(code);
+                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
+                    'result in unbounded memory consumption.';
+                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+            }
+        }
+    }
+    /**
+     * Return the number of ms left in the item's TTL. If item is not in cache,
+     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+     */
+    getRemainingTTL(key) {
+        return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+        const ttls = new ZeroArray(this.#max);
+        const starts = new ZeroArray(this.#max);
+        this.#ttls = ttls;
+        this.#starts = starts;
+        this.#setItemTTL = (index, ttl, start = perf.now()) => {
+            starts[index] = ttl !== 0 ? start : 0;
+            ttls[index] = ttl;
+            if (ttl !== 0 && this.ttlAutopurge) {
+                const t = setTimeout(() => {
+                    if (this.#isStale(index)) {
+                        this.#delete(this.#keyList[index], 'expire');
+                    }
+                }, ttl + 1);
+                // unref() not supported on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+        };
+        this.#updateItemAge = index => {
+            starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+        };
+        this.#statusTTL = (status, index) => {
+            if (ttls[index]) {
+                const ttl = ttls[index];
+                const start = starts[index];
+                /* c8 ignore next */
+                if (!ttl || !start)
+                    return;
+                status.ttl = ttl;
+                status.start = start;
+                status.now = cachedNow || getNow();
+                const age = status.now - start;
+                status.remainingTTL = ttl - age;
+            }
+        };
+        // debounce calls to perf.now() to 1s so we're not hitting
+        // that costly call repeatedly.
+        let cachedNow = 0;
+        const getNow = () => {
+            const n = perf.now();
+            if (this.ttlResolution > 0) {
+                cachedNow = n;
+                const t = setTimeout(() => (cachedNow = 0), this.ttlResolution);
+                // not available on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+            return n;
+        };
+        this.getRemainingTTL = key => {
+            const index = this.#keyMap.get(key);
+            if (index === undefined) {
+                return 0;
+            }
+            const ttl = ttls[index];
+            const start = starts[index];
+            if (!ttl || !start) {
+                return Infinity;
+            }
+            const age = (cachedNow || getNow()) - start;
+            return ttl - age;
+        };
+        this.#isStale = index => {
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        };
+    }
+    // conditionally set private methods related to TTL
+    #updateItemAge = () => { };
+    #statusTTL = () => { };
+    #setItemTTL = () => { };
+    /* c8 ignore stop */
+    #isStale = () => false;
+    #initializeSizeTracking() {
+        const sizes = new ZeroArray(this.#max);
+        this.#calculatedSize = 0;
+        this.#sizes = sizes;
+        this.#removeItemSize = index => {
+            this.#calculatedSize -= sizes[index];
+            sizes[index] = 0;
+        };
+        this.#requireSize = (k, v, size, sizeCalculation) => {
+            // provisionally accept background fetches.
+            // actual value size will be checked when they return.
+            if (this.#isBackgroundFetch(v)) {
+                return 0;
+            }
+            if (!isPosInt(size)) {
+                if (sizeCalculation) {
+                    if (typeof sizeCalculation !== 'function') {
+                        throw new TypeError('sizeCalculation must be a function');
+                    }
+                    size = sizeCalculation(v, k);
+                    if (!isPosInt(size)) {
+                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+                    }
+                }
+                else {
+                    throw new TypeError('invalid size value (must be positive integer). ' +
+                        'When maxSize or maxEntrySize is used, sizeCalculation ' +
+                        'or size must be set.');
+                }
+            }
+            return size;
+        };
+        this.#addItemSize = (index, size, status) => {
+            sizes[index] = size;
+            if (this.#maxSize) {
+                const maxSize = this.#maxSize - sizes[index];
+                while (this.#calculatedSize > maxSize) {
+                    this.#evict(true);
+                }
+            }
+            this.#calculatedSize += sizes[index];
+            if (status) {
+                status.entrySize = size;
+                status.totalCalculatedSize = this.#calculatedSize;
+            }
+        };
+    }
+    #removeItemSize = _i => { };
+    #addItemSize = (_i, _s, _st) => { };
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+        if (size || sizeCalculation) {
+            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+        }
+        return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#tail; true;) {
+                if (!this.#isValidIndex(i)) {
+                    break;
+                }
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#head) {
+                    break;
+                }
+                else {
+                    i = this.#prev[i];
+                }
+            }
+        }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#head; true;) {
+                if (!this.#isValidIndex(i)) {
+                    break;
+                }
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#tail) {
+                    break;
+                }
+                else {
+                    i = this.#next[i];
+                }
+            }
+        }
+    }
+    #isValidIndex(index) {
+        return (index !== undefined &&
+            this.#keyMap.get(this.#keyList[index]) === index);
+    }
+    /**
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from most recently used to least recently used.
+     */
+    *entries() {
+        for (const i of this.#indexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.entries}
+     *
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from least recently used to most recently used.
+     */
+    *rentries() {
+        for (const i of this.#rindexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the keys in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *keys() {
+        for (const i of this.#indexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.keys}
+     *
+     * Return a generator yielding the keys in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rkeys() {
+        for (const i of this.#rindexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the values in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *values() {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.values}
+     *
+     * Return a generator yielding the values in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rvalues() {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Iterating over the cache itself yields the same results as
+     * {@link LRUCache.entries}
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
+     */
+    [Symbol.toStringTag] = 'LRUCache';
+    /**
+     * Find a value for which the supplied fn method returns a truthy value,
+     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+     */
+    find(fn, getOptions = {}) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            if (fn(value, this.#keyList[i], this)) {
+                return this.get(this.#keyList[i], getOptions);
+            }
+        }
+    }
+    /**
+     * Call the supplied function on each item in the cache, in order from most
+     * recently used to least recently used.
+     *
+     * `fn` is called as `fn(value, key, cache)`.
+     *
+     * If `thisp` is provided, function will be called in the `this`-context of
+     * the provided object, or the cache if no `thisp` object is provided.
+     *
+     * Does not update age or recenty of use, or iterate over stale values.
+     */
+    forEach(fn, thisp = this) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * The same as {@link LRUCache.forEach} but items are iterated over in
+     * reverse order.  (ie, less recently used items are iterated over first.)
+     */
+    rforEach(fn, thisp = this) {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * Delete any stale entries. Returns true if anything was removed,
+     * false otherwise.
+     */
+    purgeStale() {
+        let deleted = false;
+        for (const i of this.#rindexes({ allowStale: true })) {
+            if (this.#isStale(i)) {
+                this.#delete(this.#keyList[i], 'expire');
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Returns `undefined` if the key is not present.
+     *
+     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+     * serialization, the `start` value is always the current timestamp, and the
+     * `ttl` is a calculated remaining time to live (negative if expired).
+     *
+     * Always returns stale values, if their info is found in the cache, so be
+     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+     * if relevant.
+     */
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (i === undefined)
+            return undefined;
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v)
+            ? v.__staleWhileFetching
+            : v;
+        if (value === undefined)
+            return undefined;
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) {
+            entry.size = this.#sizes[i];
+        }
+        return entry;
+    }
+    /**
+     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+     * passed to {@link LRLUCache#load}.
+     *
+     * The `start` fields are calculated relative to a portable `Date.now()`
+     * timestamp, even if `performance.now()` is available.
+     *
+     * Stale entries are always included in the `dump`, even if
+     * {@link LRUCache.OptionsBase.allowStale} is false.
+     *
+     * Note: this returns an actual array, not a generator, so it can be more
+     * easily passed around.
+     */
+    dump() {
+        const arr = [];
+        for (const i of this.#indexes({ allowStale: true })) {
+            const key = this.#keyList[i];
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined || key === undefined)
+                continue;
+            const entry = { value };
+            if (this.#ttls && this.#starts) {
+                entry.ttl = this.#ttls[i];
+                // always dump the start relative to a portable timestamp
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = perf.now() - this.#starts[i];
+                entry.start = Math.floor(Date.now() - age);
+            }
+            if (this.#sizes) {
+                entry.size = this.#sizes[i];
+            }
+            arr.unshift([key, entry]);
+        }
+        return arr;
+    }
+    /**
+     * Reset the cache and load in the items in entries in the order listed.
+     *
+     * The shape of the resulting cache may be different if the same options are
+     * not used in both caches.
+     *
+     * The `start` fields are assumed to be calculated relative to a portable
+     * `Date.now()` timestamp, even if `performance.now()` is available.
+     */
+    load(arr) {
+        this.clear();
+        for (const [key, entry] of arr) {
+            if (entry.start) {
+                // entry.start is a portable timestamp, but we may be using
+                // node's performance.now(), so calculate the offset, so that
+                // we get the intended remaining TTL, no matter how long it's
+                // been on ice.
+                //
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = Date.now() - entry.start;
+                entry.start = perf.now() - age;
+            }
+            this.set(key, entry.value, entry);
+        }
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * Note: if `undefined` is specified as a value, this is an alias for
+     * {@link LRUCache#delete}
+     *
+     * Fields on the {@link LRUCache.SetOptions} options param will override
+     * their corresponding values in the constructor options for the scope
+     * of this single `set()` operation.
+     *
+     * If `start` is provided, then that will set the effective start
+     * time for the TTL calculation. Note that this must be a previous
+     * value of `performance.now()` if supported, or a previous value of
+     * `Date.now()` if not.
+     *
+     * Options object may also include `size`, which will prevent
+     * calling the `sizeCalculation` function and just use the specified
+     * number if it is a positive integer, and `noDisposeOnSet` which
+     * will prevent calling a `dispose` function in the case of
+     * overwrites.
+     *
+     * If the `size` (or return value of `sizeCalculation`) for a given
+     * entry is greater than `maxEntrySize`, then the item will not be
+     * added to the cache.
+     *
+     * Will update the recency of the entry.
+     *
+     * If the value is `undefined`, then this is an alias for
+     * `cache.delete(key)`. `undefined` is never stored in the cache.
+     */
+    set(k, v, setOptions = {}) {
+        if (v === undefined) {
+            this.delete(k);
+            return this;
+        }
+        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+        // if the item doesn't fit, don't do anything
+        // NB: maxEntrySize set to maxSize by default
+        if (this.maxEntrySize && size > this.maxEntrySize) {
+            if (status) {
+                status.set = 'miss';
+                status.maxEntrySizeExceeded = true;
+            }
+            // have to delete, in case something is there already.
+            this.#delete(k, 'set');
+            return this;
+        }
+        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+        if (index === undefined) {
+            // addition
+            index = (this.#size === 0
+                ? this.#tail
+                : this.#free.length !== 0
+                    ? this.#free.pop()
+                    : this.#size === this.#max
+                        ? this.#evict(false)
+                        : this.#size);
+            this.#keyList[index] = k;
+            this.#valList[index] = v;
+            this.#keyMap.set(k, index);
+            this.#next[this.#tail] = index;
+            this.#prev[index] = this.#tail;
+            this.#tail = index;
+            this.#size++;
+            this.#addItemSize(index, size, status);
+            if (status)
+                status.set = 'add';
+            noUpdateTTL = false;
+        }
+        else {
+            // update
+            this.#moveToTail(index);
+            const oldVal = this.#valList[index];
+            if (v !== oldVal) {
+                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+                    oldVal.__abortController.abort(new Error('replaced'));
+                    const { __staleWhileFetching: s } = oldVal;
+                    if (s !== undefined && !noDisposeOnSet) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(s, k, 'set');
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([s, k, 'set']);
+                        }
+                    }
+                }
+                else if (!noDisposeOnSet) {
+                    if (this.#hasDispose) {
+                        this.#dispose?.(oldVal, k, 'set');
+                    }
+                    if (this.#hasDisposeAfter) {
+                        this.#disposed?.push([oldVal, k, 'set']);
+                    }
+                }
+                this.#removeItemSize(index);
+                this.#addItemSize(index, size, status);
+                this.#valList[index] = v;
+                if (status) {
+                    status.set = 'replace';
+                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal)
+                        ? oldVal.__staleWhileFetching
+                        : oldVal;
+                    if (oldValue !== undefined)
+                        status.oldValue = oldValue;
+                }
+            }
+            else if (status) {
+                status.set = 'update';
+            }
+        }
+        if (ttl !== 0 && !this.#ttls) {
+            this.#initializeTTLTracking();
+        }
+        if (this.#ttls) {
+            if (!noUpdateTTL) {
+                this.#setItemTTL(index, ttl, start);
+            }
+            if (status)
+                this.#statusTTL(status, index);
+        }
+        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return this;
+    }
+    /**
+     * Evict the least recently used item, returning its value or
+     * `undefined` if cache is empty.
+     */
+    pop() {
+        try {
+            while (this.#size) {
+                const val = this.#valList[this.#head];
+                this.#evict(true);
+                if (this.#isBackgroundFetch(val)) {
+                    if (val.__staleWhileFetching) {
+                        return val.__staleWhileFetching;
+                    }
+                }
+                else if (val !== undefined) {
+                    return val;
+                }
+            }
+        }
+        finally {
+            if (this.#hasDisposeAfter && this.#disposed) {
+                const dt = this.#disposed;
+                let task;
+                while ((task = dt?.shift())) {
+                    this.#disposeAfter?.(...task);
+                }
+            }
+        }
+    }
+    #evict(free) {
+        const head = this.#head;
+        const k = this.#keyList[head];
+        const v = this.#valList[head];
+        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+            v.__abortController.abort(new Error('evicted'));
+        }
+        else if (this.#hasDispose || this.#hasDisposeAfter) {
+            if (this.#hasDispose) {
+                this.#dispose?.(v, k, 'evict');
+            }
+            if (this.#hasDisposeAfter) {
+                this.#disposed?.push([v, k, 'evict']);
+            }
+        }
+        this.#removeItemSize(head);
+        // if we aren't about to use the index, then null these out
+        if (free) {
+            this.#keyList[head] = undefined;
+            this.#valList[head] = undefined;
+            this.#free.push(head);
+        }
+        if (this.#size === 1) {
+            this.#head = this.#tail = 0;
+            this.#free.length = 0;
+        }
+        else {
+            this.#head = this.#next[head];
+        }
+        this.#keyMap.delete(k);
+        this.#size--;
+        return head;
+    }
+    /**
+     * Check if a key is in the cache, without updating the recency of use.
+     * Will return false if the item is stale, even though it is technically
+     * in the cache.
+     *
+     * Check if a key is in the cache, without updating the recency of
+     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+     * to `true` in either the options or the constructor.
+     *
+     * Will return `false` if the item is stale, even though it is technically in
+     * the cache. The difference can be determined (if it matters) by using a
+     * `status` argument, and inspecting the `has` field.
+     *
+     * Will not update item age unless
+     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+     */
+    has(k, hasOptions = {}) {
+        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v) &&
+                v.__staleWhileFetching === undefined) {
+                return false;
+            }
+            if (!this.#isStale(index)) {
+                if (updateAgeOnHas) {
+                    this.#updateItemAge(index);
+                }
+                if (status) {
+                    status.has = 'hit';
+                    this.#statusTTL(status, index);
+                }
+                return true;
+            }
+            else if (status) {
+                status.has = 'stale';
+                this.#statusTTL(status, index);
+            }
+        }
+        else if (status) {
+            status.has = 'miss';
+        }
+        return false;
+    }
+    /**
+     * Like {@link LRUCache#get} but doesn't update recency or delete stale
+     * items.
+     *
+     * Returns `undefined` if the item is stale, unless
+     * {@link LRUCache.OptionsBase.allowStale} is set.
+     */
+    peek(k, peekOptions = {}) {
+        const { allowStale = this.allowStale } = peekOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined ||
+            (!allowStale && this.#isStale(index))) {
+            return;
+        }
+        const v = this.#valList[index];
+        // either stale and allowed, or forcing a refresh of non-stale value
+        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+    #backgroundFetch(k, index, options, context) {
+        const v = index === undefined ? undefined : this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+            return v;
+        }
+        const ac = new AC();
+        const { signal } = options;
+        // when/if our AC signals, then stop listening to theirs.
+        signal?.addEventListener('abort', () => ac.abort(signal.reason), {
+            signal: ac.signal,
+        });
+        const fetchOpts = {
+            signal: ac.signal,
+            options,
+            context,
+        };
+        const cb = (v, updateCache = false) => {
+            const { aborted } = ac.signal;
+            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
+            if (options.status) {
+                if (aborted && !updateCache) {
+                    options.status.fetchAborted = true;
+                    options.status.fetchError = ac.signal.reason;
+                    if (ignoreAbort)
+                        options.status.fetchAbortIgnored = true;
+                }
+                else {
+                    options.status.fetchResolved = true;
+                }
+            }
+            if (aborted && !ignoreAbort && !updateCache) {
+                return fetchFail(ac.signal.reason);
+            }
+            // either we didn't abort, and are still here, or we did, and ignored
+            const bf = p;
+            if (this.#valList[index] === p) {
+                if (v === undefined) {
+                    if (bf.__staleWhileFetching) {
+                        this.#valList[index] = bf.__staleWhileFetching;
+                    }
+                    else {
+                        this.#delete(k, 'fetch');
+                    }
+                }
+                else {
+                    if (options.status)
+                        options.status.fetchUpdated = true;
+                    this.set(k, v, fetchOpts.options);
+                }
+            }
+            return v;
+        };
+        const eb = (er) => {
+            if (options.status) {
+                options.status.fetchRejected = true;
+                options.status.fetchError = er;
+            }
+            return fetchFail(er);
+        };
+        const fetchFail = (er) => {
+            const { aborted } = ac.signal;
+            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+            const noDelete = allowStale || options.noDeleteOnFetchRejection;
+            const bf = p;
+            if (this.#valList[index] === p) {
+                // if we allow stale on fetch rejections, then we need to ensure that
+                // the stale value is not removed from the cache when the fetch fails.
+                const del = !noDelete || bf.__staleWhileFetching === undefined;
+                if (del) {
+                    this.#delete(k, 'fetch');
+                }
+                else if (!allowStaleAborted) {
+                    // still replace the *promise* with the stale value,
+                    // since we are done with the promise at this point.
+                    // leave it untouched if we're still waiting for an
+                    // aborted background fetch that hasn't yet returned.
+                    this.#valList[index] = bf.__staleWhileFetching;
+                }
+            }
+            if (allowStale) {
+                if (options.status && bf.__staleWhileFetching !== undefined) {
+                    options.status.returnedStale = true;
+                }
+                return bf.__staleWhileFetching;
+            }
+            else if (bf.__returned === bf) {
+                throw er;
+            }
+        };
+        const pcall = (res, rej) => {
+            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            // ignored, we go until we finish, regardless.
+            // defer check until we are actually aborting,
+            // so fetchMethod can override.
+            ac.signal.addEventListener('abort', () => {
+                if (!options.ignoreFetchAbort ||
+                    options.allowStaleOnFetchAbort) {
+                    res(undefined);
+                    // when it eventually resolves, update the cache.
+                    if (options.allowStaleOnFetchAbort) {
+                        res = v => cb(v, true);
+                    }
+                }
+            });
+        };
+        if (options.status)
+            options.status.fetchDispatched = true;
+        const p = new Promise(pcall).then(cb, eb);
+        const bf = Object.assign(p, {
+            __abortController: ac,
+            __staleWhileFetching: v,
+            __returned: undefined,
+        });
+        if (index === undefined) {
+            // internal, don't expose status.
+            this.set(k, bf, { ...fetchOpts.options, status: undefined });
+            index = this.#keyMap.get(k);
+        }
+        else {
+            this.#valList[index] = bf;
+        }
+        return bf;
+    }
+    #isBackgroundFetch(p) {
+        if (!this.#hasFetchMethod)
+            return false;
+        const b = p;
+        return (!!b &&
+            b instanceof Promise &&
+            b.hasOwnProperty('__staleWhileFetching') &&
+            b.__abortController instanceof AC);
+    }
+    async fetch(k, fetchOptions = {}) {
+        const { 
+        // get options
+        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, 
+        // set options
+        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, 
+        // fetch exclusive options
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal, } = fetchOptions;
+        if (!this.#hasFetchMethod) {
+            if (status)
+                status.fetch = 'get';
+            return this.get(k, {
+                allowStale,
+                updateAgeOnGet,
+                noDeleteOnStaleGet,
+                status,
+            });
+        }
+        const options = {
+            allowStale,
+            updateAgeOnGet,
+            noDeleteOnStaleGet,
+            ttl,
+            noDisposeOnSet,
+            size,
+            sizeCalculation,
+            noUpdateTTL,
+            noDeleteOnFetchRejection,
+            allowStaleOnFetchRejection,
+            allowStaleOnFetchAbort,
+            ignoreFetchAbort,
+            status,
+            signal,
+        };
+        let index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.fetch = 'miss';
+            const p = this.#backgroundFetch(k, index, options, context);
+            return (p.__returned = p);
+        }
+        else {
+            // in cache, maybe already fetching
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                const stale = allowStale && v.__staleWhileFetching !== undefined;
+                if (status) {
+                    status.fetch = 'inflight';
+                    if (stale)
+                        status.returnedStale = true;
+                }
+                return stale ? v.__staleWhileFetching : (v.__returned = v);
+            }
+            // if we force a refresh, that means do NOT serve the cached value,
+            // unless we are already in the process of refreshing the cache.
+            const isStale = this.#isStale(index);
+            if (!forceRefresh && !isStale) {
+                if (status)
+                    status.fetch = 'hit';
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                if (status)
+                    this.#statusTTL(status, index);
+                return v;
+            }
+            // ok, it is stale or a forced refresh, and not already fetching.
+            // refresh the cache.
+            const p = this.#backgroundFetch(k, index, options, context);
+            const hasStale = p.__staleWhileFetching !== undefined;
+            const staleVal = hasStale && allowStale;
+            if (status) {
+                status.fetch = isStale ? 'stale' : 'refresh';
+                if (staleVal && isStale)
+                    status.returnedStale = true;
+            }
+            return staleVal ? p.__staleWhileFetching : (p.__returned = p);
+        }
+    }
+    async forceFetch(k, fetchOptions = {}) {
+        const v = await this.fetch(k, fetchOptions);
+        if (v === undefined)
+            throw new Error('fetch() returned undefined');
+        return v;
+    }
+    memo(k, memoOptions = {}) {
+        const memoMethod = this.#memoMethod;
+        if (!memoMethod) {
+            throw new Error('no memoMethod provided to constructor');
+        }
+        const { context, forceRefresh, ...options } = memoOptions;
+        const v = this.get(k, options);
+        if (!forceRefresh && v !== undefined)
+            return v;
+        const vv = memoMethod(k, v, {
+            options,
+            context,
+        });
+        this.set(k, vv, options);
+        return vv;
+    }
+    /**
+     * Return a value from the cache. Will update the recency of the cache
+     * entry found.
+     *
+     * If the key is not found, get() will return `undefined`.
+     */
+    get(k, getOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status, } = getOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const value = this.#valList[index];
+            const fetching = this.#isBackgroundFetch(value);
+            if (status)
+                this.#statusTTL(status, index);
+            if (this.#isStale(index)) {
+                if (status)
+                    status.get = 'stale';
+                // delete only if not an in-flight background fetch
+                if (!fetching) {
+                    if (!noDeleteOnStaleGet) {
+                        this.#delete(k, 'expire');
+                    }
+                    if (status && allowStale)
+                        status.returnedStale = true;
+                    return allowStale ? value : undefined;
+                }
+                else {
+                    if (status &&
+                        allowStale &&
+                        value.__staleWhileFetching !== undefined) {
+                        status.returnedStale = true;
+                    }
+                    return allowStale ? value.__staleWhileFetching : undefined;
+                }
+            }
+            else {
+                if (status)
+                    status.get = 'hit';
+                // if we're currently fetching it, we don't actually have it yet
+                // it's not stale, which means this isn't a staleWhileRefetching.
+                // If it's not stale, and fetching, AND has a __staleWhileFetching
+                // value, then that means the user fetched with {forceRefresh:true},
+                // so it's safe to return that value.
+                if (fetching) {
+                    return value.__staleWhileFetching;
+                }
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                return value;
+            }
+        }
+        else if (status) {
+            status.get = 'miss';
+        }
+    }
+    #connect(p, n) {
+        this.#prev[n] = p;
+        this.#next[p] = n;
+    }
+    #moveToTail(index) {
+        // if tail already, nothing to do
+        // if head, move head to next[index]
+        // else
+        //   move next[prev[index]] to next[index] (head has no prev)
+        //   move prev[next[index]] to prev[index]
+        // prev[index] = tail
+        // next[tail] = index
+        // tail = index
+        if (index !== this.#tail) {
+            if (index === this.#head) {
+                this.#head = this.#next[index];
+            }
+            else {
+                this.#connect(this.#prev[index], this.#next[index]);
+            }
+            this.#connect(this.#tail, index);
+            this.#tail = index;
+        }
+    }
+    /**
+     * Deletes a key out of the cache.
+     *
+     * Returns true if the key was deleted, false otherwise.
+     */
+    delete(k) {
+        return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
+        let deleted = false;
+        if (this.#size !== 0) {
+            const index = this.#keyMap.get(k);
+            if (index !== undefined) {
+                deleted = true;
+                if (this.#size === 1) {
+                    this.#clear(reason);
+                }
+                else {
+                    this.#removeItemSize(index);
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) {
+                        v.__abortController.abort(new Error('deleted'));
+                    }
+                    else if (this.#hasDispose || this.#hasDisposeAfter) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(v, k, reason);
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([v, k, reason]);
+                        }
+                    }
+                    this.#keyMap.delete(k);
+                    this.#keyList[index] = undefined;
+                    this.#valList[index] = undefined;
+                    if (index === this.#tail) {
+                        this.#tail = this.#prev[index];
+                    }
+                    else if (index === this.#head) {
+                        this.#head = this.#next[index];
+                    }
+                    else {
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
+                    }
+                    this.#size--;
+                    this.#free.push(index);
+                }
+            }
+        }
+        if (this.#hasDisposeAfter && this.#disposed?.length) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Clear the cache entirely, throwing away all values.
+     */
+    clear() {
+        return this.#clear('delete');
+    }
+    #clear(reason) {
+        for (const index of this.#rindexes({ allowStale: true })) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                v.__abortController.abort(new Error('deleted'));
+            }
+            else {
+                const k = this.#keyList[index];
+                if (this.#hasDispose) {
+                    this.#dispose?.(v, k, reason);
+                }
+                if (this.#hasDisposeAfter) {
+                    this.#disposed?.push([v, k, reason]);
+                }
+            }
+        }
+        this.#keyMap.clear();
+        this.#valList.fill(undefined);
+        this.#keyList.fill(undefined);
+        if (this.#ttls && this.#starts) {
+            this.#ttls.fill(0);
+            this.#starts.fill(0);
+        }
+        if (this.#sizes) {
+            this.#sizes.fill(0);
+        }
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free.length = 0;
+        this.#calculatedSize = 0;
+        this.#size = 0;
+        if (this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+    }
+}
+
+const proc = typeof process === 'object' && process
+    ? process
+    : {
+        stdout: null,
+        stderr: null,
+    };
+/**
+ * Return true if the argument is a Minipass stream, Node stream, or something
+ * else that Minipass can interact with.
+ */
+const isStream = (s) => !!s &&
+    typeof s === 'object' &&
+    (s instanceof Minipass ||
+        s instanceof Stream$1 ||
+        isReadable(s) ||
+        isWritable(s));
+/**
+ * Return true if the argument is a valid {@link Minipass.Readable}
+ */
+const isReadable = (s) => !!s &&
+    typeof s === 'object' &&
+    s instanceof EventEmitter$4 &&
+    typeof s.pipe === 'function' &&
+    // node core Writable streams have a pipe() method, but it throws
+    s.pipe !== Stream$1.Writable.prototype.pipe;
+/**
+ * Return true if the argument is a valid {@link Minipass.Writable}
+ */
+const isWritable = (s) => !!s &&
+    typeof s === 'object' &&
+    s instanceof EventEmitter$4 &&
+    typeof s.write === 'function' &&
+    typeof s.end === 'function';
+const EOF = Symbol('EOF');
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd');
+const EMITTED_END = Symbol('emittedEnd');
+const EMITTING_END = Symbol('emittingEnd');
+const EMITTED_ERROR = Symbol('emittedError');
+const CLOSED$1 = Symbol('closed');
+const READ = Symbol('read');
+const FLUSH = Symbol('flush');
+const FLUSHCHUNK = Symbol('flushChunk');
+const ENCODING$1 = Symbol('encoding');
+const DECODER = Symbol('decoder');
+const FLOWING = Symbol('flowing');
+const PAUSED = Symbol('paused');
+const RESUME = Symbol('resume');
+const BUFFER = Symbol('buffer');
+const PIPES = Symbol('pipes');
+const BUFFERLENGTH = Symbol('bufferLength');
+const BUFFERPUSH = Symbol('bufferPush');
+const BUFFERSHIFT = Symbol('bufferShift');
+const OBJECTMODE = Symbol('objectMode');
+// internal event when stream is destroyed
+const DESTROYED = Symbol('destroyed');
+// internal event when stream has an error
+const ERROR = Symbol('error');
+const EMITDATA = Symbol('emitData');
+const EMITEND = Symbol('emitEnd');
+const EMITEND2 = Symbol('emitEnd2');
+const ASYNC = Symbol('async');
+const ABORT = Symbol('abort');
+const ABORTED = Symbol('aborted');
+const SIGNAL = Symbol('signal');
+const DATALISTENERS = Symbol('dataListeners');
+const DISCARDED = Symbol('discarded');
+const defer$3 = (fn) => Promise.resolve().then(fn);
+const nodefer = (fn) => fn();
+const isEndish = (ev) => ev === 'end' || ev === 'finish' || ev === 'prefinish';
+const isArrayBufferLike = (b) => b instanceof ArrayBuffer ||
+    (!!b &&
+        typeof b === 'object' &&
+        b.constructor &&
+        b.constructor.name === 'ArrayBuffer' &&
+        b.byteLength >= 0);
+const isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+/**
+ * Internal class representing a pipe to a destination stream.
+ *
+ * @internal
+ */
+class Pipe {
+    src;
+    dest;
+    opts;
+    ondrain;
+    constructor(src, dest, opts) {
+        this.src = src;
+        this.dest = dest;
+        this.opts = opts;
+        this.ondrain = () => src[RESUME]();
+        this.dest.on('drain', this.ondrain);
+    }
+    unpipe() {
+        this.dest.removeListener('drain', this.ondrain);
+    }
+    // only here for the prototype
+    /* c8 ignore start */
+    proxyErrors(_er) { }
+    /* c8 ignore stop */
+    end() {
+        this.unpipe();
+        if (this.opts.end)
+            this.dest.end();
+    }
+}
+/**
+ * Internal class representing a pipe to a destination stream where
+ * errors are proxied.
+ *
+ * @internal
+ */
+class PipeProxyErrors extends Pipe {
+    unpipe() {
+        this.src.removeListener('error', this.proxyErrors);
+        super.unpipe();
+    }
+    constructor(src, dest, opts) {
+        super(src, dest, opts);
+        this.proxyErrors = er => dest.emit('error', er);
+        src.on('error', this.proxyErrors);
+    }
+}
+const isObjectModeOptions = (o) => !!o.objectMode;
+const isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== 'buffer';
+/**
+ * Main export, the Minipass class
+ *
+ * `RType` is the type of data emitted, defaults to Buffer
+ *
+ * `WType` is the type of data to be written, if RType is buffer or string,
+ * then any {@link Minipass.ContiguousData} is allowed.
+ *
+ * `Events` is the set of event handler signatures that this object
+ * will emit, see {@link Minipass.Events}
+ */
+class Minipass extends EventEmitter$4 {
+    [FLOWING] = false;
+    [PAUSED] = false;
+    [PIPES] = [];
+    [BUFFER] = [];
+    [OBJECTMODE];
+    [ENCODING$1];
+    [ASYNC];
+    [DECODER];
+    [EOF] = false;
+    [EMITTED_END] = false;
+    [EMITTING_END] = false;
+    [CLOSED$1] = false;
+    [EMITTED_ERROR] = null;
+    [BUFFERLENGTH] = 0;
+    [DESTROYED] = false;
+    [SIGNAL];
+    [ABORTED] = false;
+    [DATALISTENERS] = 0;
+    [DISCARDED] = false;
+    /**
+     * true if the stream can be written
+     */
+    writable = true;
+    /**
+     * true if the stream can be read
+     */
+    readable = true;
+    /**
+     * If `RType` is Buffer, then options do not need to be provided.
+     * Otherwise, an options object must be provided to specify either
+     * {@link Minipass.SharedOptions.objectMode} or
+     * {@link Minipass.SharedOptions.encoding}, as appropriate.
+     */
+    constructor(...args) {
+        const options = (args[0] ||
+            {});
+        super();
+        if (options.objectMode && typeof options.encoding === 'string') {
+            throw new TypeError('Encoding and objectMode may not be used together');
+        }
+        if (isObjectModeOptions(options)) {
+            this[OBJECTMODE] = true;
+            this[ENCODING$1] = null;
+        }
+        else if (isEncodingOptions(options)) {
+            this[ENCODING$1] = options.encoding;
+            this[OBJECTMODE] = false;
+        }
+        else {
+            this[OBJECTMODE] = false;
+            this[ENCODING$1] = null;
+        }
+        this[ASYNC] = !!options.async;
+        this[DECODER] = this[ENCODING$1]
+            ? new StringDecoder(this[ENCODING$1])
+            : null;
+        //@ts-ignore - private option for debugging and testing
+        if (options && options.debugExposeBuffer === true) {
+            Object.defineProperty(this, 'buffer', { get: () => this[BUFFER] });
+        }
+        //@ts-ignore - private option for debugging and testing
+        if (options && options.debugExposePipes === true) {
+            Object.defineProperty(this, 'pipes', { get: () => this[PIPES] });
+        }
+        const { signal } = options;
+        if (signal) {
+            this[SIGNAL] = signal;
+            if (signal.aborted) {
+                this[ABORT]();
+            }
+            else {
+                signal.addEventListener('abort', () => this[ABORT]());
+            }
+        }
+    }
+    /**
+     * The amount of data stored in the buffer waiting to be read.
+     *
+     * For Buffer strings, this will be the total byte length.
+     * For string encoding streams, this will be the string character length,
+     * according to JavaScript's `string.length` logic.
+     * For objectMode streams, this is a count of the items waiting to be
+     * emitted.
+     */
+    get bufferLength() {
+        return this[BUFFERLENGTH];
+    }
+    /**
+     * The `BufferEncoding` currently in use, or `null`
+     */
+    get encoding() {
+        return this[ENCODING$1];
+    }
+    /**
+     * @deprecated - This is a read only property
+     */
+    set encoding(_enc) {
+        throw new Error('Encoding must be set at instantiation time');
+    }
+    /**
+     * @deprecated - Encoding may only be set at instantiation time
+     */
+    setEncoding(_enc) {
+        throw new Error('Encoding must be set at instantiation time');
+    }
+    /**
+     * True if this is an objectMode stream
+     */
+    get objectMode() {
+        return this[OBJECTMODE];
+    }
+    /**
+     * @deprecated - This is a read-only property
+     */
+    set objectMode(_om) {
+        throw new Error('objectMode must be set at instantiation time');
+    }
+    /**
+     * true if this is an async stream
+     */
+    get ['async']() {
+        return this[ASYNC];
+    }
+    /**
+     * Set to true to make this stream async.
+     *
+     * Once set, it cannot be unset, as this would potentially cause incorrect
+     * behavior.  Ie, a sync stream can be made async, but an async stream
+     * cannot be safely made sync.
+     */
+    set ['async'](a) {
+        this[ASYNC] = this[ASYNC] || !!a;
+    }
+    // drop everything and get out of the flow completely
+    [ABORT]() {
+        this[ABORTED] = true;
+        this.emit('abort', this[SIGNAL]?.reason);
+        this.destroy(this[SIGNAL]?.reason);
+    }
+    /**
+     * True if the stream has been aborted.
+     */
+    get aborted() {
+        return this[ABORTED];
+    }
+    /**
+     * No-op setter. Stream aborted status is set via the AbortSignal provided
+     * in the constructor options.
+     */
+    set aborted(_) { }
+    write(chunk, encoding, cb) {
+        if (this[ABORTED])
+            return false;
+        if (this[EOF])
+            throw new Error('write after end');
+        if (this[DESTROYED]) {
+            this.emit('error', Object.assign(new Error('Cannot call write after a stream was destroyed'), { code: 'ERR_STREAM_DESTROYED' }));
+            return true;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = 'utf8';
+        }
+        if (!encoding)
+            encoding = 'utf8';
+        const fn = this[ASYNC] ? defer$3 : nodefer;
+        // convert array buffers and typed array views into buffers
+        // at some point in the future, we may want to do the opposite!
+        // leave strings and buffers as-is
+        // anything is only allowed if in object mode, so throw
+        if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+            if (isArrayBufferView(chunk)) {
+                //@ts-ignore - sinful unsafe type changing
+                chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            }
+            else if (isArrayBufferLike(chunk)) {
+                //@ts-ignore - sinful unsafe type changing
+                chunk = Buffer.from(chunk);
+            }
+            else if (typeof chunk !== 'string') {
+                throw new Error('Non-contiguous data written to non-objectMode stream');
+            }
+        }
+        // handle object mode up front, since it's simpler
+        // this yields better performance, fewer checks later.
+        if (this[OBJECTMODE]) {
+            // maybe impossible?
+            /* c8 ignore start */
+            if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
+                this[FLUSH](true);
+            /* c8 ignore stop */
+            if (this[FLOWING])
+                this.emit('data', chunk);
+            else
+                this[BUFFERPUSH](chunk);
+            if (this[BUFFERLENGTH] !== 0)
+                this.emit('readable');
+            if (cb)
+                fn(cb);
+            return this[FLOWING];
+        }
+        // at this point the chunk is a buffer or string
+        // don't buffer it up or send it to the decoder
+        if (!chunk.length) {
+            if (this[BUFFERLENGTH] !== 0)
+                this.emit('readable');
+            if (cb)
+                fn(cb);
+            return this[FLOWING];
+        }
+        // fast-path writing strings of same encoding to a stream with
+        // an empty buffer, skipping the buffer/decoder dance
+        if (typeof chunk === 'string' &&
+            // unless it is a string already ready for us to use
+            !(encoding === this[ENCODING$1] && !this[DECODER]?.lastNeed)) {
+            //@ts-ignore - sinful unsafe type change
+            chunk = Buffer.from(chunk, encoding);
+        }
+        if (Buffer.isBuffer(chunk) && this[ENCODING$1]) {
+            //@ts-ignore - sinful unsafe type change
+            chunk = this[DECODER].write(chunk);
+        }
+        // Note: flushing CAN potentially switch us into not-flowing mode
+        if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
+            this[FLUSH](true);
+        if (this[FLOWING])
+            this.emit('data', chunk);
+        else
+            this[BUFFERPUSH](chunk);
+        if (this[BUFFERLENGTH] !== 0)
+            this.emit('readable');
+        if (cb)
+            fn(cb);
+        return this[FLOWING];
+    }
+    /**
+     * Low-level explicit read method.
+     *
+     * In objectMode, the argument is ignored, and one item is returned if
+     * available.
+     *
+     * `n` is the number of bytes (or in the case of encoding streams,
+     * characters) to consume. If `n` is not provided, then the entire buffer
+     * is returned, or `null` is returned if no data is available.
+     *
+     * If `n` is greater that the amount of data in the internal buffer,
+     * then `null` is returned.
+     */
+    read(n) {
+        if (this[DESTROYED])
+            return null;
+        this[DISCARDED] = false;
+        if (this[BUFFERLENGTH] === 0 ||
+            n === 0 ||
+            (n && n > this[BUFFERLENGTH])) {
+            this[MAYBE_EMIT_END]();
+            return null;
+        }
+        if (this[OBJECTMODE])
+            n = null;
+        if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
+            // not object mode, so if we have an encoding, then RType is string
+            // otherwise, must be Buffer
+            this[BUFFER] = [
+                (this[ENCODING$1]
+                    ? this[BUFFER].join('')
+                    : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])),
+            ];
+        }
+        const ret = this[READ](n || null, this[BUFFER][0]);
+        this[MAYBE_EMIT_END]();
+        return ret;
+    }
+    [READ](n, chunk) {
+        if (this[OBJECTMODE])
+            this[BUFFERSHIFT]();
+        else {
+            const c = chunk;
+            if (n === c.length || n === null)
+                this[BUFFERSHIFT]();
+            else if (typeof c === 'string') {
+                this[BUFFER][0] = c.slice(n);
+                chunk = c.slice(0, n);
+                this[BUFFERLENGTH] -= n;
+            }
+            else {
+                this[BUFFER][0] = c.subarray(n);
+                chunk = c.subarray(0, n);
+                this[BUFFERLENGTH] -= n;
+            }
+        }
+        this.emit('data', chunk);
+        if (!this[BUFFER].length && !this[EOF])
+            this.emit('drain');
+        return chunk;
+    }
+    end(chunk, encoding, cb) {
+        if (typeof chunk === 'function') {
+            cb = chunk;
+            chunk = undefined;
+        }
+        if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = 'utf8';
+        }
+        if (chunk !== undefined)
+            this.write(chunk, encoding);
+        if (cb)
+            this.once('end', cb);
+        this[EOF] = true;
+        this.writable = false;
+        // if we haven't written anything, then go ahead and emit,
+        // even if we're not reading.
+        // we'll re-emit if a new 'end' listener is added anyway.
+        // This makes MP more suitable to write-only use cases.
+        if (this[FLOWING] || !this[PAUSED])
+            this[MAYBE_EMIT_END]();
+        return this;
+    }
+    // don't let the internal resume be overwritten
+    [RESUME]() {
+        if (this[DESTROYED])
+            return;
+        if (!this[DATALISTENERS] && !this[PIPES].length) {
+            this[DISCARDED] = true;
+        }
+        this[PAUSED] = false;
+        this[FLOWING] = true;
+        this.emit('resume');
+        if (this[BUFFER].length)
+            this[FLUSH]();
+        else if (this[EOF])
+            this[MAYBE_EMIT_END]();
+        else
+            this.emit('drain');
+    }
+    /**
+     * Resume the stream if it is currently in a paused state
+     *
+     * If called when there are no pipe destinations or `data` event listeners,
+     * this will place the stream in a "discarded" state, where all data will
+     * be thrown away. The discarded state is removed if a pipe destination or
+     * data handler is added, if pause() is called, or if any synchronous or
+     * asynchronous iteration is started.
+     */
+    resume() {
+        return this[RESUME]();
+    }
+    /**
+     * Pause the stream
+     */
+    pause() {
+        this[FLOWING] = false;
+        this[PAUSED] = true;
+        this[DISCARDED] = false;
+    }
+    /**
+     * true if the stream has been forcibly destroyed
+     */
+    get destroyed() {
+        return this[DESTROYED];
+    }
+    /**
+     * true if the stream is currently in a flowing state, meaning that
+     * any writes will be immediately emitted.
+     */
+    get flowing() {
+        return this[FLOWING];
+    }
+    /**
+     * true if the stream is currently in a paused state
+     */
+    get paused() {
+        return this[PAUSED];
+    }
+    [BUFFERPUSH](chunk) {
+        if (this[OBJECTMODE])
+            this[BUFFERLENGTH] += 1;
+        else
+            this[BUFFERLENGTH] += chunk.length;
+        this[BUFFER].push(chunk);
+    }
+    [BUFFERSHIFT]() {
+        if (this[OBJECTMODE])
+            this[BUFFERLENGTH] -= 1;
+        else
+            this[BUFFERLENGTH] -= this[BUFFER][0].length;
+        return this[BUFFER].shift();
+    }
+    [FLUSH](noDrain = false) {
+        do { } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) &&
+            this[BUFFER].length);
+        if (!noDrain && !this[BUFFER].length && !this[EOF])
+            this.emit('drain');
+    }
+    [FLUSHCHUNK](chunk) {
+        this.emit('data', chunk);
+        return this[FLOWING];
+    }
+    /**
+     * Pipe all data emitted by this stream into the destination provided.
+     *
+     * Triggers the flow of data.
+     */
+    pipe(dest, opts) {
+        if (this[DESTROYED])
+            return dest;
+        this[DISCARDED] = false;
+        const ended = this[EMITTED_END];
+        opts = opts || {};
+        if (dest === proc.stdout || dest === proc.stderr)
+            opts.end = false;
+        else
+            opts.end = opts.end !== false;
+        opts.proxyErrors = !!opts.proxyErrors;
+        // piping an ended stream ends immediately
+        if (ended) {
+            if (opts.end)
+                dest.end();
+        }
+        else {
+            // "as" here just ignores the WType, which pipes don't care about,
+            // since they're only consuming from us, and writing to the dest
+            this[PIPES].push(!opts.proxyErrors
+                ? new Pipe(this, dest, opts)
+                : new PipeProxyErrors(this, dest, opts));
+            if (this[ASYNC])
+                defer$3(() => this[RESUME]());
+            else
+                this[RESUME]();
+        }
+        return dest;
+    }
+    /**
+     * Fully unhook a piped destination stream.
+     *
+     * If the destination stream was the only consumer of this stream (ie,
+     * there are no other piped destinations or `'data'` event listeners)
+     * then the flow of data will stop until there is another consumer or
+     * {@link Minipass#resume} is explicitly called.
+     */
+    unpipe(dest) {
+        const p = this[PIPES].find(p => p.dest === dest);
+        if (p) {
+            if (this[PIPES].length === 1) {
+                if (this[FLOWING] && this[DATALISTENERS] === 0) {
+                    this[FLOWING] = false;
+                }
+                this[PIPES] = [];
+            }
+            else
+                this[PIPES].splice(this[PIPES].indexOf(p), 1);
+            p.unpipe();
+        }
+    }
+    /**
+     * Alias for {@link Minipass#on}
+     */
+    addListener(ev, handler) {
+        return this.on(ev, handler);
+    }
+    /**
+     * Mostly identical to `EventEmitter.on`, with the following
+     * behavior differences to prevent data loss and unnecessary hangs:
+     *
+     * - Adding a 'data' event handler will trigger the flow of data
+     *
+     * - Adding a 'readable' event handler when there is data waiting to be read
+     *   will cause 'readable' to be emitted immediately.
+     *
+     * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+     *   already passed will cause the event to be emitted immediately and all
+     *   handlers removed.
+     *
+     * - Adding an 'error' event handler after an error has been emitted will
+     *   cause the event to be re-emitted immediately with the error previously
+     *   raised.
+     */
+    on(ev, handler) {
+        const ret = super.on(ev, handler);
+        if (ev === 'data') {
+            this[DISCARDED] = false;
+            this[DATALISTENERS]++;
+            if (!this[PIPES].length && !this[FLOWING]) {
+                this[RESUME]();
+            }
+        }
+        else if (ev === 'readable' && this[BUFFERLENGTH] !== 0) {
+            super.emit('readable');
+        }
+        else if (isEndish(ev) && this[EMITTED_END]) {
+            super.emit(ev);
+            this.removeAllListeners(ev);
+        }
+        else if (ev === 'error' && this[EMITTED_ERROR]) {
+            const h = handler;
+            if (this[ASYNC])
+                defer$3(() => h.call(this, this[EMITTED_ERROR]));
+            else
+                h.call(this, this[EMITTED_ERROR]);
+        }
+        return ret;
+    }
+    /**
+     * Alias for {@link Minipass#off}
+     */
+    removeListener(ev, handler) {
+        return this.off(ev, handler);
+    }
+    /**
+     * Mostly identical to `EventEmitter.off`
+     *
+     * If a 'data' event handler is removed, and it was the last consumer
+     * (ie, there are no pipe destinations or other 'data' event listeners),
+     * then the flow of data will stop until there is another consumer or
+     * {@link Minipass#resume} is explicitly called.
+     */
+    off(ev, handler) {
+        const ret = super.off(ev, handler);
+        // if we previously had listeners, and now we don't, and we don't
+        // have any pipes, then stop the flow, unless it's been explicitly
+        // put in a discarded flowing state via stream.resume().
+        if (ev === 'data') {
+            this[DATALISTENERS] = this.listeners('data').length;
+            if (this[DATALISTENERS] === 0 &&
+                !this[DISCARDED] &&
+                !this[PIPES].length) {
+                this[FLOWING] = false;
+            }
+        }
+        return ret;
+    }
+    /**
+     * Mostly identical to `EventEmitter.removeAllListeners`
+     *
+     * If all 'data' event handlers are removed, and they were the last consumer
+     * (ie, there are no pipe destinations), then the flow of data will stop
+     * until there is another consumer or {@link Minipass#resume} is explicitly
+     * called.
+     */
+    removeAllListeners(ev) {
+        const ret = super.removeAllListeners(ev);
+        if (ev === 'data' || ev === undefined) {
+            this[DATALISTENERS] = 0;
+            if (!this[DISCARDED] && !this[PIPES].length) {
+                this[FLOWING] = false;
+            }
+        }
+        return ret;
+    }
+    /**
+     * true if the 'end' event has been emitted
+     */
+    get emittedEnd() {
+        return this[EMITTED_END];
+    }
+    [MAYBE_EMIT_END]() {
+        if (!this[EMITTING_END] &&
+            !this[EMITTED_END] &&
+            !this[DESTROYED] &&
+            this[BUFFER].length === 0 &&
+            this[EOF]) {
+            this[EMITTING_END] = true;
+            this.emit('end');
+            this.emit('prefinish');
+            this.emit('finish');
+            if (this[CLOSED$1])
+                this.emit('close');
+            this[EMITTING_END] = false;
+        }
+    }
+    /**
+     * Mostly identical to `EventEmitter.emit`, with the following
+     * behavior differences to prevent data loss and unnecessary hangs:
+     *
+     * If the stream has been destroyed, and the event is something other
+     * than 'close' or 'error', then `false` is returned and no handlers
+     * are called.
+     *
+     * If the event is 'end', and has already been emitted, then the event
+     * is ignored. If the stream is in a paused or non-flowing state, then
+     * the event will be deferred until data flow resumes. If the stream is
+     * async, then handlers will be called on the next tick rather than
+     * immediately.
+     *
+     * If the event is 'close', and 'end' has not yet been emitted, then
+     * the event will be deferred until after 'end' is emitted.
+     *
+     * If the event is 'error', and an AbortSignal was provided for the stream,
+     * and there are no listeners, then the event is ignored, matching the
+     * behavior of node core streams in the presense of an AbortSignal.
+     *
+     * If the event is 'finish' or 'prefinish', then all listeners will be
+     * removed after emitting the event, to prevent double-firing.
+     */
+    emit(ev, ...args) {
+        const data = args[0];
+        // error and close are only events allowed after calling destroy()
+        if (ev !== 'error' &&
+            ev !== 'close' &&
+            ev !== DESTROYED &&
+            this[DESTROYED]) {
+            return false;
+        }
+        else if (ev === 'data') {
+            return !this[OBJECTMODE] && !data
+                ? false
+                : this[ASYNC]
+                    ? (defer$3(() => this[EMITDATA](data)), true)
+                    : this[EMITDATA](data);
+        }
+        else if (ev === 'end') {
+            return this[EMITEND]();
+        }
+        else if (ev === 'close') {
+            this[CLOSED$1] = true;
+            // don't emit close before 'end' and 'finish'
+            if (!this[EMITTED_END] && !this[DESTROYED])
+                return false;
+            const ret = super.emit('close');
+            this.removeAllListeners('close');
+            return ret;
+        }
+        else if (ev === 'error') {
+            this[EMITTED_ERROR] = data;
+            super.emit(ERROR, data);
+            const ret = !this[SIGNAL] || this.listeners('error').length
+                ? super.emit('error', data)
+                : false;
+            this[MAYBE_EMIT_END]();
+            return ret;
+        }
+        else if (ev === 'resume') {
+            const ret = super.emit('resume');
+            this[MAYBE_EMIT_END]();
+            return ret;
+        }
+        else if (ev === 'finish' || ev === 'prefinish') {
+            const ret = super.emit(ev);
+            this.removeAllListeners(ev);
+            return ret;
+        }
+        // Some other unknown event
+        const ret = super.emit(ev, ...args);
+        this[MAYBE_EMIT_END]();
+        return ret;
+    }
+    [EMITDATA](data) {
+        for (const p of this[PIPES]) {
+            if (p.dest.write(data) === false)
+                this.pause();
+        }
+        const ret = this[DISCARDED] ? false : super.emit('data', data);
+        this[MAYBE_EMIT_END]();
+        return ret;
+    }
+    [EMITEND]() {
+        if (this[EMITTED_END])
+            return false;
+        this[EMITTED_END] = true;
+        this.readable = false;
+        return this[ASYNC]
+            ? (defer$3(() => this[EMITEND2]()), true)
+            : this[EMITEND2]();
+    }
+    [EMITEND2]() {
+        if (this[DECODER]) {
+            const data = this[DECODER].end();
+            if (data) {
+                for (const p of this[PIPES]) {
+                    p.dest.write(data);
+                }
+                if (!this[DISCARDED])
+                    super.emit('data', data);
+            }
+        }
+        for (const p of this[PIPES]) {
+            p.end();
+        }
+        const ret = super.emit('end');
+        this.removeAllListeners('end');
+        return ret;
+    }
+    /**
+     * Return a Promise that resolves to an array of all emitted data once
+     * the stream ends.
+     */
+    async collect() {
+        const buf = Object.assign([], {
+            dataLength: 0,
+        });
+        if (!this[OBJECTMODE])
+            buf.dataLength = 0;
+        // set the promise first, in case an error is raised
+        // by triggering the flow here.
+        const p = this.promise();
+        this.on('data', c => {
+            buf.push(c);
+            if (!this[OBJECTMODE])
+                buf.dataLength += c.length;
+        });
+        await p;
+        return buf;
+    }
+    /**
+     * Return a Promise that resolves to the concatenation of all emitted data
+     * once the stream ends.
+     *
+     * Not allowed on objectMode streams.
+     */
+    async concat() {
+        if (this[OBJECTMODE]) {
+            throw new Error('cannot concat in objectMode');
+        }
+        const buf = await this.collect();
+        return (this[ENCODING$1]
+            ? buf.join('')
+            : Buffer.concat(buf, buf.dataLength));
+    }
+    /**
+     * Return a void Promise that resolves once the stream ends.
+     */
+    async promise() {
+        return new Promise((resolve, reject) => {
+            this.on(DESTROYED, () => reject(new Error('stream destroyed')));
+            this.on('error', er => reject(er));
+            this.on('end', () => resolve());
+        });
+    }
+    /**
+     * Asynchronous `for await of` iteration.
+     *
+     * This will continue emitting all chunks until the stream terminates.
+     */
+    [Symbol.asyncIterator]() {
+        // set this up front, in case the consumer doesn't call next()
+        // right away.
+        this[DISCARDED] = false;
+        let stopped = false;
+        const stop = async () => {
+            this.pause();
+            stopped = true;
+            return { value: undefined, done: true };
+        };
+        const next = () => {
+            if (stopped)
+                return stop();
+            const res = this.read();
+            if (res !== null)
+                return Promise.resolve({ done: false, value: res });
+            if (this[EOF])
+                return stop();
+            let resolve;
+            let reject;
+            const onerr = (er) => {
+                this.off('data', ondata);
+                this.off('end', onend);
+                this.off(DESTROYED, ondestroy);
+                stop();
+                reject(er);
+            };
+            const ondata = (value) => {
+                this.off('error', onerr);
+                this.off('end', onend);
+                this.off(DESTROYED, ondestroy);
+                this.pause();
+                resolve({ value, done: !!this[EOF] });
+            };
+            const onend = () => {
+                this.off('error', onerr);
+                this.off('data', ondata);
+                this.off(DESTROYED, ondestroy);
+                stop();
+                resolve({ done: true, value: undefined });
+            };
+            const ondestroy = () => onerr(new Error('stream destroyed'));
+            return new Promise((res, rej) => {
+                reject = rej;
+                resolve = res;
+                this.once(DESTROYED, ondestroy);
+                this.once('error', onerr);
+                this.once('end', onend);
+                this.once('data', ondata);
+            });
+        };
+        return {
+            next,
+            throw: stop,
+            return: stop,
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+    /**
+     * Synchronous `for of` iteration.
+     *
+     * The iteration will terminate when the internal buffer runs out, even
+     * if the stream has not yet terminated.
+     */
+    [Symbol.iterator]() {
+        // set this up front, in case the consumer doesn't call next()
+        // right away.
+        this[DISCARDED] = false;
+        let stopped = false;
+        const stop = () => {
+            this.pause();
+            this.off(ERROR, stop);
+            this.off(DESTROYED, stop);
+            this.off('end', stop);
+            stopped = true;
+            return { done: true, value: undefined };
+        };
+        const next = () => {
+            if (stopped)
+                return stop();
+            const value = this.read();
+            return value === null ? stop() : { done: false, value };
+        };
+        this.once('end', stop);
+        this.once(ERROR, stop);
+        this.once(DESTROYED, stop);
+        return {
+            next,
+            throw: stop,
+            return: stop,
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+    }
+    /**
+     * Destroy a stream, preventing it from being used for any further purpose.
+     *
+     * If the stream has a `close()` method, then it will be called on
+     * destruction.
+     *
+     * After destruction, any attempt to write data, read data, or emit most
+     * events will be ignored.
+     *
+     * If an error argument is provided, then it will be emitted in an
+     * 'error' event.
+     */
+    destroy(er) {
+        if (this[DESTROYED]) {
+            if (er)
+                this.emit('error', er);
+            else
+                this.emit(DESTROYED);
+            return this;
+        }
+        this[DESTROYED] = true;
+        this[DISCARDED] = true;
+        // throw away all buffered data, it's never coming out
+        this[BUFFER].length = 0;
+        this[BUFFERLENGTH] = 0;
+        const wc = this;
+        if (typeof wc.close === 'function' && !this[CLOSED$1])
+            wc.close();
+        if (er)
+            this.emit('error', er);
+        // if no error to emit, still reject pending promises
+        else
+            this.emit(DESTROYED);
+        return this;
+    }
+    /**
+     * Alias for {@link isStream}
+     *
+     * Former export location, maintained for backwards compatibility.
+     *
+     * @deprecated
+     */
+    static get isStream() {
+        return isStream;
+    }
+}
+
+const realpathSync = realpathSync$1.native;
+const defaultFS = {
+    lstatSync,
+    readdir: readdir$4,
+    readdirSync,
+    readlinkSync,
+    realpathSync,
+    promises: {
+        lstat: lstat$3,
+        readdir: readdir$5,
+        readlink,
+        realpath: realpath$2,
+    },
+};
+// if they just gave us require('fs') then use our default
+const fsFromOption = (fsOption) => !fsOption || fsOption === defaultFS || fsOption === fs$j ?
+    defaultFS
+    : {
+        ...defaultFS,
+        ...fsOption,
+        promises: {
+            ...defaultFS.promises,
+            ...(fsOption.promises || {}),
+        },
+    };
+// turn something like //?/c:/ into c:\
+const uncDriveRegexp = /^\\\\\?\\([a-z]:)\\?$/i;
+const uncToDrive = (rootPath) => rootPath.replace(/\//g, '\\').replace(uncDriveRegexp, '$1\\');
+// windows paths are separated by either / or \
+const eitherSep = /[\\\/]/;
+const UNKNOWN = 0; // may not even exist, for all we know
+const IFIFO = 0b0001;
+const IFCHR = 0b0010;
+const IFDIR = 0b0100;
+const IFBLK = 0b0110;
+const IFREG = 0b1000;
+const IFLNK = 0b1010;
+const IFSOCK = 0b1100;
+const IFMT = 0b1111;
+// mask to unset low 4 bits
+const IFMT_UNKNOWN = ~IFMT;
+// set after successfully calling readdir() and getting entries.
+const READDIR_CALLED = 0b0000_0001_0000;
+// set after a successful lstat()
+const LSTAT_CALLED = 0b0000_0010_0000;
+// set if an entry (or one of its parents) is definitely not a dir
+const ENOTDIR = 0b0000_0100_0000;
+// set if an entry (or one of its parents) does not exist
+// (can also be set on lstat errors like EACCES or ENAMETOOLONG)
+const ENOENT = 0b0000_1000_0000;
+// cannot have child entries -- also verify &IFMT is either IFDIR or IFLNK
+// set if we fail to readlink
+const ENOREADLINK = 0b0001_0000_0000;
+// set if we know realpath() will fail
+const ENOREALPATH = 0b0010_0000_0000;
+const ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
+const TYPEMASK = 0b0011_1111_1111;
+const entToType = (s) => s.isFile() ? IFREG
+    : s.isDirectory() ? IFDIR
+        : s.isSymbolicLink() ? IFLNK
+            : s.isCharacterDevice() ? IFCHR
+                : s.isBlockDevice() ? IFBLK
+                    : s.isSocket() ? IFSOCK
+                        : s.isFIFO() ? IFIFO
+                            : UNKNOWN;
+// normalize unicode path names
+const normalizeCache = new Map();
+const normalize = (s) => {
+    const c = normalizeCache.get(s);
+    if (c)
+        return c;
+    const n = s.normalize('NFKD');
+    normalizeCache.set(s, n);
+    return n;
+};
+const normalizeNocaseCache = new Map();
+const normalizeNocase = (s) => {
+    const c = normalizeNocaseCache.get(s);
+    if (c)
+        return c;
+    const n = normalize(s.toLowerCase());
+    normalizeNocaseCache.set(s, n);
+    return n;
+};
+/**
+ * An LRUCache for storing resolved path strings or Path objects.
+ * @internal
+ */
+class ResolveCache extends LRUCache {
+    constructor() {
+        super({ max: 256 });
+    }
+}
+// In order to prevent blowing out the js heap by allocating hundreds of
+// thousands of Path entries when walking extremely large trees, the "children"
+// in this tree are represented by storing an array of Path entries in an
+// LRUCache, indexed by the parent.  At any time, Path.children() may return an
+// empty array, indicating that it doesn't know about any of its children, and
+// thus has to rebuild that cache.  This is fine, it just means that we don't
+// benefit as much from having the cached entries, but huge directory walks
+// don't blow out the stack, and smaller ones are still as fast as possible.
+//
+//It does impose some complexity when building up the readdir data, because we
+//need to pass a reference to the children array that we started with.
+/**
+ * an LRUCache for storing child entries.
+ * @internal
+ */
+class ChildrenCache extends LRUCache {
+    constructor(maxSize = 16 * 1024) {
+        super({
+            maxSize,
+            // parent + children
+            sizeCalculation: a => a.length + 1,
+        });
+    }
+}
+const setAsCwd = Symbol('PathScurry setAsCwd');
+/**
+ * Path objects are sort of like a super-powered
+ * {@link https://nodejs.org/docs/latest/api/fs.html#class-fsdirent fs.Dirent}
+ *
+ * Each one represents a single filesystem entry on disk, which may or may not
+ * exist. It includes methods for reading various types of information via
+ * lstat, readlink, and readdir, and caches all information to the greatest
+ * degree possible.
+ *
+ * Note that fs operations that would normally throw will instead return an
+ * "empty" value. This is in order to prevent excessive overhead from error
+ * stack traces.
+ */
+class PathBase {
+    /**
+     * the basename of this path
+     *
+     * **Important**: *always* test the path name against any test string
+     * usingthe {@link isNamed} method, and not by directly comparing this
+     * string. Otherwise, unicode path strings that the system sees as identical
+     * will not be properly treated as the same path, leading to incorrect
+     * behavior and possible security issues.
+     */
+    name;
+    /**
+     * the Path entry corresponding to the path root.
+     *
+     * @internal
+     */
+    root;
+    /**
+     * All roots found within the current PathScurry family
+     *
+     * @internal
+     */
+    roots;
+    /**
+     * a reference to the parent path, or undefined in the case of root entries
+     *
+     * @internal
+     */
+    parent;
+    /**
+     * boolean indicating whether paths are compared case-insensitively
+     * @internal
+     */
+    nocase;
+    /**
+     * boolean indicating that this path is the current working directory
+     * of the PathScurry collection that contains it.
+     */
+    isCWD = false;
+    // potential default fs override
+    #fs;
+    // Stats fields
+    #dev;
+    get dev() {
+        return this.#dev;
+    }
+    #mode;
+    get mode() {
+        return this.#mode;
+    }
+    #nlink;
+    get nlink() {
+        return this.#nlink;
+    }
+    #uid;
+    get uid() {
+        return this.#uid;
+    }
+    #gid;
+    get gid() {
+        return this.#gid;
+    }
+    #rdev;
+    get rdev() {
+        return this.#rdev;
+    }
+    #blksize;
+    get blksize() {
+        return this.#blksize;
+    }
+    #ino;
+    get ino() {
+        return this.#ino;
+    }
+    #size;
+    get size() {
+        return this.#size;
+    }
+    #blocks;
+    get blocks() {
+        return this.#blocks;
+    }
+    #atimeMs;
+    get atimeMs() {
+        return this.#atimeMs;
+    }
+    #mtimeMs;
+    get mtimeMs() {
+        return this.#mtimeMs;
+    }
+    #ctimeMs;
+    get ctimeMs() {
+        return this.#ctimeMs;
+    }
+    #birthtimeMs;
+    get birthtimeMs() {
+        return this.#birthtimeMs;
+    }
+    #atime;
+    get atime() {
+        return this.#atime;
+    }
+    #mtime;
+    get mtime() {
+        return this.#mtime;
+    }
+    #ctime;
+    get ctime() {
+        return this.#ctime;
+    }
+    #birthtime;
+    get birthtime() {
+        return this.#birthtime;
+    }
+    #matchName;
+    #depth;
+    #fullpath;
+    #fullpathPosix;
+    #relative;
+    #relativePosix;
+    #type;
+    #children;
+    #linkTarget;
+    #realpath;
+    /**
+     * This property is for compatibility with the Dirent class as of
+     * Node v20, where Dirent['parentPath'] refers to the path of the
+     * directory that was passed to readdir. For root entries, it's the path
+     * to the entry itself.
+     */
+    get parentPath() {
+        return (this.parent || this).fullpath();
+    }
+    /**
+     * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
+     * this property refers to the *parent* path, not the path object itself.
+     */
+    get path() {
+        return this.parentPath;
+    }
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+        this.name = name;
+        this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
+        this.#type = type & TYPEMASK;
+        this.nocase = nocase;
+        this.roots = roots;
+        this.root = root || this;
+        this.#children = children;
+        this.#fullpath = opts.fullpath;
+        this.#relative = opts.relative;
+        this.#relativePosix = opts.relativePosix;
+        this.parent = opts.parent;
+        if (this.parent) {
+            this.#fs = this.parent.#fs;
+        }
+        else {
+            this.#fs = fsFromOption(opts.fs);
+        }
+    }
+    /**
+     * Returns the depth of the Path object from its root.
+     *
+     * For example, a path at `/foo/bar` would have a depth of 2.
+     */
+    depth() {
+        if (this.#depth !== undefined)
+            return this.#depth;
+        if (!this.parent)
+            return (this.#depth = 0);
+        return (this.#depth = this.parent.depth() + 1);
+    }
+    /**
+     * @internal
+     */
+    childrenCache() {
+        return this.#children;
+    }
+    /**
+     * Get the Path object referenced by the string path, resolved from this Path
+     */
+    resolve(path) {
+        if (!path) {
+            return this;
+        }
+        const rootPath = this.getRootString(path);
+        const dir = path.substring(rootPath.length);
+        const dirParts = dir.split(this.splitSep);
+        const result = rootPath ?
+            this.getRoot(rootPath).#resolveParts(dirParts)
+            : this.#resolveParts(dirParts);
+        return result;
+    }
+    #resolveParts(dirParts) {
+        let p = this;
+        for (const part of dirParts) {
+            p = p.child(part);
+        }
+        return p;
+    }
+    /**
+     * Returns the cached children Path objects, if still available.  If they
+     * have fallen out of the cache, then returns an empty array, and resets the
+     * READDIR_CALLED bit, so that future calls to readdir() will require an fs
+     * lookup.
+     *
+     * @internal
+     */
+    children() {
+        const cached = this.#children.get(this);
+        if (cached) {
+            return cached;
+        }
+        const children = Object.assign([], { provisional: 0 });
+        this.#children.set(this, children);
+        this.#type &= ~READDIR_CALLED;
+        return children;
+    }
+    /**
+     * Resolves a path portion and returns or creates the child Path.
+     *
+     * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is
+     * `'..'`.
+     *
+     * This should not be called directly.  If `pathPart` contains any path
+     * separators, it will lead to unsafe undefined behavior.
+     *
+     * Use `Path.resolve()` instead.
+     *
+     * @internal
+     */
+    child(pathPart, opts) {
+        if (pathPart === '' || pathPart === '.') {
+            return this;
+        }
+        if (pathPart === '..') {
+            return this.parent || this;
+        }
+        // find the child
+        const children = this.children();
+        const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
+        for (const p of children) {
+            if (p.#matchName === name) {
+                return p;
+            }
+        }
+        // didn't find it, create provisional child, since it might not
+        // actually exist.  If we know the parent isn't a dir, then
+        // in fact it CAN'T exist.
+        const s = this.parent ? this.sep : '';
+        const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : undefined;
+        const pchild = this.newChild(pathPart, UNKNOWN, {
+            ...opts,
+            parent: this,
+            fullpath,
+        });
+        if (!this.canReaddir()) {
+            pchild.#type |= ENOENT;
+        }
+        // don't have to update provisional, because if we have real children,
+        // then provisional is set to children.length, otherwise a lower number
+        children.push(pchild);
+        return pchild;
+    }
+    /**
+     * The relative path from the cwd. If it does not share an ancestor with
+     * the cwd, then this ends up being equivalent to the fullpath()
+     */
+    relative() {
+        if (this.isCWD)
+            return '';
+        if (this.#relative !== undefined) {
+            return this.#relative;
+        }
+        const name = this.name;
+        const p = this.parent;
+        if (!p) {
+            return (this.#relative = this.name);
+        }
+        const pv = p.relative();
+        return pv + (!pv || !p.parent ? '' : this.sep) + name;
+    }
+    /**
+     * The relative path from the cwd, using / as the path separator.
+     * If it does not share an ancestor with
+     * the cwd, then this ends up being equivalent to the fullpathPosix()
+     * On posix systems, this is identical to relative().
+     */
+    relativePosix() {
+        if (this.sep === '/')
+            return this.relative();
+        if (this.isCWD)
+            return '';
+        if (this.#relativePosix !== undefined)
+            return this.#relativePosix;
+        const name = this.name;
+        const p = this.parent;
+        if (!p) {
+            return (this.#relativePosix = this.fullpathPosix());
+        }
+        const pv = p.relativePosix();
+        return pv + (!pv || !p.parent ? '' : '/') + name;
+    }
+    /**
+     * The fully resolved path string for this Path entry
+     */
+    fullpath() {
+        if (this.#fullpath !== undefined) {
+            return this.#fullpath;
+        }
+        const name = this.name;
+        const p = this.parent;
+        if (!p) {
+            return (this.#fullpath = this.name);
+        }
+        const pv = p.fullpath();
+        const fp = pv + (!p.parent ? '' : this.sep) + name;
+        return (this.#fullpath = fp);
+    }
+    /**
+     * On platforms other than windows, this is identical to fullpath.
+     *
+     * On windows, this is overridden to return the forward-slash form of the
+     * full UNC path.
+     */
+    fullpathPosix() {
+        if (this.#fullpathPosix !== undefined)
+            return this.#fullpathPosix;
+        if (this.sep === '/')
+            return (this.#fullpathPosix = this.fullpath());
+        if (!this.parent) {
+            const p = this.fullpath().replace(/\\/g, '/');
+            if (/^[a-z]:\//i.test(p)) {
+                return (this.#fullpathPosix = `//?/${p}`);
+            }
+            else {
+                return (this.#fullpathPosix = p);
+            }
+        }
+        const p = this.parent;
+        const pfpp = p.fullpathPosix();
+        const fpp = pfpp + (!pfpp || !p.parent ? '' : '/') + this.name;
+        return (this.#fullpathPosix = fpp);
+    }
+    /**
+     * Is the Path of an unknown type?
+     *
+     * Note that we might know *something* about it if there has been a previous
+     * filesystem operation, for example that it does not exist, or is not a
+     * link, or whether it has child entries.
+     */
+    isUnknown() {
+        return (this.#type & IFMT) === UNKNOWN;
+    }
+    isType(type) {
+        return this[`is${type}`]();
+    }
+    getType() {
+        return (this.isUnknown() ? 'Unknown'
+            : this.isDirectory() ? 'Directory'
+                : this.isFile() ? 'File'
+                    : this.isSymbolicLink() ? 'SymbolicLink'
+                        : this.isFIFO() ? 'FIFO'
+                            : this.isCharacterDevice() ? 'CharacterDevice'
+                                : this.isBlockDevice() ? 'BlockDevice'
+                                    : /* c8 ignore start */ this.isSocket() ? 'Socket'
+                                        : 'Unknown');
+        /* c8 ignore stop */
+    }
+    /**
+     * Is the Path a regular file?
+     */
+    isFile() {
+        return (this.#type & IFMT) === IFREG;
+    }
+    /**
+     * Is the Path a directory?
+     */
+    isDirectory() {
+        return (this.#type & IFMT) === IFDIR;
+    }
+    /**
+     * Is the path a character device?
+     */
+    isCharacterDevice() {
+        return (this.#type & IFMT) === IFCHR;
+    }
+    /**
+     * Is the path a block device?
+     */
+    isBlockDevice() {
+        return (this.#type & IFMT) === IFBLK;
+    }
+    /**
+     * Is the path a FIFO pipe?
+     */
+    isFIFO() {
+        return (this.#type & IFMT) === IFIFO;
+    }
+    /**
+     * Is the path a socket?
+     */
+    isSocket() {
+        return (this.#type & IFMT) === IFSOCK;
+    }
+    /**
+     * Is the path a symbolic link?
+     */
+    isSymbolicLink() {
+        return (this.#type & IFLNK) === IFLNK;
+    }
+    /**
+     * Return the entry if it has been subject of a successful lstat, or
+     * undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* simply
+     * mean that we haven't called lstat on it.
+     */
+    lstatCached() {
+        return this.#type & LSTAT_CALLED ? this : undefined;
+    }
+    /**
+     * Return the cached link target if the entry has been the subject of a
+     * successful readlink, or undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * readlink() has been called at some point.
+     */
+    readlinkCached() {
+        return this.#linkTarget;
+    }
+    /**
+     * Returns the cached realpath target if the entry has been the subject
+     * of a successful realpath, or undefined otherwise.
+     *
+     * Does not read the filesystem, so an undefined result *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * realpath() has been called at some point.
+     */
+    realpathCached() {
+        return this.#realpath;
+    }
+    /**
+     * Returns the cached child Path entries array if the entry has been the
+     * subject of a successful readdir(), or [] otherwise.
+     *
+     * Does not read the filesystem, so an empty array *could* just mean we
+     * don't have any cached data. Only use it if you are very sure that a
+     * readdir() has been called recently enough to still be valid.
+     */
+    readdirCached() {
+        const children = this.children();
+        return children.slice(0, children.provisional);
+    }
+    /**
+     * Return true if it's worth trying to readlink.  Ie, we don't (yet) have
+     * any indication that readlink will definitely fail.
+     *
+     * Returns false if the path is known to not be a symlink, if a previous
+     * readlink failed, or if the entry does not exist.
+     */
+    canReadlink() {
+        if (this.#linkTarget)
+            return true;
+        if (!this.parent)
+            return false;
+        // cases where it cannot possibly succeed
+        const ifmt = this.#type & IFMT;
+        return !((ifmt !== UNKNOWN && ifmt !== IFLNK) ||
+            this.#type & ENOREADLINK ||
+            this.#type & ENOENT);
+    }
+    /**
+     * Return true if readdir has previously been successfully called on this
+     * path, indicating that cachedReaddir() is likely valid.
+     */
+    calledReaddir() {
+        return !!(this.#type & READDIR_CALLED);
+    }
+    /**
+     * Returns true if the path is known to not exist. That is, a previous lstat
+     * or readdir failed to verify its existence when that would have been
+     * expected, or a parent entry was marked either enoent or enotdir.
+     */
+    isENOENT() {
+        return !!(this.#type & ENOENT);
+    }
+    /**
+     * Return true if the path is a match for the given path name.  This handles
+     * case sensitivity and unicode normalization.
+     *
+     * Note: even on case-sensitive systems, it is **not** safe to test the
+     * equality of the `.name` property to determine whether a given pathname
+     * matches, due to unicode normalization mismatches.
+     *
+     * Always use this method instead of testing the `path.name` property
+     * directly.
+     */
+    isNamed(n) {
+        return !this.nocase ?
+            this.#matchName === normalize(n)
+            : this.#matchName === normalizeNocase(n);
+    }
+    /**
+     * Return the Path object corresponding to the target of a symbolic link.
+     *
+     * If the Path is not a symbolic link, or if the readlink call fails for any
+     * reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     */
+    async readlink() {
+        const target = this.#linkTarget;
+        if (target) {
+            return target;
+        }
+        if (!this.canReadlink()) {
+            return undefined;
+        }
+        /* c8 ignore start */
+        // already covered by the canReadlink test, here for ts grumples
+        if (!this.parent) {
+            return undefined;
+        }
+        /* c8 ignore stop */
+        try {
+            const read = await this.#fs.promises.readlink(this.fullpath());
+            const linkTarget = (await this.parent.realpath())?.resolve(read);
+            if (linkTarget) {
+                return (this.#linkTarget = linkTarget);
+            }
+        }
+        catch (er) {
+            this.#readlinkFail(er.code);
+            return undefined;
+        }
+    }
+    /**
+     * Synchronous {@link PathBase.readlink}
+     */
+    readlinkSync() {
+        const target = this.#linkTarget;
+        if (target) {
+            return target;
+        }
+        if (!this.canReadlink()) {
+            return undefined;
+        }
+        /* c8 ignore start */
+        // already covered by the canReadlink test, here for ts grumples
+        if (!this.parent) {
+            return undefined;
+        }
+        /* c8 ignore stop */
+        try {
+            const read = this.#fs.readlinkSync(this.fullpath());
+            const linkTarget = this.parent.realpathSync()?.resolve(read);
+            if (linkTarget) {
+                return (this.#linkTarget = linkTarget);
+            }
+        }
+        catch (er) {
+            this.#readlinkFail(er.code);
+            return undefined;
+        }
+    }
+    #readdirSuccess(children) {
+        // succeeded, mark readdir called bit
+        this.#type |= READDIR_CALLED;
+        // mark all remaining provisional children as ENOENT
+        for (let p = children.provisional; p < children.length; p++) {
+            const c = children[p];
+            if (c)
+                c.#markENOENT();
+        }
+    }
+    #markENOENT() {
+        // mark as UNKNOWN and ENOENT
+        if (this.#type & ENOENT)
+            return;
+        this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN;
+        this.#markChildrenENOENT();
+    }
+    #markChildrenENOENT() {
+        // all children are provisional and do not exist
+        const children = this.children();
+        children.provisional = 0;
+        for (const p of children) {
+            p.#markENOENT();
+        }
+    }
+    #markENOREALPATH() {
+        this.#type |= ENOREALPATH;
+        this.#markENOTDIR();
+    }
+    // save the information when we know the entry is not a dir
+    #markENOTDIR() {
+        // entry is not a directory, so any children can't exist.
+        // this *should* be impossible, since any children created
+        // after it's been marked ENOTDIR should be marked ENOENT,
+        // so it won't even get to this point.
+        /* c8 ignore start */
+        if (this.#type & ENOTDIR)
+            return;
+        /* c8 ignore stop */
+        let t = this.#type;
+        // this could happen if we stat a dir, then delete it,
+        // then try to read it or one of its children.
+        if ((t & IFMT) === IFDIR)
+            t &= IFMT_UNKNOWN;
+        this.#type = t | ENOTDIR;
+        this.#markChildrenENOENT();
+    }
+    #readdirFail(code = '') {
+        // markENOTDIR and markENOENT also set provisional=0
+        if (code === 'ENOTDIR' || code === 'EPERM') {
+            this.#markENOTDIR();
+        }
+        else if (code === 'ENOENT') {
+            this.#markENOENT();
+        }
+        else {
+            this.children().provisional = 0;
+        }
+    }
+    #lstatFail(code = '') {
+        // Windows just raises ENOENT in this case, disable for win CI
+        /* c8 ignore start */
+        if (code === 'ENOTDIR') {
+            // already know it has a parent by this point
+            const p = this.parent;
+            p.#markENOTDIR();
+        }
+        else if (code === 'ENOENT') {
+            /* c8 ignore stop */
+            this.#markENOENT();
+        }
+    }
+    #readlinkFail(code = '') {
+        let ter = this.#type;
+        ter |= ENOREADLINK;
+        if (code === 'ENOENT')
+            ter |= ENOENT;
+        // windows gets a weird error when you try to readlink a file
+        if (code === 'EINVAL' || code === 'UNKNOWN') {
+            // exists, but not a symlink, we don't know WHAT it is, so remove
+            // all IFMT bits.
+            ter &= IFMT_UNKNOWN;
+        }
+        this.#type = ter;
+        // windows just gets ENOENT in this case.  We do cover the case,
+        // just disabled because it's impossible on Windows CI
+        /* c8 ignore start */
+        if (code === 'ENOTDIR' && this.parent) {
+            this.parent.#markENOTDIR();
+        }
+        /* c8 ignore stop */
+    }
+    #readdirAddChild(e, c) {
+        return (this.#readdirMaybePromoteChild(e, c) ||
+            this.#readdirAddNewChild(e, c));
+    }
+    #readdirAddNewChild(e, c) {
+        // alloc new entry at head, so it's never provisional
+        const type = entToType(e);
+        const child = this.newChild(e.name, type, { parent: this });
+        const ifmt = child.#type & IFMT;
+        if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) {
+            child.#type |= ENOTDIR;
+        }
+        c.unshift(child);
+        c.provisional++;
+        return child;
+    }
+    #readdirMaybePromoteChild(e, c) {
+        for (let p = c.provisional; p < c.length; p++) {
+            const pchild = c[p];
+            const name = this.nocase ? normalizeNocase(e.name) : normalize(e.name);
+            if (name !== pchild.#matchName) {
+                continue;
+            }
+            return this.#readdirPromoteChild(e, pchild, p, c);
+        }
+    }
+    #readdirPromoteChild(e, p, index, c) {
+        const v = p.name;
+        // retain any other flags, but set ifmt from dirent
+        p.#type = (p.#type & IFMT_UNKNOWN) | entToType(e);
+        // case sensitivity fixing when we learn the true name.
+        if (v !== e.name)
+            p.name = e.name;
+        // just advance provisional index (potentially off the list),
+        // otherwise we have to splice/pop it out and re-insert at head
+        if (index !== c.provisional) {
+            if (index === c.length - 1)
+                c.pop();
+            else
+                c.splice(index, 1);
+            c.unshift(p);
+        }
+        c.provisional++;
+        return p;
+    }
+    /**
+     * Call lstat() on this Path, and update all known information that can be
+     * determined.
+     *
+     * Note that unlike `fs.lstat()`, the returned value does not contain some
+     * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+     * information is required, you will need to call `fs.lstat` yourself.
+     *
+     * If the Path refers to a nonexistent file, or if the lstat call fails for
+     * any reason, `undefined` is returned.  Otherwise the updated Path object is
+     * returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    async lstat() {
+        if ((this.#type & ENOENT) === 0) {
+            try {
+                this.#applyStat(await this.#fs.promises.lstat(this.fullpath()));
+                return this;
+            }
+            catch (er) {
+                this.#lstatFail(er.code);
+            }
+        }
+    }
+    /**
+     * synchronous {@link PathBase.lstat}
+     */
+    lstatSync() {
+        if ((this.#type & ENOENT) === 0) {
+            try {
+                this.#applyStat(this.#fs.lstatSync(this.fullpath()));
+                return this;
+            }
+            catch (er) {
+                this.#lstatFail(er.code);
+            }
+        }
+    }
+    #applyStat(st) {
+        const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs, nlink, rdev, size, uid, } = st;
+        this.#atime = atime;
+        this.#atimeMs = atimeMs;
+        this.#birthtime = birthtime;
+        this.#birthtimeMs = birthtimeMs;
+        this.#blksize = blksize;
+        this.#blocks = blocks;
+        this.#ctime = ctime;
+        this.#ctimeMs = ctimeMs;
+        this.#dev = dev;
+        this.#gid = gid;
+        this.#ino = ino;
+        this.#mode = mode;
+        this.#mtime = mtime;
+        this.#mtimeMs = mtimeMs;
+        this.#nlink = nlink;
+        this.#rdev = rdev;
+        this.#size = size;
+        this.#uid = uid;
+        const ifmt = entToType(st);
+        // retain any other flags, but set the ifmt
+        this.#type = (this.#type & IFMT_UNKNOWN) | ifmt | LSTAT_CALLED;
+        if (ifmt !== UNKNOWN && ifmt !== IFDIR && ifmt !== IFLNK) {
+            this.#type |= ENOTDIR;
+        }
+    }
+    #onReaddirCB = [];
+    #readdirCBInFlight = false;
+    #callOnReaddirCB(children) {
+        this.#readdirCBInFlight = false;
+        const cbs = this.#onReaddirCB.slice();
+        this.#onReaddirCB.length = 0;
+        cbs.forEach(cb => cb(null, children));
+    }
+    /**
+     * Standard node-style callback interface to get list of directory entries.
+     *
+     * If the Path cannot or does not contain any children, then an empty array
+     * is returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     *
+     * @param cb The callback called with (er, entries).  Note that the `er`
+     * param is somewhat extraneous, as all readdir() errors are handled and
+     * simply result in an empty set of entries being returned.
+     * @param allowZalgo Boolean indicating that immediately known results should
+     * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release
+     * zalgo at your peril, the dark pony lord is devious and unforgiving.
+     */
+    readdirCB(cb, allowZalgo = false) {
+        if (!this.canReaddir()) {
+            if (allowZalgo)
+                cb(null, []);
+            else
+                queueMicrotask(() => cb(null, []));
+            return;
+        }
+        const children = this.children();
+        if (this.calledReaddir()) {
+            const c = children.slice(0, children.provisional);
+            if (allowZalgo)
+                cb(null, c);
+            else
+                queueMicrotask(() => cb(null, c));
+            return;
+        }
+        // don't have to worry about zalgo at this point.
+        this.#onReaddirCB.push(cb);
+        if (this.#readdirCBInFlight) {
+            return;
+        }
+        this.#readdirCBInFlight = true;
+        // else read the directory, fill up children
+        // de-provisionalize any provisional children.
+        const fullpath = this.fullpath();
+        this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {
+            if (er) {
+                this.#readdirFail(er.code);
+                children.provisional = 0;
+            }
+            else {
+                // if we didn't get an error, we always get entries.
+                //@ts-ignore
+                for (const e of entries) {
+                    this.#readdirAddChild(e, children);
+                }
+                this.#readdirSuccess(children);
+            }
+            this.#callOnReaddirCB(children.slice(0, children.provisional));
+            return;
+        });
+    }
+    #asyncReaddirInFlight;
+    /**
+     * Return an array of known child entries.
+     *
+     * If the Path cannot or does not contain any children, then an empty array
+     * is returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    async readdir() {
+        if (!this.canReaddir()) {
+            return [];
+        }
+        const children = this.children();
+        if (this.calledReaddir()) {
+            return children.slice(0, children.provisional);
+        }
+        // else read the directory, fill up children
+        // de-provisionalize any provisional children.
+        const fullpath = this.fullpath();
+        if (this.#asyncReaddirInFlight) {
+            await this.#asyncReaddirInFlight;
+        }
+        else {
+            /* c8 ignore start */
+            let resolve = () => { };
+            /* c8 ignore stop */
+            this.#asyncReaddirInFlight = new Promise(res => (resolve = res));
+            try {
+                for (const e of await this.#fs.promises.readdir(fullpath, {
+                    withFileTypes: true,
+                })) {
+                    this.#readdirAddChild(e, children);
+                }
+                this.#readdirSuccess(children);
+            }
+            catch (er) {
+                this.#readdirFail(er.code);
+                children.provisional = 0;
+            }
+            this.#asyncReaddirInFlight = undefined;
+            resolve();
+        }
+        return children.slice(0, children.provisional);
+    }
+    /**
+     * synchronous {@link PathBase.readdir}
+     */
+    readdirSync() {
+        if (!this.canReaddir()) {
+            return [];
+        }
+        const children = this.children();
+        if (this.calledReaddir()) {
+            return children.slice(0, children.provisional);
+        }
+        // else read the directory, fill up children
+        // de-provisionalize any provisional children.
+        const fullpath = this.fullpath();
+        try {
+            for (const e of this.#fs.readdirSync(fullpath, {
+                withFileTypes: true,
+            })) {
+                this.#readdirAddChild(e, children);
+            }
+            this.#readdirSuccess(children);
+        }
+        catch (er) {
+            this.#readdirFail(er.code);
+            children.provisional = 0;
+        }
+        return children.slice(0, children.provisional);
+    }
+    canReaddir() {
+        if (this.#type & ENOCHILD)
+            return false;
+        const ifmt = IFMT & this.#type;
+        // we always set ENOTDIR when setting IFMT, so should be impossible
+        /* c8 ignore start */
+        if (!(ifmt === UNKNOWN || ifmt === IFDIR || ifmt === IFLNK)) {
+            return false;
+        }
+        /* c8 ignore stop */
+        return true;
+    }
+    shouldWalk(dirs, walkFilter) {
+        return ((this.#type & IFDIR) === IFDIR &&
+            !(this.#type & ENOCHILD) &&
+            !dirs.has(this) &&
+            (!walkFilter || walkFilter(this)));
+    }
+    /**
+     * Return the Path object corresponding to path as resolved
+     * by realpath(3).
+     *
+     * If the realpath call fails for any reason, `undefined` is returned.
+     *
+     * Result is cached, and thus may be outdated if the filesystem is mutated.
+     * On success, returns a Path object.
+     */
+    async realpath() {
+        if (this.#realpath)
+            return this.#realpath;
+        if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
+            return undefined;
+        try {
+            const rp = await this.#fs.promises.realpath(this.fullpath());
+            return (this.#realpath = this.resolve(rp));
+        }
+        catch (_) {
+            this.#markENOREALPATH();
+        }
+    }
+    /**
+     * Synchronous {@link realpath}
+     */
+    realpathSync() {
+        if (this.#realpath)
+            return this.#realpath;
+        if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
+            return undefined;
+        try {
+            const rp = this.#fs.realpathSync(this.fullpath());
+            return (this.#realpath = this.resolve(rp));
+        }
+        catch (_) {
+            this.#markENOREALPATH();
+        }
+    }
+    /**
+     * Internal method to mark this Path object as the scurry cwd,
+     * called by {@link PathScurry#chdir}
+     *
+     * @internal
+     */
+    [setAsCwd](oldCwd) {
+        if (oldCwd === this)
+            return;
+        oldCwd.isCWD = false;
+        this.isCWD = true;
+        const changed = new Set([]);
+        let rp = [];
+        let p = this;
+        while (p && p.parent) {
+            changed.add(p);
+            p.#relative = rp.join(this.sep);
+            p.#relativePosix = rp.join('/');
+            p = p.parent;
+            rp.push('..');
+        }
+        // now un-memoize parents of old cwd
+        p = oldCwd;
+        while (p && p.parent && !changed.has(p)) {
+            p.#relative = undefined;
+            p.#relativePosix = undefined;
+            p = p.parent;
+        }
+    }
+}
+/**
+ * Path class used on win32 systems
+ *
+ * Uses `'\\'` as the path separator for returned paths, either `'\\'` or `'/'`
+ * as the path separator for parsing paths.
+ */
+class PathWin32 extends PathBase {
+    /**
+     * Separator for generating path strings.
+     */
+    sep = '\\';
+    /**
+     * Separator for parsing path strings.
+     */
+    splitSep = eitherSep;
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+        super(name, type, root, roots, nocase, children, opts);
+    }
+    /**
+     * @internal
+     */
+    newChild(name, type = UNKNOWN, opts = {}) {
+        return new PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+    }
+    /**
+     * @internal
+     */
+    getRootString(path) {
+        return win32$1.parse(path).root;
+    }
+    /**
+     * @internal
+     */
+    getRoot(rootPath) {
+        rootPath = uncToDrive(rootPath.toUpperCase());
+        if (rootPath === this.root.name) {
+            return this.root;
+        }
+        // ok, not that one, check if it matches another we know about
+        for (const [compare, root] of Object.entries(this.roots)) {
+            if (this.sameRoot(rootPath, compare)) {
+                return (this.roots[rootPath] = root);
+            }
+        }
+        // otherwise, have to create a new one.
+        return (this.roots[rootPath] = new PathScurryWin32(rootPath, this).root);
+    }
+    /**
+     * @internal
+     */
+    sameRoot(rootPath, compare = this.root.name) {
+        // windows can (rarely) have case-sensitive filesystem, but
+        // UNC and drive letters are always case-insensitive, and canonically
+        // represented uppercase.
+        rootPath = rootPath
+            .toUpperCase()
+            .replace(/\//g, '\\')
+            .replace(uncDriveRegexp, '$1\\');
+        return rootPath === compare;
+    }
+}
+/**
+ * Path class used on all posix systems.
+ *
+ * Uses `'/'` as the path separator.
+ */
+class PathPosix extends PathBase {
+    /**
+     * separator for parsing path strings
+     */
+    splitSep = '/';
+    /**
+     * separator for generating path strings
+     */
+    sep = '/';
+    /**
+     * Do not create new Path objects directly.  They should always be accessed
+     * via the PathScurry class or other methods on the Path class.
+     *
+     * @internal
+     */
+    constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+        super(name, type, root, roots, nocase, children, opts);
+    }
+    /**
+     * @internal
+     */
+    getRootString(path) {
+        return path.startsWith('/') ? '/' : '';
+    }
+    /**
+     * @internal
+     */
+    getRoot(_rootPath) {
+        return this.root;
+    }
+    /**
+     * @internal
+     */
+    newChild(name, type = UNKNOWN, opts = {}) {
+        return new PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+    }
+}
+/**
+ * The base class for all PathScurry classes, providing the interface for path
+ * resolution and filesystem operations.
+ *
+ * Typically, you should *not* instantiate this class directly, but rather one
+ * of the platform-specific classes, or the exported {@link PathScurry} which
+ * defaults to the current platform.
+ */
+class PathScurryBase {
+    /**
+     * The root Path entry for the current working directory of this Scurry
+     */
+    root;
+    /**
+     * The string path for the root of this Scurry's current working directory
+     */
+    rootPath;
+    /**
+     * A collection of all roots encountered, referenced by rootPath
+     */
+    roots;
+    /**
+     * The Path entry corresponding to this PathScurry's current working directory.
+     */
+    cwd;
+    #resolveCache;
+    #resolvePosixCache;
+    #children;
+    /**
+     * Perform path comparisons case-insensitively.
+     *
+     * Defaults true on Darwin and Windows systems, false elsewhere.
+     */
+    nocase;
+    #fs;
+    /**
+     * This class should not be instantiated directly.
+     *
+     * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
+     *
+     * @internal
+     */
+    constructor(cwd = process.cwd(), pathImpl, sep, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS, } = {}) {
+        this.#fs = fsFromOption(fs);
+        if (cwd instanceof URL || cwd.startsWith('file://')) {
+            cwd = fileURLToPath(cwd);
+        }
+        // resolve and split root, and then add to the store.
+        // this is the only time we call path.resolve()
+        const cwdPath = pathImpl.resolve(cwd);
+        this.roots = Object.create(null);
+        this.rootPath = this.parseRootPath(cwdPath);
+        this.#resolveCache = new ResolveCache();
+        this.#resolvePosixCache = new ResolveCache();
+        this.#children = new ChildrenCache(childrenCacheSize);
+        const split = cwdPath.substring(this.rootPath.length).split(sep);
+        // resolve('/') leaves '', splits to [''], we don't want that.
+        if (split.length === 1 && !split[0]) {
+            split.pop();
+        }
+        /* c8 ignore start */
+        if (nocase === undefined) {
+            throw new TypeError('must provide nocase setting to PathScurryBase ctor');
+        }
+        /* c8 ignore stop */
+        this.nocase = nocase;
+        this.root = this.newRoot(this.#fs);
+        this.roots[this.rootPath] = this.root;
+        let prev = this.root;
+        let len = split.length - 1;
+        const joinSep = pathImpl.sep;
+        let abs = this.rootPath;
+        let sawFirst = false;
+        for (const part of split) {
+            const l = len--;
+            prev = prev.child(part, {
+                relative: new Array(l).fill('..').join(joinSep),
+                relativePosix: new Array(l).fill('..').join('/'),
+                fullpath: (abs += (sawFirst ? '' : joinSep) + part),
+            });
+            sawFirst = true;
+        }
+        this.cwd = prev;
+    }
+    /**
+     * Get the depth of a provided path, string, or the cwd
+     */
+    depth(path = this.cwd) {
+        if (typeof path === 'string') {
+            path = this.cwd.resolve(path);
+        }
+        return path.depth();
+    }
+    /**
+     * Return the cache of child entries.  Exposed so subclasses can create
+     * child Path objects in a platform-specific way.
+     *
+     * @internal
+     */
+    childrenCache() {
+        return this.#children;
+    }
+    /**
+     * Resolve one or more path strings to a resolved string
+     *
+     * Same interface as require('path').resolve.
+     *
+     * Much faster than path.resolve() when called multiple times for the same
+     * path, because the resolved Path objects are cached.  Much slower
+     * otherwise.
+     */
+    resolve(...paths) {
+        // first figure out the minimum number of paths we have to test
+        // we always start at cwd, but any absolutes will bump the start
+        let r = '';
+        for (let i = paths.length - 1; i >= 0; i--) {
+            const p = paths[i];
+            if (!p || p === '.')
+                continue;
+            r = r ? `${p}/${r}` : p;
+            if (this.isAbsolute(p)) {
+                break;
+            }
+        }
+        const cached = this.#resolveCache.get(r);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = this.cwd.resolve(r).fullpath();
+        this.#resolveCache.set(r, result);
+        return result;
+    }
+    /**
+     * Resolve one or more path strings to a resolved string, returning
+     * the posix path.  Identical to .resolve() on posix systems, but on
+     * windows will return a forward-slash separated UNC path.
+     *
+     * Same interface as require('path').resolve.
+     *
+     * Much faster than path.resolve() when called multiple times for the same
+     * path, because the resolved Path objects are cached.  Much slower
+     * otherwise.
+     */
+    resolvePosix(...paths) {
+        // first figure out the minimum number of paths we have to test
+        // we always start at cwd, but any absolutes will bump the start
+        let r = '';
+        for (let i = paths.length - 1; i >= 0; i--) {
+            const p = paths[i];
+            if (!p || p === '.')
+                continue;
+            r = r ? `${p}/${r}` : p;
+            if (this.isAbsolute(p)) {
+                break;
+            }
+        }
+        const cached = this.#resolvePosixCache.get(r);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = this.cwd.resolve(r).fullpathPosix();
+        this.#resolvePosixCache.set(r, result);
+        return result;
+    }
+    /**
+     * find the relative path from the cwd to the supplied path string or entry
+     */
+    relative(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return entry.relative();
+    }
+    /**
+     * find the relative path from the cwd to the supplied path string or
+     * entry, using / as the path delimiter, even on Windows.
+     */
+    relativePosix(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return entry.relativePosix();
+    }
+    /**
+     * Return the basename for the provided string or Path object
+     */
+    basename(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return entry.name;
+    }
+    /**
+     * Return the dirname for the provided string or Path object
+     */
+    dirname(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return (entry.parent || entry).fullpath();
+    }
+    async readdir(entry = this.cwd, opts = {
+        withFileTypes: true,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes } = opts;
+        if (!entry.canReaddir()) {
+            return [];
+        }
+        else {
+            const p = await entry.readdir();
+            return withFileTypes ? p : p.map(e => e.name);
+        }
+    }
+    readdirSync(entry = this.cwd, opts = {
+        withFileTypes: true,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true } = opts;
+        if (!entry.canReaddir()) {
+            return [];
+        }
+        else if (withFileTypes) {
+            return entry.readdirSync();
+        }
+        else {
+            return entry.readdirSync().map(e => e.name);
+        }
+    }
+    /**
+     * Call lstat() on the string or Path object, and update all known
+     * information that can be determined.
+     *
+     * Note that unlike `fs.lstat()`, the returned value does not contain some
+     * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
+     * information is required, you will need to call `fs.lstat` yourself.
+     *
+     * If the Path refers to a nonexistent file, or if the lstat call fails for
+     * any reason, `undefined` is returned.  Otherwise the updated Path object is
+     * returned.
+     *
+     * Results are cached, and thus may be out of date if the filesystem is
+     * mutated.
+     */
+    async lstat(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return entry.lstat();
+    }
+    /**
+     * synchronous {@link PathScurryBase.lstat}
+     */
+    lstatSync(entry = this.cwd) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        return entry.lstatSync();
+    }
+    async readlink(entry = this.cwd, { withFileTypes } = {
+        withFileTypes: false,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            withFileTypes = entry.withFileTypes;
+            entry = this.cwd;
+        }
+        const e = await entry.readlink();
+        return withFileTypes ? e : e?.fullpath();
+    }
+    readlinkSync(entry = this.cwd, { withFileTypes } = {
+        withFileTypes: false,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            withFileTypes = entry.withFileTypes;
+            entry = this.cwd;
+        }
+        const e = entry.readlinkSync();
+        return withFileTypes ? e : e?.fullpath();
+    }
+    async realpath(entry = this.cwd, { withFileTypes } = {
+        withFileTypes: false,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            withFileTypes = entry.withFileTypes;
+            entry = this.cwd;
+        }
+        const e = await entry.realpath();
+        return withFileTypes ? e : e?.fullpath();
+    }
+    realpathSync(entry = this.cwd, { withFileTypes } = {
+        withFileTypes: false,
+    }) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            withFileTypes = entry.withFileTypes;
+            entry = this.cwd;
+        }
+        const e = entry.realpathSync();
+        return withFileTypes ? e : e?.fullpath();
+    }
+    async walk(entry = this.cwd, opts = {}) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true, follow = false, filter, walkFilter, } = opts;
+        const results = [];
+        if (!filter || filter(entry)) {
+            results.push(withFileTypes ? entry : entry.fullpath());
+        }
+        const dirs = new Set();
+        const walk = (dir, cb) => {
+            dirs.add(dir);
+            dir.readdirCB((er, entries) => {
+                /* c8 ignore start */
+                if (er) {
+                    return cb(er);
+                }
+                /* c8 ignore stop */
+                let len = entries.length;
+                if (!len)
+                    return cb();
+                const next = () => {
+                    if (--len === 0) {
+                        cb();
+                    }
+                };
+                for (const e of entries) {
+                    if (!filter || filter(e)) {
+                        results.push(withFileTypes ? e : e.fullpath());
+                    }
+                    if (follow && e.isSymbolicLink()) {
+                        e.realpath()
+                            .then(r => (r?.isUnknown() ? r.lstat() : r))
+                            .then(r => r?.shouldWalk(dirs, walkFilter) ? walk(r, next) : next());
+                    }
+                    else {
+                        if (e.shouldWalk(dirs, walkFilter)) {
+                            walk(e, next);
+                        }
+                        else {
+                            next();
+                        }
+                    }
+                }
+            }, true); // zalgooooooo
+        };
+        const start = entry;
+        return new Promise((res, rej) => {
+            walk(start, er => {
+                /* c8 ignore start */
+                if (er)
+                    return rej(er);
+                /* c8 ignore stop */
+                res(results);
+            });
+        });
+    }
+    walkSync(entry = this.cwd, opts = {}) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true, follow = false, filter, walkFilter, } = opts;
+        const results = [];
+        if (!filter || filter(entry)) {
+            results.push(withFileTypes ? entry : entry.fullpath());
+        }
+        const dirs = new Set([entry]);
+        for (const dir of dirs) {
+            const entries = dir.readdirSync();
+            for (const e of entries) {
+                if (!filter || filter(e)) {
+                    results.push(withFileTypes ? e : e.fullpath());
+                }
+                let r = e;
+                if (e.isSymbolicLink()) {
+                    if (!(follow && (r = e.realpathSync())))
+                        continue;
+                    if (r.isUnknown())
+                        r.lstatSync();
+                }
+                if (r.shouldWalk(dirs, walkFilter)) {
+                    dirs.add(r);
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Support for `for await`
+     *
+     * Alias for {@link PathScurryBase.iterate}
+     *
+     * Note: As of Node 19, this is very slow, compared to other methods of
+     * walking.  Consider using {@link PathScurryBase.stream} if memory overhead
+     * and backpressure are concerns, or {@link PathScurryBase.walk} if not.
+     */
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+    iterate(entry = this.cwd, options = {}) {
+        // iterating async over the stream is significantly more performant,
+        // especially in the warm-cache scenario, because it buffers up directory
+        // entries in the background instead of waiting for a yield for each one.
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            options = entry;
+            entry = this.cwd;
+        }
+        return this.stream(entry, options)[Symbol.asyncIterator]();
+    }
+    /**
+     * Iterating over a PathScurry performs a synchronous walk.
+     *
+     * Alias for {@link PathScurryBase.iterateSync}
+     */
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    *iterateSync(entry = this.cwd, opts = {}) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true, follow = false, filter, walkFilter, } = opts;
+        if (!filter || filter(entry)) {
+            yield withFileTypes ? entry : entry.fullpath();
+        }
+        const dirs = new Set([entry]);
+        for (const dir of dirs) {
+            const entries = dir.readdirSync();
+            for (const e of entries) {
+                if (!filter || filter(e)) {
+                    yield withFileTypes ? e : e.fullpath();
+                }
+                let r = e;
+                if (e.isSymbolicLink()) {
+                    if (!(follow && (r = e.realpathSync())))
+                        continue;
+                    if (r.isUnknown())
+                        r.lstatSync();
+                }
+                if (r.shouldWalk(dirs, walkFilter)) {
+                    dirs.add(r);
+                }
+            }
+        }
+    }
+    stream(entry = this.cwd, opts = {}) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true, follow = false, filter, walkFilter, } = opts;
+        const results = new Minipass({ objectMode: true });
+        if (!filter || filter(entry)) {
+            results.write(withFileTypes ? entry : entry.fullpath());
+        }
+        const dirs = new Set();
+        const queue = [entry];
+        let processing = 0;
+        const process = () => {
+            let paused = false;
+            while (!paused) {
+                const dir = queue.shift();
+                if (!dir) {
+                    if (processing === 0)
+                        results.end();
+                    return;
+                }
+                processing++;
+                dirs.add(dir);
+                const onReaddir = (er, entries, didRealpaths = false) => {
+                    /* c8 ignore start */
+                    if (er)
+                        return results.emit('error', er);
+                    /* c8 ignore stop */
+                    if (follow && !didRealpaths) {
+                        const promises = [];
+                        for (const e of entries) {
+                            if (e.isSymbolicLink()) {
+                                promises.push(e
+                                    .realpath()
+                                    .then((r) => r?.isUnknown() ? r.lstat() : r));
+                            }
+                        }
+                        if (promises.length) {
+                            Promise.all(promises).then(() => onReaddir(null, entries, true));
+                            return;
+                        }
+                    }
+                    for (const e of entries) {
+                        if (e && (!filter || filter(e))) {
+                            if (!results.write(withFileTypes ? e : e.fullpath())) {
+                                paused = true;
+                            }
+                        }
+                    }
+                    processing--;
+                    for (const e of entries) {
+                        const r = e.realpathCached() || e;
+                        if (r.shouldWalk(dirs, walkFilter)) {
+                            queue.push(r);
+                        }
+                    }
+                    if (paused && !results.flowing) {
+                        results.once('drain', process);
+                    }
+                    else if (!sync) {
+                        process();
+                    }
+                };
+                // zalgo containment
+                let sync = true;
+                dir.readdirCB(onReaddir, true);
+                sync = false;
+            }
+        };
+        process();
+        return results;
+    }
+    streamSync(entry = this.cwd, opts = {}) {
+        if (typeof entry === 'string') {
+            entry = this.cwd.resolve(entry);
+        }
+        else if (!(entry instanceof PathBase)) {
+            opts = entry;
+            entry = this.cwd;
+        }
+        const { withFileTypes = true, follow = false, filter, walkFilter, } = opts;
+        const results = new Minipass({ objectMode: true });
+        const dirs = new Set();
+        if (!filter || filter(entry)) {
+            results.write(withFileTypes ? entry : entry.fullpath());
+        }
+        const queue = [entry];
+        let processing = 0;
+        const process = () => {
+            let paused = false;
+            while (!paused) {
+                const dir = queue.shift();
+                if (!dir) {
+                    if (processing === 0)
+                        results.end();
+                    return;
+                }
+                processing++;
+                dirs.add(dir);
+                const entries = dir.readdirSync();
+                for (const e of entries) {
+                    if (!filter || filter(e)) {
+                        if (!results.write(withFileTypes ? e : e.fullpath())) {
+                            paused = true;
+                        }
+                    }
+                }
+                processing--;
+                for (const e of entries) {
+                    let r = e;
+                    if (e.isSymbolicLink()) {
+                        if (!(follow && (r = e.realpathSync())))
+                            continue;
+                        if (r.isUnknown())
+                            r.lstatSync();
+                    }
+                    if (r.shouldWalk(dirs, walkFilter)) {
+                        queue.push(r);
+                    }
+                }
+            }
+            if (paused && !results.flowing)
+                results.once('drain', process);
+        };
+        process();
+        return results;
+    }
+    chdir(path = this.cwd) {
+        const oldCwd = this.cwd;
+        this.cwd = typeof path === 'string' ? this.cwd.resolve(path) : path;
+        this.cwd[setAsCwd](oldCwd);
+    }
+}
+/**
+ * Windows implementation of {@link PathScurryBase}
+ *
+ * Defaults to case insensitve, uses `'\\'` to generate path strings.  Uses
+ * {@link PathWin32} for Path objects.
+ */
+class PathScurryWin32 extends PathScurryBase {
+    /**
+     * separator for generating path strings
+     */
+    sep = '\\';
+    constructor(cwd = process.cwd(), opts = {}) {
+        const { nocase = true } = opts;
+        super(cwd, win32$1, '\\', { ...opts, nocase });
+        this.nocase = nocase;
+        for (let p = this.cwd; p; p = p.parent) {
+            p.nocase = this.nocase;
+        }
+    }
+    /**
+     * @internal
+     */
+    parseRootPath(dir) {
+        // if the path starts with a single separator, it's not a UNC, and we'll
+        // just get separator as the root, and driveFromUNC will return \
+        // In that case, mount \ on the root from the cwd.
+        return win32$1.parse(dir).root.toUpperCase();
+    }
+    /**
+     * @internal
+     */
+    newRoot(fs) {
+        return new PathWin32(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs });
+    }
+    /**
+     * Return true if the provided path string is an absolute path
+     */
+    isAbsolute(p) {
+        return (p.startsWith('/') || p.startsWith('\\') || /^[a-z]:(\/|\\)/i.test(p));
+    }
+}
+/**
+ * {@link PathScurryBase} implementation for all posix systems other than Darwin.
+ *
+ * Defaults to case-sensitive matching, uses `'/'` to generate path strings.
+ *
+ * Uses {@link PathPosix} for Path objects.
+ */
+class PathScurryPosix extends PathScurryBase {
+    /**
+     * separator for generating path strings
+     */
+    sep = '/';
+    constructor(cwd = process.cwd(), opts = {}) {
+        const { nocase = false } = opts;
+        super(cwd, posix$1, '/', { ...opts, nocase });
+        this.nocase = nocase;
+    }
+    /**
+     * @internal
+     */
+    parseRootPath(_dir) {
+        return '/';
+    }
+    /**
+     * @internal
+     */
+    newRoot(fs) {
+        return new PathPosix(this.rootPath, IFDIR, undefined, this.roots, this.nocase, this.childrenCache(), { fs });
+    }
+    /**
+     * Return true if the provided path string is an absolute path
+     */
+    isAbsolute(p) {
+        return p.startsWith('/');
+    }
+}
+/**
+ * {@link PathScurryBase} implementation for Darwin (macOS) systems.
+ *
+ * Defaults to case-insensitive matching, uses `'/'` for generating path
+ * strings.
+ *
+ * Uses {@link PathPosix} for Path objects.
+ */
+class PathScurryDarwin extends PathScurryPosix {
+    constructor(cwd = process.cwd(), opts = {}) {
+        const { nocase = true } = opts;
+        super(cwd, { ...opts, nocase });
+    }
+}
+/**
+ * Default {@link PathBase} implementation for the current platform.
+ *
+ * {@link PathWin32} on Windows systems, {@link PathPosix} on all others.
+ */
+process.platform === 'win32' ? PathWin32 : PathPosix;
+/**
+ * Default {@link PathScurryBase} implementation for the current platform.
+ *
+ * {@link PathScurryWin32} on Windows systems, {@link PathScurryDarwin} on
+ * Darwin (macOS) systems, {@link PathScurryPosix} on all others.
+ */
+const PathScurry = process.platform === 'win32' ? PathScurryWin32
+    : process.platform === 'darwin' ? PathScurryDarwin
+        : PathScurryPosix;
+
+// this is just a very light wrapper around 2 arrays with an offset index
+const isPatternList = (pl) => pl.length >= 1;
+const isGlobList = (gl) => gl.length >= 1;
+/**
+ * An immutable-ish view on an array of glob parts and their parsed
+ * results
+ */
+class Pattern {
+    #patternList;
+    #globList;
+    #index;
+    length;
+    #platform;
+    #rest;
+    #globString;
+    #isDrive;
+    #isUNC;
+    #isAbsolute;
+    #followGlobstar = true;
+    constructor(patternList, globList, index, platform) {
+        if (!isPatternList(patternList)) {
+            throw new TypeError('empty pattern list');
+        }
+        if (!isGlobList(globList)) {
+            throw new TypeError('empty glob list');
+        }
+        if (globList.length !== patternList.length) {
+            throw new TypeError('mismatched pattern list and glob list lengths');
+        }
+        this.length = patternList.length;
+        if (index < 0 || index >= this.length) {
+            throw new TypeError('index out of range');
+        }
+        this.#patternList = patternList;
+        this.#globList = globList;
+        this.#index = index;
+        this.#platform = platform;
+        // normalize root entries of absolute patterns on initial creation.
+        if (this.#index === 0) {
+            // c: => ['c:/']
+            // C:/ => ['C:/']
+            // C:/x => ['C:/', 'x']
+            // //host/share => ['//host/share/']
+            // //host/share/ => ['//host/share/']
+            // //host/share/x => ['//host/share/', 'x']
+            // /etc => ['/', 'etc']
+            // / => ['/']
+            if (this.isUNC()) {
+                // '' / '' / 'host' / 'share'
+                const [p0, p1, p2, p3, ...prest] = this.#patternList;
+                const [g0, g1, g2, g3, ...grest] = this.#globList;
+                if (prest[0] === '') {
+                    // ends in /
+                    prest.shift();
+                    grest.shift();
+                }
+                const p = [p0, p1, p2, p3, ''].join('/');
+                const g = [g0, g1, g2, g3, ''].join('/');
+                this.#patternList = [p, ...prest];
+                this.#globList = [g, ...grest];
+                this.length = this.#patternList.length;
+            }
+            else if (this.isDrive() || this.isAbsolute()) {
+                const [p1, ...prest] = this.#patternList;
+                const [g1, ...grest] = this.#globList;
+                if (prest[0] === '') {
+                    // ends in /
+                    prest.shift();
+                    grest.shift();
+                }
+                const p = p1 + '/';
+                const g = g1 + '/';
+                this.#patternList = [p, ...prest];
+                this.#globList = [g, ...grest];
+                this.length = this.#patternList.length;
+            }
+        }
+    }
+    /**
+     * The first entry in the parsed list of patterns
+     */
+    pattern() {
+        return this.#patternList[this.#index];
+    }
+    /**
+     * true of if pattern() returns a string
+     */
+    isString() {
+        return typeof this.#patternList[this.#index] === 'string';
+    }
+    /**
+     * true of if pattern() returns GLOBSTAR
+     */
+    isGlobstar() {
+        return this.#patternList[this.#index] === GLOBSTAR$2;
+    }
+    /**
+     * true if pattern() returns a regexp
+     */
+    isRegExp() {
+        return this.#patternList[this.#index] instanceof RegExp;
+    }
+    /**
+     * The /-joined set of glob parts that make up this pattern
+     */
+    globString() {
+        return (this.#globString =
+            this.#globString ||
+                (this.#index === 0 ?
+                    this.isAbsolute() ?
+                        this.#globList[0] + this.#globList.slice(1).join('/')
+                        : this.#globList.join('/')
+                    : this.#globList.slice(this.#index).join('/')));
+    }
+    /**
+     * true if there are more pattern parts after this one
+     */
+    hasMore() {
+        return this.length > this.#index + 1;
+    }
+    /**
+     * The rest of the pattern after this part, or null if this is the end
+     */
+    rest() {
+        if (this.#rest !== undefined)
+            return this.#rest;
+        if (!this.hasMore())
+            return (this.#rest = null);
+        this.#rest = new Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
+        this.#rest.#isAbsolute = this.#isAbsolute;
+        this.#rest.#isUNC = this.#isUNC;
+        this.#rest.#isDrive = this.#isDrive;
+        return this.#rest;
+    }
+    /**
+     * true if the pattern represents a //unc/path/ on windows
+     */
+    isUNC() {
+        const pl = this.#patternList;
+        return this.#isUNC !== undefined ?
+            this.#isUNC
+            : (this.#isUNC =
+                this.#platform === 'win32' &&
+                    this.#index === 0 &&
+                    pl[0] === '' &&
+                    pl[1] === '' &&
+                    typeof pl[2] === 'string' &&
+                    !!pl[2] &&
+                    typeof pl[3] === 'string' &&
+                    !!pl[3]);
+    }
+    // pattern like C:/...
+    // split = ['C:', ...]
+    // XXX: would be nice to handle patterns like `c:*` to test the cwd
+    // in c: for *, but I don't know of a way to even figure out what that
+    // cwd is without actually chdir'ing into it?
+    /**
+     * True if the pattern starts with a drive letter on Windows
+     */
+    isDrive() {
+        const pl = this.#patternList;
+        return this.#isDrive !== undefined ?
+            this.#isDrive
+            : (this.#isDrive =
+                this.#platform === 'win32' &&
+                    this.#index === 0 &&
+                    this.length > 1 &&
+                    typeof pl[0] === 'string' &&
+                    /^[a-z]:$/i.test(pl[0]));
+    }
+    // pattern = '/' or '/...' or '/x/...'
+    // split = ['', ''] or ['', ...] or ['', 'x', ...]
+    // Drive and UNC both considered absolute on windows
+    /**
+     * True if the pattern is rooted on an absolute path
+     */
+    isAbsolute() {
+        const pl = this.#patternList;
+        return this.#isAbsolute !== undefined ?
+            this.#isAbsolute
+            : (this.#isAbsolute =
+                (pl[0] === '' && pl.length > 1) ||
+                    this.isDrive() ||
+                    this.isUNC());
+    }
+    /**
+     * consume the root of the pattern, and return it
+     */
+    root() {
+        const p = this.#patternList[0];
+        return (typeof p === 'string' && this.isAbsolute() && this.#index === 0) ?
+            p
+            : '';
+    }
+    /**
+     * Check to see if the current globstar pattern is allowed to follow
+     * a symbolic link.
+     */
+    checkFollowGlobstar() {
+        return !(this.#index === 0 ||
+            !this.isGlobstar() ||
+            !this.#followGlobstar);
+    }
+    /**
+     * Mark that the current globstar pattern is following a symbolic link
+     */
+    markFollowGlobstar() {
+        if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)
+            return false;
+        this.#followGlobstar = false;
+        return true;
+    }
+}
+
+// give it a pattern, and it'll be able to tell you if
+// a given path should be ignored.
+// Ignoring a path ignores its children if the pattern ends in /**
+// Ignores are always parsed in dot:true mode
+const defaultPlatform$1 = (typeof process === 'object' &&
+    process &&
+    typeof process.platform === 'string') ?
+    process.platform
+    : 'linux';
+/**
+ * Class used to process ignored patterns
+ */
+class Ignore {
+    relative;
+    relativeChildren;
+    absolute;
+    absoluteChildren;
+    platform;
+    mmopts;
+    constructor(ignored, { nobrace, nocase, noext, noglobstar, platform = defaultPlatform$1, }) {
+        this.relative = [];
+        this.absolute = [];
+        this.relativeChildren = [];
+        this.absoluteChildren = [];
+        this.platform = platform;
+        this.mmopts = {
+            dot: true,
+            nobrace,
+            nocase,
+            noext,
+            noglobstar,
+            optimizationLevel: 2,
+            platform,
+            nocomment: true,
+            nonegate: true,
+        };
+        for (const ign of ignored)
+            this.add(ign);
+    }
+    add(ign) {
+        // this is a little weird, but it gives us a clean set of optimized
+        // minimatch matchers, without getting tripped up if one of them
+        // ends in /** inside a brace section, and it's only inefficient at
+        // the start of the walk, not along it.
+        // It'd be nice if the Pattern class just had a .test() method, but
+        // handling globstars is a bit of a pita, and that code already lives
+        // in minimatch anyway.
+        // Another way would be if maybe Minimatch could take its set/globParts
+        // as an option, and then we could at least just use Pattern to test
+        // for absolute-ness.
+        // Yet another way, Minimatch could take an array of glob strings, and
+        // a cwd option, and do the right thing.
+        const mm = new Minimatch(ign, this.mmopts);
+        for (let i = 0; i < mm.set.length; i++) {
+            const parsed = mm.set[i];
+            const globParts = mm.globParts[i];
+            /* c8 ignore start */
+            if (!parsed || !globParts) {
+                throw new Error('invalid pattern object');
+            }
+            // strip off leading ./ portions
+            // https://github.com/isaacs/node-glob/issues/570
+            while (parsed[0] === '.' && globParts[0] === '.') {
+                parsed.shift();
+                globParts.shift();
+            }
+            /* c8 ignore stop */
+            const p = new Pattern(parsed, globParts, 0, this.platform);
+            const m = new Minimatch(p.globString(), this.mmopts);
+            const children = globParts[globParts.length - 1] === '**';
+            const absolute = p.isAbsolute();
+            if (absolute)
+                this.absolute.push(m);
+            else
+                this.relative.push(m);
+            if (children) {
+                if (absolute)
+                    this.absoluteChildren.push(m);
+                else
+                    this.relativeChildren.push(m);
+            }
+        }
+    }
+    ignored(p) {
+        const fullpath = p.fullpath();
+        const fullpaths = `${fullpath}/`;
+        const relative = p.relative() || '.';
+        const relatives = `${relative}/`;
+        for (const m of this.relative) {
+            if (m.match(relative) || m.match(relatives))
+                return true;
+        }
+        for (const m of this.absolute) {
+            if (m.match(fullpath) || m.match(fullpaths))
+                return true;
+        }
+        return false;
+    }
+    childrenIgnored(p) {
+        const fullpath = p.fullpath() + '/';
+        const relative = (p.relative() || '.') + '/';
+        for (const m of this.relativeChildren) {
+            if (m.match(relative))
+                return true;
+        }
+        for (const m of this.absoluteChildren) {
+            if (m.match(fullpath))
+                return true;
+        }
+        return false;
+    }
+}
+
+// synchronous utility for filtering entries and calculating subwalks
+/**
+ * A cache of which patterns have been processed for a given Path
+ */
+class HasWalkedCache {
+    store;
+    constructor(store = new Map()) {
+        this.store = store;
+    }
+    copy() {
+        return new HasWalkedCache(new Map(this.store));
+    }
+    hasWalked(target, pattern) {
+        return this.store.get(target.fullpath())?.has(pattern.globString());
+    }
+    storeWalked(target, pattern) {
+        const fullpath = target.fullpath();
+        const cached = this.store.get(fullpath);
+        if (cached)
+            cached.add(pattern.globString());
+        else
+            this.store.set(fullpath, new Set([pattern.globString()]));
+    }
+}
+/**
+ * A record of which paths have been matched in a given walk step,
+ * and whether they only are considered a match if they are a directory,
+ * and whether their absolute or relative path should be returned.
+ */
+class MatchRecord {
+    store = new Map();
+    add(target, absolute, ifDir) {
+        const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
+        const current = this.store.get(target);
+        this.store.set(target, current === undefined ? n : n & current);
+    }
+    // match, absolute, ifdir
+    entries() {
+        return [...this.store.entries()].map(([path, n]) => [
+            path,
+            !!(n & 2),
+            !!(n & 1),
+        ]);
+    }
+}
+/**
+ * A collection of patterns that must be processed in a subsequent step
+ * for a given path.
+ */
+class SubWalks {
+    store = new Map();
+    add(target, pattern) {
+        if (!target.canReaddir()) {
+            return;
+        }
+        const subs = this.store.get(target);
+        if (subs) {
+            if (!subs.find(p => p.globString() === pattern.globString())) {
+                subs.push(pattern);
+            }
+        }
+        else
+            this.store.set(target, [pattern]);
+    }
+    get(target) {
+        const subs = this.store.get(target);
+        /* c8 ignore start */
+        if (!subs) {
+            throw new Error('attempting to walk unknown path');
+        }
+        /* c8 ignore stop */
+        return subs;
+    }
+    entries() {
+        return this.keys().map(k => [k, this.store.get(k)]);
+    }
+    keys() {
+        return [...this.store.keys()].filter(t => t.canReaddir());
+    }
+}
+/**
+ * The class that processes patterns for a given path.
+ *
+ * Handles child entry filtering, and determining whether a path's
+ * directory contents must be read.
+ */
+class Processor {
+    hasWalkedCache;
+    matches = new MatchRecord();
+    subwalks = new SubWalks();
+    patterns;
+    follow;
+    dot;
+    opts;
+    constructor(opts, hasWalkedCache) {
+        this.opts = opts;
+        this.follow = !!opts.follow;
+        this.dot = !!opts.dot;
+        this.hasWalkedCache =
+            hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
+    }
+    processPatterns(target, patterns) {
+        this.patterns = patterns;
+        const processingSet = patterns.map(p => [target, p]);
+        // map of paths to the magic-starting subwalks they need to walk
+        // first item in patterns is the filter
+        for (let [t, pattern] of processingSet) {
+            this.hasWalkedCache.storeWalked(t, pattern);
+            const root = pattern.root();
+            const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
+            // start absolute patterns at root
+            if (root) {
+                t = t.resolve(root === '/' && this.opts.root !== undefined ?
+                    this.opts.root
+                    : root);
+                const rest = pattern.rest();
+                if (!rest) {
+                    this.matches.add(t, true, false);
+                    continue;
+                }
+                else {
+                    pattern = rest;
+                }
+            }
+            if (t.isENOENT())
+                continue;
+            let p;
+            let rest;
+            let changed = false;
+            while (typeof (p = pattern.pattern()) === 'string' &&
+                (rest = pattern.rest())) {
+                const c = t.resolve(p);
+                t = c;
+                pattern = rest;
+                changed = true;
+            }
+            p = pattern.pattern();
+            rest = pattern.rest();
+            if (changed) {
+                if (this.hasWalkedCache.hasWalked(t, pattern))
+                    continue;
+                this.hasWalkedCache.storeWalked(t, pattern);
+            }
+            // now we have either a final string for a known entry,
+            // more strings for an unknown entry,
+            // or a pattern starting with magic, mounted on t.
+            if (typeof p === 'string') {
+                // must not be final entry, otherwise we would have
+                // concatenated it earlier.
+                const ifDir = p === '..' || p === '' || p === '.';
+                this.matches.add(t.resolve(p), absolute, ifDir);
+                continue;
+            }
+            else if (p === GLOBSTAR$2) {
+                // if no rest, match and subwalk pattern
+                // if rest, process rest and subwalk pattern
+                // if it's a symlink, but we didn't get here by way of a
+                // globstar match (meaning it's the first time THIS globstar
+                // has traversed a symlink), then we follow it. Otherwise, stop.
+                if (!t.isSymbolicLink() ||
+                    this.follow ||
+                    pattern.checkFollowGlobstar()) {
+                    this.subwalks.add(t, pattern);
+                }
+                const rp = rest?.pattern();
+                const rrest = rest?.rest();
+                if (!rest || ((rp === '' || rp === '.') && !rrest)) {
+                    // only HAS to be a dir if it ends in **/ or **/.
+                    // but ending in ** will match files as well.
+                    this.matches.add(t, absolute, rp === '' || rp === '.');
+                }
+                else {
+                    if (rp === '..') {
+                        // this would mean you're matching **/.. at the fs root,
+                        // and no thanks, I'm not gonna test that specific case.
+                        /* c8 ignore start */
+                        const tp = t.parent || t;
+                        /* c8 ignore stop */
+                        if (!rrest)
+                            this.matches.add(tp, absolute, true);
+                        else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
+                            this.subwalks.add(tp, rrest);
+                        }
+                    }
+                }
+            }
+            else if (p instanceof RegExp) {
+                this.subwalks.add(t, pattern);
+            }
+        }
+        return this;
+    }
+    subwalkTargets() {
+        return this.subwalks.keys();
+    }
+    child() {
+        return new Processor(this.opts, this.hasWalkedCache);
+    }
+    // return a new Processor containing the subwalks for each
+    // child entry, and a set of matches, and
+    // a hasWalkedCache that's a copy of this one
+    // then we're going to call
+    filterEntries(parent, entries) {
+        const patterns = this.subwalks.get(parent);
+        // put matches and entry walks into the results processor
+        const results = this.child();
+        for (const e of entries) {
+            for (const pattern of patterns) {
+                const absolute = pattern.isAbsolute();
+                const p = pattern.pattern();
+                const rest = pattern.rest();
+                if (p === GLOBSTAR$2) {
+                    results.testGlobstar(e, pattern, rest, absolute);
+                }
+                else if (p instanceof RegExp) {
+                    results.testRegExp(e, p, rest, absolute);
+                }
+                else {
+                    results.testString(e, p, rest, absolute);
+                }
+            }
+        }
+        return results;
+    }
+    testGlobstar(e, pattern, rest, absolute) {
+        if (this.dot || !e.name.startsWith('.')) {
+            if (!pattern.hasMore()) {
+                this.matches.add(e, absolute, false);
+            }
+            if (e.canReaddir()) {
+                // if we're in follow mode or it's not a symlink, just keep
+                // testing the same pattern. If there's more after the globstar,
+                // then this symlink consumes the globstar. If not, then we can
+                // follow at most ONE symlink along the way, so we mark it, which
+                // also checks to ensure that it wasn't already marked.
+                if (this.follow || !e.isSymbolicLink()) {
+                    this.subwalks.add(e, pattern);
+                }
+                else if (e.isSymbolicLink()) {
+                    if (rest && pattern.checkFollowGlobstar()) {
+                        this.subwalks.add(e, rest);
+                    }
+                    else if (pattern.markFollowGlobstar()) {
+                        this.subwalks.add(e, pattern);
+                    }
+                }
+            }
+        }
+        // if the NEXT thing matches this entry, then also add
+        // the rest.
+        if (rest) {
+            const rp = rest.pattern();
+            if (typeof rp === 'string' &&
+                // dots and empty were handled already
+                rp !== '..' &&
+                rp !== '' &&
+                rp !== '.') {
+                this.testString(e, rp, rest.rest(), absolute);
+            }
+            else if (rp === '..') {
+                /* c8 ignore start */
+                const ep = e.parent || e;
+                /* c8 ignore stop */
+                this.subwalks.add(ep, rest);
+            }
+            else if (rp instanceof RegExp) {
+                this.testRegExp(e, rp, rest.rest(), absolute);
+            }
+        }
+    }
+    testRegExp(e, p, rest, absolute) {
+        if (!p.test(e.name))
+            return;
+        if (!rest) {
+            this.matches.add(e, absolute, false);
+        }
+        else {
+            this.subwalks.add(e, rest);
+        }
+    }
+    testString(e, p, rest, absolute) {
+        // should never happen?
+        if (!e.isNamed(p))
+            return;
+        if (!rest) {
+            this.matches.add(e, absolute, false);
+        }
+        else {
+            this.subwalks.add(e, rest);
+        }
+    }
+}
+
+/**
+ * Single-use utility classes to provide functionality to the {@link Glob}
+ * methods.
+ *
+ * @module
+ */
+const makeIgnore = (ignore, opts) => typeof ignore === 'string' ? new Ignore([ignore], opts)
+    : Array.isArray(ignore) ? new Ignore(ignore, opts)
+        : ignore;
+/**
+ * basic walking utilities that all the glob walker types use
+ */
+class GlobUtil {
+    path;
+    patterns;
+    opts;
+    seen = new Set();
+    paused = false;
+    aborted = false;
+    #onResume = [];
+    #ignore;
+    #sep;
+    signal;
+    maxDepth;
+    includeChildMatches;
+    constructor(patterns, path, opts) {
+        this.patterns = patterns;
+        this.path = path;
+        this.opts = opts;
+        this.#sep = !opts.posix && opts.platform === 'win32' ? '\\' : '/';
+        this.includeChildMatches = opts.includeChildMatches !== false;
+        if (opts.ignore || !this.includeChildMatches) {
+            this.#ignore = makeIgnore(opts.ignore ?? [], opts);
+            if (!this.includeChildMatches &&
+                typeof this.#ignore.add !== 'function') {
+                const m = 'cannot ignore child matches, ignore lacks add() method.';
+                throw new Error(m);
+            }
+        }
+        // ignore, always set with maxDepth, but it's optional on the
+        // GlobOptions type
+        /* c8 ignore start */
+        this.maxDepth = opts.maxDepth || Infinity;
+        /* c8 ignore stop */
+        if (opts.signal) {
+            this.signal = opts.signal;
+            this.signal.addEventListener('abort', () => {
+                this.#onResume.length = 0;
+            });
+        }
+    }
+    #ignored(path) {
+        return this.seen.has(path) || !!this.#ignore?.ignored?.(path);
+    }
+    #childrenIgnored(path) {
+        return !!this.#ignore?.childrenIgnored?.(path);
+    }
+    // backpressure mechanism
+    pause() {
+        this.paused = true;
+    }
+    resume() {
+        /* c8 ignore start */
+        if (this.signal?.aborted)
+            return;
+        /* c8 ignore stop */
+        this.paused = false;
+        let fn = undefined;
+        while (!this.paused && (fn = this.#onResume.shift())) {
+            fn();
+        }
+    }
+    onResume(fn) {
+        if (this.signal?.aborted)
+            return;
+        /* c8 ignore start */
+        if (!this.paused) {
+            fn();
+        }
+        else {
+            /* c8 ignore stop */
+            this.#onResume.push(fn);
+        }
+    }
+    // do the requisite realpath/stat checking, and return the path
+    // to add or undefined to filter it out.
+    async matchCheck(e, ifDir) {
+        if (ifDir && this.opts.nodir)
+            return undefined;
+        let rpc;
+        if (this.opts.realpath) {
+            rpc = e.realpathCached() || (await e.realpath());
+            if (!rpc)
+                return undefined;
+            e = rpc;
+        }
+        const needStat = e.isUnknown() || this.opts.stat;
+        const s = needStat ? await e.lstat() : e;
+        if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+            const target = await s.realpath();
+            /* c8 ignore start */
+            if (target && (target.isUnknown() || this.opts.stat)) {
+                await target.lstat();
+            }
+            /* c8 ignore stop */
+        }
+        return this.matchCheckTest(s, ifDir);
+    }
+    matchCheckTest(e, ifDir) {
+        return (e &&
+            (this.maxDepth === Infinity || e.depth() <= this.maxDepth) &&
+            (!ifDir || e.canReaddir()) &&
+            (!this.opts.nodir || !e.isDirectory()) &&
+            (!this.opts.nodir ||
+                !this.opts.follow ||
+                !e.isSymbolicLink() ||
+                !e.realpathCached()?.isDirectory()) &&
+            !this.#ignored(e)) ?
+            e
+            : undefined;
+    }
+    matchCheckSync(e, ifDir) {
+        if (ifDir && this.opts.nodir)
+            return undefined;
+        let rpc;
+        if (this.opts.realpath) {
+            rpc = e.realpathCached() || e.realpathSync();
+            if (!rpc)
+                return undefined;
+            e = rpc;
+        }
+        const needStat = e.isUnknown() || this.opts.stat;
+        const s = needStat ? e.lstatSync() : e;
+        if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+            const target = s.realpathSync();
+            if (target && (target?.isUnknown() || this.opts.stat)) {
+                target.lstatSync();
+            }
+        }
+        return this.matchCheckTest(s, ifDir);
+    }
+    matchFinish(e, absolute) {
+        if (this.#ignored(e))
+            return;
+        // we know we have an ignore if this is false, but TS doesn't
+        if (!this.includeChildMatches && this.#ignore?.add) {
+            const ign = `${e.relativePosix()}/**`;
+            this.#ignore.add(ign);
+        }
+        const abs = this.opts.absolute === undefined ? absolute : this.opts.absolute;
+        this.seen.add(e);
+        const mark = this.opts.mark && e.isDirectory() ? this.#sep : '';
+        // ok, we have what we need!
+        if (this.opts.withFileTypes) {
+            this.matchEmit(e);
+        }
+        else if (abs) {
+            const abs = this.opts.posix ? e.fullpathPosix() : e.fullpath();
+            this.matchEmit(abs + mark);
+        }
+        else {
+            const rel = this.opts.posix ? e.relativePosix() : e.relative();
+            const pre = this.opts.dotRelative && !rel.startsWith('..' + this.#sep) ?
+                '.' + this.#sep
+                : '';
+            this.matchEmit(!rel ? '.' + mark : pre + rel + mark);
+        }
+    }
+    async match(e, absolute, ifDir) {
+        const p = await this.matchCheck(e, ifDir);
+        if (p)
+            this.matchFinish(p, absolute);
+    }
+    matchSync(e, absolute, ifDir) {
+        const p = this.matchCheckSync(e, ifDir);
+        if (p)
+            this.matchFinish(p, absolute);
+    }
+    walkCB(target, patterns, cb) {
+        /* c8 ignore start */
+        if (this.signal?.aborted)
+            cb();
+        /* c8 ignore stop */
+        this.walkCB2(target, patterns, new Processor(this.opts), cb);
+    }
+    walkCB2(target, patterns, processor, cb) {
+        if (this.#childrenIgnored(target))
+            return cb();
+        if (this.signal?.aborted)
+            cb();
+        if (this.paused) {
+            this.onResume(() => this.walkCB2(target, patterns, processor, cb));
+            return;
+        }
+        processor.processPatterns(target, patterns);
+        // done processing.  all of the above is sync, can be abstracted out.
+        // subwalks is a map of paths to the entry filters they need
+        // matches is a map of paths to [absolute, ifDir] tuples.
+        let tasks = 1;
+        const next = () => {
+            if (--tasks === 0)
+                cb();
+        };
+        for (const [m, absolute, ifDir] of processor.matches.entries()) {
+            if (this.#ignored(m))
+                continue;
+            tasks++;
+            this.match(m, absolute, ifDir).then(() => next());
+        }
+        for (const t of processor.subwalkTargets()) {
+            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+                continue;
+            }
+            tasks++;
+            const childrenCached = t.readdirCached();
+            if (t.calledReaddir())
+                this.walkCB3(t, childrenCached, processor, next);
+            else {
+                t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
+            }
+        }
+        next();
+    }
+    walkCB3(target, entries, processor, cb) {
+        processor = processor.filterEntries(target, entries);
+        let tasks = 1;
+        const next = () => {
+            if (--tasks === 0)
+                cb();
+        };
+        for (const [m, absolute, ifDir] of processor.matches.entries()) {
+            if (this.#ignored(m))
+                continue;
+            tasks++;
+            this.match(m, absolute, ifDir).then(() => next());
+        }
+        for (const [target, patterns] of processor.subwalks.entries()) {
+            tasks++;
+            this.walkCB2(target, patterns, processor.child(), next);
+        }
+        next();
+    }
+    walkCBSync(target, patterns, cb) {
+        /* c8 ignore start */
+        if (this.signal?.aborted)
+            cb();
+        /* c8 ignore stop */
+        this.walkCB2Sync(target, patterns, new Processor(this.opts), cb);
+    }
+    walkCB2Sync(target, patterns, processor, cb) {
+        if (this.#childrenIgnored(target))
+            return cb();
+        if (this.signal?.aborted)
+            cb();
+        if (this.paused) {
+            this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
+            return;
+        }
+        processor.processPatterns(target, patterns);
+        // done processing.  all of the above is sync, can be abstracted out.
+        // subwalks is a map of paths to the entry filters they need
+        // matches is a map of paths to [absolute, ifDir] tuples.
+        let tasks = 1;
+        const next = () => {
+            if (--tasks === 0)
+                cb();
+        };
+        for (const [m, absolute, ifDir] of processor.matches.entries()) {
+            if (this.#ignored(m))
+                continue;
+            this.matchSync(m, absolute, ifDir);
+        }
+        for (const t of processor.subwalkTargets()) {
+            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+                continue;
+            }
+            tasks++;
+            const children = t.readdirSync();
+            this.walkCB3Sync(t, children, processor, next);
+        }
+        next();
+    }
+    walkCB3Sync(target, entries, processor, cb) {
+        processor = processor.filterEntries(target, entries);
+        let tasks = 1;
+        const next = () => {
+            if (--tasks === 0)
+                cb();
+        };
+        for (const [m, absolute, ifDir] of processor.matches.entries()) {
+            if (this.#ignored(m))
+                continue;
+            this.matchSync(m, absolute, ifDir);
+        }
+        for (const [target, patterns] of processor.subwalks.entries()) {
+            tasks++;
+            this.walkCB2Sync(target, patterns, processor.child(), next);
+        }
+        next();
+    }
+}
+class GlobWalker extends GlobUtil {
+    matches = new Set();
+    constructor(patterns, path, opts) {
+        super(patterns, path, opts);
+    }
+    matchEmit(e) {
+        this.matches.add(e);
+    }
+    async walk() {
+        if (this.signal?.aborted)
+            throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            await this.path.lstat();
+        }
+        await new Promise((res, rej) => {
+            this.walkCB(this.path, this.patterns, () => {
+                if (this.signal?.aborted) {
+                    rej(this.signal.reason);
+                }
+                else {
+                    res(this.matches);
+                }
+            });
+        });
+        return this.matches;
+    }
+    walkSync() {
+        if (this.signal?.aborted)
+            throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
+        }
+        // nothing for the callback to do, because this never pauses
+        this.walkCBSync(this.path, this.patterns, () => {
+            if (this.signal?.aborted)
+                throw this.signal.reason;
+        });
+        return this.matches;
+    }
+}
+class GlobStream extends GlobUtil {
+    results;
+    constructor(patterns, path, opts) {
+        super(patterns, path, opts);
+        this.results = new Minipass({
+            signal: this.signal,
+            objectMode: true,
+        });
+        this.results.on('drain', () => this.resume());
+        this.results.on('resume', () => this.resume());
+    }
+    matchEmit(e) {
+        this.results.write(e);
+        if (!this.results.flowing)
+            this.pause();
+    }
+    stream() {
+        const target = this.path;
+        if (target.isUnknown()) {
+            target.lstat().then(() => {
+                this.walkCB(target, this.patterns, () => this.results.end());
+            });
+        }
+        else {
+            this.walkCB(target, this.patterns, () => this.results.end());
+        }
+        return this.results;
+    }
+    streamSync() {
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
+        }
+        this.walkCBSync(this.path, this.patterns, () => this.results.end());
+        return this.results;
+    }
+}
+
+// if no process global, just call it linux.
+// so we default to case-sensitive, / separators
+const defaultPlatform = (typeof process === 'object' &&
+    process &&
+    typeof process.platform === 'string') ?
+    process.platform
+    : 'linux';
+/**
+ * An object that can perform glob pattern traversals.
+ */
+class Glob {
+    absolute;
+    cwd;
+    root;
+    dot;
+    dotRelative;
+    follow;
+    ignore;
+    magicalBraces;
+    mark;
+    matchBase;
+    maxDepth;
+    nobrace;
+    nocase;
+    nodir;
+    noext;
+    noglobstar;
+    pattern;
+    platform;
+    realpath;
+    scurry;
+    stat;
+    signal;
+    windowsPathsNoEscape;
+    withFileTypes;
+    includeChildMatches;
+    /**
+     * The options provided to the constructor.
+     */
+    opts;
+    /**
+     * An array of parsed immutable {@link Pattern} objects.
+     */
+    patterns;
+    /**
+     * All options are stored as properties on the `Glob` object.
+     *
+     * See {@link GlobOptions} for full options descriptions.
+     *
+     * Note that a previous `Glob` object can be passed as the
+     * `GlobOptions` to another `Glob` instantiation to re-use settings
+     * and caches with a new pattern.
+     *
+     * Traversal functions can be called multiple times to run the walk
+     * again.
+     */
+    constructor(pattern, opts) {
+        /* c8 ignore start */
+        if (!opts)
+            throw new TypeError('glob options required');
+        /* c8 ignore stop */
+        this.withFileTypes = !!opts.withFileTypes;
+        this.signal = opts.signal;
+        this.follow = !!opts.follow;
+        this.dot = !!opts.dot;
+        this.dotRelative = !!opts.dotRelative;
+        this.nodir = !!opts.nodir;
+        this.mark = !!opts.mark;
+        if (!opts.cwd) {
+            this.cwd = '';
+        }
+        else if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) {
+            opts.cwd = fileURLToPath(opts.cwd);
+        }
+        this.cwd = opts.cwd || '';
+        this.root = opts.root;
+        this.magicalBraces = !!opts.magicalBraces;
+        this.nobrace = !!opts.nobrace;
+        this.noext = !!opts.noext;
+        this.realpath = !!opts.realpath;
+        this.absolute = opts.absolute;
+        this.includeChildMatches = opts.includeChildMatches !== false;
+        this.noglobstar = !!opts.noglobstar;
+        this.matchBase = !!opts.matchBase;
+        this.maxDepth =
+            typeof opts.maxDepth === 'number' ? opts.maxDepth : Infinity;
+        this.stat = !!opts.stat;
+        this.ignore = opts.ignore;
+        if (this.withFileTypes && this.absolute !== undefined) {
+            throw new Error('cannot set absolute and withFileTypes:true');
+        }
+        if (typeof pattern === 'string') {
+            pattern = [pattern];
+        }
+        this.windowsPathsNoEscape =
+            !!opts.windowsPathsNoEscape ||
+                opts.allowWindowsEscape ===
+                    false;
+        if (this.windowsPathsNoEscape) {
+            pattern = pattern.map(p => p.replace(/\\/g, '/'));
+        }
+        if (this.matchBase) {
+            if (opts.noglobstar) {
+                throw new TypeError('base matching requires globstar');
+            }
+            pattern = pattern.map(p => (p.includes('/') ? p : `./**/${p}`));
+        }
+        this.pattern = pattern;
+        this.platform = opts.platform || defaultPlatform;
+        this.opts = { ...opts, platform: this.platform };
+        if (opts.scurry) {
+            this.scurry = opts.scurry;
+            if (opts.nocase !== undefined &&
+                opts.nocase !== opts.scurry.nocase) {
+                throw new Error('nocase option contradicts provided scurry option');
+            }
+        }
+        else {
+            const Scurry = opts.platform === 'win32' ? PathScurryWin32
+                : opts.platform === 'darwin' ? PathScurryDarwin
+                    : opts.platform ? PathScurryPosix
+                        : PathScurry;
+            this.scurry = new Scurry(this.cwd, {
+                nocase: opts.nocase,
+                fs: opts.fs,
+            });
+        }
+        this.nocase = this.scurry.nocase;
+        // If you do nocase:true on a case-sensitive file system, then
+        // we need to use regexps instead of strings for non-magic
+        // path portions, because statting `aBc` won't return results
+        // for the file `AbC` for example.
+        const nocaseMagicOnly = this.platform === 'darwin' || this.platform === 'win32';
+        const mmo = {
+            // default nocase based on platform
+            ...opts,
+            dot: this.dot,
+            matchBase: this.matchBase,
+            nobrace: this.nobrace,
+            nocase: this.nocase,
+            nocaseMagicOnly,
+            nocomment: true,
+            noext: this.noext,
+            nonegate: true,
+            optimizationLevel: 2,
+            platform: this.platform,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            debug: !!this.opts.debug,
+        };
+        const mms = this.pattern.map(p => new Minimatch(p, mmo));
+        const [matchSet, globParts] = mms.reduce((set, m) => {
+            set[0].push(...m.set);
+            set[1].push(...m.globParts);
+            return set;
+        }, [[], []]);
+        this.patterns = matchSet.map((set, i) => {
+            const g = globParts[i];
+            /* c8 ignore start */
+            if (!g)
+                throw new Error('invalid pattern object');
+            /* c8 ignore stop */
+            return new Pattern(set, g, 0, this.platform);
+        });
+    }
+    async walk() {
+        // Walkers always return array of Path objects, so we just have to
+        // coerce them into the right shape.  It will have already called
+        // realpath() if the option was set to do so, so we know that's cached.
+        // start out knowing the cwd, at least
+        return [
+            ...(await new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== Infinity ?
+                    this.maxDepth + this.scurry.cwd.depth()
+                    : Infinity,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches,
+            }).walk()),
+        ];
+    }
+    walkSync() {
+        return [
+            ...new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== Infinity ?
+                    this.maxDepth + this.scurry.cwd.depth()
+                    : Infinity,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches,
+            }).walkSync(),
+        ];
+    }
+    stream() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ?
+                this.maxDepth + this.scurry.cwd.depth()
+                : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches,
+        }).stream();
+    }
+    streamSync() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ?
+                this.maxDepth + this.scurry.cwd.depth()
+                : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches,
+        }).streamSync();
+    }
+    /**
+     * Default sync iteration function. Returns a Generator that
+     * iterates over the results.
+     */
+    iterateSync() {
+        return this.streamSync()[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    /**
+     * Default async iteration function. Returns an AsyncGenerator that
+     * iterates over the results.
+     */
+    iterate() {
+        return this.stream()[Symbol.asyncIterator]();
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
+    }
+}
+
+/**
+ * Return true if the patterns provided contain any magic glob characters,
+ * given the options provided.
+ *
+ * Brace expansion is not considered "magic" unless the `magicalBraces` option
+ * is set, as brace expansion just turns one string into an array of strings.
+ * So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and
+ * `'xby'` both do not contain any magic glob characters, and it's treated the
+ * same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`
+ * is in the options, brace expansion _is_ treated as a pattern having magic.
+ */
+const hasMagic = (pattern, options = {}) => {
+    if (!Array.isArray(pattern)) {
+        pattern = [pattern];
+    }
+    for (const p of pattern) {
+        if (new Minimatch(p, options).hasMagic())
+            return true;
+    }
+    return false;
+};
+
+function globStreamSync(pattern, options = {}) {
+    return new Glob(pattern, options).streamSync();
+}
+function globStream(pattern, options = {}) {
+    return new Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+    return new Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+    return new Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+    return new Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+    return new Glob(pattern, options).iterate();
+}
+// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc
+const streamSync = globStreamSync;
+const stream$5 = Object.assign(globStream, { sync: globStreamSync });
+const iterateSync = globIterateSync;
+const iterate = Object.assign(globIterate, {
+    sync: globIterateSync,
+});
+const sync$9 = Object.assign(globSync, {
+    stream: globStreamSync,
+    iterate: globIterateSync,
+});
+const glob$1 = Object.assign(glob_, {
+    glob: glob_,
+    globSync,
+    sync: sync$9,
+    globStream,
+    stream: stream$5,
+    globStreamSync,
+    streamSync,
+    globIterate,
+    iterate,
+    globIterateSync,
+    iterateSync,
+    Glob,
+    hasMagic,
+    escape: escape$2,
+    unescape: unescape$1,
+});
+glob$1.glob = glob$1;
+
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars$1.length; i++) {
+    const c = chars$1.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = reader.next();
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    return relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    if (reader.pos >= max)
+        return false;
+    return reader.peek() !== comma;
+}
+
+const bufLength = 1024 * 16;
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
+class StringReader {
+    constructor(buffer) {
+        this.pos = 0;
+        this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        const { buffer, pos } = this;
+        const idx = buffer.indexOf(char, pos);
+        return idx === -1 ? buffer.length : idx;
+    }
+}
+
+function decode(mappings) {
+    const { length } = mappings;
+    const reader = new StringReader(mappings);
+    const decoded = [];
+    let genColumn = 0;
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    do {
+        const semi = reader.indexOf(';');
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        genColumn = 0;
+        while (reader.pos < semi) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
+                sorted = false;
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                    namesIndex = decodeInteger(reader, namesIndex);
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+                }
+                else {
+                    seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+            }
+            else {
+                seg = [genColumn];
+            }
+            line.push(seg);
+            reader.pos++;
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        reader.pos = semi + 1;
+    } while (reader.pos <= length);
+    return decoded;
+}
+function sort(line) {
+    line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+    return a[0] - b[0];
+}
+function encode$1(decoded) {
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0)
+            writer.write(semicolon);
+        if (line.length === 0)
+            continue;
+        let genColumn = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            if (j > 0)
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
+            if (segment.length === 1)
+                continue;
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+            if (segment.length === 4)
+                continue;
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
+        }
+    }
+    return writer.flush();
+}
+
+class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+
+	has(n) {
+		return !!(this.bits[n >> 5] & (1 << (n & 31)));
+	}
+}
+
+class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+
+		this.intro = '';
+		this.outro = '';
+
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+
+		{
+			this.previous = null;
+			this.next = null;
+		}
+	}
+
+	appendLeft(content) {
+		this.outro += content;
+	}
+
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+
+		return chunk;
+	}
+
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+
+	eachNext(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+
+	eachPrevious(fn) {
+		let chunk = this;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = '';
+			this.outro = '';
+		}
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	}
+
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+
+	reset() {
+		this.intro = '';
+		this.outro = '';
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+
+	split(index) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+
+		this.original = originalBefore;
+
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = '';
+
+		this.end = index;
+
+		if (this.edited) {
+			// after split we should save the edit content record into the correct chunk
+			// to make sure sourcemap correct
+			// For example:
+			// '  test'.trim()
+			//     split   -> '  ' + 'test'
+			//   ✔️ edit    -> '' + 'test'
+			//   ✖️ edit    -> 'test' + '' 
+			// TODO is this block necessary?...
+			newChunk.edit('', false);
+			this.content = '';
+		} else {
+			this.content = originalBefore;
+		}
+
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+
+		return newChunk;
+	}
+
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				this.split(this.start + trimmed.length).edit('', undefined, true);
+				if (this.edited) {
+					// save the change, if it has been edited
+					this.edit(trimmed, this.storeName, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.intro = this.intro.replace(rx, '');
+			if (this.intro.length) return true;
+		}
+	}
+
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		const trimmed = this.content.replace(rx, '');
+
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				const newChunk = this.split(this.end - trimmed.length);
+				if (this.edited) {
+					// save the change, if it has been edited
+					newChunk.edit(trimmed, this.storeName, true);
+				}
+				this.edit('', undefined, true);
+			}
+			return true;
+		} else {
+			this.edit('', undefined, true);
+
+			this.outro = this.outro.replace(rx, '');
+			if (this.outro.length) return true;
+		}
+	}
+}
+
+function getBtoa() {
+	if (typeof globalThis !== 'undefined' && typeof globalThis.btoa === 'function') {
+		return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
+}
+
+const btoa$1 = /*#__PURE__*/ getBtoa();
+
+let SourceMap$1 = class SourceMap {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = encode$1(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== 'undefined') {
+			this.x_google_ignoreList = properties.x_google_ignoreList;
+		}
+	}
+
+	toString() {
+		return JSON.stringify(this);
+	}
+
+	toUrl() {
+		return 'data:application/json;charset=utf-8;base64,' + btoa$1(this.toString());
+	}
+};
+
+function guessIndent(code) {
+	const lines = code.split('\n');
+
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+
+	if (tabbed.length === 0 && spaced.length === 0) {
+		return null;
+	}
+
+	// More lines tabbed than spaced? Assume tabs, and
+	// default to tabs in the case of a tie (or nothing
+	// to go on)
+	if (tabbed.length >= spaced.length) {
+		return '\t';
+	}
+
+	// Otherwise, we need to guess the multiple
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+
+	return new Array(min + 1).join(' ');
+}
+
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+
+	fromParts.pop(); // get dirname
+
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = '..';
+	}
+
+	return fromParts.concat(toParts).join('/');
+}
+
+const toString$1 = Object.prototype.toString;
+
+function isObject$2(thing) {
+	return toString$1.call(thing) === '[object Object]';
+}
+
+function getLocator(source) {
+	const originalLines = source.split('\n');
+	const lineOffsets = [];
+
+	for (let i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
+	}
+
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
+		}
+		const line = i - 1;
+		const column = index - lineOffsets[line];
+		return { line, column };
+	};
+}
+
+const wordRegex = /\w/;
+
+class Mappings {
+	constructor(hires) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.pending = null;
+	}
+
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf('\n', 0);
+			let previousContentLineEnd = -1;
+			// Loop through each line in the content and add a segment, but stop if the last line is empty,
+			// else code afterwards would fill one line too many
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+				if (nameIndex >= 0) {
+					segment.push(nameIndex);
+				}
+				this.rawSegments.push(segment);
+
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+			}
+
+			const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+			if (nameIndex >= 0) {
+				segment.push(nameIndex);
+			}
+			this.rawSegments.push(segment);
+
+			this.advance(content.slice(previousContentLineEnd + 1));
+		} else if (this.pending) {
+			this.rawSegments.push(this.pending);
+			this.advance(content);
+		}
+
+		this.pending = null;
+	}
+
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		let originalCharIndex = chunk.start;
+		let first = true;
+		// when iterating each char, check if it's in a word boundary
+		let charInHiresBoundary = false;
+
+		while (originalCharIndex < chunk.end) {
+			if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+				const segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+
+				if (this.hires === 'boundary') {
+					// in hires "boundary", group segments per word boundary than per char
+					if (wordRegex.test(original[originalCharIndex])) {
+						// for first char in the boundary found, start the boundary by pushing a segment
+						if (!charInHiresBoundary) {
+							this.rawSegments.push(segment);
+							charInHiresBoundary = true;
+						}
+					} else {
+						// for non-word char, end the boundary by pushing a segment
+						this.rawSegments.push(segment);
+						charInHiresBoundary = false;
+					}
+				} else {
+					this.rawSegments.push(segment);
+				}
+			}
+
+			if (original[originalCharIndex] === '\n') {
+				loc.line += 1;
+				loc.column = 0;
+				this.generatedCodeLine += 1;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+				this.generatedCodeColumn = 0;
+				first = true;
+			} else {
+				loc.column += 1;
+				this.generatedCodeColumn += 1;
+				first = false;
+			}
+
+			originalCharIndex += 1;
+		}
+
+		this.pending = null;
+	}
+
+	advance(str) {
+		if (!str) return;
+
+		const lines = str.split('\n');
+
+		if (lines.length > 1) {
+			for (let i = 0; i < lines.length - 1; i++) {
+				this.generatedCodeLine++;
+				this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			}
+			this.generatedCodeColumn = 0;
+		}
+
+		this.generatedCodeColumn += lines[lines.length - 1].length;
+	}
+}
+
+const n$1 = '\n';
+
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false,
+};
+
+class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+
+		Object.defineProperties(this, {
+			original: { writable: true, value: string },
+			outro: { writable: true, value: '' },
+			intro: { writable: true, value: '' },
+			firstChunk: { writable: true, value: chunk },
+			lastChunk: { writable: true, value: chunk },
+			lastSearchedChunk: { writable: true, value: chunk },
+			byStart: { writable: true, value: {} },
+			byEnd: { writable: true, value: {} },
+			filename: { writable: true, value: options.filename },
+			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
+			sourcemapLocations: { writable: true, value: new BitSet() },
+			storedNames: { writable: true, value: {} },
+			indentStr: { writable: true, value: undefined },
+			ignoreList: { writable: true, value: options.ignoreList },
+		});
+
+		this.byStart[0] = chunk;
+		this.byEnd[string.length] = chunk;
+	}
+
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+
+	append(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.outro += content;
+		return this;
+	}
+
+	appendLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.appendLeft(content);
+		} else {
+			this.intro += content;
+		}
+		return this;
+	}
+
+	appendRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.appendRight(content);
+		} else {
+			this.outro += content;
+		}
+		return this;
+	}
+
+	clone() {
+		const cloned = new MagicString(this.original, { filename: this.filename });
+
+		let originalChunk = this.firstChunk;
+		let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
+
+		while (originalChunk) {
+			cloned.byStart[clonedChunk.start] = clonedChunk;
+			cloned.byEnd[clonedChunk.end] = clonedChunk;
+
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+
+				clonedChunk = nextClonedChunk;
+			}
+
+			originalChunk = nextOriginalChunk;
+		}
+
+		cloned.lastChunk = clonedChunk;
+
+		if (this.indentExclusionRanges) {
+			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		}
+
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+
+		return cloned;
+	}
+
+	generateDecodedMap(options) {
+		options = options || {};
+
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const mappings = new Mappings(options.hires);
+
+		const locate = getLocator(this.original);
+
+		if (this.intro) {
+			mappings.advance(this.intro);
+		}
+
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+
+			if (chunk.edited) {
+				mappings.addEdit(
+					sourceIndex,
+					chunk.content,
+					loc,
+					chunk.storeName ? names.indexOf(chunk.original) : -1,
+				);
+			} else {
+				mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			}
+
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
+			sources: [
+				options.source ? getRelativePath(options.file || '', options.source) : options.file || '',
+			],
+			sourcesContent: options.includeContent ? [this.original] : undefined,
+			names,
+			mappings: mappings.raw,
+			x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined,
+		};
+	}
+
+	generateMap(options) {
+		return new SourceMap$1(this.generateDecodedMap(options));
+	}
+
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? '\t' : this.indentStr;
+	}
+
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+
+		if (isObject$2(indentStr)) {
+			options = indentStr;
+			indentStr = undefined;
+		}
+
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
+
+		if (indentStr === '') return this; // noop
+
+		options = options || {};
+
+		// Process exclusion ranges
+		const isExcluded = {};
+
+		if (options.exclude) {
+			const exclusions =
+				typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+			exclusions.forEach((exclusion) => {
+				for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
+					isExcluded[i] = true;
+				}
+			});
+		}
+
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const replacer = (match) => {
+			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
+			shouldIndentNextCharacter = true;
+			return match;
+		};
+
+		this.intro = this.intro.replace(pattern, replacer);
+
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+
+		while (chunk) {
+			const end = chunk.end;
+
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) {
+					chunk.content = chunk.content.replace(pattern, replacer);
+
+					if (chunk.content.length) {
+						shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
+					}
+				}
+			} else {
+				charIndex = chunk.start;
+
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original[charIndex];
+
+						if (char === '\n') {
+							shouldIndentNextCharacter = true;
+						} else if (char !== '\r' && shouldIndentNextCharacter) {
+							shouldIndentNextCharacter = false;
+
+							if (charIndex === chunk.start) {
+								chunk.prependRight(indentStr);
+							} else {
+								this._splitChunk(chunk, charIndex);
+								chunk = chunk.next;
+								chunk.prependRight(indentStr);
+							}
+						}
+					}
+
+					charIndex += 1;
+				}
+			}
+
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+
+		this.outro = this.outro.replace(pattern, replacer);
+
+		return this;
+	}
+
+	insert() {
+		throw new Error(
+			'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)',
+		);
+	}
+
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn(
+				'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft(index, content);
+	}
+
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn(
+				'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead',
+			); // eslint-disable-line no-console
+			warned.insertRight = true;
+		}
+
+		return this.prependRight(index, content);
+	}
+
+	move(start, end, index) {
+		if (index >= start && index <= end) throw new Error('Cannot move a selection inside itself');
+
+		this._split(start);
+		this._split(end);
+		this._split(index);
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+
+		const newRight = this.byStart[index];
+		if (!newRight && last === this.lastChunk) return this;
+		const newLeft = newRight ? newRight.previous : this.lastChunk;
+
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+
+		first.previous = newLeft;
+		last.next = newRight || null;
+
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		return this;
+	}
+
+	overwrite(start, end, content, options) {
+		options = options || {};
+		return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
+	}
+
+	update(start, end, content, options) {
+		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
+
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (end > this.original.length) throw new Error('end is out of bounds');
+		if (start === end)
+			throw new Error(
+				'Cannot overwrite a zero-length range – use appendLeft or prependRight instead',
+			);
+
+		this._split(start);
+		this._split(end);
+
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn(
+					'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string',
+				); // eslint-disable-line no-console
+				warned.storeName = true;
+			}
+
+			options = { storeName: true };
+		}
+		const storeName = options !== undefined ? options.storeName : false;
+		const overwrite = options !== undefined ? options.overwrite : false;
+
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true,
+			});
+		}
+
+		const first = this.byStart[start];
+		const last = this.byEnd[end];
+
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart[chunk.end]) {
+					throw new Error('Cannot overwrite across a split point');
+				}
+				chunk = chunk.next;
+				chunk.edit('', false);
+			}
+
+			first.edit(content, storeName, !overwrite);
+		} else {
+			// must be inserting at the end
+			const newChunk = new Chunk(start, end, '').edit(content, storeName);
+
+			// TODO last chunk in the array may not be the last chunk, if it's moved...
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+
+	prepend(content) {
+		if (typeof content !== 'string') throw new TypeError('outro content must be a string');
+
+		this.intro = content + this.intro;
+		return this;
+	}
+
+	prependLeft(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byEnd[index];
+
+		if (chunk) {
+			chunk.prependLeft(content);
+		} else {
+			this.intro = content + this.intro;
+		}
+		return this;
+	}
+
+	prependRight(index, content) {
+		if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
+
+		this._split(index);
+
+		const chunk = this.byStart[index];
+
+		if (chunk) {
+			chunk.prependRight(content);
+		} else {
+			this.outro = content + this.outro;
+		}
+		return this;
+	}
+
+	remove(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit('');
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	reset(start, end) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		if (start === end) return this;
+
+		if (start < 0 || end > this.original.length) throw new Error('Character is out of bounds');
+		if (start > end) throw new Error('end must be greater than start');
+
+		this._split(start);
+		this._split(end);
+
+		let chunk = this.byStart[start];
+
+		while (chunk) {
+			chunk.reset();
+
+			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+		}
+		return this;
+	}
+
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+		} while ((chunk = chunk.previous));
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return '';
+	}
+
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n$1);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		do {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n$1);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n$1);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n$1);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+		} while ((chunk = chunk.previous));
+		lineIndex = this.intro.lastIndexOf(n$1);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+
+	slice(start = 0, end = this.original.length) {
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
+
+		let result = '';
+
+		// find start chunk
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			// found end chunk before start
+			if (chunk.start < end && chunk.end >= end) {
+				return result;
+			}
+
+			chunk = chunk.next;
+		}
+
+		if (chunk && chunk.edited && chunk.start !== start)
+			throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
+
+		const startChunk = chunk;
+		while (chunk) {
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+				result += chunk.intro;
+			}
+
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end)
+				throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
+
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+
+			result += chunk.content.slice(sliceStart, sliceEnd);
+
+			if (chunk.outro && (!containsEnd || chunk.end === end)) {
+				result += chunk.outro;
+			}
+
+			if (containsEnd) {
+				break;
+			}
+
+			chunk = chunk.next;
+		}
+
+		return result;
+	}
+
+	// TODO deprecate this? not really very useful
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+
+		return clone;
+	}
+
+	_split(index) {
+		if (this.byStart[index] || this.byEnd[index]) return;
+
+		let chunk = this.lastSearchedChunk;
+		const searchForward = index > chunk.end;
+
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+
+			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+		}
+	}
+
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			// zero-length edited chunks are a special case (overlapping replacements)
+			const loc = getLocator(this.original)(index);
+			throw new Error(
+				`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`,
+			);
+		}
+
+		const newChunk = chunk.split(index);
+
+		this.byEnd[index] = chunk;
+		this.byStart[index] = newChunk;
+		this.byEnd[newChunk.end] = newChunk;
+
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+
+	toString() {
+		let str = this.intro;
+
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+
+		return str + this.outro;
+	}
+
+	isEmpty() {
+		let chunk = this.firstChunk;
+		do {
+			if (
+				(chunk.intro.length && chunk.intro.trim()) ||
+				(chunk.content.length && chunk.content.trim()) ||
+				(chunk.outro.length && chunk.outro.trim())
+			)
+				return false;
+		} while ((chunk = chunk.next));
+		return true;
+	}
+
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		do {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+		} while ((chunk = chunk.next));
+		return length;
+	}
+
+	trimLines() {
+		return this.trim('[\\r\\n]');
+	}
+
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+
+	trimEndAborted(charType) {
+		const rx = new RegExp((charType || '\\s') + '+$');
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) return true;
+
+		let chunk = this.lastChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+
+			// if chunk was trimmed, we have a new lastChunk
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) {
+					this.lastChunk = chunk.next;
+				}
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	trimStartAborted(charType) {
+		const rx = new RegExp('^' + (charType || '\\s') + '+');
+
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) return true;
+
+		let chunk = this.firstChunk;
+
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+
+			if (chunk.end !== end) {
+				// special case...
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+
+				this.byEnd[chunk.end] = chunk;
+				this.byStart[chunk.next.start] = chunk.next;
+				this.byEnd[chunk.next.end] = chunk.next;
+			}
+
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+
+		return false;
+	}
+
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+
+	hasChanged() {
+		return this.original !== this.toString();
+	}
+
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === 'string') {
+				return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
+					// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+					if (i === '$') return '$';
+					if (i === '&') return match[0];
+					const num = +i;
+					if (num < match.length) return match[+i];
+					return `$${i}`;
+				});
+			} else {
+				return replacement(...match, match.index, str, match.groups);
+			}
+		}
+		function matchAll(re, str) {
+			let match;
+			const matches = [];
+			while ((match = re.exec(str))) {
+				matches.push(match);
+			}
+			return matches;
+		}
+		if (searchValue.global) {
+			const matches = matchAll(searchValue, this.original);
+			matches.forEach((match) => {
+				if (match.index != null) {
+					const replacement = getReplacement(match, this.original);
+					if (replacement !== match[0]) {
+						this.overwrite(
+							match.index,
+							match.index + match[0].length,
+							replacement
+						);
+					}
+				}
+			});
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && match.index != null) {
+				const replacement = getReplacement(match, this.original);
+				if (replacement !== match[0]) {
+					this.overwrite(
+						match.index,
+						match.index + match[0].length,
+						replacement
+					);
+				}
+			}
+		}
+		return this;
+	}
+
+	_replaceString(string, replacement) {
+		const { original } = this;
+		const index = original.indexOf(string);
+
+		if (index !== -1) {
+			this.overwrite(index, index + string.length, replacement);
+		}
+
+		return this;
+	}
+
+	replace(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceString(searchValue, replacement);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		for (
+			let index = original.indexOf(string);
+			index !== -1;
+			index = original.indexOf(string, index + stringLength)
+		) {
+			const previous = original.slice(index, index + stringLength);
+			if (previous !== replacement)
+				this.overwrite(index, index + stringLength, replacement);
+		}
+
+		return this;
+	}
+
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === 'string') {
+			return this._replaceAllString(searchValue, replacement);
+		}
+
+		if (!searchValue.global) {
+			throw new TypeError(
+				'MagicString.prototype.replaceAll called with a non-global RegExp argument',
+			);
+		}
+
+		return this._replaceRegexp(searchValue, replacement);
+	}
+}
+
+function isReference(node, parent) {
+    if (node.type === 'MemberExpression') {
+        return !node.computed && isReference(node.object, node);
+    }
+    if (node.type === 'Identifier') {
+        if (!parent)
+            return true;
+        switch (parent.type) {
+            // disregard `bar` in `foo.bar`
+            case 'MemberExpression': return parent.computed || node === parent.object;
+            // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+            case 'MethodDefinition': return parent.computed;
+            // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+            case 'FieldDefinition': return parent.computed || node === parent.value;
+            // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+            case 'Property': return parent.computed || node === parent.value;
+            // disregard the `bar` in `export { foo as bar }` or
+            // the foo in `import { foo as bar }`
+            case 'ExportSpecifier':
+            case 'ImportSpecifier': return node === parent.local;
+            // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+            case 'LabeledStatement':
+            case 'BreakStatement':
+            case 'ContinueStatement': return false;
+            default: return true;
+        }
+    }
+    return false;
+}
+
+var version$2 = "26.0.1";
+var peerDependencies = {
+	rollup: "^2.68.0||^3.0.0||^4.0.0"
+};
+
+function tryParse(parse, code, id) {
+  try {
+    return parse(code, { allowReturnOutsideFunction: true });
+  } catch (err) {
+    err.message += ` in ${id}`;
+    throw err;
+  }
+}
+
+const firstpassGlobal = /\b(?:require|module|exports|global)\b/;
+
+const firstpassNoGlobal = /\b(?:require|module|exports)\b/;
+
+function hasCjsKeywords(code, ignoreGlobal) {
+  const firstpass = ignoreGlobal ? firstpassNoGlobal : firstpassGlobal;
+  return firstpass.test(code);
+}
+
+/* eslint-disable no-underscore-dangle */
+
+
+function analyzeTopLevelStatements(parse, code, id) {
+  const ast = tryParse(parse, code, id);
+
+  let isEsModule = false;
+  let hasDefaultExport = false;
+  let hasNamedExports = false;
+
+  for (const node of ast.body) {
+    switch (node.type) {
+      case 'ExportDefaultDeclaration':
+        isEsModule = true;
+        hasDefaultExport = true;
+        break;
+      case 'ExportNamedDeclaration':
+        isEsModule = true;
+        if (node.declaration) {
+          hasNamedExports = true;
+        } else {
+          for (const specifier of node.specifiers) {
+            if (specifier.exported.name === 'default') {
+              hasDefaultExport = true;
+            } else {
+              hasNamedExports = true;
+            }
+          }
+        }
+        break;
+      case 'ExportAllDeclaration':
+        isEsModule = true;
+        if (node.exported && node.exported.name === 'default') {
+          hasDefaultExport = true;
+        } else {
+          hasNamedExports = true;
+        }
+        break;
+      case 'ImportDeclaration':
+        isEsModule = true;
+        break;
+    }
+  }
+
+  return { isEsModule, hasDefaultExport, hasNamedExports, ast };
+}
+
+/* eslint-disable import/prefer-default-export */
+
+
+function deconflict(scopes, globals, identifier) {
+  let i = 1;
+  let deconflicted = makeLegalIdentifier(identifier);
+  const hasConflicts = () =>
+    scopes.some((scope) => scope.contains(deconflicted)) || globals.has(deconflicted);
+
+  while (hasConflicts()) {
+    deconflicted = makeLegalIdentifier(`${identifier}_${i}`);
+    i += 1;
+  }
+
+  for (const scope of scopes) {
+    scope.declarations[deconflicted] = true;
+  }
+
+  return deconflicted;
+}
+
+function getName(id) {
+  const name = makeLegalIdentifier(basename$1(id, extname(id)));
+  if (name !== 'index') {
+    return name;
+  }
+  return makeLegalIdentifier(basename$1(dirname$1(id)));
+}
+
+function normalizePathSlashes(path) {
+  return path.replace(/\\/g, '/');
+}
+
+const getVirtualPathForDynamicRequirePath = (path, commonDir) =>
+  `/${normalizePathSlashes(relative$1(commonDir, path))}`;
+
+function capitalize(name) {
+  return name[0].toUpperCase() + name.slice(1);
+}
+
+function getStrictRequiresFilter({ strictRequires }) {
+  switch (strictRequires) {
+    case true:
+      return { strictRequiresFilter: () => true, detectCyclesAndConditional: false };
+    // eslint-disable-next-line no-undefined
+    case undefined:
+    case 'auto':
+    case 'debug':
+    case null:
+      return { strictRequiresFilter: () => false, detectCyclesAndConditional: true };
+    case false:
+      return { strictRequiresFilter: () => false, detectCyclesAndConditional: false };
+    default:
+      if (typeof strictRequires === 'string' || Array.isArray(strictRequires)) {
+        return {
+          strictRequiresFilter: createFilter$1(strictRequires),
+          detectCyclesAndConditional: false
+        };
+      }
+      throw new Error('Unexpected value for "strictRequires" option.');
+  }
+}
+
+function getPackageEntryPoint(dirPath) {
+  let entryPoint = 'index.js';
+
+  try {
+    if (existsSync(join$1(dirPath, 'package.json'))) {
+      entryPoint =
+        JSON.parse(readFileSync(join$1(dirPath, 'package.json'), { encoding: 'utf8' })).main ||
+        entryPoint;
+    }
+  } catch (ignored) {
+    // ignored
+  }
+
+  return entryPoint;
+}
+
+function isDirectory$1(path) {
+  try {
+    if (statSync$1(path).isDirectory()) return true;
+  } catch (ignored) {
+    // Nothing to do here
+  }
+  return false;
+}
+
+function getDynamicRequireModules(patterns, dynamicRequireRoot) {
+  const dynamicRequireModules = new Map();
+  const dirNames = new Set();
+  for (const pattern of !patterns || Array.isArray(patterns) ? patterns || [] : [patterns]) {
+    const isNegated = pattern.startsWith('!');
+    const modifyMap = (targetPath, resolvedPath) =>
+      isNegated
+        ? dynamicRequireModules.delete(targetPath)
+        : dynamicRequireModules.set(targetPath, resolvedPath);
+    for (const path of glob$1
+      .sync(isNegated ? pattern.substr(1) : pattern)
+      .sort((a, b) => a.localeCompare(b, 'en'))) {
+      const resolvedPath = resolve$3(path);
+      const requirePath = normalizePathSlashes(resolvedPath);
+      if (isDirectory$1(resolvedPath)) {
+        dirNames.add(resolvedPath);
+        const modulePath = resolve$3(join$1(resolvedPath, getPackageEntryPoint(path)));
+        modifyMap(requirePath, modulePath);
+        modifyMap(normalizePathSlashes(modulePath), modulePath);
+      } else {
+        dirNames.add(dirname$1(resolvedPath));
+        modifyMap(requirePath, resolvedPath);
+      }
+    }
+  }
+  return {
+    commonDir: dirNames.size ? getCommonDir([...dirNames, dynamicRequireRoot]) : null,
+    dynamicRequireModules
+  };
+}
+
+const FAILED_REQUIRE_ERROR = `throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');`;
+
+const COMMONJS_REQUIRE_EXPORT = 'commonjsRequire';
+const CREATE_COMMONJS_REQUIRE_EXPORT = 'createCommonjsRequire';
+
+function getDynamicModuleRegistry(
+  isDynamicRequireModulesEnabled,
+  dynamicRequireModules,
+  commonDir,
+  ignoreDynamicRequires
+) {
+  if (!isDynamicRequireModulesEnabled) {
+    return `export function ${COMMONJS_REQUIRE_EXPORT}(path) {
+	${FAILED_REQUIRE_ERROR}
+}`;
+  }
+  const dynamicModuleImports = [...dynamicRequireModules.values()]
+    .map(
+      (id, index) =>
+        `import ${
+          id.endsWith('.json') ? `json${index}` : `{ __require as require${index} }`
+        } from ${JSON.stringify(id)};`
+    )
+    .join('\n');
+  const dynamicModuleProps = [...dynamicRequireModules.keys()]
+    .map(
+      (id, index) =>
+        `\t\t${JSON.stringify(getVirtualPathForDynamicRequirePath(id, commonDir))}: ${
+          id.endsWith('.json') ? `function () { return json${index}; }` : `require${index}`
+        }`
+    )
+    .join(',\n');
+  return `${dynamicModuleImports}
+
+var dynamicModules;
+
+function getDynamicModules() {
+	return dynamicModules || (dynamicModules = {
+${dynamicModuleProps}
+	});
+}
+
+export function ${CREATE_COMMONJS_REQUIRE_EXPORT}(originalModuleDir) {
+	function handleRequire(path) {
+		var resolvedPath = commonjsResolve(path, originalModuleDir);
+		if (resolvedPath !== null) {
+			return getDynamicModules()[resolvedPath]();
+		}
+		${ignoreDynamicRequires ? 'return require(path);' : FAILED_REQUIRE_ERROR}
+	}
+	handleRequire.resolve = function (path) {
+		var resolvedPath = commonjsResolve(path, originalModuleDir);
+		if (resolvedPath !== null) {
+			return resolvedPath;
+		}
+		return require.resolve(path);
+	}
+	return handleRequire;
+}
+
+function commonjsResolve (path, originalModuleDir) {
+	var shouldTryNodeModules = isPossibleNodeModulesPath(path);
+	path = normalize(path);
+	var relPath;
+	if (path[0] === '/') {
+		originalModuleDir = '';
+	}
+	var modules = getDynamicModules();
+	var checkedExtensions = ['', '.js', '.json'];
+	while (true) {
+		if (!shouldTryNodeModules) {
+			relPath = normalize(originalModuleDir + '/' + path);
+		} else {
+			relPath = normalize(originalModuleDir + '/node_modules/' + path);
+		}
+
+		if (relPath.endsWith('/..')) {
+			break; // Travelled too far up, avoid infinite loop
+		}
+
+		for (var extensionIndex = 0; extensionIndex < checkedExtensions.length; extensionIndex++) {
+			var resolvedPath = relPath + checkedExtensions[extensionIndex];
+			if (modules[resolvedPath]) {
+				return resolvedPath;
+			}
+		}
+		if (!shouldTryNodeModules) break;
+		var nextDir = normalize(originalModuleDir + '/..');
+		if (nextDir === originalModuleDir) break;
+		originalModuleDir = nextDir;
+	}
+	return null;
+}
+
+function isPossibleNodeModulesPath (modulePath) {
+	var c0 = modulePath[0];
+	if (c0 === '/' || c0 === '\\\\') return false;
+	var c1 = modulePath[1], c2 = modulePath[2];
+	if ((c0 === '.' && (!c1 || c1 === '/' || c1 === '\\\\')) ||
+		(c0 === '.' && c1 === '.' && (!c2 || c2 === '/' || c2 === '\\\\'))) return false;
+	if (c1 === ':' && (c2 === '/' || c2 === '\\\\')) return false;
+	return true;
+}
+
+function normalize (path) {
+	path = path.replace(/\\\\/g, '/');
+	var parts = path.split('/');
+	var slashed = parts[0] === '';
+	for (var i = 1; i < parts.length; i++) {
+		if (parts[i] === '.' || parts[i] === '') {
+			parts.splice(i--, 1);
+		}
+	}
+	for (var i = 1; i < parts.length; i++) {
+		if (parts[i] !== '..') continue;
+		if (i > 0 && parts[i - 1] !== '..' && parts[i - 1] !== '.') {
+			parts.splice(--i, 2);
+			i--;
+		}
+	}
+	path = parts.join('/');
+	if (slashed && path[0] !== '/') path = '/' + path;
+	else if (path.length === 0) path = '.';
+	return path;
+}`;
+}
+
+const isWrappedId = (id, suffix) => id.endsWith(suffix);
+const wrapId = (id, suffix) => `\0${id}${suffix}`;
+const unwrapId = (wrappedId, suffix) => wrappedId.slice(1, -suffix.length);
+
+const PROXY_SUFFIX = '?commonjs-proxy';
+const WRAPPED_SUFFIX = '?commonjs-wrapped';
+const EXTERNAL_SUFFIX = '?commonjs-external';
+const EXPORTS_SUFFIX = '?commonjs-exports';
+const MODULE_SUFFIX = '?commonjs-module';
+const ENTRY_SUFFIX = '?commonjs-entry';
+const ES_IMPORT_SUFFIX = '?commonjs-es-import';
+
+const DYNAMIC_MODULES_ID = '\0commonjs-dynamic-modules';
+const HELPERS_ID = '\0commonjsHelpers.js';
+
+const IS_WRAPPED_COMMONJS = 'withRequireFunction';
+
+// `x['default']` is used instead of `x.default` for backward compatibility with ES3 browsers.
+// Minifiers like uglify will usually transpile it back if compatibility with ES3 is not enabled.
+// This could be improved by inspecting Rollup's "generatedCode" option
+
+const HELPERS = `
+export var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+export function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export function getDefaultExportFromNamespaceIfPresent (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') ? n['default'] : n;
+}
+
+export function getDefaultExportFromNamespaceIfNotNamed (n) {
+	return n && Object.prototype.hasOwnProperty.call(n, 'default') && Object.keys(n).length === 1 ? n['default'] : n;
+}
+
+export function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+`;
+
+function getHelpersModule() {
+  return HELPERS;
+}
+
+function getUnknownRequireProxy(id, requireReturnsDefault) {
+  if (requireReturnsDefault === true || id.endsWith('.json')) {
+    return `export { default } from ${JSON.stringify(id)};`;
+  }
+  const name = getName(id);
+  const exported =
+    requireReturnsDefault === 'auto'
+      ? `import { getDefaultExportFromNamespaceIfNotNamed } from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfNotNamed(${name});`
+      : requireReturnsDefault === 'preferred'
+      ? `import { getDefaultExportFromNamespaceIfPresent } from "${HELPERS_ID}"; export default /*@__PURE__*/getDefaultExportFromNamespaceIfPresent(${name});`
+      : !requireReturnsDefault
+      ? `import { getAugmentedNamespace } from "${HELPERS_ID}"; export default /*@__PURE__*/getAugmentedNamespace(${name});`
+      : `export default ${name};`;
+  return `import * as ${name} from ${JSON.stringify(id)}; ${exported}`;
+}
+
+async function getStaticRequireProxy(id, requireReturnsDefault, loadModule) {
+  const name = getName(id);
+  const {
+    meta: { commonjs: commonjsMeta }
+  } = await loadModule({ id });
+  if (!commonjsMeta) {
+    return getUnknownRequireProxy(id, requireReturnsDefault);
+  }
+  if (commonjsMeta.isCommonJS) {
+    return `export { __moduleExports as default } from ${JSON.stringify(id)};`;
+  }
+  if (!requireReturnsDefault) {
+    return `import { getAugmentedNamespace } from "${HELPERS_ID}"; import * as ${name} from ${JSON.stringify(
+      id
+    )}; export default /*@__PURE__*/getAugmentedNamespace(${name});`;
+  }
+  if (
+    requireReturnsDefault !== true &&
+    (requireReturnsDefault === 'namespace' ||
+      !commonjsMeta.hasDefaultExport ||
+      (requireReturnsDefault === 'auto' && commonjsMeta.hasNamedExports))
+  ) {
+    return `import * as ${name} from ${JSON.stringify(id)}; export default ${name};`;
+  }
+  return `export { default } from ${JSON.stringify(id)};`;
+}
+
+function getEntryProxy(id, defaultIsModuleExports, getModuleInfo, shebang) {
+  const {
+    meta: { commonjs: commonjsMeta },
+    hasDefaultExport
+  } = getModuleInfo(id);
+  if (!commonjsMeta || commonjsMeta.isCommonJS !== IS_WRAPPED_COMMONJS) {
+    const stringifiedId = JSON.stringify(id);
+    let code = `export * from ${stringifiedId};`;
+    if (hasDefaultExport) {
+      code += `export { default } from ${stringifiedId};`;
+    }
+    return shebang + code;
+  }
+  const result = getEsImportProxy(id, defaultIsModuleExports);
+  return {
+    ...result,
+    code: shebang + result.code
+  };
+}
+
+function getEsImportProxy(id, defaultIsModuleExports) {
+  const name = getName(id);
+  const exportsName = `${name}Exports`;
+  const requireModule = `require${capitalize(name)}`;
+  let code =
+    `import { getDefaultExportFromCjs } from "${HELPERS_ID}";\n` +
+    `import { __require as ${requireModule} } from ${JSON.stringify(id)};\n` +
+    `var ${exportsName} = ${requireModule}();\n` +
+    `export { ${exportsName} as __moduleExports };`;
+  if (defaultIsModuleExports === true) {
+    code += `\nexport { ${exportsName} as default };`;
+  } else {
+    code += `export default /*@__PURE__*/getDefaultExportFromCjs(${exportsName});`;
+  }
+  return {
+    code,
+    syntheticNamedExports: '__moduleExports'
+  };
+}
+
+/* eslint-disable no-param-reassign, no-undefined */
+
+
+function getCandidatesForExtension(resolved, extension) {
+  return [resolved + extension, `${resolved}${sep$1}index${extension}`];
+}
+
+function getCandidates(resolved, extensions) {
+  return extensions.reduce(
+    (paths, extension) => paths.concat(getCandidatesForExtension(resolved, extension)),
+    [resolved]
+  );
+}
+
+function resolveExtensions(importee, importer, extensions) {
+  // not our problem
+  if (importee[0] !== '.' || !importer) return undefined;
+
+  const resolved = resolve$3(dirname$1(importer), importee);
+  const candidates = getCandidates(resolved, extensions);
+
+  for (let i = 0; i < candidates.length; i += 1) {
+    try {
+      const stats = statSync$1(candidates[i]);
+      if (stats.isFile()) return { id: candidates[i] };
+    } catch (err) {
+      /* noop */
+    }
+  }
+
+  return undefined;
+}
+
+function getResolveId(extensions, isPossibleCjsId) {
+  const currentlyResolving = new Map();
+
+  return {
+    /**
+     * This is a Maps of importers to Sets of require sources being resolved at
+     * the moment by resolveRequireSourcesAndUpdateMeta
+     */
+    currentlyResolving,
+    async resolveId(importee, importer, resolveOptions) {
+      const customOptions = resolveOptions.custom;
+      // All logic below is specific to ES imports.
+      // Also, if we do not skip this logic for requires that are resolved while
+      // transforming a commonjs file, it can easily lead to deadlocks.
+      if (
+        customOptions &&
+        customOptions['node-resolve'] &&
+        customOptions['node-resolve'].isRequire
+      ) {
+        return null;
+      }
+      const currentlyResolvingForParent = currentlyResolving.get(importer);
+      if (currentlyResolvingForParent && currentlyResolvingForParent.has(importee)) {
+        this.warn({
+          code: 'THIS_RESOLVE_WITHOUT_OPTIONS',
+          message:
+            'It appears a plugin has implemented a "resolveId" hook that uses "this.resolve" without forwarding the third "options" parameter of "resolveId". This is problematic as it can lead to wrong module resolutions especially for the node-resolve plugin and in certain cases cause early exit errors for the commonjs plugin.\nIn rare cases, this warning can appear if the same file is both imported and required from the same mixed ES/CommonJS module, in which case it can be ignored.',
+          url: 'https://rollupjs.org/guide/en/#resolveid'
+        });
+        return null;
+      }
+
+      if (isWrappedId(importee, WRAPPED_SUFFIX)) {
+        return unwrapId(importee, WRAPPED_SUFFIX);
+      }
+
+      if (
+        importee.endsWith(ENTRY_SUFFIX) ||
+        isWrappedId(importee, MODULE_SUFFIX) ||
+        isWrappedId(importee, EXPORTS_SUFFIX) ||
+        isWrappedId(importee, PROXY_SUFFIX) ||
+        isWrappedId(importee, ES_IMPORT_SUFFIX) ||
+        isWrappedId(importee, EXTERNAL_SUFFIX) ||
+        importee.startsWith(HELPERS_ID) ||
+        importee === DYNAMIC_MODULES_ID
+      ) {
+        return importee;
+      }
+
+      if (importer) {
+        if (
+          importer === DYNAMIC_MODULES_ID ||
+          // Proxies are only importing resolved ids, no need to resolve again
+          isWrappedId(importer, PROXY_SUFFIX) ||
+          isWrappedId(importer, ES_IMPORT_SUFFIX) ||
+          importer.endsWith(ENTRY_SUFFIX)
+        ) {
+          return importee;
+        }
+        if (isWrappedId(importer, EXTERNAL_SUFFIX)) {
+          // We need to return null for unresolved imports so that the proper warning is shown
+          if (
+            !(await this.resolve(
+              importee,
+              importer,
+              Object.assign({ skipSelf: true }, resolveOptions)
+            ))
+          ) {
+            return null;
+          }
+          // For other external imports, we need to make sure they are handled as external
+          return { id: importee, external: true };
+        }
+      }
+
+      if (importee.startsWith('\0')) {
+        return null;
+      }
+
+      // If this is an entry point or ESM import, we need to figure out if the importee is wrapped and
+      // if that is the case, we need to add a proxy.
+      const resolved =
+        (await this.resolve(
+          importee,
+          importer,
+          Object.assign({ skipSelf: true }, resolveOptions)
+        )) || resolveExtensions(importee, importer, extensions);
+      // Make sure that even if other plugins resolve again, we ignore our own proxies
+      if (
+        !resolved ||
+        resolved.external ||
+        resolved.id.endsWith(ENTRY_SUFFIX) ||
+        isWrappedId(resolved.id, ES_IMPORT_SUFFIX) ||
+        !isPossibleCjsId(resolved.id)
+      ) {
+        return resolved;
+      }
+      const moduleInfo = await this.load(resolved);
+      const {
+        meta: { commonjs: commonjsMeta }
+      } = moduleInfo;
+      if (commonjsMeta) {
+        const { isCommonJS } = commonjsMeta;
+        if (isCommonJS) {
+          if (resolveOptions.isEntry) {
+            moduleInfo.moduleSideEffects = true;
+            // We must not precede entry proxies with a `\0` as that will mess up relative external resolution
+            return resolved.id + ENTRY_SUFFIX;
+          }
+          if (isCommonJS === IS_WRAPPED_COMMONJS) {
+            return { id: wrapId(resolved.id, ES_IMPORT_SUFFIX), meta: { commonjs: { resolved } } };
+          }
+        }
+      }
+      return resolved;
+    }
+  };
+}
+
+function getRequireResolver(extensions, detectCyclesAndConditional, currentlyResolving) {
+  const knownCjsModuleTypes = Object.create(null);
+  const requiredIds = Object.create(null);
+  const unconditionallyRequiredIds = Object.create(null);
+  const dependencies = Object.create(null);
+  const getDependencies = (id) => dependencies[id] || (dependencies[id] = new Set());
+
+  const isCyclic = (id) => {
+    const dependenciesToCheck = new Set(getDependencies(id));
+    for (const dependency of dependenciesToCheck) {
+      if (dependency === id) {
+        return true;
+      }
+      for (const childDependency of getDependencies(dependency)) {
+        dependenciesToCheck.add(childDependency);
+      }
+    }
+    return false;
+  };
+
+  // Once a module is listed here, its type (wrapped or not) is fixed and may
+  // not change for the rest of the current build, to not break already
+  // transformed modules.
+  const fullyAnalyzedModules = Object.create(null);
+
+  const getTypeForFullyAnalyzedModule = (id) => {
+    const knownType = knownCjsModuleTypes[id];
+    if (knownType !== true || !detectCyclesAndConditional || fullyAnalyzedModules[id]) {
+      return knownType;
+    }
+    if (isCyclic(id)) {
+      return (knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS);
+    }
+    return knownType;
+  };
+
+  const setInitialParentType = (id, initialCommonJSType) => {
+    // Fully analyzed modules may never change type
+    if (fullyAnalyzedModules[id]) {
+      return;
+    }
+    knownCjsModuleTypes[id] = initialCommonJSType;
+    if (
+      detectCyclesAndConditional &&
+      knownCjsModuleTypes[id] === true &&
+      requiredIds[id] &&
+      !unconditionallyRequiredIds[id]
+    ) {
+      knownCjsModuleTypes[id] = IS_WRAPPED_COMMONJS;
+    }
+  };
+
+  const analyzeRequiredModule = async (parentId, resolved, isConditional, loadModule) => {
+    const childId = resolved.id;
+    requiredIds[childId] = true;
+    if (!(isConditional || knownCjsModuleTypes[parentId] === IS_WRAPPED_COMMONJS)) {
+      unconditionallyRequiredIds[childId] = true;
+    }
+
+    getDependencies(parentId).add(childId);
+    if (!isCyclic(childId)) {
+      // This makes sure the current transform handler waits for all direct
+      // dependencies to be loaded and transformed and therefore for all
+      // transitive CommonJS dependencies to be loaded as well so that all
+      // cycles have been found and knownCjsModuleTypes is reliable.
+      await loadModule(resolved);
+    }
+  };
+
+  const getTypeForImportedModule = async (resolved, loadModule) => {
+    if (resolved.id in knownCjsModuleTypes) {
+      // This handles cyclic ES dependencies
+      return knownCjsModuleTypes[resolved.id];
+    }
+    const {
+      meta: { commonjs }
+    } = await loadModule(resolved);
+    return (commonjs && commonjs.isCommonJS) || false;
+  };
+
+  return {
+    getWrappedIds: () =>
+      Object.keys(knownCjsModuleTypes).filter(
+        (id) => knownCjsModuleTypes[id] === IS_WRAPPED_COMMONJS
+      ),
+    isRequiredId: (id) => requiredIds[id],
+    async shouldTransformCachedModule({
+      id: parentId,
+      resolvedSources,
+      meta: { commonjs: parentMeta }
+    }) {
+      // We explicitly track ES modules to handle circular imports
+      if (!(parentMeta && parentMeta.isCommonJS)) knownCjsModuleTypes[parentId] = false;
+      if (isWrappedId(parentId, ES_IMPORT_SUFFIX)) return false;
+      const parentRequires = parentMeta && parentMeta.requires;
+      if (parentRequires) {
+        setInitialParentType(parentId, parentMeta.initialCommonJSType);
+        await Promise.all(
+          parentRequires.map(({ resolved, isConditional }) =>
+            analyzeRequiredModule(parentId, resolved, isConditional, this.load)
+          )
+        );
+        if (getTypeForFullyAnalyzedModule(parentId) !== parentMeta.isCommonJS) {
+          return true;
+        }
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          if (getTypeForFullyAnalyzedModule(id) !== parentMeta.isRequiredCommonJS[id]) {
+            return true;
+          }
+        }
+        // Now that we decided to go with the cached copy, neither the parent
+        // module nor any of its children may change types anymore
+        fullyAnalyzedModules[parentId] = true;
+        for (const {
+          resolved: { id }
+        } of parentRequires) {
+          fullyAnalyzedModules[id] = true;
+        }
+      }
+      const parentRequireSet = new Set((parentRequires || []).map(({ resolved: { id } }) => id));
+      return (
+        await Promise.all(
+          Object.keys(resolvedSources)
+            .map((source) => resolvedSources[source])
+            .filter(({ id, external }) => !(external || parentRequireSet.has(id)))
+            .map(async (resolved) => {
+              if (isWrappedId(resolved.id, ES_IMPORT_SUFFIX)) {
+                return (
+                  (await getTypeForImportedModule(
+                    (
+                      await this.load({ id: resolved.id })
+                    ).meta.commonjs.resolved,
+                    this.load
+                  )) !== IS_WRAPPED_COMMONJS
+                );
+              }
+              return (await getTypeForImportedModule(resolved, this.load)) === IS_WRAPPED_COMMONJS;
+            })
+        )
+      ).some((shouldTransform) => shouldTransform);
+    },
+    /* eslint-disable no-param-reassign */
+    resolveRequireSourcesAndUpdateMeta:
+      (rollupContext) => async (parentId, isParentCommonJS, parentMeta, sources) => {
+        parentMeta.initialCommonJSType = isParentCommonJS;
+        parentMeta.requires = [];
+        parentMeta.isRequiredCommonJS = Object.create(null);
+        setInitialParentType(parentId, isParentCommonJS);
+        const currentlyResolvingForParent = currentlyResolving.get(parentId) || new Set();
+        currentlyResolving.set(parentId, currentlyResolvingForParent);
+        const requireTargets = await Promise.all(
+          sources.map(async ({ source, isConditional }) => {
+            // Never analyze or proxy internal modules
+            if (source.startsWith('\0')) {
+              return { id: source, allowProxy: false };
+            }
+            currentlyResolvingForParent.add(source);
+            const resolved =
+              (await rollupContext.resolve(source, parentId, {
+                skipSelf: false,
+                custom: { 'node-resolve': { isRequire: true } }
+              })) || resolveExtensions(source, parentId, extensions);
+            currentlyResolvingForParent.delete(source);
+            if (!resolved) {
+              return { id: wrapId(source, EXTERNAL_SUFFIX), allowProxy: false };
+            }
+            const childId = resolved.id;
+            if (resolved.external) {
+              return { id: wrapId(childId, EXTERNAL_SUFFIX), allowProxy: false };
+            }
+            parentMeta.requires.push({ resolved, isConditional });
+            await analyzeRequiredModule(parentId, resolved, isConditional, rollupContext.load);
+            return { id: childId, allowProxy: true };
+          })
+        );
+        parentMeta.isCommonJS = getTypeForFullyAnalyzedModule(parentId);
+        fullyAnalyzedModules[parentId] = true;
+        return requireTargets.map(({ id: dependencyId, allowProxy }, index) => {
+          // eslint-disable-next-line no-multi-assign
+          const isCommonJS = (parentMeta.isRequiredCommonJS[dependencyId] =
+            getTypeForFullyAnalyzedModule(dependencyId));
+          fullyAnalyzedModules[dependencyId] = true;
+          return {
+            source: sources[index].source,
+            id: allowProxy
+              ? isCommonJS === IS_WRAPPED_COMMONJS
+                ? wrapId(dependencyId, WRAPPED_SUFFIX)
+                : wrapId(dependencyId, PROXY_SUFFIX)
+              : dependencyId,
+            isCommonJS
+          };
+        });
+      },
+    isCurrentlyResolving(source, parentId) {
+      const currentlyResolvingForParent = currentlyResolving.get(parentId);
+      return currentlyResolvingForParent && currentlyResolvingForParent.has(source);
+    }
+  };
+}
+
+function validateVersion(actualVersion, peerDependencyVersion, name) {
+  const versionRegexp = /\^(\d+\.\d+\.\d+)/g;
+  let minMajor = Infinity;
+  let minMinor = Infinity;
+  let minPatch = Infinity;
+  let foundVersion;
+  // eslint-disable-next-line no-cond-assign
+  while ((foundVersion = versionRegexp.exec(peerDependencyVersion))) {
+    const [foundMajor, foundMinor, foundPatch] = foundVersion[1].split('.').map(Number);
+    if (foundMajor < minMajor) {
+      minMajor = foundMajor;
+      minMinor = foundMinor;
+      minPatch = foundPatch;
+    }
+  }
+  if (!actualVersion) {
+    throw new Error(
+      `Insufficient ${name} version: "@rollup/plugin-commonjs" requires at least ${name}@${minMajor}.${minMinor}.${minPatch}.`
+    );
+  }
+  const [major, minor, patch] = actualVersion.split('.').map(Number);
+  if (
+    major < minMajor ||
+    (major === minMajor && (minor < minMinor || (minor === minMinor && patch < minPatch)))
+  ) {
+    throw new Error(
+      `Insufficient ${name} version: "@rollup/plugin-commonjs" requires at least ${name}@${minMajor}.${minMinor}.${minPatch} but found ${name}@${actualVersion}.`
+    );
+  }
+}
+
+const operators = {
+  '==': (x) => equals(x.left, x.right, false),
+
+  '!=': (x) => not(operators['=='](x)),
+
+  '===': (x) => equals(x.left, x.right, true),
+
+  '!==': (x) => not(operators['==='](x)),
+
+  '!': (x) => isFalsy(x.argument),
+
+  '&&': (x) => isTruthy(x.left) && isTruthy(x.right),
+
+  '||': (x) => isTruthy(x.left) || isTruthy(x.right)
+};
+
+function not(value) {
+  return value === null ? value : !value;
+}
+
+function equals(a, b, strict) {
+  if (a.type !== b.type) return null;
+  // eslint-disable-next-line eqeqeq
+  if (a.type === 'Literal') return strict ? a.value === b.value : a.value == b.value;
+  return null;
+}
+
+function isTruthy(node) {
+  if (!node) return false;
+  if (node.type === 'Literal') return !!node.value;
+  if (node.type === 'ParenthesizedExpression') return isTruthy(node.expression);
+  if (node.operator in operators) return operators[node.operator](node);
+  return null;
+}
+
+function isFalsy(node) {
+  return not(isTruthy(node));
+}
+
+function getKeypath(node) {
+  const parts = [];
+
+  while (node.type === 'MemberExpression') {
+    if (node.computed) return null;
+
+    parts.unshift(node.property.name);
+    // eslint-disable-next-line no-param-reassign
+    node = node.object;
+  }
+
+  if (node.type !== 'Identifier') return null;
+
+  const { name } = node;
+  parts.unshift(name);
+
+  return { name, keypath: parts.join('.') };
+}
+
+const KEY_COMPILED_ESM = '__esModule';
+
+function getDefineCompiledEsmType(node) {
+  const definedPropertyWithExports = getDefinePropertyCallName(node, 'exports');
+  const definedProperty =
+    definedPropertyWithExports || getDefinePropertyCallName(node, 'module.exports');
+  if (definedProperty && definedProperty.key === KEY_COMPILED_ESM) {
+    return isTruthy(definedProperty.value)
+      ? definedPropertyWithExports
+        ? 'exports'
+        : 'module'
+      : false;
+  }
+  return false;
+}
+
+function getDefinePropertyCallName(node, targetName) {
+  const {
+    callee: { object, property }
+  } = node;
+  if (!object || object.type !== 'Identifier' || object.name !== 'Object') return;
+  if (!property || property.type !== 'Identifier' || property.name !== 'defineProperty') return;
+  if (node.arguments.length !== 3) return;
+
+  const targetNames = targetName.split('.');
+  const [target, key, value] = node.arguments;
+  if (targetNames.length === 1) {
+    if (target.type !== 'Identifier' || target.name !== targetNames[0]) {
+      return;
+    }
+  }
+
+  if (targetNames.length === 2) {
+    if (
+      target.type !== 'MemberExpression' ||
+      target.object.name !== targetNames[0] ||
+      target.property.name !== targetNames[1]
+    ) {
+      return;
+    }
+  }
+
+  if (value.type !== 'ObjectExpression' || !value.properties) return;
+
+  const valueProperty = value.properties.find((p) => p.key && p.key.name === 'value');
+  if (!valueProperty || !valueProperty.value) return;
+
+  // eslint-disable-next-line consistent-return
+  return { key: key.value, value: valueProperty.value };
+}
+
+function isShorthandProperty(parent) {
+  return parent && parent.type === 'Property' && parent.shorthand;
+}
+
+function wrapCode(magicString, uses, moduleName, exportsName, indentExclusionRanges) {
+  const args = [];
+  const passedArgs = [];
+  if (uses.module) {
+    args.push('module');
+    passedArgs.push(moduleName);
+  }
+  if (uses.exports) {
+    args.push('exports');
+    passedArgs.push(uses.module ? `${moduleName}.exports` : exportsName);
+  }
+  magicString
+    .trim()
+    .indent('\t', { exclude: indentExclusionRanges })
+    .prepend(`(function (${args.join(', ')}) {\n`)
+    // For some reason, this line is only indented correctly when using a
+    // require-wrapper if we have this leading space
+    .append(` \n} (${passedArgs.join(', ')}));`);
+}
+
+function rewriteExportsAndGetExportsBlock(
+  magicString,
+  moduleName,
+  exportsName,
+  exportedExportsName,
+  wrapped,
+  moduleExportsAssignments,
+  firstTopLevelModuleExportsAssignment,
+  exportsAssignmentsByName,
+  topLevelAssignments,
+  defineCompiledEsmExpressions,
+  deconflictedExportNames,
+  code,
+  HELPERS_NAME,
+  exportMode,
+  defaultIsModuleExports,
+  usesRequireWrapper,
+  requireName
+) {
+  const exports = [];
+  const exportDeclarations = [];
+
+  if (usesRequireWrapper) {
+    getExportsWhenUsingRequireWrapper(
+      magicString,
+      wrapped,
+      exportMode,
+      exports,
+      moduleExportsAssignments,
+      exportsAssignmentsByName,
+      moduleName,
+      exportsName,
+      requireName,
+      defineCompiledEsmExpressions
+    );
+  } else if (exportMode === 'replace') {
+    getExportsForReplacedModuleExports(
+      magicString,
+      exports,
+      exportDeclarations,
+      moduleExportsAssignments,
+      firstTopLevelModuleExportsAssignment,
+      exportsName,
+      defaultIsModuleExports,
+      HELPERS_NAME
+    );
+  } else {
+    if (exportMode === 'module') {
+      exportDeclarations.push(`var ${exportedExportsName} = ${moduleName}.exports`);
+      exports.push(`${exportedExportsName} as __moduleExports`);
+    } else {
+      exports.push(`${exportsName} as __moduleExports`);
+    }
+    if (wrapped) {
+      exportDeclarations.push(
+        getDefaultExportDeclaration(exportedExportsName, defaultIsModuleExports, HELPERS_NAME)
+      );
+    } else {
+      getExports(
+        magicString,
+        exports,
+        exportDeclarations,
+        moduleExportsAssignments,
+        exportsAssignmentsByName,
+        deconflictedExportNames,
+        topLevelAssignments,
+        moduleName,
+        exportsName,
+        exportedExportsName,
+        defineCompiledEsmExpressions,
+        HELPERS_NAME,
+        defaultIsModuleExports,
+        exportMode
+      );
+    }
+  }
+  if (exports.length) {
+    exportDeclarations.push(`export { ${exports.join(', ')} }`);
+  }
+
+  return `\n\n${exportDeclarations.join(';\n')};`;
+}
+
+function getExportsWhenUsingRequireWrapper(
+  magicString,
+  wrapped,
+  exportMode,
+  exports,
+  moduleExportsAssignments,
+  exportsAssignmentsByName,
+  moduleName,
+  exportsName,
+  requireName,
+  defineCompiledEsmExpressions
+) {
+  exports.push(`${requireName} as __require`);
+  if (wrapped) return;
+  if (exportMode === 'replace') {
+    rewriteModuleExportsAssignments(magicString, moduleExportsAssignments, exportsName);
+  } else {
+    rewriteModuleExportsAssignments(magicString, moduleExportsAssignments, `${moduleName}.exports`);
+    // Collect and rewrite named exports
+    for (const [exportName, { nodes }] of exportsAssignmentsByName) {
+      for (const { node, type } of nodes) {
+        magicString.overwrite(
+          node.start,
+          node.left.end,
+          `${
+            exportMode === 'module' && type === 'module' ? `${moduleName}.exports` : exportsName
+          }.${exportName}`
+        );
+      }
+    }
+    replaceDefineCompiledEsmExpressionsAndGetIfRestorable(
+      defineCompiledEsmExpressions,
+      magicString,
+      exportMode,
+      moduleName,
+      exportsName
+    );
+  }
+}
+
+function getExportsForReplacedModuleExports(
+  magicString,
+  exports,
+  exportDeclarations,
+  moduleExportsAssignments,
+  firstTopLevelModuleExportsAssignment,
+  exportsName,
+  defaultIsModuleExports,
+  HELPERS_NAME
+) {
+  for (const { left } of moduleExportsAssignments) {
+    magicString.overwrite(left.start, left.end, exportsName);
+  }
+  magicString.prependRight(firstTopLevelModuleExportsAssignment.left.start, 'var ');
+  exports.push(`${exportsName} as __moduleExports`);
+  exportDeclarations.push(
+    getDefaultExportDeclaration(exportsName, defaultIsModuleExports, HELPERS_NAME)
+  );
+}
+
+function getDefaultExportDeclaration(exportedExportsName, defaultIsModuleExports, HELPERS_NAME) {
+  return `export default ${
+    defaultIsModuleExports === true
+      ? exportedExportsName
+      : defaultIsModuleExports === false
+      ? `${exportedExportsName}.default`
+      : `/*@__PURE__*/${HELPERS_NAME}.getDefaultExportFromCjs(${exportedExportsName})`
+  }`;
+}
+
+function getExports(
+  magicString,
+  exports,
+  exportDeclarations,
+  moduleExportsAssignments,
+  exportsAssignmentsByName,
+  deconflictedExportNames,
+  topLevelAssignments,
+  moduleName,
+  exportsName,
+  exportedExportsName,
+  defineCompiledEsmExpressions,
+  HELPERS_NAME,
+  defaultIsModuleExports,
+  exportMode
+) {
+  let deconflictedDefaultExportName;
+  // Collect and rewrite module.exports assignments
+  for (const { left } of moduleExportsAssignments) {
+    magicString.overwrite(left.start, left.end, `${moduleName}.exports`);
+  }
+
+  // Collect and rewrite named exports
+  for (const [exportName, { nodes }] of exportsAssignmentsByName) {
+    const deconflicted = deconflictedExportNames[exportName];
+    let needsDeclaration = true;
+    for (const { node, type } of nodes) {
+      let replacement = `${deconflicted} = ${
+        exportMode === 'module' && type === 'module' ? `${moduleName}.exports` : exportsName
+      }.${exportName}`;
+      if (needsDeclaration && topLevelAssignments.has(node)) {
+        replacement = `var ${replacement}`;
+        needsDeclaration = false;
+      }
+      magicString.overwrite(node.start, node.left.end, replacement);
+    }
+    if (needsDeclaration) {
+      magicString.prepend(`var ${deconflicted};\n`);
+    }
+
+    if (exportName === 'default') {
+      deconflictedDefaultExportName = deconflicted;
+    } else {
+      exports.push(exportName === deconflicted ? exportName : `${deconflicted} as ${exportName}`);
+    }
+  }
+
+  const isRestorableCompiledEsm = replaceDefineCompiledEsmExpressionsAndGetIfRestorable(
+    defineCompiledEsmExpressions,
+    magicString,
+    exportMode,
+    moduleName,
+    exportsName
+  );
+
+  if (
+    defaultIsModuleExports === false ||
+    (defaultIsModuleExports === 'auto' &&
+      isRestorableCompiledEsm &&
+      moduleExportsAssignments.length === 0)
+  ) {
+    // If there is no deconflictedDefaultExportName, then we use the namespace as
+    // fallback because there can be no "default" property on the namespace
+    exports.push(`${deconflictedDefaultExportName || exportedExportsName} as default`);
+  } else if (
+    defaultIsModuleExports === true ||
+    (!isRestorableCompiledEsm && moduleExportsAssignments.length === 0)
+  ) {
+    exports.push(`${exportedExportsName} as default`);
+  } else {
+    exportDeclarations.push(
+      getDefaultExportDeclaration(exportedExportsName, defaultIsModuleExports, HELPERS_NAME)
+    );
+  }
+}
+
+function rewriteModuleExportsAssignments(magicString, moduleExportsAssignments, exportsName) {
+  for (const { left } of moduleExportsAssignments) {
+    magicString.overwrite(left.start, left.end, exportsName);
+  }
+}
+
+function replaceDefineCompiledEsmExpressionsAndGetIfRestorable(
+  defineCompiledEsmExpressions,
+  magicString,
+  exportMode,
+  moduleName,
+  exportsName
+) {
+  let isRestorableCompiledEsm = false;
+  for (const { node, type } of defineCompiledEsmExpressions) {
+    isRestorableCompiledEsm = true;
+    const moduleExportsExpression =
+      node.type === 'CallExpression' ? node.arguments[0] : node.left.object;
+    magicString.overwrite(
+      moduleExportsExpression.start,
+      moduleExportsExpression.end,
+      exportMode === 'module' && type === 'module' ? `${moduleName}.exports` : exportsName
+    );
+  }
+  return isRestorableCompiledEsm;
+}
+
+function isRequireExpression(node, scope) {
+  if (!node) return false;
+  if (node.type !== 'CallExpression') return false;
+
+  // Weird case of `require()` or `module.require()` without arguments
+  if (node.arguments.length === 0) return false;
+
+  return isRequire(node.callee, scope);
+}
+
+function isRequire(node, scope) {
+  return (
+    (node.type === 'Identifier' && node.name === 'require' && !scope.contains('require')) ||
+    (node.type === 'MemberExpression' && isModuleRequire(node, scope))
+  );
+}
+
+function isModuleRequire({ object, property }, scope) {
+  return (
+    object.type === 'Identifier' &&
+    object.name === 'module' &&
+    property.type === 'Identifier' &&
+    property.name === 'require' &&
+    !scope.contains('module')
+  );
+}
+
+function hasDynamicArguments(node) {
+  return (
+    node.arguments.length > 1 ||
+    (node.arguments[0].type !== 'Literal' &&
+      (node.arguments[0].type !== 'TemplateLiteral' || node.arguments[0].expressions.length > 0))
+  );
+}
+
+const reservedMethod = { resolve: true, cache: true, main: true };
+
+function isNodeRequirePropertyAccess(parent) {
+  return parent && parent.property && reservedMethod[parent.property.name];
+}
+
+function getRequireStringArg(node) {
+  return node.arguments[0].type === 'Literal'
+    ? node.arguments[0].value
+    : node.arguments[0].quasis[0].value.cooked;
+}
+
+function getRequireHandlers() {
+  const requireExpressions = [];
+
+  function addRequireExpression(
+    sourceId,
+    node,
+    scope,
+    usesReturnValue,
+    isInsideTryBlock,
+    isInsideConditional,
+    toBeRemoved
+  ) {
+    requireExpressions.push({
+      sourceId,
+      node,
+      scope,
+      usesReturnValue,
+      isInsideTryBlock,
+      isInsideConditional,
+      toBeRemoved
+    });
+  }
+
+  async function rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    reassignedNames,
+    helpersName,
+    dynamicRequireName,
+    moduleName,
+    exportsName,
+    id,
+    exportMode,
+    resolveRequireSourcesAndUpdateMeta,
+    needsRequireWrapper,
+    isEsModule,
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
+  ) {
+    const imports = [];
+    imports.push(`import * as ${helpersName} from "${HELPERS_ID}"`);
+    if (dynamicRequireName) {
+      imports.push(
+        `import { ${
+          isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT
+        } as ${dynamicRequireName} } from "${DYNAMIC_MODULES_ID}"`
+      );
+    }
+    if (exportMode === 'module') {
+      imports.push(
+        `import { __module as ${moduleName} } from ${JSON.stringify(wrapId(id, MODULE_SUFFIX))}`,
+        `var ${exportsName} = ${moduleName}.exports`
+      );
+    } else if (exportMode === 'exports') {
+      imports.push(
+        `import { __exports as ${exportsName} } from ${JSON.stringify(wrapId(id, EXPORTS_SUFFIX))}`
+      );
+    }
+    const requiresBySource = collectSources(requireExpressions);
+    const requireTargets = await resolveRequireSourcesAndUpdateMeta(
+      id,
+      needsRequireWrapper ? IS_WRAPPED_COMMONJS : !isEsModule,
+      commonjsMeta,
+      Object.keys(requiresBySource).map((source) => {
+        return {
+          source,
+          isConditional: requiresBySource[source].every((require) => require.isInsideConditional)
+        };
+      })
+    );
+    processRequireExpressions(
+      imports,
+      requireTargets,
+      requiresBySource,
+      getIgnoreTryCatchRequireStatementMode,
+      magicString
+    );
+    return imports.length ? `${imports.join(';\n')};\n\n` : '';
+  }
+
+  return {
+    addRequireExpression,
+    rewriteRequireExpressionsAndGetImportBlock
+  };
+}
+
+function collectSources(requireExpressions) {
+  const requiresBySource = Object.create(null);
+  for (const requireExpression of requireExpressions) {
+    const { sourceId } = requireExpression;
+    if (!requiresBySource[sourceId]) {
+      requiresBySource[sourceId] = [];
+    }
+    const requires = requiresBySource[sourceId];
+    requires.push(requireExpression);
+  }
+  return requiresBySource;
+}
+
+function processRequireExpressions(
+  imports,
+  requireTargets,
+  requiresBySource,
+  getIgnoreTryCatchRequireStatementMode,
+  magicString
+) {
+  const generateRequireName = getGenerateRequireName();
+  for (const { source, id: resolvedId, isCommonJS } of requireTargets) {
+    const requires = requiresBySource[source];
+    const name = generateRequireName(requires);
+    let usesRequired = false;
+    let needsImport = false;
+    for (const { node, usesReturnValue, toBeRemoved, isInsideTryBlock } of requires) {
+      const { canConvertRequire, shouldRemoveRequire } =
+        isInsideTryBlock && isWrappedId(resolvedId, EXTERNAL_SUFFIX)
+          ? getIgnoreTryCatchRequireStatementMode(source)
+          : { canConvertRequire: true, shouldRemoveRequire: false };
+      if (shouldRemoveRequire) {
+        if (usesReturnValue) {
+          magicString.overwrite(node.start, node.end, 'undefined');
+        } else {
+          magicString.remove(toBeRemoved.start, toBeRemoved.end);
+        }
+      } else if (canConvertRequire) {
+        needsImport = true;
+        if (isCommonJS === IS_WRAPPED_COMMONJS) {
+          magicString.overwrite(node.start, node.end, `${name}()`);
+        } else if (usesReturnValue) {
+          usesRequired = true;
+          magicString.overwrite(node.start, node.end, name);
+        } else {
+          magicString.remove(toBeRemoved.start, toBeRemoved.end);
+        }
+      }
+    }
+    if (needsImport) {
+      if (isCommonJS === IS_WRAPPED_COMMONJS) {
+        imports.push(`import { __require as ${name} } from ${JSON.stringify(resolvedId)}`);
+      } else {
+        imports.push(`import ${usesRequired ? `${name} from ` : ''}${JSON.stringify(resolvedId)}`);
+      }
+    }
+  }
+}
+
+function getGenerateRequireName() {
+  let uid = 0;
+  return (requires) => {
+    let name;
+    const hasNameConflict = ({ scope }) => scope.contains(name);
+    do {
+      name = `require$$${uid}`;
+      uid += 1;
+    } while (requires.some(hasNameConflict));
+    return name;
+  };
+}
+
+/* eslint-disable no-param-reassign, no-shadow, no-underscore-dangle, no-continue */
+
+
+const exportsPattern = /^(?:module\.)?exports(?:\.([a-zA-Z_$][a-zA-Z_$0-9]*))?$/;
+
+const functionType = /^(?:FunctionDeclaration|FunctionExpression|ArrowFunctionExpression)$/;
+
+// There are three different types of CommonJS modules, described by their
+// "exportMode":
+// - exports: Only assignments to (module.)exports properties
+// - replace: A single assignment to module.exports itself
+// - module: Anything else
+// Special cases:
+// - usesRequireWrapper
+// - isWrapped
+async function transformCommonjs(
+  parse,
+  code,
+  id,
+  isEsModule,
+  ignoreGlobal,
+  ignoreRequire,
+  ignoreDynamicRequires,
+  getIgnoreTryCatchRequireStatementMode,
+  sourceMap,
+  isDynamicRequireModulesEnabled,
+  dynamicRequireModules,
+  commonDir,
+  astCache,
+  defaultIsModuleExports,
+  needsRequireWrapper,
+  resolveRequireSourcesAndUpdateMeta,
+  isRequired,
+  checkDynamicRequire,
+  commonjsMeta
+) {
+  const ast = astCache || tryParse(parse, code, id);
+  const magicString = new MagicString(code);
+  const uses = {
+    module: false,
+    exports: false,
+    global: false,
+    require: false
+  };
+  const virtualDynamicRequirePath =
+    isDynamicRequireModulesEnabled && getVirtualPathForDynamicRequirePath(dirname$1(id), commonDir);
+  let scope = attachScopes(ast, 'scope');
+  let lexicalDepth = 0;
+  let programDepth = 0;
+  let classBodyDepth = 0;
+  let currentTryBlockEnd = null;
+  let shouldWrap = false;
+
+  const globals = new Set();
+  // A conditionalNode is a node for which execution is not guaranteed. If such a node is a require
+  // or contains nested requires, those should be handled as function calls unless there is an
+  // unconditional require elsewhere.
+  let currentConditionalNodeEnd = null;
+  const conditionalNodes = new Set();
+  const { addRequireExpression, rewriteRequireExpressionsAndGetImportBlock } = getRequireHandlers();
+
+  // See which names are assigned to. This is necessary to prevent
+  // illegally replacing `var foo = require('foo')` with `import foo from 'foo'`,
+  // where `foo` is later reassigned. (This happens in the wild. CommonJS, sigh)
+  const reassignedNames = new Set();
+  const topLevelDeclarations = [];
+  const skippedNodes = new Set();
+  const moduleAccessScopes = new Set([scope]);
+  const exportsAccessScopes = new Set([scope]);
+  const moduleExportsAssignments = [];
+  let firstTopLevelModuleExportsAssignment = null;
+  const exportsAssignmentsByName = new Map();
+  const topLevelAssignments = new Set();
+  const topLevelDefineCompiledEsmExpressions = [];
+  const replacedGlobal = [];
+  const replacedDynamicRequires = [];
+  const importedVariables = new Set();
+  const indentExclusionRanges = [];
+
+  walk$3(ast, {
+    enter(node, parent) {
+      if (skippedNodes.has(node)) {
+        this.skip();
+        return;
+      }
+
+      if (currentTryBlockEnd !== null && node.start > currentTryBlockEnd) {
+        currentTryBlockEnd = null;
+      }
+      if (currentConditionalNodeEnd !== null && node.start > currentConditionalNodeEnd) {
+        currentConditionalNodeEnd = null;
+      }
+      if (currentConditionalNodeEnd === null && conditionalNodes.has(node)) {
+        currentConditionalNodeEnd = node.end;
+      }
+
+      programDepth += 1;
+      if (node.scope) ({ scope } = node);
+      if (functionType.test(node.type)) lexicalDepth += 1;
+      if (sourceMap) {
+        magicString.addSourcemapLocation(node.start);
+        magicString.addSourcemapLocation(node.end);
+      }
+
+      // eslint-disable-next-line default-case
+      switch (node.type) {
+        case 'AssignmentExpression':
+          if (node.left.type === 'MemberExpression') {
+            const flattened = getKeypath(node.left);
+            if (!flattened || scope.contains(flattened.name)) return;
+
+            const exportsPatternMatch = exportsPattern.exec(flattened.keypath);
+            if (!exportsPatternMatch || flattened.keypath === 'exports') return;
+
+            const [, exportName] = exportsPatternMatch;
+            uses[flattened.name] = true;
+
+            // we're dealing with `module.exports = ...` or `[module.]exports.foo = ...` –
+            if (flattened.keypath === 'module.exports') {
+              moduleExportsAssignments.push(node);
+              if (programDepth > 3) {
+                moduleAccessScopes.add(scope);
+              } else if (!firstTopLevelModuleExportsAssignment) {
+                firstTopLevelModuleExportsAssignment = node;
+              }
+            } else if (exportName === KEY_COMPILED_ESM) {
+              if (programDepth > 3) {
+                shouldWrap = true;
+              } else {
+                // The "type" is either "module" or "exports" to discern
+                // assignments to module.exports vs exports if needed
+                topLevelDefineCompiledEsmExpressions.push({ node, type: flattened.name });
+              }
+            } else {
+              const exportsAssignments = exportsAssignmentsByName.get(exportName) || {
+                nodes: [],
+                scopes: new Set()
+              };
+              exportsAssignments.nodes.push({ node, type: flattened.name });
+              exportsAssignments.scopes.add(scope);
+              exportsAccessScopes.add(scope);
+              exportsAssignmentsByName.set(exportName, exportsAssignments);
+              if (programDepth <= 3) {
+                topLevelAssignments.add(node);
+              }
+            }
+
+            skippedNodes.add(node.left);
+          } else {
+            for (const name of extractAssignedNames(node.left)) {
+              reassignedNames.add(name);
+            }
+          }
+          return;
+        case 'CallExpression': {
+          const defineCompiledEsmType = getDefineCompiledEsmType(node);
+          if (defineCompiledEsmType) {
+            if (programDepth === 3 && parent.type === 'ExpressionStatement') {
+              // skip special handling for [module.]exports until we know we render this
+              skippedNodes.add(node.arguments[0]);
+              topLevelDefineCompiledEsmExpressions.push({ node, type: defineCompiledEsmType });
+            } else {
+              shouldWrap = true;
+            }
+            return;
+          }
+
+          // Transform require.resolve
+          if (
+            isDynamicRequireModulesEnabled &&
+            node.callee.object &&
+            isRequire(node.callee.object, scope) &&
+            node.callee.property.name === 'resolve'
+          ) {
+            checkDynamicRequire(node.start);
+            uses.require = true;
+            const requireNode = node.callee.object;
+            replacedDynamicRequires.push(requireNode);
+            skippedNodes.add(node.callee);
+            return;
+          }
+
+          if (!isRequireExpression(node, scope)) {
+            const keypath = getKeypath(node.callee);
+            if (keypath && importedVariables.has(keypath.name)) {
+              // Heuristic to deoptimize requires after a required function has been called
+              currentConditionalNodeEnd = Infinity;
+            }
+            return;
+          }
+
+          skippedNodes.add(node.callee);
+          uses.require = true;
+
+          if (hasDynamicArguments(node)) {
+            if (isDynamicRequireModulesEnabled) {
+              checkDynamicRequire(node.start);
+            }
+            if (!ignoreDynamicRequires) {
+              replacedDynamicRequires.push(node.callee);
+            }
+            return;
+          }
+
+          const requireStringArg = getRequireStringArg(node);
+          if (!ignoreRequire(requireStringArg)) {
+            const usesReturnValue = parent.type !== 'ExpressionStatement';
+            const toBeRemoved =
+              parent.type === 'ExpressionStatement' &&
+              (!currentConditionalNodeEnd ||
+                // We should completely remove requires directly in a try-catch
+                // so that Rollup can remove up the try-catch
+                (currentTryBlockEnd !== null && currentTryBlockEnd < currentConditionalNodeEnd))
+                ? parent
+                : node;
+            addRequireExpression(
+              requireStringArg,
+              node,
+              scope,
+              usesReturnValue,
+              currentTryBlockEnd !== null,
+              currentConditionalNodeEnd !== null,
+              toBeRemoved
+            );
+            if (parent.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+              for (const name of extractAssignedNames(parent.id)) {
+                importedVariables.add(name);
+              }
+            }
+          }
+          return;
+        }
+        case 'ClassBody':
+          classBodyDepth += 1;
+          return;
+        case 'ConditionalExpression':
+        case 'IfStatement':
+          // skip dead branches
+          if (isFalsy(node.test)) {
+            skippedNodes.add(node.consequent);
+          } else if (isTruthy(node.test)) {
+            if (node.alternate) {
+              skippedNodes.add(node.alternate);
+            }
+          } else {
+            conditionalNodes.add(node.consequent);
+            if (node.alternate) {
+              conditionalNodes.add(node.alternate);
+            }
+          }
+          return;
+        case 'ArrowFunctionExpression':
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+          // requires in functions should be conditional unless it is an IIFE
+          if (
+            currentConditionalNodeEnd === null &&
+            !(parent.type === 'CallExpression' && parent.callee === node)
+          ) {
+            currentConditionalNodeEnd = node.end;
+          }
+          return;
+        case 'Identifier': {
+          const { name } = node;
+          if (
+            !isReference(node, parent) ||
+            scope.contains(name) ||
+            (parent.type === 'PropertyDefinition' && parent.key === node)
+          )
+            return;
+          switch (name) {
+            case 'require':
+              uses.require = true;
+              if (isNodeRequirePropertyAccess(parent)) {
+                return;
+              }
+              if (!ignoreDynamicRequires) {
+                if (isShorthandProperty(parent)) {
+                  // as key and value are the same object, isReference regards
+                  // both as references, so we need to skip now
+                  skippedNodes.add(parent.value);
+                  magicString.prependRight(node.start, 'require: ');
+                }
+                replacedDynamicRequires.push(node);
+              }
+              return;
+            case 'module':
+            case 'exports':
+              shouldWrap = true;
+              uses[name] = true;
+              return;
+            case 'global':
+              uses.global = true;
+              if (!ignoreGlobal) {
+                replacedGlobal.push(node);
+              }
+              return;
+            case 'define':
+              magicString.overwrite(node.start, node.end, 'undefined', {
+                storeName: true
+              });
+              return;
+            default:
+              globals.add(name);
+              return;
+          }
+        }
+        case 'LogicalExpression':
+          // skip dead branches
+          if (node.operator === '&&') {
+            if (isFalsy(node.left)) {
+              skippedNodes.add(node.right);
+            } else if (!isTruthy(node.left)) {
+              conditionalNodes.add(node.right);
+            }
+          } else if (node.operator === '||') {
+            if (isTruthy(node.left)) {
+              skippedNodes.add(node.right);
+            } else if (!isFalsy(node.left)) {
+              conditionalNodes.add(node.right);
+            }
+          }
+          return;
+        case 'MemberExpression':
+          if (!isDynamicRequireModulesEnabled && isModuleRequire(node, scope)) {
+            uses.require = true;
+            replacedDynamicRequires.push(node);
+            skippedNodes.add(node.object);
+            skippedNodes.add(node.property);
+          }
+          return;
+        case 'ReturnStatement':
+          // if top-level return, we need to wrap it
+          if (lexicalDepth === 0) {
+            shouldWrap = true;
+          }
+          return;
+        case 'ThisExpression':
+          // rewrite top-level `this` as `commonjsHelpers.commonjsGlobal`
+          if (lexicalDepth === 0 && !classBodyDepth) {
+            uses.global = true;
+            if (!ignoreGlobal) {
+              replacedGlobal.push(node);
+            }
+          }
+          return;
+        case 'TryStatement':
+          if (currentTryBlockEnd === null) {
+            currentTryBlockEnd = node.block.end;
+          }
+          if (currentConditionalNodeEnd === null) {
+            currentConditionalNodeEnd = node.end;
+          }
+          return;
+        case 'UnaryExpression':
+          // rewrite `typeof module`, `typeof module.exports` and `typeof exports` (https://github.com/rollup/rollup-plugin-commonjs/issues/151)
+          if (node.operator === 'typeof') {
+            const flattened = getKeypath(node.argument);
+            if (!flattened) return;
+
+            if (scope.contains(flattened.name)) return;
+
+            if (
+              !isEsModule &&
+              (flattened.keypath === 'module.exports' ||
+                flattened.keypath === 'module' ||
+                flattened.keypath === 'exports')
+            ) {
+              magicString.overwrite(node.start, node.end, `'object'`, {
+                storeName: false
+              });
+            }
+          }
+          return;
+        case 'VariableDeclaration':
+          if (!scope.parent) {
+            topLevelDeclarations.push(node);
+          }
+          return;
+        case 'TemplateElement':
+          if (node.value.raw.includes('\n')) {
+            indentExclusionRanges.push([node.start, node.end]);
+          }
+      }
+    },
+
+    leave(node) {
+      programDepth -= 1;
+      if (node.scope) scope = scope.parent;
+      if (functionType.test(node.type)) lexicalDepth -= 1;
+      if (node.type === 'ClassBody') classBodyDepth -= 1;
+    }
+  });
+
+  const nameBase = getName(id);
+  const exportsName = deconflict([...exportsAccessScopes], globals, nameBase);
+  const moduleName = deconflict([...moduleAccessScopes], globals, `${nameBase}Module`);
+  const requireName = deconflict([scope], globals, `require${capitalize(nameBase)}`);
+  const isRequiredName = deconflict([scope], globals, `hasRequired${capitalize(nameBase)}`);
+  const helpersName = deconflict([scope], globals, 'commonjsHelpers');
+  const dynamicRequireName =
+    replacedDynamicRequires.length > 0 &&
+    deconflict(
+      [scope],
+      globals,
+      isDynamicRequireModulesEnabled ? CREATE_COMMONJS_REQUIRE_EXPORT : COMMONJS_REQUIRE_EXPORT
+    );
+  const deconflictedExportNames = Object.create(null);
+  for (const [exportName, { scopes }] of exportsAssignmentsByName) {
+    deconflictedExportNames[exportName] = deconflict([...scopes], globals, exportName);
+  }
+
+  for (const node of replacedGlobal) {
+    magicString.overwrite(node.start, node.end, `${helpersName}.commonjsGlobal`, {
+      storeName: true
+    });
+  }
+  for (const node of replacedDynamicRequires) {
+    magicString.overwrite(
+      node.start,
+      node.end,
+      isDynamicRequireModulesEnabled
+        ? `${dynamicRequireName}(${JSON.stringify(virtualDynamicRequirePath)})`
+        : dynamicRequireName,
+      {
+        contentOnly: true,
+        storeName: true
+      }
+    );
+  }
+
+  // We cannot wrap ES/mixed modules
+  shouldWrap = !isEsModule && (shouldWrap || (uses.exports && moduleExportsAssignments.length > 0));
+
+  if (
+    !(
+      shouldWrap ||
+      isRequired ||
+      needsRequireWrapper ||
+      uses.module ||
+      uses.exports ||
+      uses.require ||
+      topLevelDefineCompiledEsmExpressions.length > 0
+    ) &&
+    (ignoreGlobal || !uses.global)
+  ) {
+    return { meta: { commonjs: { isCommonJS: false } } };
+  }
+
+  let leadingComment = '';
+  if (code.startsWith('/*')) {
+    const commentEnd = code.indexOf('*/', 2) + 2;
+    leadingComment = `${code.slice(0, commentEnd)}\n`;
+    magicString.remove(0, commentEnd).trim();
+  }
+
+  let shebang = '';
+  if (code.startsWith('#!')) {
+    const shebangEndPosition = code.indexOf('\n') + 1;
+    shebang = code.slice(0, shebangEndPosition);
+    magicString.remove(0, shebangEndPosition).trim();
+  }
+
+  const exportMode = isEsModule
+    ? 'none'
+    : shouldWrap
+    ? uses.module
+      ? 'module'
+      : 'exports'
+    : firstTopLevelModuleExportsAssignment
+    ? exportsAssignmentsByName.size === 0 && topLevelDefineCompiledEsmExpressions.length === 0
+      ? 'replace'
+      : 'module'
+    : moduleExportsAssignments.length === 0
+    ? 'exports'
+    : 'module';
+
+  const exportedExportsName =
+    exportMode === 'module' ? deconflict([], globals, `${nameBase}Exports`) : exportsName;
+
+  const importBlock = await rewriteRequireExpressionsAndGetImportBlock(
+    magicString,
+    topLevelDeclarations,
+    reassignedNames,
+    helpersName,
+    dynamicRequireName,
+    moduleName,
+    exportsName,
+    id,
+    exportMode,
+    resolveRequireSourcesAndUpdateMeta,
+    needsRequireWrapper,
+    isEsModule,
+    isDynamicRequireModulesEnabled,
+    getIgnoreTryCatchRequireStatementMode,
+    commonjsMeta
+  );
+  const usesRequireWrapper = commonjsMeta.isCommonJS === IS_WRAPPED_COMMONJS;
+  const exportBlock = isEsModule
+    ? ''
+    : rewriteExportsAndGetExportsBlock(
+        magicString,
+        moduleName,
+        exportsName,
+        exportedExportsName,
+        shouldWrap,
+        moduleExportsAssignments,
+        firstTopLevelModuleExportsAssignment,
+        exportsAssignmentsByName,
+        topLevelAssignments,
+        topLevelDefineCompiledEsmExpressions,
+        deconflictedExportNames,
+        code,
+        helpersName,
+        exportMode,
+        defaultIsModuleExports,
+        usesRequireWrapper,
+        requireName
+      );
+
+  if (shouldWrap) {
+    wrapCode(magicString, uses, moduleName, exportsName, indentExclusionRanges);
+  }
+
+  if (usesRequireWrapper) {
+    magicString.trim().indent('\t', {
+      exclude: indentExclusionRanges
+    });
+    const exported = exportMode === 'module' ? `${moduleName}.exports` : exportsName;
+    magicString.prepend(
+      `var ${isRequiredName};
+
+function ${requireName} () {
+\tif (${isRequiredName}) return ${exported};
+\t${isRequiredName} = 1;
+`
+    ).append(`
+\treturn ${exported};
+}`);
+    if (exportMode === 'replace') {
+      magicString.prepend(`var ${exportsName};\n`);
+    }
+  }
+
+  magicString
+    .trim()
+    .prepend(shebang + leadingComment + importBlock)
+    .append(exportBlock);
+
+  return {
+    code: magicString.toString(),
+    map: sourceMap ? magicString.generateMap() : null,
+    syntheticNamedExports: isEsModule || usesRequireWrapper ? false : '__moduleExports',
+    meta: { commonjs: { ...commonjsMeta, shebang } }
+  };
+}
+
+const PLUGIN_NAME = 'commonjs';
+
+function commonjs(options = {}) {
+  const {
+    ignoreGlobal,
+    ignoreDynamicRequires,
+    requireReturnsDefault: requireReturnsDefaultOption,
+    defaultIsModuleExports: defaultIsModuleExportsOption,
+    esmExternals
+  } = options;
+  const extensions = options.extensions || ['.js'];
+  const filter = createFilter$1(options.include, options.exclude);
+  const isPossibleCjsId = (id) => {
+    const extName = extname(id);
+    return extName === '.cjs' || (extensions.includes(extName) && filter(id));
+  };
+
+  const { strictRequiresFilter, detectCyclesAndConditional } = getStrictRequiresFilter(options);
+
+  const getRequireReturnsDefault =
+    typeof requireReturnsDefaultOption === 'function'
+      ? requireReturnsDefaultOption
+      : () => requireReturnsDefaultOption;
+
+  let esmExternalIds;
+  const isEsmExternal =
+    typeof esmExternals === 'function'
+      ? esmExternals
+      : Array.isArray(esmExternals)
+      ? ((esmExternalIds = new Set(esmExternals)), (id) => esmExternalIds.has(id))
+      : () => esmExternals;
+
+  const getDefaultIsModuleExports =
+    typeof defaultIsModuleExportsOption === 'function'
+      ? defaultIsModuleExportsOption
+      : () =>
+          typeof defaultIsModuleExportsOption === 'boolean' ? defaultIsModuleExportsOption : 'auto';
+
+  const dynamicRequireRoot =
+    typeof options.dynamicRequireRoot === 'string'
+      ? resolve$3(options.dynamicRequireRoot)
+      : process.cwd();
+  const { commonDir, dynamicRequireModules } = getDynamicRequireModules(
+    options.dynamicRequireTargets,
+    dynamicRequireRoot
+  );
+  const isDynamicRequireModulesEnabled = dynamicRequireModules.size > 0;
+
+  const ignoreRequire =
+    typeof options.ignore === 'function'
+      ? options.ignore
+      : Array.isArray(options.ignore)
+      ? (id) => options.ignore.includes(id)
+      : () => false;
+
+  const getIgnoreTryCatchRequireStatementMode = (id) => {
+    const mode =
+      typeof options.ignoreTryCatch === 'function'
+        ? options.ignoreTryCatch(id)
+        : Array.isArray(options.ignoreTryCatch)
+        ? options.ignoreTryCatch.includes(id)
+        : typeof options.ignoreTryCatch !== 'undefined'
+        ? options.ignoreTryCatch
+        : true;
+
+    return {
+      canConvertRequire: mode !== 'remove' && mode !== true,
+      shouldRemoveRequire: mode === 'remove'
+    };
+  };
+
+  const { currentlyResolving, resolveId } = getResolveId(extensions, isPossibleCjsId);
+
+  const sourceMap = options.sourceMap !== false;
+
+  // Initialized in buildStart
+  let requireResolver;
+
+  function transformAndCheckExports(code, id) {
+    const normalizedId = normalizePathSlashes(id);
+    const { isEsModule, hasDefaultExport, hasNamedExports, ast } = analyzeTopLevelStatements(
+      this.parse,
+      code,
+      id
+    );
+
+    const commonjsMeta = this.getModuleInfo(id).meta.commonjs || {};
+    if (hasDefaultExport) {
+      commonjsMeta.hasDefaultExport = true;
+    }
+    if (hasNamedExports) {
+      commonjsMeta.hasNamedExports = true;
+    }
+
+    if (
+      !dynamicRequireModules.has(normalizedId) &&
+      (!(hasCjsKeywords(code, ignoreGlobal) || requireResolver.isRequiredId(id)) ||
+        (isEsModule && !options.transformMixedEsModules))
+    ) {
+      commonjsMeta.isCommonJS = false;
+      return { meta: { commonjs: commonjsMeta } };
+    }
+
+    const needsRequireWrapper =
+      !isEsModule && (dynamicRequireModules.has(normalizedId) || strictRequiresFilter(id));
+
+    const checkDynamicRequire = (position) => {
+      const normalizedDynamicRequireRoot = normalizePathSlashes(dynamicRequireRoot);
+
+      if (normalizedId.indexOf(normalizedDynamicRequireRoot) !== 0) {
+        this.error(
+          {
+            code: 'DYNAMIC_REQUIRE_OUTSIDE_ROOT',
+            normalizedId,
+            normalizedDynamicRequireRoot,
+            message: `"${normalizedId}" contains dynamic require statements but it is not within the current dynamicRequireRoot "${normalizedDynamicRequireRoot}". You should set dynamicRequireRoot to "${dirname$1(
+              normalizedId
+            )}" or one of its parent directories.`
+          },
+          position
+        );
+      }
+    };
+
+    return transformCommonjs(
+      this.parse,
+      code,
+      id,
+      isEsModule,
+      ignoreGlobal || isEsModule,
+      ignoreRequire,
+      ignoreDynamicRequires && !isDynamicRequireModulesEnabled,
+      getIgnoreTryCatchRequireStatementMode,
+      sourceMap,
+      isDynamicRequireModulesEnabled,
+      dynamicRequireModules,
+      commonDir,
+      ast,
+      getDefaultIsModuleExports(id),
+      needsRequireWrapper,
+      requireResolver.resolveRequireSourcesAndUpdateMeta(this),
+      requireResolver.isRequiredId(id),
+      checkDynamicRequire,
+      commonjsMeta
+    );
+  }
+
+  return {
+    name: PLUGIN_NAME,
+
+    version: version$2,
+
+    options(rawOptions) {
+      // We inject the resolver in the beginning so that "catch-all-resolver" like node-resolver
+      // do not prevent our plugin from resolving entry points ot proxies.
+      const plugins = Array.isArray(rawOptions.plugins)
+        ? [...rawOptions.plugins]
+        : rawOptions.plugins
+        ? [rawOptions.plugins]
+        : [];
+      plugins.unshift({
+        name: 'commonjs--resolver',
+        resolveId
+      });
+      return { ...rawOptions, plugins };
+    },
+
+    buildStart({ plugins }) {
+      validateVersion(this.meta.rollupVersion, peerDependencies.rollup, 'rollup');
+      const nodeResolve = plugins.find(({ name }) => name === 'node-resolve');
+      if (nodeResolve) {
+        validateVersion(nodeResolve.version, '^13.0.6', '@rollup/plugin-node-resolve');
+      }
+      if (options.namedExports != null) {
+        this.warn(
+          'The namedExports option from "@rollup/plugin-commonjs" is deprecated. Named exports are now handled automatically.'
+        );
+      }
+      requireResolver = getRequireResolver(
+        extensions,
+        detectCyclesAndConditional,
+        currentlyResolving
+      );
+    },
+
+    buildEnd() {
+      if (options.strictRequires === 'debug') {
+        const wrappedIds = requireResolver.getWrappedIds();
+        if (wrappedIds.length) {
+          this.warn({
+            code: 'WRAPPED_IDS',
+            ids: wrappedIds,
+            message: `The commonjs plugin automatically wrapped the following files:\n[\n${wrappedIds
+              .map((id) => `\t${JSON.stringify(relative$1(process.cwd(), id))}`)
+              .join(',\n')}\n]`
+          });
+        } else {
+          this.warn({
+            code: 'WRAPPED_IDS',
+            ids: wrappedIds,
+            message: 'The commonjs plugin did not wrap any files.'
+          });
+        }
+      }
+    },
+
+    load(id) {
+      if (id === HELPERS_ID) {
+        return getHelpersModule();
+      }
+
+      if (isWrappedId(id, MODULE_SUFFIX)) {
+        const name = getName(unwrapId(id, MODULE_SUFFIX));
+        return {
+          code: `var ${name} = {exports: {}}; export {${name} as __module}`,
+          meta: { commonjs: { isCommonJS: false } }
+        };
+      }
+
+      if (isWrappedId(id, EXPORTS_SUFFIX)) {
+        const name = getName(unwrapId(id, EXPORTS_SUFFIX));
+        return {
+          code: `var ${name} = {}; export {${name} as __exports}`,
+          meta: { commonjs: { isCommonJS: false } }
+        };
+      }
+
+      if (isWrappedId(id, EXTERNAL_SUFFIX)) {
+        const actualId = unwrapId(id, EXTERNAL_SUFFIX);
+        return getUnknownRequireProxy(
+          actualId,
+          isEsmExternal(actualId) ? getRequireReturnsDefault(actualId) : true
+        );
+      }
+
+      // entry suffix is just appended to not mess up relative external resolution
+      if (id.endsWith(ENTRY_SUFFIX)) {
+        const acutalId = id.slice(0, -ENTRY_SUFFIX.length);
+        const {
+          meta: { commonjs: commonjsMeta }
+        } = this.getModuleInfo(acutalId);
+        const shebang = commonjsMeta?.shebang ?? '';
+        return getEntryProxy(
+          acutalId,
+          getDefaultIsModuleExports(acutalId),
+          this.getModuleInfo,
+          shebang
+        );
+      }
+
+      if (isWrappedId(id, ES_IMPORT_SUFFIX)) {
+        const actualId = unwrapId(id, ES_IMPORT_SUFFIX);
+        return getEsImportProxy(actualId, getDefaultIsModuleExports(actualId));
+      }
+
+      if (id === DYNAMIC_MODULES_ID) {
+        return getDynamicModuleRegistry(
+          isDynamicRequireModulesEnabled,
+          dynamicRequireModules,
+          commonDir,
+          ignoreDynamicRequires
+        );
+      }
+
+      if (isWrappedId(id, PROXY_SUFFIX)) {
+        const actualId = unwrapId(id, PROXY_SUFFIX);
+        return getStaticRequireProxy(actualId, getRequireReturnsDefault(actualId), this.load);
+      }
+
+      return null;
+    },
+
+    shouldTransformCachedModule(...args) {
+      return requireResolver.shouldTransformCachedModule.call(this, ...args);
+    },
+
+    transform(code, id) {
+      if (!isPossibleCjsId(id)) return null;
+
+      try {
+        return transformAndCheckExports.call(this, code, id);
+      } catch (err) {
+        return this.error(err, err.pos);
+      }
+    }
+  };
+}
+
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
+ */
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+    return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+    return input.startsWith('//');
+}
+function isAbsolutePath(input) {
+    return input.startsWith('/');
+}
+function isFileUrl(input) {
+    return input.startsWith('file:');
+}
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+    const match = urlRegex.exec(input);
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function parseFileUrl(input) {
+    const match = fileRegex.exec(input);
+    const path = match[2];
+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+    return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: 7 /* Absolute */,
+    };
+}
+function parseUrl$3(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        url.type = 6 /* SchemeRelative */;
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = 5 /* AbsolutePath */;
+        return url;
+    }
+    if (isFileUrl(input))
+        return parseFileUrl(input);
+    if (isAbsoluteUrl(input))
+        return parseAbsoluteUrl(input);
+    const url = parseAbsoluteUrl('http://foo.com/' + input);
+    url.scheme = '';
+    url.host = '';
+    url.type = input
+        ? input.startsWith('?')
+            ? 3 /* Query */
+            : input.startsWith('#')
+                ? 2 /* Hash */
+                : 4 /* RelativePath */
+        : 1 /* Empty */;
+    return url;
+}
+function stripPathFilename(path) {
+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
+    // paths. It's not a file, so we can't strip it.
+    if (path.endsWith('/..'))
+        return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    normalizePath$4(base, base.type);
+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+    // path).
+    if (url.path === '/') {
+        url.path = base.path;
+    }
+    else {
+        // Resolution happens relative to the base path's directory, not the file.
+        url.path = stripPathFilename(base.path) + url.path;
+    }
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath$4(url, type) {
+    const rel = type <= 4 /* RelativePath */;
+    const pieces = url.path.split('/');
+    // We need to preserve the first piece always, so that we output a leading slash. The item at
+    // pieces[0] is an empty string.
+    let pointer = 1;
+    // Positive is the number of real directories we've output, used for popping a parent directory.
+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+    let positive = 0;
+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+    // real directory, we won't need to append, unless the other conditions happen again.
+    let addTrailingSlash = false;
+    for (let i = 1; i < pieces.length; i++) {
+        const piece = pieces[i];
+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
+        if (!piece) {
+            addTrailingSlash = true;
+            continue;
+        }
+        // If we encounter a real directory, then we don't need to append anymore.
+        addTrailingSlash = false;
+        // A current directory, which we can always drop.
+        if (piece === '.')
+            continue;
+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
+        // have an excess of parents, and we'll need to keep the "..".
+        if (piece === '..') {
+            if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+            }
+            else if (rel) {
+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                pieces[pointer++] = piece;
+            }
+            continue;
+        }
+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+        // any popped or dropped directories.
+        pieces[pointer++] = piece;
+        positive++;
+    }
+    let path = '';
+    for (let i = 1; i < pointer; i++) {
+        path += '/' + pieces[i];
+    }
+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+        path += '/';
+    }
+    url.path = path;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve$2(input, base) {
+    if (!input && !base)
+        return '';
+    const url = parseUrl$3(input);
+    let inputType = url.type;
+    if (base && inputType !== 7 /* Absolute */) {
+        const baseUrl = parseUrl$3(base);
+        const baseType = baseUrl.type;
+        switch (inputType) {
+            case 1 /* Empty */:
+                url.hash = baseUrl.hash;
+            // fall through
+            case 2 /* Hash */:
+                url.query = baseUrl.query;
+            // fall through
+            case 3 /* Query */:
+            case 4 /* RelativePath */:
+                mergePaths(url, baseUrl);
+            // fall through
+            case 5 /* AbsolutePath */:
+                // The host, user, and port are joined, you can't copy one without the others.
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            // fall through
+            case 6 /* SchemeRelative */:
+                // The input doesn't have a schema at least, so we need to copy at least that over.
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+            inputType = baseType;
+    }
+    normalizePath$4(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch (inputType) {
+        // This is impossible, because of the empty checks at the start of the function.
+        // case UrlType.Empty:
+        case 2 /* Hash */:
+        case 3 /* Query */:
+            return queryHash;
+        case 4 /* RelativePath */: {
+            // The first char is always a "/", and we need it to be relative.
+            const path = url.path.slice(1);
+            if (!path)
+                return queryHash || '.';
+            if (isRelative(base || input) && !isRelative(path)) {
+                // If base started with a leading ".", or there is no base and input started with a ".",
+                // then we need to ensure that the relative path starts with a ".". We don't know if
+                // relative starts with a "..", though, so check before prepending.
+                return './' + path + queryHash;
+            }
+            return path + queryHash;
+        }
+        case 5 /* AbsolutePath */:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+    }
+}
+
+function resolve$1(input, base) {
+    // The base is always treated as a directory, if it's not empty.
+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
+    if (base && !base.endsWith('/'))
+        base += '/';
+    return resolve$2(input, base);
+}
+
+/**
+ * Removes everything after the last "/", but leaves the slash.
+ */
+function stripFilename(path) {
+    if (!path)
+        return '';
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+
+const COLUMN$1 = 0;
+const SOURCES_INDEX$1 = 1;
+const SOURCE_LINE$1 = 2;
+const SOURCE_COLUMN$1 = 3;
+const NAMES_INDEX$1 = 4;
+
+function maybeSort(mappings, owned) {
+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+    if (unsortedIndex === mappings.length)
+        return mappings;
+    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
+    // not, we do not want to modify the consumer's input array.
+    if (!owned)
+        mappings = mappings.slice();
+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+        mappings[i] = sortSegments(mappings[i], owned);
+    }
+    return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+    for (let i = start; i < mappings.length; i++) {
+        if (!isSorted(mappings[i]))
+            return i;
+    }
+    return mappings.length;
+}
+function isSorted(line) {
+    for (let j = 1; j < line.length; j++) {
+        if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) {
+            return false;
+        }
+    }
+    return true;
+}
+function sortSegments(line, owned) {
+    if (!owned)
+        line = line.slice();
+    return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[COLUMN$1] - b[COLUMN$1];
+}
+
+let found = false;
+/**
+ * A binary search implementation that returns the index if a match is found.
+ * If no match is found, then the left-index (the index associated with the item that comes just
+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
+ * the next index:
+ *
+ * ```js
+ * const array = [1, 3];
+ * const needle = 2;
+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
+ *
+ * assert.equal(index, 0);
+ * array.splice(index + 1, 0, needle);
+ * assert.deepEqual(array, [1, 2, 3]);
+ * ```
+ */
+function binarySearch(haystack, needle, low, high) {
+    while (low <= high) {
+        const mid = low + ((high - low) >> 1);
+        const cmp = haystack[mid][COLUMN$1] - needle;
+        if (cmp === 0) {
+            found = true;
+            return mid;
+        }
+        if (cmp < 0) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    found = false;
+    return low - 1;
+}
+function upperBound(haystack, needle, index) {
+    for (let i = index + 1; i < haystack.length; index = i++) {
+        if (haystack[i][COLUMN$1] !== needle)
+            break;
+    }
+    return index;
+}
+function lowerBound(haystack, needle, index) {
+    for (let i = index - 1; i >= 0; index = i--) {
+        if (haystack[i][COLUMN$1] !== needle)
+            break;
+    }
+    return index;
+}
+function memoizedState() {
+    return {
+        lastKey: -1,
+        lastNeedle: -1,
+        lastIndex: -1,
+    };
+}
+/**
+ * This overly complicated beast is just to record the last tested line/column and the resulting
+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
+ */
+function memoizedBinarySearch(haystack, needle, state, key) {
+    const { lastKey, lastNeedle, lastIndex } = state;
+    let low = 0;
+    let high = haystack.length - 1;
+    if (key === lastKey) {
+        if (needle === lastNeedle) {
+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
+            return lastIndex;
+        }
+        if (needle >= lastNeedle) {
+            // lastIndex may be -1 if the previous needle was not found.
+            low = lastIndex === -1 ? 0 : lastIndex;
+        }
+        else {
+            high = lastIndex;
+        }
+    }
+    state.lastKey = key;
+    state.lastNeedle = needle;
+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
+}
+
+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
+const LEAST_UPPER_BOUND = -1;
+const GREATEST_LOWER_BOUND = 1;
+class TraceMap {
+    constructor(map, mapUrl) {
+        const isString = typeof map === 'string';
+        if (!isString && map._decodedMemo)
+            return map;
+        const parsed = (isString ? JSON.parse(map) : map);
+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+        this.version = version;
+        this.file = file;
+        this.names = names || [];
+        this.sourceRoot = sourceRoot;
+        this.sources = sources;
+        this.sourcesContent = sourcesContent;
+        this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || undefined;
+        const from = resolve$1(sourceRoot || '', stripFilename(mapUrl));
+        this.resolvedSources = sources.map((s) => resolve$1(s || '', from));
+        const { mappings } = parsed;
+        if (typeof mappings === 'string') {
+            this._encoded = mappings;
+            this._decoded = undefined;
+        }
+        else {
+            this._encoded = undefined;
+            this._decoded = maybeSort(mappings, isString);
+        }
+        this._decodedMemo = memoizedState();
+        this._bySources = undefined;
+        this._bySourceMemos = undefined;
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast$2(map) {
+    return map;
+}
+/**
+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
+ */
+function encodedMappings(map) {
+    var _a;
+    var _b;
+    return ((_a = (_b = cast$2(map))._encoded) !== null && _a !== void 0 ? _a : (_b._encoded = encode$1(cast$2(map)._decoded)));
+}
+/**
+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
+ */
+function decodedMappings(map) {
+    var _a;
+    return ((_a = cast$2(map))._decoded || (_a._decoded = decode(cast$2(map)._encoded)));
+}
+/**
+ * A low-level API to find the segment associated with a generated line/column (think, from a
+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
+ */
+function traceSegment(map, line, column) {
+    const decoded = decodedMappings(map);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return null;
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast$2(map)._decodedMemo, line, column, GREATEST_LOWER_BOUND);
+    return index === -1 ? null : segments[index];
+}
+/**
+ * A higher-level API to find the source/line/column associated with a generated line/column
+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
+ * `source-map` library.
+ */
+function originalPositionFor$1(map, needle) {
+    let { line, column, bias } = needle;
+    line--;
+    if (line < 0)
+        throw new Error(LINE_GTR_ZERO);
+    if (column < 0)
+        throw new Error(COL_GTR_EQ_ZERO);
+    const decoded = decodedMappings(map);
+    // It's common for parent source maps to have pointers to lines that have no
+    // mapping (like a "//# sourceMappingURL=") at the end of the child file.
+    if (line >= decoded.length)
+        return OMapping(null, null, null, null);
+    const segments = decoded[line];
+    const index = traceSegmentInternal(segments, cast$2(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+    if (index === -1)
+        return OMapping(null, null, null, null);
+    const segment = segments[index];
+    if (segment.length === 1)
+        return OMapping(null, null, null, null);
+    const { names, resolvedSources } = map;
+    return OMapping(resolvedSources[segment[SOURCES_INDEX$1]], segment[SOURCE_LINE$1] + 1, segment[SOURCE_COLUMN$1], segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null);
+}
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function decodedMap(map) {
+    return clone(map, decodedMappings(map));
+}
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function encodedMap(map) {
+    return clone(map, encodedMappings(map));
+}
+function clone(map, mappings) {
+    return {
+        version: map.version,
+        file: map.file,
+        names: map.names,
+        sourceRoot: map.sourceRoot,
+        sources: map.sources,
+        sourcesContent: map.sourcesContent,
+        mappings,
+        ignoreList: map.ignoreList || map.x_google_ignoreList,
+    };
+}
+function OMapping(source, line, column, name) {
+    return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+    let index = memoizedBinarySearch(segments, column, memo, line);
+    if (found) {
+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+    }
+    else if (bias === LEAST_UPPER_BOUND)
+        index++;
+    if (index === -1 || index === segments.length)
+        return -1;
+    return index;
+}
+
+/**
+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
+ * index of the `key` in the backing array.
+ *
+ * This is designed to allow synchronizing a second array with the contents of the backing array,
+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
+ * and there are never duplicates.
+ */
+class SetArray {
+    constructor() {
+        this._indexes = { __proto__: null };
+        this.array = [];
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the set into a type
+ * with public access modifiers.
+ */
+function cast$1(set) {
+    return set;
+}
+/**
+ * Gets the index associated with `key` in the backing array, if it is already present.
+ */
+function get(setarr, key) {
+    return cast$1(setarr)._indexes[key];
+}
+/**
+ * Puts `key` into the backing array, if it is not already present. Returns
+ * the index of the `key` in the backing array.
+ */
+function put(setarr, key) {
+    // The key may or may not be present. If it is present, it's a number.
+    const index = get(setarr, key);
+    if (index !== undefined)
+        return index;
+    const { array, _indexes: indexes } = cast$1(setarr);
+    const length = array.push(key);
+    return (indexes[key] = length - 1);
+}
+/**
+ * Removes the key, if it exists in the set.
+ */
+function remove(setarr, key) {
+    const index = get(setarr, key);
+    if (index === undefined)
+        return;
+    const { array, _indexes: indexes } = cast$1(setarr);
+    for (let i = index + 1; i < array.length; i++) {
+        const k = array[i];
+        array[i - 1] = k;
+        indexes[k]--;
+    }
+    indexes[key] = undefined;
+    array.pop();
+}
+
+const COLUMN = 0;
+const SOURCES_INDEX = 1;
+const SOURCE_LINE = 2;
+const SOURCE_COLUMN = 3;
+const NAMES_INDEX = 4;
+
+const NO_NAME = -1;
+/**
+ * Provides the state to generate a sourcemap.
+ */
+class GenMapping {
+    constructor({ file, sourceRoot } = {}) {
+        this._names = new SetArray();
+        this._sources = new SetArray();
+        this._sourcesContent = [];
+        this._mappings = [];
+        this.file = file;
+        this.sourceRoot = sourceRoot;
+        this._ignoreList = new SetArray();
+    }
+}
+/**
+ * Typescript doesn't allow friend access to private fields, so this just casts the map into a type
+ * with public access modifiers.
+ */
+function cast(map) {
+    return map;
+}
+/**
+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
+ * not add a segment with a lower generated line/column than one that came before.
+ */
+const maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
+    return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name);
+};
+/**
+ * Adds/removes the content of the source file to the source map.
+ */
+function setSourceContent(map, source, content) {
+    const { _sources: sources, _sourcesContent: sourcesContent } = cast(map);
+    const index = put(sources, source);
+    sourcesContent[index] = content;
+}
+function setIgnore(map, source, ignore = true) {
+    const { _sources: sources, _sourcesContent: sourcesContent, _ignoreList: ignoreList } = cast(map);
+    const index = put(sources, source);
+    if (index === sourcesContent.length)
+        sourcesContent[index] = null;
+    if (ignore)
+        put(ignoreList, index);
+    else
+        remove(ignoreList, index);
+}
+/**
+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function toDecodedMap(map) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, _ignoreList: ignoreList, } = cast(map);
+    removeEmptyFinalLines(mappings);
+    return {
+        version: 3,
+        file: map.file || undefined,
+        names: names.array,
+        sourceRoot: map.sourceRoot || undefined,
+        sources: sources.array,
+        sourcesContent,
+        mappings,
+        ignoreList: ignoreList.array,
+    };
+}
+/**
+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
+ * a sourcemap, or to JSON.stringify.
+ */
+function toEncodedMap(map) {
+    const decoded = toDecodedMap(map);
+    return Object.assign(Object.assign({}, decoded), { mappings: encode$1(decoded.mappings) });
+}
+// This split declaration is only so that terser can elminiate the static initialization block.
+function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+    const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = cast(map);
+    const line = getLine(mappings, genLine);
+    const index = getColumnIndex(line, genColumn);
+    if (!source) {
+        if (skipSourceless(line, index))
+            return;
+        return insert(line, index, [genColumn]);
+    }
+    const sourcesIndex = put(sources, source);
+    const namesIndex = name ? put(names, name) : NO_NAME;
+    if (sourcesIndex === sourcesContent.length)
+        sourcesContent[sourcesIndex] = null;
+    if (skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
+        return;
+    }
+    return insert(line, index, name
+        ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
+        : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
+}
+function getLine(mappings, index) {
+    for (let i = mappings.length; i <= index; i++) {
+        mappings[i] = [];
+    }
+    return mappings[index];
+}
+function getColumnIndex(line, genColumn) {
+    let index = line.length;
+    for (let i = index - 1; i >= 0; index = i--) {
+        const current = line[i];
+        if (genColumn >= current[COLUMN])
+            break;
+    }
+    return index;
+}
+function insert(array, index, value) {
+    for (let i = array.length; i > index; i--) {
+        array[i] = array[i - 1];
+    }
+    array[index] = value;
+}
+function removeEmptyFinalLines(mappings) {
+    const { length } = mappings;
+    let len = length;
+    for (let i = len - 1; i >= 0; len = i, i--) {
+        if (mappings[i].length > 0)
+            break;
+    }
+    if (len < length)
+        mappings.length = len;
+}
+function skipSourceless(line, index) {
+    // The start of a line is already sourceless, so adding a sourceless segment to the beginning
+    // doesn't generate any useful information.
+    if (index === 0)
+        return true;
+    const prev = line[index - 1];
+    // If the previous segment is also sourceless, then adding another sourceless segment doesn't
+    // genrate any new information. Else, this segment will end the source/named segment and point to
+    // a sourceless position, which is useful.
+    return prev.length === 1;
+}
+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+    // A source/named segment at the start of a line gives position at that genColumn
+    if (index === 0)
+        return false;
+    const prev = line[index - 1];
+    // If the previous segment is sourceless, then we're transitioning to a source.
+    if (prev.length === 1)
+        return false;
+    // If the previous segment maps to the exact same source position, then this segment doesn't
+    // provide any new position information.
+    return (sourcesIndex === prev[SOURCES_INDEX] &&
+        sourceLine === prev[SOURCE_LINE] &&
+        sourceColumn === prev[SOURCE_COLUMN] &&
+        namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
+}
+
+const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);
+const EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+    return { source, line, column, name, content, ignore };
+}
+function Source(map, sources, source, content, ignore) {
+    return {
+        map,
+        sources,
+        source,
+        content,
+        ignore,
+    };
+}
+/**
+ * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+ * (which may themselves be SourceMapTrees).
+ */
+function MapSource(map, sources) {
+    return Source(map, sources, '', null, false);
+}
+/**
+ * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+ * segment tracing ends at the `OriginalSource`.
+ */
+function OriginalSource(source, content, ignore) {
+    return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+/**
+ * traceMappings is only called on the root level SourceMapTree, and begins the process of
+ * resolving each mapping in terms of the original source files.
+ */
+function traceMappings(tree) {
+    // TODO: Eventually support sourceRoot, which has to be removed because the sources are already
+    // fully resolved. We'll need to make sources relative to the sourceRoot before adding them.
+    const gen = new GenMapping({ file: tree.map.file });
+    const { sources: rootSources, map } = tree;
+    const rootNames = map.names;
+    const rootMappings = decodedMappings(map);
+    for (let i = 0; i < rootMappings.length; i++) {
+        const segments = rootMappings[i];
+        for (let j = 0; j < segments.length; j++) {
+            const segment = segments[j];
+            const genCol = segment[0];
+            let traced = SOURCELESS_MAPPING;
+            // 1-length segments only move the current generated column, there's no source information
+            // to gather from it.
+            if (segment.length !== 1) {
+                const source = rootSources[segment[1]];
+                traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
+                // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
+                // respective segment into an original source.
+                if (traced == null)
+                    continue;
+            }
+            const { column, line, name, content, source, ignore } = traced;
+            maybeAddSegment(gen, i, genCol, source, line, column, name);
+            if (source && content != null)
+                setSourceContent(gen, source, content);
+            if (ignore)
+                setIgnore(gen, source, true);
+        }
+    }
+    return gen;
+}
+/**
+ * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+ * child SourceMapTrees, until we find the original source map.
+ */
+function originalPositionFor(source, line, column, name) {
+    if (!source.map) {
+        return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+    }
+    const segment = traceSegment(source.map, line, column);
+    // If we couldn't find a segment, then this doesn't exist in the sourcemap.
+    if (segment == null)
+        return null;
+    // 1-length segments only move the current generated column, there's no source information
+    // to gather from it.
+    if (segment.length === 1)
+        return SOURCELESS_MAPPING;
+    return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    return [value];
+}
+/**
+ * Recursively builds a tree structure out of sourcemap files, with each node
+ * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+ * `OriginalSource`s and `SourceMapTree`s.
+ *
+ * Every sourcemap is composed of a collection of source files and mappings
+ * into locations of those source files. When we generate a `SourceMapTree` for
+ * the sourcemap, we attempt to load each source file's own sourcemap. If it
+ * does not have an associated sourcemap, it is considered an original,
+ * unmodified source file.
+ */
+function buildSourceMapTree(input, loader) {
+    const maps = asArray(input).map((m) => new TraceMap(m, ''));
+    const map = maps.pop();
+    for (let i = 0; i < maps.length; i++) {
+        if (maps[i].sources.length > 1) {
+            throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
+                'Did you specify these with the most recent transformation maps first?');
+        }
+    }
+    let tree = build$2(map, loader, '', 0);
+    for (let i = maps.length - 1; i >= 0; i--) {
+        tree = MapSource(maps[i], [tree]);
+    }
+    return tree;
+}
+function build$2(map, loader, importer, importerDepth) {
+    const { resolvedSources, sourcesContent, ignoreList } = map;
+    const depth = importerDepth + 1;
+    const children = resolvedSources.map((sourceFile, i) => {
+        // The loading context gives the loader more information about why this file is being loaded
+        // (eg, from which importer). It also allows the loader to override the location of the loaded
+        // sourcemap/original source, or to override the content in the sourcesContent field if it's
+        // an unmodified source file.
+        const ctx = {
+            importer,
+            depth,
+            source: sourceFile || '',
+            content: undefined,
+            ignore: undefined,
+        };
+        // Use the provided loader callback to retrieve the file's sourcemap.
+        // TODO: We should eventually support async loading of sourcemap files.
+        const sourceMap = loader(ctx.source, ctx);
+        const { source, content, ignore } = ctx;
+        // If there is a sourcemap, then we need to recurse into it to load its source files.
+        if (sourceMap)
+            return build$2(new TraceMap(sourceMap, source), loader, source, depth);
+        // Else, it's an unmodified source file.
+        // The contents of this unmodified source file can be overridden via the loader context,
+        // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
+        // the importing sourcemap's `sourcesContent` field.
+        const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
+        const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;
+        return OriginalSource(source, sourceContent, ignored);
+    });
+    return MapSource(map, children);
+}
+
+/**
+ * A SourceMap v3 compatible sourcemap, which only includes fields that were
+ * provided to it.
+ */
+class SourceMap {
+    constructor(map, options) {
+        const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+        this.version = out.version; // SourceMap spec says this should be first.
+        this.file = out.file;
+        this.mappings = out.mappings;
+        this.names = out.names;
+        this.ignoreList = out.ignoreList;
+        this.sourceRoot = out.sourceRoot;
+        this.sources = out.sources;
+        if (!options.excludeContent) {
+            this.sourcesContent = out.sourcesContent;
+        }
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+}
+
+/**
+ * Traces through all the mappings in the root sourcemap, through the sources
+ * (and their sourcemaps), all the way back to the original source location.
+ *
+ * `loader` will be called every time we encounter a source file. If it returns
+ * a sourcemap, we will recurse into that sourcemap to continue the trace. If
+ * it returns a falsey value, that source file is treated as an original,
+ * unmodified source file.
+ *
+ * Pass `excludeContent` to exclude any self-containing source file content
+ * from the output sourcemap.
+ *
+ * Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+ * VLQ encoded) mappings.
+ */
+function remapping(input, loader, options) {
+    const opts = { excludeContent: !!options, decodedMappings: false };
+    const tree = buildSourceMapTree(input, loader);
+    return new SourceMap(traceMappings(tree), opts);
+}
+
+var src$3 = {exports: {}};
+
+var browser$3 = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms$1;
+var hasRequiredMs$1;
+
+function requireMs$1 () {
+	if (hasRequiredMs$1) return ms$1;
+	hasRequiredMs$1 = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms$1 = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms$1;
+}
+
+var common$b;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common$b;
+	hasRequiredCommon = 1;
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs$1();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
+
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
+
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
+
+				const self = debug;
+
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+
+				args[0] = createDebug.coerce(args[0]);
+
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
+				}
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
+					}
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
+			}
+
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
+					}
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
+				}
+			});
+
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
+			}
+
+			return debug;
+		}
+
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			let i;
+			const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+			const len = split.length;
+
+			for (i = 0; i < len; i++) {
+				if (!split[i]) {
+					// ignore empty strings
+					continue;
+				}
+
+				namespaces = split[i].replace(/\*/g, '.*?');
+
+				if (namespaces[0] === '-') {
+					createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+				} else {
+					createDebug.names.push(new RegExp('^' + namespaces + '$'));
+				}
+			}
+		}
+
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names.map(toNamespace),
+				...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
+		}
+
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			if (name[name.length - 1] === '*') {
+				return true;
+			}
+
+			let i;
+			let len;
+
+			for (i = 0, len = createDebug.skips.length; i < len; i++) {
+				if (createDebug.skips[i].test(name)) {
+					return false;
+				}
+			}
+
+			for (i = 0, len = createDebug.names.length; i < len; i++) {
+				if (createDebug.names[i].test(name)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		* Convert regexp to namespace
+		*
+		* @param {RegExp} regxep
+		* @return {String} namespace
+		* @api private
+		*/
+		function toNamespace(regexp) {
+			return regexp.toString()
+				.substring(2, regexp.toString().length - 2)
+				.replace(/\.\*\?$/, '*');
+		}
+
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
+			}
+			return val;
+		}
+
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+
+		createDebug.enable(createDebug.load());
+
+		return createDebug;
+	}
+
+	common$b = setup;
+	return common$b;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser$1;
+
+function requireBrowser$1 () {
+	if (hasRequiredBrowser$1) return browser$3.exports;
+	hasRequiredBrowser$1 = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
+			}
+
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
+
+			let m;
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+		}
+
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
+
+			if (!this.useColors) {
+				return;
+			}
+
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
+		}
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		}; 
+	} (browser$3, browser$3.exports));
+	return browser$3.exports;
+}
+
+var node$1 = {exports: {}};
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode$1;
+
+function requireNode$1 () {
+	if (hasRequiredNode$1) return node$1.exports;
+	hasRequiredNode$1 = 1;
+	(function (module, exports) {
+		const tty = require$$0$3;
+		const util = require$$0$5;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
+			() => {},
+			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+		);
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const supportsColor = require('supports-color');
+
+			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+				exports.colors = [
+					20,
+					21,
+					26,
+					27,
+					32,
+					33,
+					38,
+					39,
+					40,
+					41,
+					42,
+					43,
+					44,
+					45,
+					56,
+					57,
+					62,
+					63,
+					68,
+					69,
+					74,
+					75,
+					76,
+					77,
+					78,
+					79,
+					80,
+					81,
+					92,
+					93,
+					98,
+					99,
+					112,
+					113,
+					128,
+					129,
+					134,
+					135,
+					148,
+					149,
+					160,
+					161,
+					162,
+					163,
+					164,
+					165,
+					166,
+					167,
+					168,
+					169,
+					170,
+					171,
+					172,
+					173,
+					178,
+					179,
+					184,
+					185,
+					196,
+					197,
+					198,
+					199,
+					200,
+					201,
+					202,
+					203,
+					204,
+					205,
+					206,
+					207,
+					208,
+					209,
+					214,
+					215,
+					220,
+					221
+				];
+			}
+		} catch (error) {
+			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		}
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		}; 
+	} (node$1, node$1.exports));
+	return node$1.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	src$3.exports = requireBrowser$1();
+} else {
+	src$3.exports = requireNode$1();
+}
+
+var srcExports$1 = src$3.exports;
+var debug$i = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
+
+let pnp;
+if (process.versions.pnp) {
+  try {
+    pnp = createRequire$1(import.meta.url)("pnpapi");
+  } catch {
+  }
+}
+function invalidatePackageData(packageCache, pkgPath) {
+  const pkgDir = normalizePath$3(path$n.dirname(pkgPath));
+  packageCache.forEach((pkg, cacheKey) => {
+    if (pkg.dir === pkgDir) {
+      packageCache.delete(cacheKey);
+    }
+  });
+}
+function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageCache) {
+  if (pnp) {
+    const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+    if (packageCache?.has(cacheKey)) return packageCache.get(cacheKey);
+    try {
+      const pkg = pnp.resolveToUnqualified(pkgName, basedir, {
+        considerBuiltins: false
+      });
+      if (!pkg) return null;
+      const pkgData = loadPackageData(path$n.join(pkg, "package.json"));
+      packageCache?.set(cacheKey, pkgData);
+      return pkgData;
+    } catch {
+      return null;
+    }
+  }
+  const originalBasedir = basedir;
+  while (basedir) {
+    if (packageCache) {
+      const cached = getRpdCache(
+        packageCache,
+        pkgName,
+        basedir,
+        originalBasedir,
+        preserveSymlinks
+      );
+      if (cached) return cached;
+    }
+    const pkg = path$n.join(basedir, "node_modules", pkgName, "package.json");
+    try {
+      if (fs__default.existsSync(pkg)) {
+        const pkgPath = preserveSymlinks ? pkg : safeRealpathSync(pkg);
+        const pkgData = loadPackageData(pkgPath);
+        if (packageCache) {
+          setRpdCache(
+            packageCache,
+            pkgData,
+            pkgName,
+            basedir,
+            originalBasedir,
+            preserveSymlinks
+          );
+        }
+        return pkgData;
+      }
+    } catch {
+    }
+    const nextBasedir = path$n.dirname(basedir);
+    if (nextBasedir === basedir) break;
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function findNearestPackageData(basedir, packageCache) {
+  const originalBasedir = basedir;
+  while (basedir) {
+    if (packageCache) {
+      const cached = getFnpdCache(packageCache, basedir, originalBasedir);
+      if (cached) return cached;
+    }
+    const pkgPath = path$n.join(basedir, "package.json");
+    if (tryStatSync(pkgPath)?.isFile()) {
+      try {
+        const pkgData = loadPackageData(pkgPath);
+        if (packageCache) {
+          setFnpdCache(packageCache, pkgData, basedir, originalBasedir);
+        }
+        return pkgData;
+      } catch {
+      }
+    }
+    const nextBasedir = path$n.dirname(basedir);
+    if (nextBasedir === basedir) break;
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function findNearestMainPackageData(basedir, packageCache) {
+  const nearestPackage = findNearestPackageData(basedir, packageCache);
+  return nearestPackage && (nearestPackage.data.name ? nearestPackage : findNearestMainPackageData(
+    path$n.dirname(nearestPackage.dir),
+    packageCache
+  ));
+}
+function loadPackageData(pkgPath) {
+  const data = JSON.parse(fs__default.readFileSync(pkgPath, "utf-8"));
+  const pkgDir = normalizePath$3(path$n.dirname(pkgPath));
+  const { sideEffects } = data;
+  let hasSideEffects;
+  if (typeof sideEffects === "boolean") {
+    hasSideEffects = () => sideEffects;
+  } else if (Array.isArray(sideEffects)) {
+    if (sideEffects.length <= 0) {
+      hasSideEffects = () => false;
+    } else {
+      const finalPackageSideEffects = sideEffects.map((sideEffect) => {
+        if (sideEffect.includes("/")) {
+          return sideEffect;
+        }
+        return `**/${sideEffect}`;
+      });
+      hasSideEffects = createFilter(finalPackageSideEffects, null, {
+        resolve: pkgDir
+      });
+    }
+  } else {
+    hasSideEffects = () => null;
+  }
+  const pkg = {
+    dir: pkgDir,
+    data,
+    hasSideEffects,
+    webResolvedImports: {},
+    nodeResolvedImports: {},
+    setResolvedCache(key, entry, targetWeb) {
+      if (targetWeb) {
+        pkg.webResolvedImports[key] = entry;
+      } else {
+        pkg.nodeResolvedImports[key] = entry;
+      }
+    },
+    getResolvedCache(key, targetWeb) {
+      if (targetWeb) {
+        return pkg.webResolvedImports[key];
+      } else {
+        return pkg.nodeResolvedImports[key];
+      }
+    }
+  };
+  return pkg;
+}
+function watchPackageDataPlugin(packageCache) {
+  const watchQueue = /* @__PURE__ */ new Set();
+  const watchedDirs = /* @__PURE__ */ new Set();
+  const watchFileStub = (id) => {
+    watchQueue.add(id);
+  };
+  let watchFile = watchFileStub;
+  const setPackageData = packageCache.set.bind(packageCache);
+  packageCache.set = (id, pkg) => {
+    if (!isInNodeModules$1(pkg.dir) && !watchedDirs.has(pkg.dir)) {
+      watchedDirs.add(pkg.dir);
+      watchFile(path$n.join(pkg.dir, "package.json"));
+    }
+    return setPackageData(id, pkg);
+  };
+  return {
+    name: "vite:watch-package-data",
+    buildStart() {
+      watchFile = this.addWatchFile.bind(this);
+      watchQueue.forEach(watchFile);
+      watchQueue.clear();
+    },
+    buildEnd() {
+      watchFile = watchFileStub;
+    },
+    watchChange(id) {
+      if (id.endsWith("/package.json")) {
+        invalidatePackageData(packageCache, path$n.normalize(id));
+      }
+    }
+  };
+}
+function getRpdCache(packageCache, pkgName, basedir, originalBasedir, preserveSymlinks) {
+  const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+  const pkgData = packageCache.get(cacheKey);
+  if (pkgData) {
+    traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+      packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+    });
+    return pkgData;
+  }
+}
+function setRpdCache(packageCache, pkgData, pkgName, basedir, originalBasedir, preserveSymlinks) {
+  packageCache.set(getRpdCacheKey(pkgName, basedir, preserveSymlinks), pkgData);
+  traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+    packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+  });
+}
+function getRpdCacheKey(pkgName, basedir, preserveSymlinks) {
+  return `rpd_${pkgName}_${basedir}_${preserveSymlinks}`;
+}
+function getFnpdCache(packageCache, basedir, originalBasedir) {
+  const cacheKey = getFnpdCacheKey(basedir);
+  const pkgData = packageCache.get(cacheKey);
+  if (pkgData) {
+    traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+      packageCache.set(getFnpdCacheKey(dir), pkgData);
+    });
+    return pkgData;
+  }
+}
+function setFnpdCache(packageCache, pkgData, basedir, originalBasedir) {
+  packageCache.set(getFnpdCacheKey(basedir), pkgData);
+  traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+    packageCache.set(getFnpdCacheKey(dir), pkgData);
+  });
+}
+function getFnpdCacheKey(basedir) {
+  return `fnpd_${basedir}`;
+}
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+  while (longerDir !== shorterDir) {
+    cb(longerDir);
+    longerDir = path$n.dirname(longerDir);
+  }
+}
+
+const createFilter = createFilter$1;
+const replaceSlashOrColonRE = /[/:]/g;
+const replaceDotRE = /\./g;
+const replaceNestedIdRE = /\s*>\s*/g;
+const replaceHashRE = /#/g;
+const flattenId = (id) => {
+  const flatId = limitFlattenIdLength(
+    id.replace(replaceSlashOrColonRE, "_").replace(replaceDotRE, "__").replace(replaceNestedIdRE, "___").replace(replaceHashRE, "____")
+  );
+  return flatId;
+};
+const FLATTEN_ID_HASH_LENGTH = 8;
+const FLATTEN_ID_MAX_FILE_LENGTH = 170;
+const limitFlattenIdLength = (id, limit = FLATTEN_ID_MAX_FILE_LENGTH) => {
+  if (id.length <= limit) {
+    return id;
+  }
+  return id.slice(0, limit - (FLATTEN_ID_HASH_LENGTH + 1)) + "_" + getHash(id);
+};
+const normalizeId = (id) => id.replace(replaceNestedIdRE, " > ");
+const NODE_BUILTIN_NAMESPACE = "node:";
+const NPM_BUILTIN_NAMESPACE = "npm:";
+const BUN_BUILTIN_NAMESPACE = "bun:";
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+function isBuiltin(id) {
+  if (process.versions.deno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
+  if (process.versions.bun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
+  return isNodeBuiltin(id);
+}
+function isNodeBuiltin(id) {
+  if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
+  return nodeBuiltins.includes(id);
+}
+function isInNodeModules$1(id) {
+  return id.includes("node_modules");
+}
+function moduleListContains(moduleList, id) {
+  return moduleList?.some(
+    (m) => m === id || id.startsWith(withTrailingSlash(m))
+  );
+}
+function isOptimizable(id, optimizeDeps) {
+  const { extensions } = optimizeDeps;
+  return OPTIMIZABLE_ENTRY_RE.test(id) || (extensions?.some((ext) => id.endsWith(ext)) ?? false);
+}
+const bareImportRE = /^(?![a-zA-Z]:)[\w@](?!.*:\/\/)/;
+const deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
+const _require$1 = createRequire$1(import.meta.url);
+function resolveDependencyVersion(dep, pkgRelativePath = "../../package.json") {
+  const pkgPath = path$n.resolve(_require$1.resolve(dep), pkgRelativePath);
+  return JSON.parse(fs__default.readFileSync(pkgPath, "utf-8")).version;
+}
+const rollupVersion = resolveDependencyVersion("rollup");
+const filter = process.env.VITE_DEBUG_FILTER;
+const DEBUG = process.env.DEBUG;
+function createDebugger(namespace, options = {}) {
+  const log = debug$i(namespace);
+  const { onlyWhenFocused } = options;
+  let enabled = log.enabled;
+  if (enabled && onlyWhenFocused) {
+    const ns = typeof onlyWhenFocused === "string" ? onlyWhenFocused : namespace;
+    enabled = !!DEBUG?.includes(ns);
+  }
+  if (enabled) {
+    return (...args) => {
+      if (!filter || args.some((a) => a?.includes?.(filter))) {
+        log(...args);
+      }
+    };
+  }
+}
+function testCaseInsensitiveFS() {
+  if (!CLIENT_ENTRY.endsWith("client.mjs")) {
+    throw new Error(
+      `cannot test case insensitive FS, CLIENT_ENTRY const doesn't contain client.mjs`
+    );
+  }
+  if (!fs__default.existsSync(CLIENT_ENTRY)) {
+    throw new Error(
+      "cannot test case insensitive FS, CLIENT_ENTRY does not point to an existing file: " + CLIENT_ENTRY
+    );
+  }
+  return fs__default.existsSync(CLIENT_ENTRY.replace("client.mjs", "cLiEnT.mjs"));
+}
+const urlCanParse = (
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  URL$3.canParse ?? // URL.canParse is supported from Node.js 18.17.0+, 20.0.0+
+  ((path2, base) => {
+    try {
+      new URL$3(path2, base);
+      return true;
+    } catch {
+      return false;
+    }
+  })
+);
+const isCaseInsensitiveFS = testCaseInsensitiveFS();
+const VOLUME_RE = /^[A-Z]:/i;
+function normalizePath$3(id) {
+  return path$n.posix.normalize(isWindows$3 ? slash$1(id) : id);
+}
+function fsPathFromId(id) {
+  const fsPath = normalizePath$3(
+    id.startsWith(FS_PREFIX) ? id.slice(FS_PREFIX.length) : id
+  );
+  return fsPath[0] === "/" || VOLUME_RE.test(fsPath) ? fsPath : `/${fsPath}`;
+}
+function fsPathFromUrl(url) {
+  return fsPathFromId(cleanUrl(url));
+}
+function isParentDirectory(dir, file) {
+  dir = withTrailingSlash(dir);
+  return file.startsWith(dir) || isCaseInsensitiveFS && file.toLowerCase().startsWith(dir.toLowerCase());
+}
+function isSameFileUri(file1, file2) {
+  return file1 === file2 || isCaseInsensitiveFS && file1.toLowerCase() === file2.toLowerCase();
+}
+const externalRE = /^(https?:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+const dataUrlRE = /^\s*data:/i;
+const isDataUrl = (url) => dataUrlRE.test(url);
+const virtualModuleRE = /^virtual-module:.*/;
+const virtualModulePrefix = "virtual-module:";
+const knownJsSrcRE = /\.(?:[jt]sx?|m[jt]s|vue|marko|svelte|astro|imba|mdx)(?:$|\?)/;
+const isJSRequest = (url) => {
+  url = cleanUrl(url);
+  if (knownJsSrcRE.test(url)) {
+    return true;
+  }
+  if (!path$n.extname(url) && url[url.length - 1] !== "/") {
+    return true;
+  }
+  return false;
+};
+const knownTsRE = /\.(?:ts|mts|cts|tsx)(?:$|\?)/;
+const isTsRequest = (url) => knownTsRE.test(url);
+const importQueryRE = /(\?|&)import=?(?:&|$)/;
+const directRequestRE$1 = /(\?|&)direct=?(?:&|$)/;
+const internalPrefixes = [
+  FS_PREFIX,
+  VALID_ID_PREFIX,
+  CLIENT_PUBLIC_PATH,
+  ENV_PUBLIC_PATH
+];
+const InternalPrefixRE = new RegExp(`^(?:${internalPrefixes.join("|")})`);
+const trailingSeparatorRE = /[?&]$/;
+const isImportRequest = (url) => importQueryRE.test(url);
+const isInternalRequest = (url) => InternalPrefixRE.test(url);
+function removeImportQuery(url) {
+  return url.replace(importQueryRE, "$1").replace(trailingSeparatorRE, "");
+}
+function removeDirectQuery(url) {
+  return url.replace(directRequestRE$1, "$1").replace(trailingSeparatorRE, "");
+}
+const urlRE = /(\?|&)url(?:&|$)/;
+const rawRE = /(\?|&)raw(?:&|$)/;
+function removeUrlQuery(url) {
+  return url.replace(urlRE, "$1").replace(trailingSeparatorRE, "");
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url, queryToInject) {
+  const resolvedUrl = new URL$3(
+    url.replace(replacePercentageRE, "%25"),
+    "relative:///"
+  );
+  const { search, hash } = resolvedUrl;
+  let pathname = cleanUrl(url);
+  pathname = isWindows$3 ? slash$1(pathname) : pathname;
+  return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash ?? ""}`;
+}
+const timestampRE = /\bt=\d{13}&?\b/;
+function removeTimestampQuery(url) {
+  return url.replace(timestampRE, "").replace(trailingSeparatorRE, "");
+}
+async function asyncReplace(input, re, replacer) {
+  let match;
+  let remaining = input;
+  let rewritten = "";
+  while (match = re.exec(remaining)) {
+    rewritten += remaining.slice(0, match.index);
+    rewritten += await replacer(match);
+    remaining = remaining.slice(match.index + match[0].length);
+  }
+  rewritten += remaining;
+  return rewritten;
+}
+function timeFrom(start, subtract = 0) {
+  const time = performance$1.now() - start - subtract;
+  const timeString = (time.toFixed(2) + `ms`).padEnd(5, " ");
+  if (time < 10) {
+    return colors$1.green(timeString);
+  } else if (time < 50) {
+    return colors$1.yellow(timeString);
+  } else {
+    return colors$1.red(timeString);
+  }
+}
+function prettifyUrl(url, root) {
+  url = removeTimestampQuery(url);
+  const isAbsoluteFile = url.startsWith(root);
+  if (isAbsoluteFile || url.startsWith(FS_PREFIX)) {
+    const file = path$n.posix.relative(
+      root,
+      isAbsoluteFile ? url : fsPathFromId(url)
+    );
+    return colors$1.dim(file);
+  } else {
+    return colors$1.dim(url);
+  }
+}
+function isObject$1(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isDefined(value) {
+  return value != null;
+}
+function tryStatSync(file) {
+  try {
+    return fs__default.statSync(file, { throwIfNoEntry: false });
+  } catch {
+  }
+}
+function lookupFile(dir, fileNames) {
+  while (dir) {
+    for (const fileName of fileNames) {
+      const fullPath = path$n.join(dir, fileName);
+      if (tryStatSync(fullPath)?.isFile()) return fullPath;
+    }
+    const parentDir = path$n.dirname(dir);
+    if (parentDir === dir) return;
+    dir = parentDir;
+  }
+}
+function isFilePathESM(filePath, packageCache) {
+  if (/\.m[jt]s$/.test(filePath)) {
+    return true;
+  } else if (/\.c[jt]s$/.test(filePath)) {
+    return false;
+  } else {
+    try {
+      const pkg = findNearestPackageData(path$n.dirname(filePath), packageCache);
+      return pkg?.data.type === "module";
+    } catch {
+      return false;
+    }
+  }
+}
+const splitRE = /\r?\n/g;
+const range = 2;
+function pad$1(source, n = 2) {
+  const lines = source.split(splitRE);
+  return lines.map((l) => ` `.repeat(n) + l).join(`
+`);
+}
+function posToNumber(source, pos) {
+  if (typeof pos === "number") return pos;
+  const lines = source.split(splitRE);
+  const { line, column } = pos;
+  let start = 0;
+  for (let i = 0; i < line - 1 && i < lines.length; i++) {
+    start += lines[i].length + 1;
+  }
+  return start + column;
+}
+function numberToPos(source, offset) {
+  if (typeof offset !== "number") return offset;
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(splitRE);
+  let counted = 0;
+  let line = 0;
+  let column = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + 1;
+    if (counted + lineLength >= offset) {
+      column = offset - counted + 1;
+      break;
+    }
+    counted += lineLength;
+  }
+  return { line: line + 1, column };
+}
+function generateCodeFrame(source, start = 0, end) {
+  start = Math.max(posToNumber(source, start), 0);
+  end = Math.min(
+    end !== void 0 ? posToNumber(source, end) : start,
+    source.length
+  );
+  const lines = source.split(splitRE);
+  let count = 0;
+  const res = [];
+  for (let i = 0; i < lines.length; i++) {
+    count += lines[i].length;
+    if (count >= start) {
+      for (let j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) continue;
+        const line = j + 1;
+        res.push(
+          `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+        );
+        const lineLength = lines[j].length;
+        if (j === i) {
+          const pad2 = Math.max(start - (count - lineLength), 0);
+          const length = Math.max(
+            1,
+            end > count ? lineLength - pad2 : end - start
+          );
+          res.push(`   |  ` + " ".repeat(pad2) + "^".repeat(length));
+        } else if (j > i) {
+          if (end > count) {
+            const length = Math.max(Math.min(end - count, lineLength), 1);
+            res.push(`   |  ` + "^".repeat(length));
+          }
+          count += lineLength + 1;
+        }
+      }
+      break;
+    }
+    count++;
+  }
+  return res.join("\n");
+}
+function isFileReadable(filename) {
+  if (!tryStatSync(filename)) {
+    return false;
+  }
+  try {
+    fs__default.accessSync(filename, fs__default.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const splitFirstDirRE = /(.+?)[\\/](.+)/;
+function emptyDir(dir, skip) {
+  const skipInDir = [];
+  let nested = null;
+  if (skip?.length) {
+    for (const file of skip) {
+      if (path$n.dirname(file) !== ".") {
+        const matched = splitFirstDirRE.exec(file);
+        if (matched) {
+          nested ??= /* @__PURE__ */ new Map();
+          const [, nestedDir, skipPath] = matched;
+          let nestedSkip = nested.get(nestedDir);
+          if (!nestedSkip) {
+            nestedSkip = [];
+            nested.set(nestedDir, nestedSkip);
+          }
+          if (!nestedSkip.includes(skipPath)) {
+            nestedSkip.push(skipPath);
+          }
+        }
+      } else {
+        skipInDir.push(file);
+      }
+    }
+  }
+  for (const file of fs__default.readdirSync(dir)) {
+    if (skipInDir.includes(file)) {
+      continue;
+    }
+    if (nested?.has(file)) {
+      emptyDir(path$n.resolve(dir, file), nested.get(file));
+    } else {
+      fs__default.rmSync(path$n.resolve(dir, file), { recursive: true, force: true });
+    }
+  }
+}
+function copyDir(srcDir, destDir) {
+  fs__default.mkdirSync(destDir, { recursive: true });
+  for (const file of fs__default.readdirSync(srcDir)) {
+    const srcFile = path$n.resolve(srcDir, file);
+    if (srcFile === destDir) {
+      continue;
+    }
+    const destFile = path$n.resolve(destDir, file);
+    const stat = fs__default.statSync(srcFile);
+    if (stat.isDirectory()) {
+      copyDir(srcFile, destFile);
+    } else {
+      fs__default.copyFileSync(srcFile, destFile);
+    }
+  }
+}
+const ERR_SYMLINK_IN_RECURSIVE_READDIR = "ERR_SYMLINK_IN_RECURSIVE_READDIR";
+async function recursiveReaddir(dir) {
+  if (!fs__default.existsSync(dir)) {
+    return [];
+  }
+  let dirents;
+  try {
+    dirents = await fsp.readdir(dir, { withFileTypes: true });
+  } catch (e) {
+    if (e.code === "EACCES") {
+      return [];
+    }
+    throw e;
+  }
+  if (dirents.some((dirent) => dirent.isSymbolicLink())) {
+    const err = new Error(
+      "Symbolic links are not supported in recursiveReaddir"
+    );
+    err.code = ERR_SYMLINK_IN_RECURSIVE_READDIR;
+    throw err;
+  }
+  const files = await Promise.all(
+    dirents.map((dirent) => {
+      const res = path$n.resolve(dir, dirent.name);
+      return dirent.isDirectory() ? recursiveReaddir(res) : normalizePath$3(res);
+    })
+  );
+  return files.flat(1);
+}
+let safeRealpathSync = isWindows$3 ? windowsSafeRealPathSync : fs__default.realpathSync.native;
+const windowsNetworkMap = /* @__PURE__ */ new Map();
+function windowsMappedRealpathSync(path2) {
+  const realPath = fs__default.realpathSync.native(path2);
+  if (realPath.startsWith("\\\\")) {
+    for (const [network, volume] of windowsNetworkMap) {
+      if (realPath.startsWith(network)) return realPath.replace(network, volume);
+    }
+  }
+  return realPath;
+}
+const parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
+let firstSafeRealPathSyncRun = false;
+function windowsSafeRealPathSync(path2) {
+  if (!firstSafeRealPathSyncRun) {
+    optimizeSafeRealPathSync();
+    firstSafeRealPathSyncRun = true;
+  }
+  return fs__default.realpathSync(path2);
+}
+function optimizeSafeRealPathSync() {
+  const nodeVersion = process.versions.node.split(".").map(Number);
+  if (nodeVersion[0] < 18 || nodeVersion[0] === 18 && nodeVersion[1] < 10) {
+    safeRealpathSync = fs__default.realpathSync;
+    return;
+  }
+  try {
+    fs__default.realpathSync.native(path$n.resolve("./"));
+  } catch (error) {
+    if (error.message.includes("EISDIR: illegal operation on a directory")) {
+      safeRealpathSync = fs__default.realpathSync;
+      return;
+    }
+  }
+  exec("net use", (error, stdout) => {
+    if (error) return;
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+      const m = parseNetUseRE.exec(line);
+      if (m) windowsNetworkMap.set(m[2], m[1]);
+    }
+    if (windowsNetworkMap.size === 0) {
+      safeRealpathSync = fs__default.realpathSync.native;
+    } else {
+      safeRealpathSync = windowsMappedRealpathSync;
+    }
+  });
+}
+function ensureWatchedFile(watcher, file, root) {
+  if (file && // only need to watch if out of root
+  !file.startsWith(withTrailingSlash(root)) && // some rollup plugins use null bytes for private resolved Ids
+  !file.includes("\0") && fs__default.existsSync(file)) {
+    watcher.add(path$n.resolve(file));
+  }
+}
+const escapedSpaceCharacters = /(?: |\\t|\\n|\\f|\\r)+/g;
+const imageSetUrlRE = /^(?:[\w\-]+\(.*?\)|'.*?'|".*?"|\S*)/;
+function joinSrcset(ret) {
+  return ret.map(({ url, descriptor }) => url + (descriptor ? ` ${descriptor}` : "")).join(", ");
+}
+function splitSrcSetDescriptor(srcs) {
+  return splitSrcSet(srcs).map((s) => {
+    const src = s.replace(escapedSpaceCharacters, " ").trim();
+    const url = imageSetUrlRE.exec(src)?.[0] ?? "";
+    return {
+      url,
+      descriptor: src.slice(url.length).trim()
+    };
+  }).filter(({ url }) => !!url);
+}
+function processSrcSet(srcs, replacer) {
+  return Promise.all(
+    splitSrcSetDescriptor(srcs).map(async ({ url, descriptor }) => ({
+      url: await replacer({ url, descriptor }),
+      descriptor
+    }))
+  ).then(joinSrcset);
+}
+function processSrcSetSync(srcs, replacer) {
+  return joinSrcset(
+    splitSrcSetDescriptor(srcs).map(({ url, descriptor }) => ({
+      url: replacer({ url, descriptor }),
+      descriptor
+    }))
+  );
+}
+const cleanSrcSetRE = /(?:url|image|gradient|cross-fade)\([^)]*\)|"([^"]|(?<=\\)")*"|'([^']|(?<=\\)')*'|data:\w+\/[\w.+\-]+;base64,[\w+/=]+|\?\S+,/g;
+function splitSrcSet(srcs) {
+  const parts = [];
+  const cleanedSrcs = srcs.replace(cleanSrcSetRE, blankReplacer);
+  let startIndex = 0;
+  let splitIndex;
+  do {
+    splitIndex = cleanedSrcs.indexOf(",", startIndex);
+    parts.push(
+      srcs.slice(startIndex, splitIndex !== -1 ? splitIndex : void 0)
+    );
+    startIndex = splitIndex + 1;
+  } while (splitIndex !== -1);
+  return parts;
+}
+const windowsDriveRE = /^[A-Z]:/;
+const replaceWindowsDriveRE = /^([A-Z]):\//;
+const linuxAbsolutePathRE = /^\/[^/]/;
+function escapeToLinuxLikePath(path2) {
+  if (windowsDriveRE.test(path2)) {
+    return path2.replace(replaceWindowsDriveRE, "/windows/$1/");
+  }
+  if (linuxAbsolutePathRE.test(path2)) {
+    return `/linux${path2}`;
+  }
+  return path2;
+}
+const revertWindowsDriveRE = /^\/windows\/([A-Z])\//;
+function unescapeToLinuxLikePath(path2) {
+  if (path2.startsWith("/linux/")) {
+    return path2.slice("/linux".length);
+  }
+  if (path2.startsWith("/windows/")) {
+    return path2.replace(revertWindowsDriveRE, "$1:/");
+  }
+  return path2;
+}
+const nullSourceMap = {
+  names: [],
+  sources: [],
+  mappings: "",
+  version: 3
+};
+function combineSourcemaps(filename, sourcemapList) {
+  if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0)) {
+    return { ...nullSourceMap };
+  }
+  sourcemapList = sourcemapList.map((sourcemap) => {
+    const newSourcemaps = { ...sourcemap };
+    newSourcemaps.sources = sourcemap.sources.map(
+      (source) => source ? escapeToLinuxLikePath(source) : null
+    );
+    if (sourcemap.sourceRoot) {
+      newSourcemaps.sourceRoot = escapeToLinuxLikePath(sourcemap.sourceRoot);
+    }
+    return newSourcemaps;
+  });
+  let map;
+  let mapIndex = 1;
+  const useArrayInterface = sourcemapList.slice(0, -1).find((m) => m.sources.length !== 1) === void 0;
+  if (useArrayInterface) {
+    map = remapping(sourcemapList, () => null);
+  } else {
+    map = remapping(sourcemapList[0], function loader(sourcefile) {
+      const mapForSources = sourcemapList.slice(mapIndex).find((s) => s.sources.includes(sourcefile));
+      if (mapForSources) {
+        mapIndex++;
+        return mapForSources;
+      }
+      return null;
+    });
+  }
+  if (!map.file) {
+    delete map.file;
+  }
+  map.sources = map.sources.map(
+    (source) => source ? unescapeToLinuxLikePath(source) : source
+  );
+  map.file = filename;
+  return map;
+}
+function unique(arr) {
+  return Array.from(new Set(arr));
+}
+async function getLocalhostAddressIfDiffersFromDNS() {
+  const [nodeResult, dnsResult] = await Promise.all([
+    promises.lookup("localhost"),
+    promises.lookup("localhost", { verbatim: true })
+  ]);
+  const isSame = nodeResult.family === dnsResult.family && nodeResult.address === dnsResult.address;
+  return isSame ? void 0 : nodeResult.address;
+}
+function diffDnsOrderChange(oldUrls, newUrls) {
+  return !(oldUrls === newUrls || oldUrls && newUrls && arrayEqual(oldUrls.local, newUrls.local) && arrayEqual(oldUrls.network, newUrls.network));
+}
+async function resolveHostname(optionsHost) {
+  let host;
+  if (optionsHost === void 0 || optionsHost === false) {
+    host = "localhost";
+  } else if (optionsHost === true) {
+    host = void 0;
+  } else {
+    host = optionsHost;
+  }
+  let name = host === void 0 || wildcardHosts.has(host) ? "localhost" : host;
+  if (host === "localhost") {
+    const localhostAddr = await getLocalhostAddressIfDiffersFromDNS();
+    if (localhostAddr) {
+      name = localhostAddr;
+    }
+  }
+  return { host, name };
+}
+async function resolveServerUrls(server, options, config) {
+  const address = server.address();
+  const isAddressInfo = (x) => x?.address;
+  if (!isAddressInfo(address)) {
+    return { local: [], network: [] };
+  }
+  const local = [];
+  const network = [];
+  const hostname = await resolveHostname(options.host);
+  const protocol = options.https ? "https" : "http";
+  const port = address.port;
+  const base = config.rawBase === "./" || config.rawBase === "" ? "/" : config.rawBase;
+  if (hostname.host !== void 0 && !wildcardHosts.has(hostname.host)) {
+    let hostnameName = hostname.name;
+    if (hostnameName.includes(":")) {
+      hostnameName = `[${hostnameName}]`;
+    }
+    const address2 = `${protocol}://${hostnameName}:${port}${base}`;
+    if (loopbackHosts.has(hostname.host)) {
+      local.push(address2);
+    } else {
+      network.push(address2);
+    }
+  } else {
+    Object.values(os$5.networkInterfaces()).flatMap((nInterface) => nInterface ?? []).filter(
+      (detail) => detail && detail.address && (detail.family === "IPv4" || // @ts-expect-error Node 18.0 - 18.3 returns number
+      detail.family === 4)
+    ).forEach((detail) => {
+      let host = detail.address.replace("127.0.0.1", hostname.name);
+      if (host.includes(":")) {
+        host = `[${host}]`;
+      }
+      const url = `${protocol}://${host}:${port}${base}`;
+      if (detail.address.includes("127.0.0.1")) {
+        local.push(url);
+      } else {
+        network.push(url);
+      }
+    });
+  }
+  return { local, network };
+}
+function arraify(target) {
+  return Array.isArray(target) ? target : [target];
+}
+const multilineCommentsRE = /\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g;
+const singlelineCommentsRE = /\/\/.*/g;
+const requestQuerySplitRE = /\?(?!.*[/|}])/;
+const requestQueryMaybeEscapedSplitRE = /\\?\?(?!.*[/|}])/;
+const blankReplacer = (match) => " ".repeat(match.length);
+function getHash(text, length = 8) {
+  const h = createHash$2("sha256").update(text).digest("hex").substring(0, length);
+  if (length <= 64) return h;
+  return h.padEnd(length, "_");
+}
+const _dirname = path$n.dirname(fileURLToPath(import.meta.url));
+const requireResolveFromRootWithFallback = (root, id) => {
+  const found = resolvePackageData(id, root) || resolvePackageData(id, _dirname);
+  if (!found) {
+    const error = new Error(`${JSON.stringify(id)} not found.`);
+    error.code = "MODULE_NOT_FOUND";
+    throw error;
+  }
+  return _require$1.resolve(id, { paths: [root, _dirname] });
+};
+function emptyCssComments(raw) {
+  return raw.replace(multilineCommentsRE, blankReplacer);
+}
+function backwardCompatibleWorkerPlugins(plugins) {
+  if (Array.isArray(plugins)) {
+    return plugins;
+  }
+  if (typeof plugins === "function") {
+    return plugins();
+  }
+  return [];
+}
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
+    }
+    const existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "alias" && (rootPath === "resolve" || rootPath === "")) {
+      merged[key] = mergeAlias(existing, value);
+      continue;
+    } else if (key === "assetsInclude" && rootPath === "") {
+      merged[key] = [].concat(existing, value);
+      continue;
+    } else if (key === "noExternal" && rootPath === "ssr" && (existing === true || value === true)) {
+      merged[key] = true;
+      continue;
+    } else if (key === "plugins" && rootPath === "worker") {
+      merged[key] = () => [
+        ...backwardCompatibleWorkerPlugins(existing),
+        ...backwardCompatibleWorkerPlugins(value)
+      ];
+      continue;
+    } else if (key === "server" && rootPath === "server.hmr") {
+      merged[key] = value;
+      continue;
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing), ...arraify(value)];
+      continue;
+    }
+    if (isObject$1(existing) && isObject$1(value)) {
+      merged[key] = mergeConfigRecursively(
+        existing,
+        value,
+        rootPath ? `${rootPath}.${key}` : key
+      );
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+  if (typeof defaults === "function" || typeof overrides === "function") {
+    throw new Error(`Cannot merge config in form of callback`);
+  }
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
+function mergeAlias(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  if (isObject$1(a) && isObject$1(b)) {
+    return { ...a, ...b };
+  }
+  return [...normalizeAlias(b), ...normalizeAlias(a)];
+}
+function normalizeAlias(o = []) {
+  return Array.isArray(o) ? o.map(normalizeSingleAlias) : Object.keys(o).map(
+    (find) => normalizeSingleAlias({
+      find,
+      replacement: o[find]
+    })
+  );
+}
+function normalizeSingleAlias({
+  find,
+  replacement,
+  customResolver
+}) {
+  if (typeof find === "string" && find[find.length - 1] === "/" && replacement[replacement.length - 1] === "/") {
+    find = find.slice(0, find.length - 1);
+    replacement = replacement.slice(0, replacement.length - 1);
+  }
+  const alias = {
+    find,
+    replacement
+  };
+  if (customResolver) {
+    alias.customResolver = customResolver;
+  }
+  return alias;
+}
+function transformStableResult(s, id, config) {
+  return {
+    code: s.toString(),
+    map: config.command === "build" && config.build.sourcemap ? s.generateMap({ hires: "boundary", source: id }) : null
+  };
+}
+async function asyncFlatten(arr) {
+  do {
+    arr = (await Promise.all(arr)).flat(Infinity);
+  } while (arr.some((v) => v?.then));
+  return arr;
+}
+function stripBomTag(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+const windowsDrivePathPrefixRE = /^[A-Za-z]:[/\\]/;
+const isNonDriveRelativeAbsolutePath = (p) => {
+  if (!isWindows$3) return p[0] === "/";
+  return windowsDrivePathPrefixRE.test(p);
+};
+function shouldServeFile(filePath, root) {
+  if (!isCaseInsensitiveFS) return true;
+  return hasCorrectCase(filePath, root);
+}
+function hasCorrectCase(file, assets) {
+  if (file === assets) return true;
+  const parent = path$n.dirname(file);
+  if (fs__default.readdirSync(parent).includes(path$n.basename(file))) {
+    return hasCorrectCase(parent, assets);
+  }
+  return false;
+}
+function joinUrlSegments(a, b) {
+  if (!a || !b) {
+    return a || b || "";
+  }
+  if (a[a.length - 1] === "/") {
+    a = a.substring(0, a.length - 1);
+  }
+  if (b[0] !== "/") {
+    b = "/" + b;
+  }
+  return a + b;
+}
+function removeLeadingSlash(str) {
+  return str[0] === "/" ? str.slice(1) : str;
+}
+function stripBase(path2, base) {
+  if (path2 === base) {
+    return "/";
+  }
+  const devBase = withTrailingSlash(base);
+  return path2.startsWith(devBase) ? path2.slice(devBase.length - 1) : path2;
+}
+function arrayEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function evalValue(rawValue) {
+  const fn = new Function(`
+    var console, exports, global, module, process, require
+    return (
+${rawValue}
+)
+  `);
+  return fn();
+}
+function getNpmPackageName(importPath) {
+  const parts = importPath.split("/");
+  if (parts[0][0] === "@") {
+    if (!parts[1]) return null;
+    return `${parts[0]}/${parts[1]}`;
+  } else {
+    return parts[0];
+  }
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+  return str.replace(escapeRegexRE, "\\$&");
+}
+function getPackageManagerCommand(type = "install") {
+  const packageManager = process.env.npm_config_user_agent?.split(" ")[0].split("/")[0] || "npm";
+  switch (type) {
+    case "install":
+      return packageManager === "npm" ? "npm install" : `${packageManager} add`;
+    case "uninstall":
+      return packageManager === "npm" ? "npm uninstall" : `${packageManager} remove`;
+    case "update":
+      return packageManager === "yarn" ? "yarn upgrade" : `${packageManager} update`;
+    default:
+      throw new TypeError(`Unknown command type: ${type}`);
+  }
+}
+function isDevServer(server) {
+  return "pluginContainer" in server;
+}
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { promise, resolve, reject };
+}
+function createSerialPromiseQueue() {
+  let previousTask;
+  return {
+    async run(f) {
+      const thisTask = f();
+      const depTasks = Promise.all([previousTask, thisTask]);
+      previousTask = depTasks;
+      const [, result] = await depTasks;
+      if (previousTask === depTasks) {
+        previousTask = void 0;
+      }
+      return result;
+    }
+  };
+}
+function sortObjectKeys(obj) {
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+function displayTime(time) {
+  if (time < 1e3) {
+    return `${time}ms`;
+  }
+  time = time / 1e3;
+  if (time < 60) {
+    return `${time.toFixed(2)}s`;
+  }
+  const mins = parseInt((time / 60).toString());
+  const seconds = time % 60;
+  return `${mins}m${seconds < 1 ? "" : ` ${seconds.toFixed(0)}s`}`;
+}
+function encodeURIPath(uri) {
+  if (uri.startsWith("data:")) return uri;
+  const filePath = cleanUrl(uri);
+  const postfix = filePath !== uri ? uri.slice(filePath.length) : "";
+  return encodeURI(filePath) + postfix;
+}
+function partialEncodeURIPath(uri) {
+  if (uri.startsWith("data:")) return uri;
+  const filePath = cleanUrl(uri);
+  const postfix = filePath !== uri ? uri.slice(filePath.length) : "";
+  return filePath.replaceAll("%", "%25") + postfix;
+}
+const setupSIGTERMListener = (callback) => {
+  process.once("SIGTERM", callback);
+  if (process.env.CI !== "true") {
+    process.stdin.on("end", callback);
+  }
+};
+const teardownSIGTERMListener = (callback) => {
+  process.off("SIGTERM", callback);
+  if (process.env.CI !== "true") {
+    process.stdin.off("end", callback);
+  }
+};
+
+const LogLevels = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3
+};
+let lastType;
+let lastMsg;
+let sameCount = 0;
+function clearScreen() {
+  const repeatCount = process.stdout.rows - 2;
+  const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+  console.log(blank);
+  readline.cursorTo(process.stdout, 0, 0);
+  readline.clearScreenDown(process.stdout);
+}
+let timeFormatter;
+function getTimeFormatter() {
+  timeFormatter ??= new Intl.DateTimeFormat(void 0, {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+  return timeFormatter;
+}
+function createLogger(level = "info", options = {}) {
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const { prefix = "[vite]", allowClearScreen = true } = options;
+  const thresh = LogLevels[level];
+  const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+  const clear = canClearScreen ? clearScreen : () => {
+  };
+  function format(type, msg, options2 = {}) {
+    if (options2.timestamp) {
+      let tag = "";
+      if (type === "info") {
+        tag = colors$1.cyan(colors$1.bold(prefix));
+      } else if (type === "warn") {
+        tag = colors$1.yellow(colors$1.bold(prefix));
+      } else {
+        tag = colors$1.red(colors$1.bold(prefix));
+      }
+      return `${colors$1.dim(getTimeFormatter().format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
+    } else {
+      return msg;
+    }
+  }
+  function output(type, msg, options2 = {}) {
+    if (thresh >= LogLevels[type]) {
+      const method = type === "info" ? "log" : type;
+      if (options2.error) {
+        loggedErrors.add(options2.error);
+      }
+      if (canClearScreen) {
+        if (type === lastType && msg === lastMsg) {
+          sameCount++;
+          clear();
+          console[method](
+            format(type, msg, options2),
+            colors$1.yellow(`(x${sameCount + 1})`)
+          );
+        } else {
+          sameCount = 0;
+          lastMsg = msg;
+          lastType = type;
+          if (options2.clear) {
+            clear();
+          }
+          console[method](format(type, msg, options2));
+        }
+      } else {
+        console[method](format(type, msg, options2));
+      }
+    }
+  }
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const logger = {
+    hasWarned: false,
+    info(msg, opts) {
+      output("info", msg, opts);
+    },
+    warn(msg, opts) {
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+    },
+    warnOnce(msg, opts) {
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      logger.hasWarned = true;
+      output("error", msg, opts);
+    },
+    clearScreen(type) {
+      if (thresh >= LogLevels[type]) {
+        clear();
+      }
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
+    }
+  };
+  return logger;
+}
+function printServerUrls(urls, optionsHost, info) {
+  const colorUrl = (url) => colors$1.cyan(url.replace(/:(\d+)\//, (_, port) => `:${colors$1.bold(port)}/`));
+  for (const url of urls.local) {
+    info(`  ${colors$1.green("\u279C")}  ${colors$1.bold("Local")}:   ${colorUrl(url)}`);
+  }
+  for (const url of urls.network) {
+    info(`  ${colors$1.green("\u279C")}  ${colors$1.bold("Network")}: ${colorUrl(url)}`);
+  }
+  if (urls.network.length === 0 && optionsHost === void 0) {
+    info(
+      colors$1.dim(`  ${colors$1.green("\u279C")}  ${colors$1.bold("Network")}: use `) + colors$1.bold("--host") + colors$1.dim(" to expose")
+    );
+  }
+}
+
+const groups = [
+  { name: "Assets", color: colors$1.green },
+  { name: "CSS", color: colors$1.magenta },
+  { name: "JS", color: colors$1.cyan }
+];
+const COMPRESSIBLE_ASSETS_RE = /\.(?:html|json|svg|txt|xml|xhtml)$/;
+function buildReporterPlugin(config) {
+  const compress = promisify$4(gzip);
+  const chunkLimit = config.build.chunkSizeWarningLimit;
+  const numberFormatter = new Intl.NumberFormat("en", {
+    maximumFractionDigits: 2,
+    minimumFractionDigits: 2
+  });
+  const displaySize = (bytes) => {
+    return `${numberFormatter.format(bytes / 1e3)} kB`;
+  };
+  const tty = process.stdout.isTTY && !process.env.CI;
+  const shouldLogInfo = LogLevels[config.logLevel || "info"] >= LogLevels.info;
+  let hasTransformed = false;
+  let hasRenderedChunk = false;
+  let hasCompressChunk = false;
+  let transformedCount = 0;
+  let chunkCount = 0;
+  let compressedCount = 0;
+  async function getCompressedSize(code) {
+    if (config.build.ssr || !config.build.reportCompressedSize) {
+      return null;
+    }
+    if (shouldLogInfo && !hasCompressChunk) {
+      if (!tty) {
+        config.logger.info("computing gzip size...");
+      } else {
+        writeLine("computing gzip size (0)...");
+      }
+      hasCompressChunk = true;
+    }
+    const compressed = await compress(
+      typeof code === "string" ? code : Buffer.from(code)
+    );
+    compressedCount++;
+    if (shouldLogInfo && tty) {
+      writeLine(`computing gzip size (${compressedCount})...`);
+    }
+    return compressed.length;
+  }
+  const logTransform = throttle((id) => {
+    writeLine(
+      `transforming (${transformedCount}) ${colors$1.dim(
+        path$n.relative(config.root, id)
+      )}`
+    );
+  });
+  return {
+    name: "vite:reporter",
+    transform(_, id) {
+      transformedCount++;
+      if (shouldLogInfo) {
+        if (!tty) {
+          if (!hasTransformed) {
+            config.logger.info(`transforming...`);
+          }
+        } else {
+          if (id.includes(`?`)) return;
+          logTransform(id);
+        }
+        hasTransformed = true;
+      }
+      return null;
+    },
+    buildStart() {
+      transformedCount = 0;
+    },
+    buildEnd() {
+      if (shouldLogInfo) {
+        if (tty) {
+          clearLine$1();
+        }
+        config.logger.info(
+          `${colors$1.green(`\u2713`)} ${transformedCount} modules transformed.`
+        );
+      }
+    },
+    renderStart() {
+      chunkCount = 0;
+      compressedCount = 0;
+    },
+    renderChunk(code, chunk, options) {
+      if (!options.inlineDynamicImports) {
+        for (const id of chunk.moduleIds) {
+          const module = this.getModuleInfo(id);
+          if (!module) continue;
+          if (module.importers.length && module.dynamicImporters.length) {
+            const detectedIneffectiveDynamicImport = module.dynamicImporters.some(
+              (id2) => !isInNodeModules$1(id2) && chunk.moduleIds.includes(id2)
+            );
+            if (detectedIneffectiveDynamicImport) {
+              this.warn(
+                `
+(!) ${module.id} is dynamically imported by ${module.dynamicImporters.join(
+                  ", "
+                )} but also statically imported by ${module.importers.join(
+                  ", "
+                )}, dynamic import will not move module into another chunk.
+`
+              );
+            }
+          }
+        }
+      }
+      chunkCount++;
+      if (shouldLogInfo) {
+        if (!tty) {
+          if (!hasRenderedChunk) {
+            config.logger.info("rendering chunks...");
+          }
+        } else {
+          writeLine(`rendering chunks (${chunkCount})...`);
+        }
+        hasRenderedChunk = true;
+      }
+      return null;
+    },
+    generateBundle() {
+      if (shouldLogInfo && tty) clearLine$1();
+    },
+    async writeBundle({ dir: outDir }, output) {
+      let hasLargeChunks = false;
+      if (shouldLogInfo) {
+        const entries = (await Promise.all(
+          Object.values(output).map(
+            async (chunk) => {
+              if (chunk.type === "chunk") {
+                return {
+                  name: chunk.fileName,
+                  group: "JS",
+                  size: chunk.code.length,
+                  compressedSize: await getCompressedSize(chunk.code),
+                  mapSize: chunk.map ? chunk.map.toString().length : null
+                };
+              } else {
+                if (chunk.fileName.endsWith(".map")) return null;
+                const isCSS = chunk.fileName.endsWith(".css");
+                const isCompressible = isCSS || COMPRESSIBLE_ASSETS_RE.test(chunk.fileName);
+                return {
+                  name: chunk.fileName,
+                  group: isCSS ? "CSS" : "Assets",
+                  size: chunk.source.length,
+                  mapSize: null,
+                  // Rollup doesn't support CSS maps?
+                  compressedSize: isCompressible ? await getCompressedSize(chunk.source) : null
+                };
+              }
+            }
+          )
+        )).filter(isDefined);
+        if (tty) clearLine$1();
+        let longest = 0;
+        let biggestSize = 0;
+        let biggestMap = 0;
+        let biggestCompressSize = 0;
+        for (const entry of entries) {
+          if (entry.name.length > longest) longest = entry.name.length;
+          if (entry.size > biggestSize) biggestSize = entry.size;
+          if (entry.mapSize && entry.mapSize > biggestMap) {
+            biggestMap = entry.mapSize;
+          }
+          if (entry.compressedSize && entry.compressedSize > biggestCompressSize) {
+            biggestCompressSize = entry.compressedSize;
+          }
+        }
+        const sizePad = displaySize(biggestSize).length;
+        const mapPad = displaySize(biggestMap).length;
+        const compressPad = displaySize(biggestCompressSize).length;
+        const relativeOutDir = normalizePath$3(
+          path$n.relative(
+            config.root,
+            path$n.resolve(config.root, outDir ?? config.build.outDir)
+          )
+        );
+        const assetsDir = path$n.join(config.build.assetsDir, "/");
+        for (const group of groups) {
+          const filtered = entries.filter((e) => e.group === group.name);
+          if (!filtered.length) continue;
+          for (const entry of filtered.sort((a, z) => a.size - z.size)) {
+            const isLarge = group.name === "JS" && entry.size / 1e3 > chunkLimit;
+            if (isLarge) hasLargeChunks = true;
+            const sizeColor = isLarge ? colors$1.yellow : colors$1.dim;
+            let log = colors$1.dim(withTrailingSlash(relativeOutDir));
+            log += !config.build.lib && entry.name.startsWith(withTrailingSlash(assetsDir)) ? colors$1.dim(assetsDir) + group.color(
+              entry.name.slice(assetsDir.length).padEnd(longest + 2 - assetsDir.length)
+            ) : group.color(entry.name.padEnd(longest + 2));
+            log += colors$1.bold(
+              sizeColor(displaySize(entry.size).padStart(sizePad))
+            );
+            if (entry.compressedSize) {
+              log += colors$1.dim(
+                ` \u2502 gzip: ${displaySize(entry.compressedSize).padStart(
+                  compressPad
+                )}`
+              );
+            }
+            if (entry.mapSize) {
+              log += colors$1.dim(
+                ` \u2502 map: ${displaySize(entry.mapSize).padStart(mapPad)}`
+              );
+            }
+            config.logger.info(log);
+          }
+        }
+      } else {
+        hasLargeChunks = Object.values(output).some((chunk) => {
+          return chunk.type === "chunk" && chunk.code.length / 1e3 > chunkLimit;
+        });
+      }
+      if (hasLargeChunks && config.build.minify && !config.build.lib && !config.build.ssr) {
+        config.logger.warn(
+          colors$1.yellow(
+            `
+(!) Some chunks are larger than ${chunkLimit} kB after minification. Consider:
+- Using dynamic import() to code-split the application
+- Use build.rollupOptions.output.manualChunks to improve chunking: https://rollupjs.org/configuration-options/#output-manualchunks
+- Adjust chunk size limit for this warning via build.chunkSizeWarningLimit.`
+          )
+        );
+      }
+    }
+  };
+}
+function writeLine(output) {
+  clearLine$1();
+  if (output.length < process.stdout.columns) {
+    process.stdout.write(output);
+  } else {
+    process.stdout.write(output.substring(0, process.stdout.columns - 1));
+  }
+}
+function clearLine$1() {
+  process.stdout.clearLine(0);
+  process.stdout.cursorTo(0);
+}
+function throttle(fn) {
+  let timerHandle = null;
+  return (...args) => {
+    if (timerHandle) return;
+    fn(...args);
+    timerHandle = setTimeout(() => {
+      timerHandle = null;
+    }, 100);
+  };
+}
+
+const POSIX_SEP_RE = new RegExp('\\' + path$n.posix.sep, 'g');
+const NATIVE_SEP_RE = new RegExp('\\' + path$n.sep, 'g');
+/** @type {Map<string,RegExp>}*/
+const PATTERN_REGEX_CACHE = new Map();
+const GLOB_ALL_PATTERN = `**/*`;
+const TS_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts'];
+const JS_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs'];
+const TSJS_EXTENSIONS = TS_EXTENSIONS.concat(JS_EXTENSIONS);
+const TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext) => ext.substring(1)).join('|')})`;
+const TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext) => ext.substring(1)).join(
+	'|'
+)})`;
+const IS_POSIX = path$n.posix.sep === path$n.sep;
+
+/**
+ * @template T
+ * @returns {{resolve:(result:T)=>void, reject:(error:any)=>void, promise: Promise<T>}}
+ */
+function makePromise() {
+	let resolve, reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return { promise, resolve, reject };
+}
+
+/**
+ * @param {string} filename
+ * @param {import('./cache.js').TSConfckCache} [cache]
+ * @returns {Promise<string|void>}
+ */
+async function resolveTSConfigJson(filename, cache) {
+	if (path$n.extname(filename) !== '.json') {
+		return; // ignore files that are not json
+	}
+	const tsconfig = path$n.resolve(filename);
+	if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) {
+		return tsconfig;
+	}
+	return promises$1.stat(tsconfig).then((stat) => {
+		if (stat.isFile() || stat.isFIFO()) {
+			return tsconfig;
+		} else {
+			throw new Error(`${filename} exists but is not a regular file.`);
+		}
+	});
+}
+
+/**
+ *
+ * @param {string} dir an absolute directory path
+ * @returns {boolean}  if dir path includes a node_modules segment
+ */
+const isInNodeModules = IS_POSIX
+	? (dir) => dir.includes('/node_modules/')
+	: (dir) => dir.match(/[/\\]node_modules[/\\]/);
+
+/**
+ * convert posix separator to native separator
+ *
+ * eg.
+ * windows: C:/foo/bar -> c:\foo\bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @param {string} filename with posix separators
+ * @returns {string} filename with native separators
+ */
+const posix2native = IS_POSIX
+	? (filename) => filename
+	: (filename) => filename.replace(POSIX_SEP_RE, path$n.sep);
+
+/**
+ * convert native separator to posix separator
+ *
+ * eg.
+ * windows: C:\foo\bar -> c:/foo/bar
+ * linux: /foo/bar -> /foo/bar
+ *
+ * @param {string} filename - filename with native separators
+ * @returns {string} filename with posix separators
+ */
+const native2posix = IS_POSIX
+	? (filename) => filename
+	: (filename) => filename.replace(NATIVE_SEP_RE, path$n.posix.sep);
+
+/**
+ * converts params to native separator, resolves path and converts native back to posix
+ *
+ * needed on windows to handle posix paths in tsconfig
+ *
+ * @param dir {string|null} directory to resolve from
+ * @param filename {string} filename or pattern to resolve
+ * @returns string
+ */
+const resolve2posix = IS_POSIX
+	? (dir, filename) => (dir ? path$n.resolve(dir, filename) : path$n.resolve(filename))
+	: (dir, filename) =>
+			native2posix(
+				dir
+					? path$n.resolve(posix2native(dir), posix2native(filename))
+					: path$n.resolve(posix2native(filename))
+			);
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options]
+ * @returns {string[]}
+ */
+function resolveReferencedTSConfigFiles(result, options) {
+	const dir = path$n.dirname(result.tsconfigFile);
+	return result.tsconfig.references.map((ref) => {
+		const refPath = ref.path.endsWith('.json')
+			? ref.path
+			: path$n.join(ref.path, options?.configName ?? 'tsconfig.json');
+		return resolve2posix(dir, refPath);
+	});
+}
+
+/**
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {import('./public.d.ts').TSConfckParseResult}
+ */
+function resolveSolutionTSConfig(filename, result) {
+	const allowJs = result.tsconfig.compilerOptions?.allowJs;
+	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+	if (
+		result.referenced &&
+		extensions.some((ext) => filename.endsWith(ext)) &&
+		!isIncluded(filename, result)
+	) {
+		const solutionTSConfig = result.referenced.find((referenced) =>
+			isIncluded(filename, referenced)
+		);
+		if (solutionTSConfig) {
+			return solutionTSConfig;
+		}
+	}
+	return result;
+}
+
+/**
+ *
+ * @param {string} filename
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @returns {boolean}
+ */
+function isIncluded(filename, result) {
+	const dir = native2posix(path$n.dirname(result.tsconfigFile));
+	const files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file));
+	const absoluteFilename = resolve2posix(null, filename);
+	if (files.includes(filename)) {
+		return true;
+	}
+	const allowJs = result.tsconfig.compilerOptions?.allowJs;
+	const isIncluded = isGlobMatch(
+		absoluteFilename,
+		dir,
+		result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN]),
+		allowJs
+	);
+	if (isIncluded) {
+		const isExcluded = isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs);
+		return !isExcluded;
+	}
+	return false;
+}
+
+/**
+ * test filenames agains glob patterns in tsconfig
+ *
+ * @param filename {string} posix style abolute path to filename to test
+ * @param dir {string} posix style absolute path to directory of tsconfig containing patterns
+ * @param patterns {string[]} glob patterns to match against
+ * @param allowJs {boolean} allowJs setting in tsconfig to include js extensions in checks
+ * @returns {boolean} true when at least one pattern matches filename
+ */
+function isGlobMatch(filename, dir, patterns, allowJs) {
+	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+	return patterns.some((pattern) => {
+		// filename must end with part of pattern that comes after last wildcard
+		let lastWildcardIndex = pattern.length;
+		let hasWildcard = false;
+		for (let i = pattern.length - 1; i > -1; i--) {
+			if (pattern[i] === '*' || pattern[i] === '?') {
+				lastWildcardIndex = i;
+				hasWildcard = true;
+				break;
+			}
+		}
+
+		// if pattern does not end with wildcard, filename must end with pattern after last wildcard
+		if (
+			lastWildcardIndex < pattern.length - 1 &&
+			!filename.endsWith(pattern.slice(lastWildcardIndex + 1))
+		) {
+			return false;
+		}
+
+		// if pattern ends with *, filename must end with a default extension
+		if (pattern.endsWith('*') && !extensions.some((ext) => filename.endsWith(ext))) {
+			return false;
+		}
+
+		// for **/* , filename must start with the dir
+		if (pattern === GLOB_ALL_PATTERN) {
+			return filename.startsWith(`${dir}/`);
+		}
+
+		const resolvedPattern = resolve2posix(dir, pattern);
+
+		// filename must start with part of pattern that comes before first wildcard
+		let firstWildcardIndex = -1;
+		for (let i = 0; i < resolvedPattern.length; i++) {
+			if (resolvedPattern[i] === '*' || resolvedPattern[i] === '?') {
+				firstWildcardIndex = i;
+				hasWildcard = true;
+				break;
+			}
+		}
+		if (
+			firstWildcardIndex > 1 &&
+			!filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))
+		) {
+			return false;
+		}
+
+		// if no wildcard in pattern, filename must be equal to resolved pattern
+		if (!hasWildcard) {
+			return filename === resolvedPattern;
+		}
+
+		// complex pattern, use regex to check it
+		if (PATTERN_REGEX_CACHE.has(resolvedPattern)) {
+			return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
+		}
+		const regex = pattern2regex(resolvedPattern, allowJs);
+		PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
+		return regex.test(filename);
+	});
+}
+
+/**
+ * @param {string} resolvedPattern
+ * @param {boolean} allowJs
+ * @returns {RegExp}
+ */
+function pattern2regex(resolvedPattern, allowJs) {
+	let regexStr = '^';
+	for (let i = 0; i < resolvedPattern.length; i++) {
+		const char = resolvedPattern[i];
+		if (char === '?') {
+			regexStr += '[^\\/]';
+			continue;
+		}
+		if (char === '*') {
+			if (resolvedPattern[i + 1] === '*' && resolvedPattern[i + 2] === '/') {
+				i += 2;
+				regexStr += '(?:[^\\/]*\\/)*'; // zero or more path segments
+				continue;
+			}
+			regexStr += '[^\\/]*';
+			continue;
+		}
+		if ('/.+^${}()|[]\\'.includes(char)) {
+			regexStr += `\\`;
+		}
+		regexStr += char;
+	}
+
+	// add known file endings if pattern ends on *
+	if (resolvedPattern.endsWith('*')) {
+		regexStr += allowJs ? TSJS_EXTENSIONS_RE_GROUP : TS_EXTENSIONS_RE_GROUP;
+	}
+	regexStr += '$';
+
+	return new RegExp(regexStr);
+}
+
+/**
+ * replace tokens like ${configDir}
+ * @param {any} tsconfig
+ * @param {string} configDir
+ * @returns {any}
+ */
+function replaceTokens(tsconfig, configDir) {
+	return JSON.parse(
+		JSON.stringify(tsconfig)
+			// replace ${configDir}
+			.replaceAll(/"\${configDir}/g, `"${native2posix(configDir)}`)
+	);
+}
+
+/**
+ * find the closest tsconfig.json file
+ *
+ * @param {string} filename - path to file to find tsconfig for (absolute or relative to cwd)
+ * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
+ * @returns {Promise<string|null>} absolute path to closest tsconfig.json or null if not found
+ */
+async function find(filename, options) {
+	let dir = path$n.dirname(path$n.resolve(filename));
+	if (options?.ignoreNodeModules && isInNodeModules(dir)) {
+		return null;
+	}
+	const cache = options?.cache;
+	const configName = options?.configName ?? 'tsconfig.json';
+	if (cache?.hasConfigPath(dir, configName)) {
+		return cache.getConfigPath(dir, configName);
+	}
+	const { /** @type {Promise<string|null>} */ promise, resolve, reject } = makePromise();
+	if (options?.root && !path$n.isAbsolute(options.root)) {
+		options.root = path$n.resolve(options.root);
+	}
+	findUp(dir, { promise, resolve, reject }, options);
+	return promise;
+}
+
+/**
+ *
+ * @param {string} dir
+ * @param {{promise:Promise<string|null>,resolve:(result:string|null)=>void,reject:(err:any)=>void}} madePromise
+ * @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
+ */
+function findUp(dir, { resolve, reject, promise }, options) {
+	const { cache, root, configName } = options ?? {};
+	if (cache) {
+		if (cache.hasConfigPath(dir, configName)) {
+			let cached;
+			try {
+				cached = cache.getConfigPath(dir, configName);
+			} catch (e) {
+				reject(e);
+				return;
+			}
+			if (cached?.then) {
+				cached.then(resolve).catch(reject);
+			} else {
+				resolve(cached);
+			}
+		} else {
+			cache.setConfigPath(dir, promise, configName);
+		}
+	}
+	const tsconfig = path$n.join(dir, options?.configName ?? 'tsconfig.json');
+	fs__default.stat(tsconfig, (err, stats) => {
+		if (stats && (stats.isFile() || stats.isFIFO())) {
+			resolve(tsconfig);
+		} else if (err?.code !== 'ENOENT') {
+			reject(err);
+		} else {
+			let parent;
+			if (root === dir || (parent = path$n.dirname(dir)) === dir) {
+				resolve(null);
+			} else {
+				findUp(parent, { promise, resolve, reject }, options);
+			}
+		}
+	});
+}
+
+/*
+ this file contains code from strip-bom and strip-json-comments by Sindre Sorhus
+ https://github.com/sindresorhus/strip-json-comments/blob/v4.0.0/index.js
+ https://github.com/sindresorhus/strip-bom/blob/v5.0.0/index.js
+ licensed under MIT, see ../LICENSE
+*/
+
+/**
+ * convert content of tsconfig.json to regular json
+ *
+ * @param {string} tsconfigJson - content of tsconfig.json
+ * @returns {string} content as regular json, comments and dangling commas have been replaced with whitespace
+ */
+function toJson(tsconfigJson) {
+	const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
+	if (stripped.trim() === '') {
+		// only whitespace left after stripping, return empty object so that JSON.parse still works
+		return '{}';
+	} else {
+		return stripped;
+	}
+}
+
+/**
+ * replace dangling commas from pseudo-json string with single space
+ * implementation heavily inspired by strip-json-comments
+ *
+ * @param {string} pseudoJson
+ * @returns {string}
+ */
+function stripDanglingComma(pseudoJson) {
+	let insideString = false;
+	let offset = 0;
+	let result = '';
+	let danglingCommaPos = null;
+	for (let i = 0; i < pseudoJson.length; i++) {
+		const currentCharacter = pseudoJson[i];
+		if (currentCharacter === '"') {
+			const escaped = isEscaped(pseudoJson, i);
+			if (!escaped) {
+				insideString = !insideString;
+			}
+		}
+		if (insideString) {
+			danglingCommaPos = null;
+			continue;
+		}
+		if (currentCharacter === ',') {
+			danglingCommaPos = i;
+			continue;
+		}
+		if (danglingCommaPos) {
+			if (currentCharacter === '}' || currentCharacter === ']') {
+				result += pseudoJson.slice(offset, danglingCommaPos) + ' ';
+				offset = danglingCommaPos + 1;
+				danglingCommaPos = null;
+			} else if (!currentCharacter.match(/\s/)) {
+				danglingCommaPos = null;
+			}
+		}
+	}
+	return result + pseudoJson.substring(offset);
+}
+
+// start strip-json-comments
+/**
+ *
+ * @param {string} jsonString
+ * @param {number} quotePosition
+ * @returns {boolean}
+ */
+function isEscaped(jsonString, quotePosition) {
+	let index = quotePosition - 1;
+	let backslashCount = 0;
+
+	while (jsonString[index] === '\\') {
+		index -= 1;
+		backslashCount += 1;
+	}
+
+	return Boolean(backslashCount % 2);
+}
+
+/**
+ *
+ * @param {string} string
+ * @param {number?} start
+ * @param {number?} end
+ */
+function strip(string, start, end) {
+	return string.slice(start, end).replace(/\S/g, ' ');
+}
+
+const singleComment = Symbol('singleComment');
+const multiComment = Symbol('multiComment');
+
+/**
+ * @param {string} jsonString
+ * @returns {string}
+ */
+function stripJsonComments(jsonString) {
+	let isInsideString = false;
+	/** @type {false | symbol} */
+	let isInsideComment = false;
+	let offset = 0;
+	let result = '';
+
+	for (let index = 0; index < jsonString.length; index++) {
+		const currentCharacter = jsonString[index];
+		const nextCharacter = jsonString[index + 1];
+
+		if (!isInsideComment && currentCharacter === '"') {
+			const escaped = isEscaped(jsonString, index);
+			if (!escaped) {
+				isInsideString = !isInsideString;
+			}
+		}
+
+		if (isInsideString) {
+			continue;
+		}
+
+		if (!isInsideComment && currentCharacter + nextCharacter === '//') {
+			result += jsonString.slice(offset, index);
+			offset = index;
+			isInsideComment = singleComment;
+			index++;
+		} else if (isInsideComment === singleComment && currentCharacter + nextCharacter === '\r\n') {
+			index++;
+			isInsideComment = false;
+			result += strip(jsonString, offset, index);
+			offset = index;
+		} else if (isInsideComment === singleComment && currentCharacter === '\n') {
+			isInsideComment = false;
+			result += strip(jsonString, offset, index);
+			offset = index;
+		} else if (!isInsideComment && currentCharacter + nextCharacter === '/*') {
+			result += jsonString.slice(offset, index);
+			offset = index;
+			isInsideComment = multiComment;
+			index++;
+		} else if (isInsideComment === multiComment && currentCharacter + nextCharacter === '*/') {
+			index++;
+			isInsideComment = false;
+			result += strip(jsonString, offset, index + 1);
+			offset = index + 1;
+		}
+	}
+
+	return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+// end strip-json-comments
+
+// start strip-bom
+/**
+ * @param {string} string
+ * @returns {string}
+ */
+function stripBom(string) {
+	// Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+	// conversion translates it to FEFF (UTF-16 BOM).
+	if (string.charCodeAt(0) === 0xfeff) {
+		return string.slice(1);
+	}
+	return string;
+}
+// end strip-bom
+
+const not_found_result = {
+	tsconfigFile: null,
+	tsconfig: {}
+};
+
+/**
+ * parse the closest tsconfig.json file
+ *
+ * @param {string} filename - path to a tsconfig .json or a source file or directory (absolute or relative to cwd)
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options] - options
+ * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
+ * @throws {TSConfckParseError}
+ */
+async function parse$e(filename, options) {
+	/** @type {import('./cache.js').TSConfckCache} */
+	const cache = options?.cache;
+	if (cache?.hasParseResult(filename)) {
+		return getParsedDeep(filename, cache, options);
+	}
+	const {
+		resolve,
+		reject,
+		/** @type {Promise<import('./public.d.ts').TSConfckParseResult>}*/
+		promise
+	} = makePromise();
+	cache?.setParseResult(filename, promise, true);
+	try {
+		let tsconfigFile =
+			(await resolveTSConfigJson(filename, cache)) || (await find(filename, options));
+		if (!tsconfigFile) {
+			resolve(not_found_result);
+			return promise;
+		}
+		let result;
+		if (filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile)) {
+			result = await getParsedDeep(tsconfigFile, cache, options);
+		} else {
+			result = await parseFile$1(tsconfigFile, cache, filename === tsconfigFile);
+			await Promise.all([parseExtends(result, cache), parseReferences(result, options)]);
+		}
+		result.tsconfig = replaceTokens(result.tsconfig, path$n.dirname(tsconfigFile));
+		resolve(resolveSolutionTSConfig(filename, result));
+	} catch (e) {
+		reject(e);
+	}
+	return promise;
+}
+
+/**
+ * ensure extends and references are parsed
+ *
+ * @param {string} filename - cached file
+ * @param {import('./cache.js').TSConfckCache} cache - cache
+ * @param {import('./public.d.ts').TSConfckParseOptions} options - options
+ */
+async function getParsedDeep(filename, cache, options) {
+	const result = await cache.getParseResult(filename);
+	if (
+		(result.tsconfig.extends && !result.extended) ||
+		(result.tsconfig.references && !result.referenced)
+	) {
+		const promise = Promise.all([
+			parseExtends(result, cache),
+			parseReferences(result, options)
+		]).then(() => result);
+		cache.setParseResult(filename, promise, true);
+		return promise;
+	}
+	return result;
+}
+
+/**
+ *
+ * @param {string} tsconfigFile - path to tsconfig file
+ * @param {import('./cache.js').TSConfckCache} [cache] - cache
+ * @param {boolean} [skipCache] - skip cache
+ * @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
+ */
+async function parseFile$1(tsconfigFile, cache, skipCache) {
+	if (
+		!skipCache &&
+		cache?.hasParseResult(tsconfigFile) &&
+		!cache.getParseResult(tsconfigFile)._isRootFile_
+	) {
+		return cache.getParseResult(tsconfigFile);
+	}
+	const promise = promises$1
+		.readFile(tsconfigFile, 'utf-8')
+		.then(toJson)
+		.then((json) => {
+			const parsed = JSON.parse(json);
+			applyDefaults(parsed, tsconfigFile);
+			return {
+				tsconfigFile,
+				tsconfig: normalizeTSConfig(parsed, path$n.dirname(tsconfigFile))
+			};
+		})
+		.catch((e) => {
+			throw new TSConfckParseError(
+				`parsing ${tsconfigFile} failed: ${e}`,
+				'PARSE_FILE',
+				tsconfigFile,
+				e
+			);
+		});
+	if (
+		!skipCache &&
+		(!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_)
+	) {
+		cache?.setParseResult(tsconfigFile, promise);
+	}
+	return promise;
+}
+
+/**
+ * normalize to match the output of ts.parseJsonConfigFileContent
+ *
+ * @param {any} tsconfig - typescript tsconfig output
+ * @param {string} dir - directory
+ */
+function normalizeTSConfig(tsconfig, dir) {
+	// set baseUrl to absolute path
+	const baseUrl = tsconfig.compilerOptions?.baseUrl;
+	if (baseUrl && !baseUrl.startsWith('${') && !path$n.isAbsolute(baseUrl)) {
+		tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
+	}
+	return tsconfig;
+}
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./public.d.ts').TSConfckParseOptions} [options]
+ * @returns {Promise<void>}
+ */
+async function parseReferences(result, options) {
+	if (!result.tsconfig.references) {
+		return;
+	}
+	const referencedFiles = resolveReferencedTSConfigFiles(result, options);
+	const referenced = await Promise.all(
+		referencedFiles.map((file) => parseFile$1(file, options?.cache))
+	);
+	await Promise.all(referenced.map((ref) => parseExtends(ref, options?.cache)));
+	referenced.forEach((ref) => {
+		ref.solution = result;
+	});
+	result.referenced = referenced;
+}
+
+/**
+ * @param {import('./public.d.ts').TSConfckParseResult} result
+ * @param {import('./cache.js').TSConfckCache}[cache]
+ * @returns {Promise<void>}
+ */
+async function parseExtends(result, cache) {
+	if (!result.tsconfig.extends) {
+		return;
+	}
+	// use result as first element in extended
+	// but dereference tsconfig so that mergeExtended can modify the original without affecting extended[0]
+	/** @type {import('./public.d.ts').TSConfckParseResult[]} */
+	const extended = [
+		{ tsconfigFile: result.tsconfigFile, tsconfig: JSON.parse(JSON.stringify(result.tsconfig)) }
+	];
+
+	// flatten extends graph into extended
+	let pos = 0;
+	/** @type {string[]} */
+	const extendsPath = [];
+	let currentBranchDepth = 0;
+	while (pos < extended.length) {
+		const extending = extended[pos];
+		extendsPath.push(extending.tsconfigFile);
+		if (extending.tsconfig.extends) {
+			// keep following this branch
+			currentBranchDepth += 1;
+			/** @type {string[]} */
+			let resolvedExtends;
+			if (!Array.isArray(extending.tsconfig.extends)) {
+				resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
+			} else {
+				// reverse because typescript 5.0 treats ['a','b','c'] as c extends b extends a
+				resolvedExtends = extending.tsconfig.extends
+					.reverse()
+					.map((ex) => resolveExtends(ex, extending.tsconfigFile));
+			}
+
+			const circularExtends = resolvedExtends.find((tsconfigFile) =>
+				extendsPath.includes(tsconfigFile)
+			);
+			if (circularExtends) {
+				const circle = extendsPath.concat([circularExtends]).join(' -> ');
+				throw new TSConfckParseError(
+					`Circular dependency in "extends": ${circle}`,
+					'EXTENDS_CIRCULAR',
+					result.tsconfigFile
+				);
+			}
+			// add new extends to the list directly after current
+			extended.splice(
+				pos + 1,
+				0,
+				...(await Promise.all(resolvedExtends.map((file) => parseFile$1(file, cache))))
+			);
+		} else {
+			// reached a leaf, backtrack to the last branching point and continue
+			extendsPath.splice(-currentBranchDepth);
+			currentBranchDepth = 0;
+		}
+		pos = pos + 1;
+	}
+	result.extended = extended;
+	// skip first as it is the original config
+	for (const ext of result.extended.slice(1)) {
+		extendTSConfig(result, ext);
+	}
+}
+
+/**
+ *
+ * @param {string} extended
+ * @param {string} from
+ * @returns {string}
+ */
+function resolveExtends(extended, from) {
+	if (extended === '..') {
+		// see #149
+		extended = '../tsconfig.json';
+	}
+	const req = createRequire$2(from);
+	let error;
+	try {
+		return req.resolve(extended);
+	} catch (e) {
+		error = e;
+	}
+	if (extended[0] !== '.' && !path$n.isAbsolute(extended)) {
+		try {
+			return req.resolve(`${extended}/tsconfig.json`);
+		} catch (e) {
+			error = e;
+		}
+	}
+
+	throw new TSConfckParseError(
+		`failed to resolve "extends":"${extended}" in ${from}`,
+		'EXTENDS_RESOLVE',
+		from,
+		error
+	);
+}
+
+// references, extends and custom keys are not carried over
+const EXTENDABLE_KEYS = [
+	'compilerOptions',
+	'files',
+	'include',
+	'exclude',
+	'watchOptions',
+	'compileOnSave',
+	'typeAcquisition',
+	'buildOptions'
+];
+
+/**
+ *
+ * @param {import('./public.d.ts').TSConfckParseResult} extending
+ * @param {import('./public.d.ts').TSConfckParseResult} extended
+ * @returns void
+ */
+function extendTSConfig(extending, extended) {
+	const extendingConfig = extending.tsconfig;
+	const extendedConfig = extended.tsconfig;
+	const relativePath = native2posix(
+		path$n.relative(path$n.dirname(extending.tsconfigFile), path$n.dirname(extended.tsconfigFile))
+	);
+	for (const key of Object.keys(extendedConfig).filter((key) => EXTENDABLE_KEYS.includes(key))) {
+		if (key === 'compilerOptions') {
+			if (!extendingConfig.compilerOptions) {
+				extendingConfig.compilerOptions = {};
+			}
+			for (const option of Object.keys(extendedConfig.compilerOptions)) {
+				if (Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) {
+					continue; // already set
+				}
+				extendingConfig.compilerOptions[option] = rebaseRelative(
+					option,
+					extendedConfig.compilerOptions[option],
+					relativePath
+				);
+			}
+		} else if (extendingConfig[key] === undefined) {
+			if (key === 'watchOptions') {
+				extendingConfig.watchOptions = {};
+				for (const option of Object.keys(extendedConfig.watchOptions)) {
+					extendingConfig.watchOptions[option] = rebaseRelative(
+						option,
+						extendedConfig.watchOptions[option],
+						relativePath
+					);
+				}
+			} else {
+				extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
+			}
+		}
+	}
+}
+
+const REBASE_KEYS = [
+	// root
+	'files',
+	'include',
+	'exclude',
+	// compilerOptions
+	'baseUrl',
+	'rootDir',
+	'rootDirs',
+	'typeRoots',
+	'outDir',
+	'outFile',
+	'declarationDir',
+	// watchOptions
+	'excludeDirectories',
+	'excludeFiles'
+];
+
+/** @typedef {string | string[]} PathValue */
+
+/**
+ *
+ * @param {string} key
+ * @param {PathValue} value
+ * @param {string} prependPath
+ * @returns {PathValue}
+ */
+function rebaseRelative(key, value, prependPath) {
+	if (!REBASE_KEYS.includes(key)) {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map((x) => rebasePath(x, prependPath));
+	} else {
+		return rebasePath(value, prependPath);
+	}
+}
+
+/**
+ *
+ * @param {string} value
+ * @param {string} prependPath
+ * @returns {string}
+ */
+function rebasePath(value, prependPath) {
+	if (path$n.isAbsolute(value) || value.startsWith('${configDir}')) {
+		return value;
+	} else {
+		// relative paths use posix syntax in tsconfig
+		return path$n.posix.normalize(path$n.posix.join(prependPath, value));
+	}
+}
+
+class TSConfckParseError extends Error {
+	/**
+	 * error code
+	 * @type {string}
+	 */
+	code;
+	/**
+	 * error cause
+	 * @type { Error | undefined}
+	 */
+	cause;
+
+	/**
+	 * absolute path of tsconfig file where the error happened
+	 * @type {string}
+	 */
+	tsconfigFile;
+	/**
+	 *
+	 * @param {string} message - error message
+	 * @param {string} code - error code
+	 * @param {string} tsconfigFile - path to tsconfig file
+	 * @param {Error?} cause - cause of this error
+	 */
+	constructor(message, code, tsconfigFile, cause) {
+		super(message);
+		// Set the prototype explicitly.
+		Object.setPrototypeOf(this, TSConfckParseError.prototype);
+		this.name = TSConfckParseError.name;
+		this.code = code;
+		this.cause = cause;
+		this.tsconfigFile = tsconfigFile;
+	}
+}
+
+/**
+ *
+ * @param {any} tsconfig
+ * @param {string} tsconfigFile
+ */
+function applyDefaults(tsconfig, tsconfigFile) {
+	if (isJSConfig(tsconfigFile)) {
+		tsconfig.compilerOptions = {
+			...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
+			...tsconfig.compilerOptions
+		};
+	}
+}
+
+const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
+	allowJs: true,
+	maxNodeModuleJsDepth: 2,
+	allowSyntheticDefaultImports: true,
+	skipLibCheck: true,
+	noEmit: true
+};
+
+/**
+ * @param {string} configFileName
+ */
+function isJSConfig(configFileName) {
+	return path$n.basename(configFileName) === 'jsconfig.json';
+}
+
+/** @template T */
+class TSConfckCache {
+	/**
+	 * clear cache, use this if you have a long running process and tsconfig files have been added,changed or deleted
+	 */
+	clear() {
+		this.#configPaths.clear();
+		this.#parsed.clear();
+	}
+
+	/**
+	 * has cached closest config for files in dir
+	 * @param {string} dir
+	 * @param {string} [configName=tsconfig.json]
+	 * @returns {boolean}
+	 */
+	hasConfigPath(dir, configName = 'tsconfig.json') {
+		return this.#configPaths.has(`${dir}/${configName}`);
+	}
+
+	/**
+	 * get cached closest tsconfig for files in dir
+	 * @param {string} dir
+	 * @param {string} [configName=tsconfig.json]
+	 * @returns {Promise<string|null>|string|null}
+	 * @throws {unknown} if cached value is an error
+	 */
+	getConfigPath(dir, configName = 'tsconfig.json') {
+		const key = `${dir}/${configName}`;
+		const value = this.#configPaths.get(key);
+		if (value == null || value.length || value.then) {
+			return value;
+		} else {
+			throw value;
+		}
+	}
+
+	/**
+	 * has parsed tsconfig for file
+	 * @param {string} file
+	 * @returns {boolean}
+	 */
+	hasParseResult(file) {
+		return this.#parsed.has(file);
+	}
+
+	/**
+	 * get parsed tsconfig for file
+	 * @param {string} file
+	 * @returns {Promise<T>|T}
+	 * @throws {unknown} if cached value is an error
+	 */
+	getParseResult(file) {
+		const value = this.#parsed.get(file);
+		if (value.then || value.tsconfig) {
+			return value;
+		} else {
+			throw value; // cached error, rethrow
+		}
+	}
+
+	/**
+	 * @internal
+	 * @private
+	 * @param file
+	 * @param {boolean} isRootFile a flag to check if current file which involking the parse() api, used to distinguish the normal cache which only parsed by parseFile()
+	 * @param {Promise<T>} result
+	 */
+	setParseResult(file, result, isRootFile = false) {
+		// _isRootFile_ is a temporary property for Promise result, used to prevent deadlock with cache
+		Object.defineProperty(result, '_isRootFile_', {
+			value: isRootFile,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+		this.#parsed.set(file, result);
+		result
+			.then((parsed) => {
+				if (this.#parsed.get(file) === result) {
+					this.#parsed.set(file, parsed);
+				}
+			})
+			.catch((e) => {
+				if (this.#parsed.get(file) === result) {
+					this.#parsed.set(file, e);
+				}
+			});
+	}
+
+	/**
+	 * @internal
+	 * @private
+	 * @param {string} dir
+	 * @param {Promise<string|null>} configPath
+	 * @param {string} [configName=tsconfig.json]
+	 */
+	setConfigPath(dir, configPath, configName = 'tsconfig.json') {
+		const key = `${dir}/${configName}`;
+		this.#configPaths.set(key, configPath);
+		configPath
+			.then((path) => {
+				if (this.#configPaths.get(key) === configPath) {
+					this.#configPaths.set(key, path);
+				}
+			})
+			.catch((e) => {
+				if (this.#configPaths.get(key) === configPath) {
+					this.#configPaths.set(key, e);
+				}
+			});
+	}
+
+	/**
+	 * map directories to their closest tsconfig.json
+	 * @internal
+	 * @private
+	 * @type{Map<string,(Promise<string|null>|string|null)>}
+	 */
+	#configPaths = new Map();
+
+	/**
+	 * map files to their parsed tsconfig result
+	 * @internal
+	 * @private
+	 * @type {Map<string,(Promise<T>|T)> }
+	 */
+	#parsed = new Map();
+}
+
+const debug$h = createDebugger("vite:esbuild");
+const IIFE_BEGIN_RE = /(?:const|var)\s+\S+\s*=\s*function\([^()]*\)\s*\{\s*"use strict";/;
+const validExtensionRE = /\.\w+$/;
+const jsxExtensionsRE = /\.(?:j|t)sx\b/;
+const defaultEsbuildSupported = {
+  "dynamic-import": true,
+  "import-meta": true
+};
+let server;
+async function transformWithEsbuild(code, filename, options, inMap) {
+  let loader = options?.loader;
+  if (!loader) {
+    const ext = path$n.extname(validExtensionRE.test(filename) ? filename : cleanUrl(filename)).slice(1);
+    if (ext === "cjs" || ext === "mjs") {
+      loader = "js";
+    } else if (ext === "cts" || ext === "mts") {
+      loader = "ts";
+    } else {
+      loader = ext;
+    }
+  }
+  let tsconfigRaw = options?.tsconfigRaw;
+  if (typeof tsconfigRaw !== "string") {
+    const meaningfulFields = [
+      "alwaysStrict",
+      "experimentalDecorators",
+      "importsNotUsedAsValues",
+      "jsx",
+      "jsxFactory",
+      "jsxFragmentFactory",
+      "jsxImportSource",
+      "preserveValueImports",
+      "target",
+      "useDefineForClassFields",
+      "verbatimModuleSyntax"
+    ];
+    const compilerOptionsForFile = {};
+    if (loader === "ts" || loader === "tsx") {
+      const loadedTsconfig = await loadTsconfigJsonForFile(filename);
+      const loadedCompilerOptions = loadedTsconfig.compilerOptions ?? {};
+      for (const field of meaningfulFields) {
+        if (field in loadedCompilerOptions) {
+          compilerOptionsForFile[field] = loadedCompilerOptions[field];
+        }
+      }
+    }
+    const compilerOptions = {
+      ...compilerOptionsForFile,
+      ...tsconfigRaw?.compilerOptions
+    };
+    if (compilerOptions.useDefineForClassFields === void 0 && compilerOptions.target === void 0) {
+      compilerOptions.useDefineForClassFields = false;
+    }
+    if (options) {
+      options.jsx && (compilerOptions.jsx = void 0);
+      options.jsxFactory && (compilerOptions.jsxFactory = void 0);
+      options.jsxFragment && (compilerOptions.jsxFragmentFactory = void 0);
+      options.jsxImportSource && (compilerOptions.jsxImportSource = void 0);
+    }
+    tsconfigRaw = {
+      ...tsconfigRaw,
+      compilerOptions
+    };
+  }
+  const resolvedOptions = {
+    sourcemap: true,
+    // ensure source file name contains full query
+    sourcefile: filename,
+    ...options,
+    loader,
+    tsconfigRaw
+  };
+  delete resolvedOptions.include;
+  delete resolvedOptions.exclude;
+  delete resolvedOptions.jsxInject;
+  try {
+    const result = await transform$1(code, resolvedOptions);
+    let map;
+    if (inMap && resolvedOptions.sourcemap) {
+      const nextMap = JSON.parse(result.map);
+      nextMap.sourcesContent = [];
+      map = combineSourcemaps(filename, [
+        nextMap,
+        inMap
+      ]);
+    } else {
+      map = resolvedOptions.sourcemap && resolvedOptions.sourcemap !== "inline" ? JSON.parse(result.map) : { mappings: "" };
+    }
+    return {
+      ...result,
+      map
+    };
+  } catch (e) {
+    debug$h?.(`esbuild error with options used: `, resolvedOptions);
+    if (e.errors) {
+      e.frame = "";
+      e.errors.forEach((m) => {
+        if (m.text === "Experimental decorators are not currently enabled" || m.text === "Parameter decorators only work when experimental decorators are enabled") {
+          m.text += '. Vite 5 now uses esbuild 0.18 and you need to enable them by adding "experimentalDecorators": true in your "tsconfig.json" file.';
+        }
+        e.frame += `
+` + prettifyMessage(m, code);
+      });
+      e.loc = e.errors[0].location;
+    }
+    throw e;
+  }
+}
+function esbuildPlugin(config) {
+  const options = config.esbuild;
+  const { jsxInject, include, exclude, ...esbuildTransformOptions } = options;
+  const filter = createFilter(include || /\.(m?ts|[jt]sx)$/, exclude || /\.js$/);
+  const transformOptions = {
+    target: "esnext",
+    charset: "utf8",
+    ...esbuildTransformOptions,
+    minify: false,
+    minifyIdentifiers: false,
+    minifySyntax: false,
+    minifyWhitespace: false,
+    treeShaking: false,
+    // keepNames is not needed when minify is disabled.
+    // Also transforming multiple times with keepNames enabled breaks
+    // tree-shaking. (#9164)
+    keepNames: false,
+    supported: {
+      ...defaultEsbuildSupported,
+      ...esbuildTransformOptions.supported
+    }
+  };
+  return {
+    name: "vite:esbuild",
+    configureServer(_server) {
+      server = _server;
+      server.watcher.on("add", reloadOnTsconfigChange).on("change", reloadOnTsconfigChange).on("unlink", reloadOnTsconfigChange);
+    },
+    buildEnd() {
+      server = null;
+    },
+    async transform(code, id) {
+      if (filter(id) || filter(cleanUrl(id))) {
+        const result = await transformWithEsbuild(code, id, transformOptions);
+        if (result.warnings.length) {
+          result.warnings.forEach((m) => {
+            this.warn(prettifyMessage(m, code));
+          });
+        }
+        if (jsxInject && jsxExtensionsRE.test(id)) {
+          result.code = jsxInject + ";" + result.code;
+        }
+        return {
+          code: result.code,
+          map: result.map
+        };
+      }
+    }
+  };
+}
+const rollupToEsbuildFormatMap = {
+  es: "esm",
+  cjs: "cjs",
+  // passing `var Lib = (() => {})()` to esbuild with format = "iife"
+  // will turn it to `(() => { var Lib = (() => {})() })()`,
+  // so we remove the format config to tell esbuild not doing this
+  //
+  // although esbuild doesn't change format, there is still possibility
+  // that `{ treeShaking: true }` removes a top-level no-side-effect variable
+  // like: `var Lib = 1`, which becomes `` after esbuild transforming,
+  // but thankfully rollup does not do this optimization now
+  iife: void 0
+};
+const buildEsbuildPlugin = (config) => {
+  return {
+    name: "vite:esbuild-transpile",
+    async renderChunk(code, chunk, opts) {
+      if (opts.__vite_skip_esbuild__) {
+        return null;
+      }
+      const options = resolveEsbuildTranspileOptions(config, opts.format);
+      if (!options) {
+        return null;
+      }
+      const res = await transformWithEsbuild(code, chunk.fileName, options);
+      if (config.build.lib) {
+        const esbuildCode = res.code;
+        const contentIndex = opts.format === "iife" ? Math.max(esbuildCode.search(IIFE_BEGIN_RE), 0) : opts.format === "umd" ? esbuildCode.indexOf(`(function(`) : 0;
+        if (contentIndex > 0) {
+          const esbuildHelpers = esbuildCode.slice(0, contentIndex);
+          res.code = esbuildCode.slice(contentIndex).replace(`"use strict";`, `"use strict";` + esbuildHelpers);
+        }
+      }
+      return res;
+    }
+  };
+};
+function resolveEsbuildTranspileOptions(config, format) {
+  const target = config.build.target;
+  const minify = config.build.minify === "esbuild";
+  if ((!target || target === "esnext") && !minify) {
+    return null;
+  }
+  const isEsLibBuild = config.build.lib && format === "es";
+  const esbuildOptions = config.esbuild || {};
+  const options = {
+    charset: "utf8",
+    ...esbuildOptions,
+    loader: "js",
+    target: target || void 0,
+    format: rollupToEsbuildFormatMap[format],
+    supported: {
+      ...defaultEsbuildSupported,
+      ...esbuildOptions.supported
+    }
+  };
+  if (!minify) {
+    return {
+      ...options,
+      minify: false,
+      minifyIdentifiers: false,
+      minifySyntax: false,
+      minifyWhitespace: false,
+      treeShaking: false
+    };
+  }
+  if (options.minifyIdentifiers != null || options.minifySyntax != null || options.minifyWhitespace != null) {
+    if (isEsLibBuild) {
+      return {
+        ...options,
+        minify: false,
+        minifyIdentifiers: options.minifyIdentifiers ?? true,
+        minifySyntax: options.minifySyntax ?? true,
+        minifyWhitespace: false,
+        treeShaking: true
+      };
+    } else {
+      return {
+        ...options,
+        minify: false,
+        minifyIdentifiers: options.minifyIdentifiers ?? true,
+        minifySyntax: options.minifySyntax ?? true,
+        minifyWhitespace: options.minifyWhitespace ?? true,
+        treeShaking: true
+      };
+    }
+  }
+  if (isEsLibBuild) {
+    return {
+      ...options,
+      minify: false,
+      minifyIdentifiers: true,
+      minifySyntax: true,
+      minifyWhitespace: false,
+      treeShaking: true
+    };
+  } else {
+    return {
+      ...options,
+      minify: true,
+      treeShaking: true
+    };
+  }
+}
+function prettifyMessage(m, code) {
+  let res = colors$1.yellow(m.text);
+  if (m.location) {
+    res += `
+` + generateCodeFrame(code, m.location);
+  }
+  return res + `
+`;
+}
+let tsconfckCache;
+async function loadTsconfigJsonForFile(filename) {
+  try {
+    if (!tsconfckCache) {
+      tsconfckCache = new TSConfckCache();
+    }
+    const result = await parse$e(filename, {
+      cache: tsconfckCache,
+      ignoreNodeModules: true
+    });
+    if (server && result.tsconfigFile) {
+      ensureWatchedFile(server.watcher, result.tsconfigFile, server.config.root);
+    }
+    return result.tsconfig;
+  } catch (e) {
+    if (e instanceof TSConfckParseError) {
+      if (server && e.tsconfigFile) {
+        ensureWatchedFile(server.watcher, e.tsconfigFile, server.config.root);
+      }
+    }
+    throw e;
+  }
+}
+async function reloadOnTsconfigChange(changedFile) {
+  if (!server) return;
+  if (path$n.basename(changedFile) === "tsconfig.json" || changedFile.endsWith(".json") && tsconfckCache?.hasParseResult(changedFile)) {
+    server.config.logger.info(
+      `changed tsconfig file detected: ${changedFile} - Clearing cache and forcing full-reload to ensure TypeScript is compiled with updated config values.`,
+      { clear: server.config.clearScreen, timestamp: true }
+    );
+    server.moduleGraph.invalidateAll();
+    tsconfckCache?.clear();
+    if (server) {
+      server.hot.send({
+        type: "full-reload",
+        path: "*"
+      });
+    }
+  }
+}
+
+// src/realWorker.ts
+var Worker = class {
+  /** @internal */
+  _code;
+  /** @internal */
+  _parentFunctions;
+  /** @internal */
+  _max;
+  /** @internal */
+  _pool;
+  /** @internal */
+  _idlePool;
+  /** @internal */
+  _queue;
+  constructor(fn, options = {}) {
+    this._code = genWorkerCode(fn, options.parentFunctions ?? {});
+    this._parentFunctions = options.parentFunctions ?? {};
+    const defaultMax = Math.max(
+      1,
+      // os.availableParallelism is available from Node.js 18.14.0
+      (os$5.availableParallelism?.() ?? os$5.cpus().length) - 1
+    );
+    this._max = options.max || defaultMax;
+    this._pool = [];
+    this._idlePool = [];
+    this._queue = [];
+  }
+  async run(...args) {
+    const worker = await this._getAvailableWorker();
+    return new Promise((resolve, reject) => {
+      worker.currentResolve = resolve;
+      worker.currentReject = reject;
+      worker.postMessage({ type: "run", args });
+    });
+  }
+  stop() {
+    this._pool.forEach((w) => w.unref());
+    this._queue.forEach(
+      ([, reject]) => reject(
+        new Error("Main worker pool stopped before a worker was available.")
+      )
+    );
+    this._pool = [];
+    this._idlePool = [];
+    this._queue = [];
+  }
+  /** @internal */
+  async _getAvailableWorker() {
+    if (this._idlePool.length) {
+      return this._idlePool.shift();
+    }
+    if (this._pool.length < this._max) {
+      const worker = new Worker$1(this._code, { eval: true });
+      worker.on("message", async (args) => {
+        if (args.type === "run") {
+          if ("result" in args) {
+            worker.currentResolve && worker.currentResolve(args.result);
+            worker.currentResolve = null;
+          } else {
+            if (args.error instanceof ReferenceError) {
+              args.error.message += ". Maybe you forgot to pass the function to parentFunction?";
+            }
+            worker.currentReject && worker.currentReject(args.error);
+            worker.currentReject = null;
+          }
+          this._assignDoneWorker(worker);
+        } else if (args.type === "parentFunction") {
+          try {
+            const result = await this._parentFunctions[args.name](...args.args);
+            worker.postMessage({ type: "parentFunction", id: args.id, result });
+          } catch (e) {
+            worker.postMessage({
+              type: "parentFunction",
+              id: args.id,
+              error: e
+            });
+          }
+        }
+      });
+      worker.on("error", (err) => {
+        worker.currentReject && worker.currentReject(err);
+        worker.currentReject = null;
+      });
+      worker.on("exit", (code) => {
+        const i = this._pool.indexOf(worker);
+        if (i > -1)
+          this._pool.splice(i, 1);
+        if (code !== 0 && worker.currentReject) {
+          worker.currentReject(
+            new Error(`Worker stopped with non-0 exit code ${code}`)
+          );
+          worker.currentReject = null;
+        }
+      });
+      this._pool.push(worker);
+      return worker;
+    }
+    let resolve;
+    let reject;
+    const onWorkerAvailablePromise = new Promise((r, rj) => {
+      resolve = r;
+      reject = rj;
+    });
+    this._queue.push([resolve, reject]);
+    return onWorkerAvailablePromise;
+  }
+  /** @internal */
+  _assignDoneWorker(worker) {
+    if (this._queue.length) {
+      const [resolve] = this._queue.shift();
+      resolve(worker);
+      return;
+    }
+    this._idlePool.push(worker);
+  }
+};
+function genWorkerCode(fn, parentFunctions) {
+  const createParentFunctionCaller = (parentPort) => {
+    let id = 0;
+    const resolvers = /* @__PURE__ */ new Map();
+    const call = (key) => async (...args) => {
+      id++;
+      let resolve, reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      resolvers.set(id, { resolve, reject });
+      parentPort.postMessage({ type: "parentFunction", id, name: key, args });
+      return await promise;
+    };
+    const receive = (id2, args) => {
+      if (resolvers.has(id2)) {
+        const { resolve, reject } = resolvers.get(id2);
+        resolvers.delete(id2);
+        if ("result" in args) {
+          resolve(args.result);
+        } else {
+          reject(args.error);
+        }
+      }
+    };
+    return { call, receive };
+  };
+  return `
+const { parentPort } = require('worker_threads')
+const parentFunctionCaller = (${createParentFunctionCaller.toString()})(parentPort)
+
+const doWork = (() => {
+  ${Object.keys(parentFunctions).map(
+    (key) => `const ${key} = parentFunctionCaller.call(${JSON.stringify(key)});`
+  ).join("\n")}
+  return (${fn.toString()})()
+})()
+
+parentPort.on('message', async (args) => {
+  if (args.type === 'run') {
+    try {
+      const res = await doWork(...args.args)
+      parentPort.postMessage({ type: 'run', result: res })
+    } catch (e) {
+      parentPort.postMessage({ type: 'run', error: e })
+    }
+  } else if (args.type === 'parentFunction') {
+    parentFunctionCaller.receive(args.id, args)
+  }
+})
+  `;
+}
+var FakeWorker = class {
+  /** @internal */
+  _fn;
+  constructor(fn, options = {}) {
+    const argsAndCode = genFakeWorkerArgsAndCode(
+      fn,
+      options.parentFunctions ?? {}
+    );
+    const require2 = createRequire$1(import.meta.url);
+    this._fn = new Function(...argsAndCode)(require2, options.parentFunctions);
+  }
+  async run(...args) {
+    try {
+      return await this._fn(...args);
+    } catch (err) {
+      if (err instanceof ReferenceError) {
+        err.message += ". Maybe you forgot to pass the function to parentFunction?";
+      }
+      throw err;
+    }
+  }
+  stop() {
+  }
+};
+function genFakeWorkerArgsAndCode(fn, parentFunctions) {
+  return [
+    "require",
+    "parentFunctions",
+    `
+${Object.keys(parentFunctions).map((key) => `const ${key} = parentFunctions[${JSON.stringify(key)}];`).join("\n")}
+return (${fn.toString()})()
+  `
+  ];
+}
+
+// src/workerWithFallback.ts
+var WorkerWithFallback = class {
+  /** @internal */
+  _disableReal;
+  /** @internal */
+  _realWorker;
+  /** @internal */
+  _fakeWorker;
+  /** @internal */
+  _shouldUseFake;
+  constructor(fn, options) {
+    this._disableReal = options.max !== void 0 && options.max <= 0;
+    this._realWorker = new Worker(fn, options);
+    this._fakeWorker = new FakeWorker(fn, options);
+    this._shouldUseFake = options.shouldUseFake;
+  }
+  async run(...args) {
+    const useFake = this._disableReal || this._shouldUseFake(...args);
+    return this[useFake ? "_fakeWorker" : "_realWorker"].run(...args);
+  }
+  stop() {
+    this._realWorker.stop();
+    this._fakeWorker.stop();
+  }
+};
+
+let terserPath;
+const loadTerserPath = (root) => {
+  if (terserPath) return terserPath;
+  try {
+    terserPath = requireResolveFromRootWithFallback(root, "terser");
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "terser not found. Since Vite v3, terser has become an optional dependency. You need to install it."
+      );
+    } else {
+      const message = new Error(`terser failed to load:
+${e.message}`);
+      message.stack = e.stack + "\n" + message.stack;
+      throw message;
+    }
+  }
+  return terserPath;
+};
+function terserPlugin(config) {
+  const { maxWorkers, ...terserOptions } = config.build.terserOptions;
+  const makeWorker = () => new Worker(
+    () => async (terserPath2, code, options) => {
+      const terser = require(terserPath2);
+      return terser.minify(code, options);
+    },
+    {
+      max: maxWorkers
+    }
+  );
+  let worker;
+  return {
+    name: "vite:terser",
+    async renderChunk(code, _chunk, outputOptions) {
+      if (config.build.minify !== "terser" && // @ts-expect-error injected by @vitejs/plugin-legacy
+      !outputOptions.__vite_force_terser__) {
+        return null;
+      }
+      if (config.build.lib && outputOptions.format === "es") {
+        return null;
+      }
+      worker ||= makeWorker();
+      const terserPath2 = loadTerserPath(config.root);
+      const res = await worker.run(terserPath2, code, {
+        safari10: true,
+        ...terserOptions,
+        sourceMap: !!outputOptions.sourcemap,
+        module: outputOptions.format.startsWith("es"),
+        toplevel: outputOptions.format === "cjs"
+      });
+      return {
+        code: res.code,
+        map: res.map
+      };
+    },
+    closeBundle() {
+      worker?.stop();
+    }
+  };
+}
+
+const mimes = {
+  "3g2": "video/3gpp2",
+  "3gp": "video/3gpp",
+  "3gpp": "video/3gpp",
+  "3mf": "model/3mf",
+  "aac": "audio/aac",
+  "ac": "application/pkix-attr-cert",
+  "adp": "audio/adpcm",
+  "adts": "audio/aac",
+  "ai": "application/postscript",
+  "aml": "application/automationml-aml+xml",
+  "amlx": "application/automationml-amlx+zip",
+  "amr": "audio/amr",
+  "apng": "image/apng",
+  "appcache": "text/cache-manifest",
+  "appinstaller": "application/appinstaller",
+  "appx": "application/appx",
+  "appxbundle": "application/appxbundle",
+  "asc": "application/pgp-keys",
+  "atom": "application/atom+xml",
+  "atomcat": "application/atomcat+xml",
+  "atomdeleted": "application/atomdeleted+xml",
+  "atomsvc": "application/atomsvc+xml",
+  "au": "audio/basic",
+  "avci": "image/avci",
+  "avcs": "image/avcs",
+  "avif": "image/avif",
+  "aw": "application/applixware",
+  "bdoc": "application/bdoc",
+  "bin": "application/octet-stream",
+  "bmp": "image/bmp",
+  "bpk": "application/octet-stream",
+  "btf": "image/prs.btif",
+  "btif": "image/prs.btif",
+  "buffer": "application/octet-stream",
+  "ccxml": "application/ccxml+xml",
+  "cdfx": "application/cdfx+xml",
+  "cdmia": "application/cdmi-capability",
+  "cdmic": "application/cdmi-container",
+  "cdmid": "application/cdmi-domain",
+  "cdmio": "application/cdmi-object",
+  "cdmiq": "application/cdmi-queue",
+  "cer": "application/pkix-cert",
+  "cgm": "image/cgm",
+  "cjs": "application/node",
+  "class": "application/java-vm",
+  "coffee": "text/coffeescript",
+  "conf": "text/plain",
+  "cpl": "application/cpl+xml",
+  "cpt": "application/mac-compactpro",
+  "crl": "application/pkix-crl",
+  "css": "text/css",
+  "csv": "text/csv",
+  "cu": "application/cu-seeme",
+  "cwl": "application/cwl",
+  "cww": "application/prs.cww",
+  "davmount": "application/davmount+xml",
+  "dbk": "application/docbook+xml",
+  "deb": "application/octet-stream",
+  "def": "text/plain",
+  "deploy": "application/octet-stream",
+  "dib": "image/bmp",
+  "disposition-notification": "message/disposition-notification",
+  "dist": "application/octet-stream",
+  "distz": "application/octet-stream",
+  "dll": "application/octet-stream",
+  "dmg": "application/octet-stream",
+  "dms": "application/octet-stream",
+  "doc": "application/msword",
+  "dot": "application/msword",
+  "dpx": "image/dpx",
+  "drle": "image/dicom-rle",
+  "dsc": "text/prs.lines.tag",
+  "dssc": "application/dssc+der",
+  "dtd": "application/xml-dtd",
+  "dump": "application/octet-stream",
+  "dwd": "application/atsc-dwd+xml",
+  "ear": "application/java-archive",
+  "ecma": "application/ecmascript",
+  "elc": "application/octet-stream",
+  "emf": "image/emf",
+  "eml": "message/rfc822",
+  "emma": "application/emma+xml",
+  "emotionml": "application/emotionml+xml",
+  "eps": "application/postscript",
+  "epub": "application/epub+zip",
+  "exe": "application/octet-stream",
+  "exi": "application/exi",
+  "exp": "application/express",
+  "exr": "image/aces",
+  "ez": "application/andrew-inset",
+  "fdf": "application/fdf",
+  "fdt": "application/fdt+xml",
+  "fits": "image/fits",
+  "g3": "image/g3fax",
+  "gbr": "application/rpki-ghostbusters",
+  "geojson": "application/geo+json",
+  "gif": "image/gif",
+  "glb": "model/gltf-binary",
+  "gltf": "model/gltf+json",
+  "gml": "application/gml+xml",
+  "gpx": "application/gpx+xml",
+  "gram": "application/srgs",
+  "grxml": "application/srgs+xml",
+  "gxf": "application/gxf",
+  "gz": "application/gzip",
+  "h261": "video/h261",
+  "h263": "video/h263",
+  "h264": "video/h264",
+  "heic": "image/heic",
+  "heics": "image/heic-sequence",
+  "heif": "image/heif",
+  "heifs": "image/heif-sequence",
+  "hej2": "image/hej2k",
+  "held": "application/atsc-held+xml",
+  "hjson": "application/hjson",
+  "hlp": "application/winhlp",
+  "hqx": "application/mac-binhex40",
+  "hsj2": "image/hsj2",
+  "htm": "text/html",
+  "html": "text/html",
+  "ics": "text/calendar",
+  "ief": "image/ief",
+  "ifb": "text/calendar",
+  "iges": "model/iges",
+  "igs": "model/iges",
+  "img": "application/octet-stream",
+  "in": "text/plain",
+  "ini": "text/plain",
+  "ink": "application/inkml+xml",
+  "inkml": "application/inkml+xml",
+  "ipfix": "application/ipfix",
+  "iso": "application/octet-stream",
+  "its": "application/its+xml",
+  "jade": "text/jade",
+  "jar": "application/java-archive",
+  "jhc": "image/jphc",
+  "jls": "image/jls",
+  "jp2": "image/jp2",
+  "jpe": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "jpf": "image/jpx",
+  "jpg": "image/jpeg",
+  "jpg2": "image/jp2",
+  "jpgm": "image/jpm",
+  "jpgv": "video/jpeg",
+  "jph": "image/jph",
+  "jpm": "image/jpm",
+  "jpx": "image/jpx",
+  "js": "text/javascript",
+  "json": "application/json",
+  "json5": "application/json5",
+  "jsonld": "application/ld+json",
+  "jsonml": "application/jsonml+json",
+  "jsx": "text/jsx",
+  "jt": "model/jt",
+  "jxr": "image/jxr",
+  "jxra": "image/jxra",
+  "jxrs": "image/jxrs",
+  "jxs": "image/jxs",
+  "jxsc": "image/jxsc",
+  "jxsi": "image/jxsi",
+  "jxss": "image/jxss",
+  "kar": "audio/midi",
+  "ktx": "image/ktx",
+  "ktx2": "image/ktx2",
+  "less": "text/less",
+  "lgr": "application/lgr+xml",
+  "list": "text/plain",
+  "litcoffee": "text/coffeescript",
+  "log": "text/plain",
+  "lostxml": "application/lost+xml",
+  "lrf": "application/octet-stream",
+  "m1v": "video/mpeg",
+  "m21": "application/mp21",
+  "m2a": "audio/mpeg",
+  "m2v": "video/mpeg",
+  "m3a": "audio/mpeg",
+  "m4a": "audio/mp4",
+  "m4p": "application/mp4",
+  "m4s": "video/iso.segment",
+  "ma": "application/mathematica",
+  "mads": "application/mads+xml",
+  "maei": "application/mmt-aei+xml",
+  "man": "text/troff",
+  "manifest": "text/cache-manifest",
+  "map": "application/json",
+  "mar": "application/octet-stream",
+  "markdown": "text/markdown",
+  "mathml": "application/mathml+xml",
+  "mb": "application/mathematica",
+  "mbox": "application/mbox",
+  "md": "text/markdown",
+  "mdx": "text/mdx",
+  "me": "text/troff",
+  "mesh": "model/mesh",
+  "meta4": "application/metalink4+xml",
+  "metalink": "application/metalink+xml",
+  "mets": "application/mets+xml",
+  "mft": "application/rpki-manifest",
+  "mid": "audio/midi",
+  "midi": "audio/midi",
+  "mime": "message/rfc822",
+  "mj2": "video/mj2",
+  "mjp2": "video/mj2",
+  "mjs": "text/javascript",
+  "mml": "text/mathml",
+  "mods": "application/mods+xml",
+  "mov": "video/quicktime",
+  "mp2": "audio/mpeg",
+  "mp21": "application/mp21",
+  "mp2a": "audio/mpeg",
+  "mp3": "audio/mpeg",
+  "mp4": "video/mp4",
+  "mp4a": "audio/mp4",
+  "mp4s": "application/mp4",
+  "mp4v": "video/mp4",
+  "mpd": "application/dash+xml",
+  "mpe": "video/mpeg",
+  "mpeg": "video/mpeg",
+  "mpf": "application/media-policy-dataset+xml",
+  "mpg": "video/mpeg",
+  "mpg4": "video/mp4",
+  "mpga": "audio/mpeg",
+  "mpp": "application/dash-patch+xml",
+  "mrc": "application/marc",
+  "mrcx": "application/marcxml+xml",
+  "ms": "text/troff",
+  "mscml": "application/mediaservercontrol+xml",
+  "msh": "model/mesh",
+  "msi": "application/octet-stream",
+  "msix": "application/msix",
+  "msixbundle": "application/msixbundle",
+  "msm": "application/octet-stream",
+  "msp": "application/octet-stream",
+  "mtl": "model/mtl",
+  "musd": "application/mmt-usd+xml",
+  "mxf": "application/mxf",
+  "mxmf": "audio/mobile-xmf",
+  "mxml": "application/xv+xml",
+  "n3": "text/n3",
+  "nb": "application/mathematica",
+  "nq": "application/n-quads",
+  "nt": "application/n-triples",
+  "obj": "model/obj",
+  "oda": "application/oda",
+  "oga": "audio/ogg",
+  "ogg": "audio/ogg",
+  "ogv": "video/ogg",
+  "ogx": "application/ogg",
+  "omdoc": "application/omdoc+xml",
+  "onepkg": "application/onenote",
+  "onetmp": "application/onenote",
+  "onetoc": "application/onenote",
+  "onetoc2": "application/onenote",
+  "opf": "application/oebps-package+xml",
+  "opus": "audio/ogg",
+  "otf": "font/otf",
+  "owl": "application/rdf+xml",
+  "oxps": "application/oxps",
+  "p10": "application/pkcs10",
+  "p7c": "application/pkcs7-mime",
+  "p7m": "application/pkcs7-mime",
+  "p7s": "application/pkcs7-signature",
+  "p8": "application/pkcs8",
+  "pdf": "application/pdf",
+  "pfr": "application/font-tdpfr",
+  "pgp": "application/pgp-encrypted",
+  "pkg": "application/octet-stream",
+  "pki": "application/pkixcmp",
+  "pkipath": "application/pkix-pkipath",
+  "pls": "application/pls+xml",
+  "png": "image/png",
+  "prc": "model/prc",
+  "prf": "application/pics-rules",
+  "provx": "application/provenance+xml",
+  "ps": "application/postscript",
+  "pskcxml": "application/pskc+xml",
+  "pti": "image/prs.pti",
+  "qt": "video/quicktime",
+  "raml": "application/raml+yaml",
+  "rapd": "application/route-apd+xml",
+  "rdf": "application/rdf+xml",
+  "relo": "application/p2p-overlay+xml",
+  "rif": "application/reginfo+xml",
+  "rl": "application/resource-lists+xml",
+  "rld": "application/resource-lists-diff+xml",
+  "rmi": "audio/midi",
+  "rnc": "application/relax-ng-compact-syntax",
+  "rng": "application/xml",
+  "roa": "application/rpki-roa",
+  "roff": "text/troff",
+  "rq": "application/sparql-query",
+  "rs": "application/rls-services+xml",
+  "rsat": "application/atsc-rsat+xml",
+  "rsd": "application/rsd+xml",
+  "rsheet": "application/urc-ressheet+xml",
+  "rss": "application/rss+xml",
+  "rtf": "text/rtf",
+  "rtx": "text/richtext",
+  "rusd": "application/route-usd+xml",
+  "s3m": "audio/s3m",
+  "sbml": "application/sbml+xml",
+  "scq": "application/scvp-cv-request",
+  "scs": "application/scvp-cv-response",
+  "sdp": "application/sdp",
+  "senmlx": "application/senml+xml",
+  "sensmlx": "application/sensml+xml",
+  "ser": "application/java-serialized-object",
+  "setpay": "application/set-payment-initiation",
+  "setreg": "application/set-registration-initiation",
+  "sgi": "image/sgi",
+  "sgm": "text/sgml",
+  "sgml": "text/sgml",
+  "shex": "text/shex",
+  "shf": "application/shf+xml",
+  "shtml": "text/html",
+  "sieve": "application/sieve",
+  "sig": "application/pgp-signature",
+  "sil": "audio/silk",
+  "silo": "model/mesh",
+  "siv": "application/sieve",
+  "slim": "text/slim",
+  "slm": "text/slim",
+  "sls": "application/route-s-tsid+xml",
+  "smi": "application/smil+xml",
+  "smil": "application/smil+xml",
+  "snd": "audio/basic",
+  "so": "application/octet-stream",
+  "spdx": "text/spdx",
+  "spp": "application/scvp-vp-response",
+  "spq": "application/scvp-vp-request",
+  "spx": "audio/ogg",
+  "sql": "application/sql",
+  "sru": "application/sru+xml",
+  "srx": "application/sparql-results+xml",
+  "ssdl": "application/ssdl+xml",
+  "ssml": "application/ssml+xml",
+  "stk": "application/hyperstudio",
+  "stl": "model/stl",
+  "stpx": "model/step+xml",
+  "stpxz": "model/step-xml+zip",
+  "stpz": "model/step+zip",
+  "styl": "text/stylus",
+  "stylus": "text/stylus",
+  "svg": "image/svg+xml",
+  "svgz": "image/svg+xml",
+  "swidtag": "application/swid+xml",
+  "t": "text/troff",
+  "t38": "image/t38",
+  "td": "application/urc-targetdesc+xml",
+  "tei": "application/tei+xml",
+  "teicorpus": "application/tei+xml",
+  "text": "text/plain",
+  "tfi": "application/thraud+xml",
+  "tfx": "image/tiff-fx",
+  "tif": "image/tiff",
+  "tiff": "image/tiff",
+  "toml": "application/toml",
+  "tr": "text/troff",
+  "trig": "application/trig",
+  "ts": "video/mp2t",
+  "tsd": "application/timestamped-data",
+  "tsv": "text/tab-separated-values",
+  "ttc": "font/collection",
+  "ttf": "font/ttf",
+  "ttl": "text/turtle",
+  "ttml": "application/ttml+xml",
+  "txt": "text/plain",
+  "u3d": "model/u3d",
+  "u8dsn": "message/global-delivery-status",
+  "u8hdr": "message/global-headers",
+  "u8mdn": "message/global-disposition-notification",
+  "u8msg": "message/global",
+  "ubj": "application/ubjson",
+  "uri": "text/uri-list",
+  "uris": "text/uri-list",
+  "urls": "text/uri-list",
+  "vcard": "text/vcard",
+  "vrml": "model/vrml",
+  "vtt": "text/vtt",
+  "vxml": "application/voicexml+xml",
+  "war": "application/java-archive",
+  "wasm": "application/wasm",
+  "wav": "audio/wav",
+  "weba": "audio/webm",
+  "webm": "video/webm",
+  "webmanifest": "application/manifest+json",
+  "webp": "image/webp",
+  "wgsl": "text/wgsl",
+  "wgt": "application/widget",
+  "wif": "application/watcherinfo+xml",
+  "wmf": "image/wmf",
+  "woff": "font/woff",
+  "woff2": "font/woff2",
+  "wrl": "model/vrml",
+  "wsdl": "application/wsdl+xml",
+  "wspolicy": "application/wspolicy+xml",
+  "x3d": "model/x3d+xml",
+  "x3db": "model/x3d+fastinfoset",
+  "x3dbz": "model/x3d+binary",
+  "x3dv": "model/x3d-vrml",
+  "x3dvz": "model/x3d+vrml",
+  "x3dz": "model/x3d+xml",
+  "xaml": "application/xaml+xml",
+  "xav": "application/xcap-att+xml",
+  "xca": "application/xcap-caps+xml",
+  "xcs": "application/calendar+xml",
+  "xdf": "application/xcap-diff+xml",
+  "xdssc": "application/dssc+xml",
+  "xel": "application/xcap-el+xml",
+  "xenc": "application/xenc+xml",
+  "xer": "application/patch-ops-error+xml",
+  "xfdf": "application/xfdf",
+  "xht": "application/xhtml+xml",
+  "xhtml": "application/xhtml+xml",
+  "xhvml": "application/xv+xml",
+  "xlf": "application/xliff+xml",
+  "xm": "audio/xm",
+  "xml": "text/xml",
+  "xns": "application/xcap-ns+xml",
+  "xop": "application/xop+xml",
+  "xpl": "application/xproc+xml",
+  "xsd": "application/xml",
+  "xsf": "application/prs.xsf+xml",
+  "xsl": "application/xml",
+  "xslt": "application/xml",
+  "xspf": "application/xspf+xml",
+  "xvm": "application/xv+xml",
+  "xvml": "application/xv+xml",
+  "yaml": "text/yaml",
+  "yang": "application/yang",
+  "yin": "application/yin+xml",
+  "yml": "text/yaml",
+  "zip": "application/zip"
+};
+
+function lookup(extn) {
+	let tmp = ('' + extn).trim().toLowerCase();
+	let idx = tmp.lastIndexOf('.');
+	return mimes[!~idx ? tmp : tmp.substring(++idx)];
+}
+
+const publicFilesMap = /* @__PURE__ */ new WeakMap();
+async function initPublicFiles(config) {
+  let fileNames;
+  try {
+    fileNames = await recursiveReaddir(config.publicDir);
+  } catch (e) {
+    if (e.code === ERR_SYMLINK_IN_RECURSIVE_READDIR) {
+      return;
+    }
+    throw e;
+  }
+  const publicFiles = new Set(
+    fileNames.map((fileName) => fileName.slice(config.publicDir.length))
+  );
+  publicFilesMap.set(config, publicFiles);
+  return publicFiles;
+}
+function getPublicFiles(config) {
+  return publicFilesMap.get(config);
+}
+function checkPublicFile(url, config) {
+  const { publicDir } = config;
+  if (!publicDir || url[0] !== "/") {
+    return;
+  }
+  const fileName = cleanUrl(url);
+  const publicFiles = getPublicFiles(config);
+  if (publicFiles) {
+    return publicFiles.has(fileName) ? normalizePath$3(path$n.join(publicDir, fileName)) : void 0;
+  }
+  const publicFile = normalizePath$3(path$n.join(publicDir, fileName));
+  if (!publicFile.startsWith(withTrailingSlash(publicDir))) {
+    return;
+  }
+  return fs__default.existsSync(publicFile) ? publicFile : void 0;
+}
+
+const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g;
+const jsSourceMapRE = /\.[cm]?js\.map$/;
+const assetCache = /* @__PURE__ */ new WeakMap();
+const generatedAssets = /* @__PURE__ */ new WeakMap();
+function registerCustomMime() {
+  mimes["ico"] = "image/x-icon";
+  mimes["flac"] = "audio/flac";
+  mimes["eot"] = "application/vnd.ms-fontobject";
+}
+function renderAssetUrlInJS(ctx, config, chunk, opts, code) {
+  const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(
+    opts.format,
+    config.isWorker
+  );
+  let match;
+  let s;
+  assetUrlRE.lastIndex = 0;
+  while (match = assetUrlRE.exec(code)) {
+    s ||= new MagicString(code);
+    const [full, referenceId, postfix = ""] = match;
+    const file = ctx.getFileName(referenceId);
+    chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+    const filename = file + postfix;
+    const replacement = toOutputFilePathInJS(
+      filename,
+      "asset",
+      chunk.fileName,
+      "js",
+      config,
+      toRelativeRuntime
+    );
+    const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+    s.update(match.index, match.index + full.length, replacementString);
+  }
+  const publicAssetUrlMap = publicAssetUrlCache.get(config);
+  publicAssetUrlRE.lastIndex = 0;
+  while (match = publicAssetUrlRE.exec(code)) {
+    s ||= new MagicString(code);
+    const [full, hash] = match;
+    const publicUrl = publicAssetUrlMap.get(hash).slice(1);
+    const replacement = toOutputFilePathInJS(
+      publicUrl,
+      "public",
+      chunk.fileName,
+      "js",
+      config,
+      toRelativeRuntime
+    );
+    const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+    s.update(match.index, match.index + full.length, replacementString);
+  }
+  return s;
+}
+function assetPlugin(config) {
+  registerCustomMime();
+  let moduleGraph;
+  return {
+    name: "vite:asset",
+    buildStart() {
+      assetCache.set(config, /* @__PURE__ */ new Map());
+      generatedAssets.set(config, /* @__PURE__ */ new Map());
+    },
+    configureServer(server) {
+      moduleGraph = server.moduleGraph;
+    },
+    resolveId(id) {
+      if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
+        return;
+      }
+      const publicFile = checkPublicFile(id, config);
+      if (publicFile) {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id[0] === "\0") {
+        return;
+      }
+      if (rawRE.test(id)) {
+        const file = checkPublicFile(id, config) || cleanUrl(id);
+        this.addWatchFile(file);
+        return `export default ${JSON.stringify(
+          await fsp.readFile(file, "utf-8")
+        )}`;
+      }
+      if (!urlRE.test(id) && !config.assetsInclude(cleanUrl(id))) {
+        return;
+      }
+      id = removeUrlQuery(id);
+      let url = await fileToUrl$1(id, config, this);
+      if (moduleGraph) {
+        const mod = moduleGraph.getModuleById(id);
+        if (mod && mod.lastHMRTimestamp > 0) {
+          url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+        }
+      }
+      return {
+        code: `export default ${JSON.stringify(encodeURIPath(url))}`,
+        // Force rollup to keep this module from being shared between other entry points if it's an entrypoint.
+        // If the resulting chunk is empty, it will be removed in generateBundle.
+        moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false,
+        meta: config.command === "build" ? { "vite:asset": true } : void 0
+      };
+    },
+    renderChunk(code, chunk, opts) {
+      const s = renderAssetUrlInJS(this, config, chunk, opts, code);
+      if (s) {
+        return {
+          code: s.toString(),
+          map: config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+        };
+      } else {
+        return null;
+      }
+    },
+    generateBundle(_, bundle) {
+      for (const file in bundle) {
+        const chunk = bundle[file];
+        if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) {
+          delete bundle[file];
+        }
+      }
+      if (config.command === "build" && config.build.ssr && !config.build.ssrEmitAssets) {
+        for (const file in bundle) {
+          if (bundle[file].type === "asset" && !file.endsWith("ssr-manifest.json") && !jsSourceMapRE.test(file)) {
+            delete bundle[file];
+          }
+        }
+      }
+    }
+  };
+}
+async function fileToUrl$1(id, config, ctx) {
+  if (config.command === "serve") {
+    return fileToDevUrl(id, config);
+  } else {
+    return fileToBuiltUrl(id, config, ctx);
+  }
+}
+function fileToDevUrl(id, config, skipBase = false) {
+  let rtn;
+  if (checkPublicFile(id, config)) {
+    rtn = id;
+  } else if (id.startsWith(withTrailingSlash(config.root))) {
+    rtn = "/" + path$n.posix.relative(config.root, id);
+  } else {
+    rtn = path$n.posix.join(FS_PREFIX, id);
+  }
+  if (skipBase) {
+    return rtn;
+  }
+  const base = joinUrlSegments(config.server?.origin ?? "", config.decodedBase);
+  return joinUrlSegments(base, removeLeadingSlash(rtn));
+}
+function getPublicAssetFilename(hash, config) {
+  return publicAssetUrlCache.get(config)?.get(hash);
+}
+const publicAssetUrlCache = /* @__PURE__ */ new WeakMap();
+const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g;
+function publicFileToBuiltUrl(url, config) {
+  if (config.command !== "build") {
+    return joinUrlSegments(config.decodedBase, url);
+  }
+  const hash = getHash(url);
+  let cache = publicAssetUrlCache.get(config);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    publicAssetUrlCache.set(config, cache);
+  }
+  if (!cache.get(hash)) {
+    cache.set(hash, url);
+  }
+  return `__VITE_PUBLIC_ASSET__${hash}__`;
+}
+const GIT_LFS_PREFIX = Buffer$1.from("version https://git-lfs.github.com");
+function isGitLfsPlaceholder(content) {
+  if (content.length < GIT_LFS_PREFIX.length) return false;
+  return GIT_LFS_PREFIX.compare(content, 0, GIT_LFS_PREFIX.length) === 0;
+}
+async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false, forceInline) {
+  if (!skipPublicCheck && checkPublicFile(id, config)) {
+    return publicFileToBuiltUrl(id, config);
+  }
+  const cache = assetCache.get(config);
+  const cached = cache.get(id);
+  if (cached) {
+    return cached;
+  }
+  const file = cleanUrl(id);
+  const content = await fsp.readFile(file);
+  let url;
+  if (shouldInline(config, file, id, content, pluginContext, forceInline)) {
+    if (config.build.lib && isGitLfsPlaceholder(content)) {
+      config.logger.warn(
+        colors$1.yellow(`Inlined file ${id} was not downloaded via Git LFS`)
+      );
+    }
+    if (file.endsWith(".svg")) {
+      url = svgToDataURL(content);
+    } else {
+      const mimeType = lookup(file) ?? "application/octet-stream";
+      url = `data:${mimeType};base64,${content.toString("base64")}`;
+    }
+  } else {
+    const { search, hash } = parse$h(id);
+    const postfix = (search || "") + (hash || "");
+    const originalFileName = normalizePath$3(path$n.relative(config.root, file));
+    const referenceId = pluginContext.emitFile({
+      type: "asset",
+      // Ignore directory structure for asset file names
+      name: path$n.basename(file),
+      originalFileName,
+      source: content
+    });
+    generatedAssets.get(config).set(referenceId, { originalFileName });
+    url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`;
+  }
+  cache.set(id, url);
+  return url;
+}
+async function urlToBuiltUrl(url, importer, config, pluginContext, forceInline) {
+  if (checkPublicFile(url, config)) {
+    return publicFileToBuiltUrl(url, config);
+  }
+  const file = url[0] === "/" ? path$n.join(config.root, url) : path$n.join(path$n.dirname(importer), url);
+  return fileToBuiltUrl(
+    file,
+    config,
+    pluginContext,
+    // skip public check since we just did it above
+    true,
+    forceInline
+  );
+}
+const shouldInline = (config, file, id, content, pluginContext, forceInline) => {
+  if (config.build.lib) return true;
+  if (pluginContext.getModuleInfo(id)?.isEntry) return false;
+  if (forceInline !== void 0) return forceInline;
+  let limit;
+  if (typeof config.build.assetsInlineLimit === "function") {
+    const userShouldInline = config.build.assetsInlineLimit(file, content);
+    if (userShouldInline != null) return userShouldInline;
+    limit = DEFAULT_ASSETS_INLINE_LIMIT;
+  } else {
+    limit = Number(config.build.assetsInlineLimit);
+  }
+  if (file.endsWith(".html")) return false;
+  if (file.endsWith(".svg") && id.includes("#")) return false;
+  return content.length < limit && !isGitLfsPlaceholder(content);
+};
+const nestedQuotesRE = /"[^"']*'[^"]*"|'[^'"]*"[^']*'/;
+function svgToDataURL(content) {
+  const stringContent = content.toString();
+  if (stringContent.includes("<text") || stringContent.includes("<foreignObject") || nestedQuotesRE.test(stringContent)) {
+    return `data:image/svg+xml;base64,${content.toString("base64")}`;
+  } else {
+    return "data:image/svg+xml," + stringContent.trim().replaceAll(/>\s+</g, "><").replaceAll('"', "'").replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("<", "%3c").replaceAll(">", "%3e").replaceAll(/\s+/g, "%20");
+  }
+}
+
+const endsWithJSRE = /\.[cm]?js$/;
+function manifestPlugin(config) {
+  const manifest = {};
+  let outputCount;
+  return {
+    name: "vite:manifest",
+    buildStart() {
+      outputCount = 0;
+    },
+    generateBundle({ format }, bundle) {
+      function getChunkName(chunk) {
+        return getChunkOriginalFileName(chunk, config.root, format);
+      }
+      function getInternalImports(imports) {
+        const filteredImports = [];
+        for (const file of imports) {
+          if (bundle[file] === void 0) {
+            continue;
+          }
+          filteredImports.push(getChunkName(bundle[file]));
+        }
+        return filteredImports;
+      }
+      function createChunk(chunk) {
+        const manifestChunk = {
+          file: chunk.fileName,
+          name: chunk.name
+        };
+        if (chunk.facadeModuleId) {
+          manifestChunk.src = getChunkName(chunk);
+        }
+        if (chunk.isEntry) {
+          manifestChunk.isEntry = true;
+        }
+        if (chunk.isDynamicEntry) {
+          manifestChunk.isDynamicEntry = true;
+        }
+        if (chunk.imports.length) {
+          const internalImports = getInternalImports(chunk.imports);
+          if (internalImports.length > 0) {
+            manifestChunk.imports = internalImports;
+          }
+        }
+        if (chunk.dynamicImports.length) {
+          const internalImports = getInternalImports(chunk.dynamicImports);
+          if (internalImports.length > 0) {
+            manifestChunk.dynamicImports = internalImports;
+          }
+        }
+        if (chunk.viteMetadata?.importedCss.size) {
+          manifestChunk.css = [...chunk.viteMetadata.importedCss];
+        }
+        if (chunk.viteMetadata?.importedAssets.size) {
+          manifestChunk.assets = [...chunk.viteMetadata.importedAssets];
+        }
+        return manifestChunk;
+      }
+      function createAsset(asset, src, isEntry) {
+        const manifestChunk = {
+          file: asset.fileName,
+          src
+        };
+        if (isEntry) manifestChunk.isEntry = true;
+        return manifestChunk;
+      }
+      const assets = generatedAssets.get(config);
+      const entryCssAssetFileNames = /* @__PURE__ */ new Set();
+      for (const [id, asset] of assets.entries()) {
+        if (asset.isEntry) {
+          try {
+            const fileName = this.getFileName(id);
+            entryCssAssetFileNames.add(fileName);
+          } catch (error) {
+            assets.delete(id);
+          }
+        }
+      }
+      const fileNameToAsset = /* @__PURE__ */ new Map();
+      for (const file in bundle) {
+        const chunk = bundle[file];
+        if (chunk.type === "chunk") {
+          manifest[getChunkName(chunk)] = createChunk(chunk);
+        } else if (chunk.type === "asset" && typeof chunk.name === "string") {
+          const src = chunk.originalFileName ?? chunk.name;
+          const isEntry = entryCssAssetFileNames.has(chunk.fileName);
+          const asset = createAsset(chunk, src, isEntry);
+          const file2 = manifest[src]?.file;
+          if (file2 && endsWithJSRE.test(file2)) continue;
+          manifest[src] = asset;
+          fileNameToAsset.set(chunk.fileName, asset);
+        }
+      }
+      for (const [referenceId, { originalFileName }] of assets.entries()) {
+        if (!manifest[originalFileName]) {
+          const fileName = this.getFileName(referenceId);
+          const asset = fileNameToAsset.get(fileName);
+          if (asset) {
+            manifest[originalFileName] = asset;
+          }
+        }
+      }
+      outputCount++;
+      const output = config.build.rollupOptions?.output;
+      const outputLength = Array.isArray(output) ? output.length : 1;
+      if (outputCount >= outputLength) {
+        this.emitFile({
+          fileName: typeof config.build.manifest === "string" ? config.build.manifest : ".vite/manifest.json",
+          type: "asset",
+          source: JSON.stringify(sortObjectKeys(manifest), void 0, 2)
+        });
+      }
+    }
+  };
+}
+function getChunkOriginalFileName(chunk, root, format) {
+  if (chunk.facadeModuleId) {
+    let name = normalizePath$3(path$n.relative(root, chunk.facadeModuleId));
+    if (format === "system" && !chunk.name.includes("-legacy")) {
+      const ext = path$n.extname(name);
+      const endPos = ext.length !== 0 ? -ext.length : void 0;
+      name = name.slice(0, endPos) + `-legacy` + ext;
+    }
+    return name.replace(/\0/g, "");
+  } else {
+    return `_` + path$n.basename(chunk.fileName);
+  }
+}
+
+const dataUriRE = /^([^/]+\/[^;,]+)(;base64)?,([\s\S]*)$/;
+const base64RE = /base64/i;
+const dataUriPrefix = `\0/@data-uri/`;
+function dataURIPlugin() {
+  let resolved;
+  return {
+    name: "vite:data-uri",
+    buildStart() {
+      resolved = /* @__PURE__ */ new Map();
+    },
+    resolveId(id) {
+      if (!dataUriRE.test(id)) {
+        return;
+      }
+      const uri = new URL$3(id);
+      if (uri.protocol !== "data:") {
+        return;
+      }
+      const match = dataUriRE.exec(uri.pathname);
+      if (!match) {
+        return;
+      }
+      const [, mime, format, data] = match;
+      if (mime !== "text/javascript") {
+        throw new Error(
+          `data URI with non-JavaScript mime type is not supported. If you're using legacy JavaScript MIME types (such as 'application/javascript'), please use 'text/javascript' instead.`
+        );
+      }
+      const base64 = format && base64RE.test(format.substring(1));
+      const content = base64 ? Buffer.from(data, "base64").toString("utf-8") : data;
+      resolved.set(id, content);
+      return dataUriPrefix + id;
+    },
+    load(id) {
+      if (id.startsWith(dataUriPrefix)) {
+        return resolved.get(id.slice(dataUriPrefix.length));
+      }
+    }
+  };
+}
+
+/* es-module-lexer 1.5.4 */
+var ImportType;!function(A){A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase";}(ImportType||(ImportType={}));const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse$d(E,g="@"){if(!C)return init.then((()=>parse$d(E)));const I=E.length+1,w=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;w>0&&C.memory.grow(Math.ceil(w/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const D=[],o=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),w=C.ss(),K=C.se();let o;C.ip()&&(o=k(E.slice(-1===I?A-1:A,-1===I?Q+1:Q))),D.push({n:o,t:B,s:A,e:Q,ss:w,se:K,d:I,a:g});}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),w=I[0],K=B<0?void 0:E.slice(B,g),D=K?K[0]:"";o.push({s:A,e:Q,ls:B,le:g,n:'"'===w||"'"===w?k(I):I,ln:'"'===D||"'"===D?k(K):K});}function k(A){try{return (0, eval)(A)}catch(A){}}return [D,o,!!C.f(),!!C.ms()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8;}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++);}let C;const init=WebAssembly.compile((E="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","undefined"!=typeof Buffer?Buffer.from(E,"base64"):Uint8Array.from(atob(E),(A=>A.charCodeAt(0))))).then(WebAssembly.instantiate).then((({exports:A})=>{C=A;}));var E;
+
+var convertSourceMap$1 = {};
+
+(function (exports) {
+
+	Object.defineProperty(exports, 'commentRegex', {
+	  get: function getCommentRegex () {
+	    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+	    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+	  }
+	});
+
+
+	Object.defineProperty(exports, 'mapFileCommentRegex', {
+	  get: function getMapFileCommentRegex () {
+	    // Matches sourceMappingURL in either // or /* comment styles.
+	    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+	  }
+	});
+
+	var decodeBase64;
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    decodeBase64 = decodeBase64WithBufferFrom;
+	  } else {
+	    decodeBase64 = decodeBase64WithNewBuffer;
+	  }
+	} else {
+	  decodeBase64 = decodeBase64WithAtob;
+	}
+
+	function decodeBase64WithBufferFrom(base64) {
+	  return Buffer.from(base64, 'base64').toString();
+	}
+
+	function decodeBase64WithNewBuffer(base64) {
+	  if (typeof value === 'number') {
+	    throw new TypeError('The value to decode must not be of type number.');
+	  }
+	  return new Buffer(base64, 'base64').toString();
+	}
+
+	function decodeBase64WithAtob(base64) {
+	  return decodeURIComponent(escape(atob(base64)));
+	}
+
+	function stripComment(sm) {
+	  return sm.split(',').pop();
+	}
+
+	function readFromFileMap(sm, read) {
+	  var r = exports.mapFileCommentRegex.exec(sm);
+	  // for some odd reason //# .. captures in 1 and /* .. */ in 2
+	  var filename = r[1] || r[2];
+
+	  try {
+	    var sm = read(filename);
+	    if (sm != null && typeof sm.catch === 'function') {
+	      return sm.catch(throwError);
+	    } else {
+	      return sm;
+	    }
+	  } catch (e) {
+	    throwError(e);
+	  }
+
+	  function throwError(e) {
+	    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+	  }
+	}
+
+	function Converter (sm, opts) {
+	  opts = opts || {};
+
+	  if (opts.hasComment) {
+	    sm = stripComment(sm);
+	  }
+
+	  if (opts.encoding === 'base64') {
+	    sm = decodeBase64(sm);
+	  } else if (opts.encoding === 'uri') {
+	    sm = decodeURIComponent(sm);
+	  }
+
+	  if (opts.isJSON || opts.encoding) {
+	    sm = JSON.parse(sm);
+	  }
+
+	  this.sourcemap = sm;
+	}
+
+	Converter.prototype.toJSON = function (space) {
+	  return JSON.stringify(this.sourcemap, null, space);
+	};
+
+	if (typeof Buffer !== 'undefined') {
+	  if (typeof Buffer.from === 'function') {
+	    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+	  } else {
+	    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+	  }
+	} else {
+	  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+	}
+
+	function encodeBase64WithBufferFrom() {
+	  var json = this.toJSON();
+	  return Buffer.from(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithNewBuffer() {
+	  var json = this.toJSON();
+	  if (typeof json === 'number') {
+	    throw new TypeError('The json to encode must not be of type number.');
+	  }
+	  return new Buffer(json, 'utf8').toString('base64');
+	}
+
+	function encodeBase64WithBtoa() {
+	  var json = this.toJSON();
+	  return btoa(unescape(encodeURIComponent(json)));
+	}
+
+	Converter.prototype.toURI = function () {
+	  var json = this.toJSON();
+	  return encodeURIComponent(json);
+	};
+
+	Converter.prototype.toComment = function (options) {
+	  var encoding, content, data;
+	  if (options != null && options.encoding === 'uri') {
+	    encoding = '';
+	    content = this.toURI();
+	  } else {
+	    encoding = ';base64';
+	    content = this.toBase64();
+	  }
+	  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+	  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+	};
+
+	// returns copy instead of original
+	Converter.prototype.toObject = function () {
+	  return JSON.parse(this.toJSON());
+	};
+
+	Converter.prototype.addProperty = function (key, value) {
+	  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+	  return this.setProperty(key, value);
+	};
+
+	Converter.prototype.setProperty = function (key, value) {
+	  this.sourcemap[key] = value;
+	  return this;
+	};
+
+	Converter.prototype.getProperty = function (key) {
+	  return this.sourcemap[key];
+	};
+
+	exports.fromObject = function (obj) {
+	  return new Converter(obj);
+	};
+
+	exports.fromJSON = function (json) {
+	  return new Converter(json, { isJSON: true });
+	};
+
+	exports.fromURI = function (uri) {
+	  return new Converter(uri, { encoding: 'uri' });
+	};
+
+	exports.fromBase64 = function (base64) {
+	  return new Converter(base64, { encoding: 'base64' });
+	};
+
+	exports.fromComment = function (comment) {
+	  var m, encoding;
+	  comment = comment
+	    .replace(/^\/\*/g, '//')
+	    .replace(/\*\/$/g, '');
+	  m = exports.commentRegex.exec(comment);
+	  encoding = m && m[4] || 'uri';
+	  return new Converter(comment, { encoding: encoding, hasComment: true });
+	};
+
+	function makeConverter(sm) {
+	  return new Converter(sm, { isJSON: true });
+	}
+
+	exports.fromMapFileComment = function (comment, read) {
+	  if (typeof read === 'string') {
+	    throw new Error(
+	      'String directory paths are no longer supported with `fromMapFileComment`\n' +
+	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+	    )
+	  }
+
+	  var sm = readFromFileMap(comment, read);
+	  if (sm != null && typeof sm.then === 'function') {
+	    return sm.then(makeConverter);
+	  } else {
+	    return makeConverter(sm);
+	  }
+	};
+
+	// Finds last sourcemap comment in file or returns null if none was found
+	exports.fromSource = function (content) {
+	  var m = content.match(exports.commentRegex);
+	  return m ? exports.fromComment(m.pop()) : null;
+	};
+
+	// Finds last sourcemap comment in file or returns null if none was found
+	exports.fromMapFileSource = function (content, read) {
+	  if (typeof read === 'string') {
+	    throw new Error(
+	      'String directory paths are no longer supported with `fromMapFileSource`\n' +
+	      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+	    )
+	  }
+	  var m = content.match(exports.mapFileCommentRegex);
+	  return m ? exports.fromMapFileComment(m.pop(), read) : null;
+	};
+
+	exports.removeComments = function (src) {
+	  return src.replace(exports.commentRegex, '');
+	};
+
+	exports.removeMapFileComments = function (src) {
+	  return src.replace(exports.mapFileCommentRegex, '');
+	};
+
+	exports.generateMapFileComment = function (file, options) {
+	  var data = 'sourceMappingURL=' + file;
+	  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+	}; 
+} (convertSourceMap$1));
+
+var convertSourceMap = /*@__PURE__*/getDefaultExportFromCjs(convertSourceMap$1);
+
+const debug$g = createDebugger("vite:sourcemap", {
+  onlyWhenFocused: true
+});
+const virtualSourceRE = /^(?:dep:|browser-external:|virtual:)|\0/;
+async function computeSourceRoute(map, file) {
+  let sourceRoot;
+  try {
+    sourceRoot = await fsp.realpath(
+      path$n.resolve(path$n.dirname(file), map.sourceRoot || "")
+    );
+  } catch {
+  }
+  return sourceRoot;
+}
+async function injectSourcesContent(map, file, logger) {
+  let sourceRootPromise;
+  const missingSources = [];
+  const sourcesContent = map.sourcesContent || [];
+  const sourcesContentPromises = [];
+  for (let index = 0; index < map.sources.length; index++) {
+    const sourcePath = map.sources[index];
+    if (sourcesContent[index] == null && sourcePath && !virtualSourceRE.test(sourcePath)) {
+      sourcesContentPromises.push(
+        (async () => {
+          sourceRootPromise ??= computeSourceRoute(map, file);
+          const sourceRoot = await sourceRootPromise;
+          let resolvedSourcePath = cleanUrl(decodeURI(sourcePath));
+          if (sourceRoot) {
+            resolvedSourcePath = path$n.resolve(sourceRoot, resolvedSourcePath);
+          }
+          sourcesContent[index] = await fsp.readFile(resolvedSourcePath, "utf-8").catch(() => {
+            missingSources.push(resolvedSourcePath);
+            return null;
+          });
+        })()
+      );
+    }
+  }
+  await Promise.all(sourcesContentPromises);
+  map.sourcesContent = sourcesContent;
+  if (missingSources.length) {
+    logger.warnOnce(`Sourcemap for "${file}" points to missing source files`);
+    debug$g?.(`Missing sources:
+  ` + missingSources.join(`
+  `));
+  }
+}
+function genSourceMapUrl(map) {
+  if (typeof map !== "string") {
+    map = JSON.stringify(map);
+  }
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getCodeWithSourcemap(type, code, map) {
+  if (debug$g) {
+    code += `
+/*${JSON.stringify(map, null, 2).replace(/\*\//g, "*\\/")}*/
+`;
+  }
+  if (type === "js") {
+    code += `
+//# sourceMappingURL=${genSourceMapUrl(map)}`;
+  } else if (type === "css") {
+    code += `
+/*# sourceMappingURL=${genSourceMapUrl(map)} */`;
+  }
+  return code;
+}
+function applySourcemapIgnoreList(map, sourcemapPath, sourcemapIgnoreList, logger) {
+  let { x_google_ignoreList } = map;
+  if (x_google_ignoreList === void 0) {
+    x_google_ignoreList = [];
+  }
+  for (let sourcesIndex = 0; sourcesIndex < map.sources.length; ++sourcesIndex) {
+    const sourcePath = map.sources[sourcesIndex];
+    if (!sourcePath) continue;
+    const ignoreList = sourcemapIgnoreList(
+      path$n.isAbsolute(sourcePath) ? sourcePath : path$n.resolve(path$n.dirname(sourcemapPath), sourcePath),
+      sourcemapPath
+    );
+    if (logger && typeof ignoreList !== "boolean") {
+      logger.warn("sourcemapIgnoreList function must return a boolean.");
+    }
+    if (ignoreList && !x_google_ignoreList.includes(sourcesIndex)) {
+      x_google_ignoreList.push(sourcesIndex);
+    }
+  }
+  if (x_google_ignoreList.length > 0) {
+    if (!map.x_google_ignoreList) map.x_google_ignoreList = x_google_ignoreList;
+  }
+}
+async function extractSourcemapFromFile(code, filePath) {
+  const map = (convertSourceMap.fromSource(code) || await convertSourceMap.fromMapFileSource(
+    code,
+    createConvertSourceMapReadMap(filePath)
+  ))?.toObject();
+  if (map) {
+    return {
+      code: code.replace(convertSourceMap.mapFileCommentRegex, blankReplacer),
+      map
+    };
+  }
+}
+function createConvertSourceMapReadMap(originalFileName) {
+  return (filename) => {
+    return fsp.readFile(
+      path$n.resolve(path$n.dirname(originalFileName), filename),
+      "utf-8"
+    );
+  };
+}
+
+var tasks = {};
+
+var utils$g = {};
+
+var array$1 = {};
+
+Object.defineProperty(array$1, "__esModule", { value: true });
+array$1.splitWhen = array$1.flatten = void 0;
+function flatten$1(items) {
+    return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+array$1.flatten = flatten$1;
+function splitWhen(items, predicate) {
+    const result = [[]];
+    let groupIndex = 0;
+    for (const item of items) {
+        if (predicate(item)) {
+            groupIndex++;
+            result[groupIndex] = [];
+        }
+        else {
+            result[groupIndex].push(item);
+        }
+    }
+    return result;
+}
+array$1.splitWhen = splitWhen;
+
+var errno$1 = {};
+
+Object.defineProperty(errno$1, "__esModule", { value: true });
+errno$1.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+}
+errno$1.isEnoentCodeError = isEnoentCodeError;
+
+var fs$i = {};
+
+Object.defineProperty(fs$i, "__esModule", { value: true });
+fs$i.createDirentFromStats = void 0;
+let DirentFromStats$1 = class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+};
+function createDirentFromStats$1(name, stats) {
+    return new DirentFromStats$1(name, stats);
+}
+fs$i.createDirentFromStats = createDirentFromStats$1;
+
+var path$i = {};
+
+Object.defineProperty(path$i, "__esModule", { value: true });
+path$i.convertPosixPathToPattern = path$i.convertWindowsPathToPattern = path$i.convertPathToPattern = path$i.escapePosixPath = path$i.escapeWindowsPath = path$i.escape = path$i.removeLeadingDotSegment = path$i.makeAbsolute = path$i.unixify = void 0;
+const os$4 = require$$2;
+const path$h = require$$0$4;
+const IS_WINDOWS_PLATFORM = os$4.platform() === 'win32';
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+/**
+ * All non-escaped special characters.
+ * Posix: ()*?[]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
+ * Windows: (){}[], !+@ before (, ! at the beginning.
+ */
+const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
+/**
+ * The device path (\\.\ or \\?\).
+ * https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
+ */
+const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
+/**
+ * All backslashes except those escaping special characters.
+ * Windows: !()+@{}
+ * https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+ */
+const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+function unixify(filepath) {
+    return filepath.replace(/\\/g, '/');
+}
+path$i.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+    return path$h.resolve(cwd, filepath);
+}
+path$i.makeAbsolute = makeAbsolute;
+function removeLeadingDotSegment(entry) {
+    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+    if (entry.charAt(0) === '.') {
+        const secondCharactery = entry.charAt(1);
+        if (secondCharactery === '/' || secondCharactery === '\\') {
+            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+        }
+    }
+    return entry;
+}
+path$i.removeLeadingDotSegment = removeLeadingDotSegment;
+path$i.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+function escapeWindowsPath(pattern) {
+    return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$i.escapeWindowsPath = escapeWindowsPath;
+function escapePosixPath(pattern) {
+    return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$i.escapePosixPath = escapePosixPath;
+path$i.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath)
+        .replace(DOS_DEVICE_PATH_RE, '//$1')
+        .replace(WINDOWS_BACKSLASHES_RE, '/');
+}
+path$i.convertWindowsPathToPattern = convertWindowsPathToPattern;
+function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+}
+path$i.convertPosixPathToPattern = convertPosixPathToPattern;
+
+var pattern$1 = {};
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob$1 = function isExtglob(str) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  var match;
+  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+    if (match[2]) return true;
+    str = str.slice(match.index + match[0].length);
+  }
+
+  return false;
+};
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isExtglob = isExtglob$1;
+var chars = { '{': '}', '(': ')', '[': ']'};
+var strictCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  var pipeIndex = -2;
+  var closeSquareIndex = -2;
+  var closeCurlyIndex = -2;
+  var closeParenIndex = -2;
+  var backSlashIndex = -2;
+  while (index < str.length) {
+    if (str[index] === '*') {
+      return true;
+    }
+
+    if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) {
+      return true;
+    }
+
+    if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') {
+      if (closeSquareIndex < index) {
+        closeSquareIndex = str.indexOf(']', index);
+      }
+      if (closeSquareIndex > index) {
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') {
+      closeCurlyIndex = str.indexOf('}', index);
+      if (closeCurlyIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') {
+      closeParenIndex = str.indexOf(')', index);
+      if (closeParenIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+      if (pipeIndex < index) {
+        pipeIndex = str.indexOf('|', index);
+      }
+      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+        closeParenIndex = str.indexOf(')', pipeIndex);
+        if (closeParenIndex > pipeIndex) {
+          backSlashIndex = str.indexOf('\\', pipeIndex);
+          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+            return true;
+          }
+        }
+      }
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var relaxedCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  while (index < str.length) {
+    if (/[*?{}()[\]]/.test(str[index])) {
+      return true;
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var isGlob$2 = function isGlob(str, options) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  if (isExtglob(str)) {
+    return true;
+  }
+
+  var check = strictCheck;
+
+  // optionally relax check
+  if (options && options.strict === false) {
+    check = relaxedCheck;
+  }
+
+  return check(str);
+};
+
+var isGlob$1 = isGlob$2;
+var pathPosixDirname = require$$0$4.posix.dirname;
+var isWin32 = require$$2.platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+var globParent$2 = function globParent(str, opts) {
+  var options = Object.assign({ flipBackslashes: true }, opts);
+
+  // flip windows path separators
+  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+    str = str.replace(backslash, slash);
+  }
+
+  // special case for strings ending in enclosure containing path separator
+  if (enclosure.test(str)) {
+    str += slash;
+  }
+
+  // preserves full path in case of trailing path separator
+  str += 'a';
+
+  // remove path parts that are globby
+  do {
+    str = pathPosixDirname(str);
+  } while (isGlob$1(str) || globby.test(str));
+
+  // remove escape chars and return result
+  return str.replace(escaped, '$1');
+};
+
+var utils$f = {};
+
+(function (exports) {
+
+	exports.isInteger = num => {
+	  if (typeof num === 'number') {
+	    return Number.isInteger(num);
+	  }
+	  if (typeof num === 'string' && num.trim() !== '') {
+	    return Number.isInteger(Number(num));
+	  }
+	  return false;
+	};
+
+	/**
+	 * Find a node of the given type
+	 */
+
+	exports.find = (node, type) => node.nodes.find(node => node.type === type);
+
+	/**
+	 * Find a node of the given type
+	 */
+
+	exports.exceedsLimit = (min, max, step = 1, limit) => {
+	  if (limit === false) return false;
+	  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+	  return ((Number(max) - Number(min)) / Number(step)) >= limit;
+	};
+
+	/**
+	 * Escape the given node with '\\' before node.value
+	 */
+
+	exports.escapeNode = (block, n = 0, type) => {
+	  const node = block.nodes[n];
+	  if (!node) return;
+
+	  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
+	    if (node.escaped !== true) {
+	      node.value = '\\' + node.value;
+	      node.escaped = true;
+	    }
+	  }
+	};
+
+	/**
+	 * Returns true if the given brace node should be enclosed in literal braces
+	 */
+
+	exports.encloseBrace = node => {
+	  if (node.type !== 'brace') return false;
+	  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
+	    node.invalid = true;
+	    return true;
+	  }
+	  return false;
+	};
+
+	/**
+	 * Returns true if a brace node is invalid.
+	 */
+
+	exports.isInvalidBrace = block => {
+	  if (block.type !== 'brace') return false;
+	  if (block.invalid === true || block.dollar) return true;
+	  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
+	    block.invalid = true;
+	    return true;
+	  }
+	  if (block.open !== true || block.close !== true) {
+	    block.invalid = true;
+	    return true;
+	  }
+	  return false;
+	};
+
+	/**
+	 * Returns true if a node is an open or close node
+	 */
+
+	exports.isOpenOrClose = node => {
+	  if (node.type === 'open' || node.type === 'close') {
+	    return true;
+	  }
+	  return node.open === true || node.close === true;
+	};
+
+	/**
+	 * Reduce an array of text nodes.
+	 */
+
+	exports.reduce = nodes => nodes.reduce((acc, node) => {
+	  if (node.type === 'text') acc.push(node.value);
+	  if (node.type === 'range') node.type = 'text';
+	  return acc;
+	}, []);
+
+	/**
+	 * Flatten an array
+	 */
+
+	exports.flatten = (...args) => {
+	  const result = [];
+
+	  const flat = arr => {
+	    for (let i = 0; i < arr.length; i++) {
+	      const ele = arr[i];
+
+	      if (Array.isArray(ele)) {
+	        flat(ele);
+	        continue;
+	      }
+
+	      if (ele !== undefined) {
+	        result.push(ele);
+	      }
+	    }
+	    return result;
+	  };
+
+	  flat(args);
+	  return result;
+	}; 
+} (utils$f));
+
+const utils$e = utils$f;
+
+var stringify$7 = (ast, options = {}) => {
+  const stringify = (node, parent = {}) => {
+    const invalidBlock = options.escapeInvalid && utils$e.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+    let output = '';
+
+    if (node.value) {
+      if ((invalidBlock || invalidNode) && utils$e.isOpenOrClose(node)) {
+        return '\\' + node.value;
+      }
+      return node.value;
+    }
+
+    if (node.value) {
+      return node.value;
+    }
+
+    if (node.nodes) {
+      for (const child of node.nodes) {
+        output += stringify(child);
+      }
+    }
+    return output;
+  };
+
+  return stringify(ast);
+};
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isNumber$2 = function(num) {
+  if (typeof num === 'number') {
+    return num - num === 0;
+  }
+  if (typeof num === 'string' && num.trim() !== '') {
+    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+  }
+  return false;
+};
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+const isNumber$1 = isNumber$2;
+
+const toRegexRange$1 = (min, max, options) => {
+  if (isNumber$1(min) === false) {
+    throw new TypeError('toRegexRange: expected the first argument to be a number');
+  }
+
+  if (max === void 0 || min === max) {
+    return String(min);
+  }
+
+  if (isNumber$1(max) === false) {
+    throw new TypeError('toRegexRange: expected the second argument to be a number.');
+  }
+
+  let opts = { relaxZeros: true, ...options };
+  if (typeof opts.strictZeros === 'boolean') {
+    opts.relaxZeros = opts.strictZeros === false;
+  }
+
+  let relax = String(opts.relaxZeros);
+  let shorthand = String(opts.shorthand);
+  let capture = String(opts.capture);
+  let wrap = String(opts.wrap);
+  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+
+  if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) {
+    return toRegexRange$1.cache[cacheKey].result;
+  }
+
+  let a = Math.min(min, max);
+  let b = Math.max(min, max);
+
+  if (Math.abs(a - b) === 1) {
+    let result = min + '|' + max;
+    if (opts.capture) {
+      return `(${result})`;
+    }
+    if (opts.wrap === false) {
+      return result;
+    }
+    return `(?:${result})`;
+  }
+
+  let isPadded = hasPadding(min) || hasPadding(max);
+  let state = { min, max, a, b };
+  let positives = [];
+  let negatives = [];
+
+  if (isPadded) {
+    state.isPadded = isPadded;
+    state.maxLen = String(state.max).length;
+  }
+
+  if (a < 0) {
+    let newMin = b < 0 ? Math.abs(b) : 1;
+    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+    a = state.a = 0;
+  }
+
+  if (b >= 0) {
+    positives = splitToPatterns(a, b, state, opts);
+  }
+
+  state.negatives = negatives;
+  state.positives = positives;
+  state.result = collatePatterns(negatives, positives);
+
+  if (opts.capture === true) {
+    state.result = `(${state.result})`;
+  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
+    state.result = `(?:${state.result})`;
+  }
+
+  toRegexRange$1.cache[cacheKey] = state;
+  return state.result;
+};
+
+function collatePatterns(neg, pos, options) {
+  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
+  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
+  let intersected = filterPatterns(neg, pos, '-?', true) || [];
+  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+  return subpatterns.join('|');
+}
+
+function splitToRanges(min, max) {
+  let nines = 1;
+  let zeros = 1;
+
+  let stop = countNines(min, nines);
+  let stops = new Set([max]);
+
+  while (min <= stop && stop <= max) {
+    stops.add(stop);
+    nines += 1;
+    stop = countNines(min, nines);
+  }
+
+  stop = countZeros(max + 1, zeros) - 1;
+
+  while (min < stop && stop <= max) {
+    stops.add(stop);
+    zeros += 1;
+    stop = countZeros(max + 1, zeros) - 1;
+  }
+
+  stops = [...stops];
+  stops.sort(compare);
+  return stops;
+}
+
+/**
+ * Convert a range to a regex pattern
+ * @param {Number} `start`
+ * @param {Number} `stop`
+ * @return {String}
+ */
+
+function rangeToPattern(start, stop, options) {
+  if (start === stop) {
+    return { pattern: start, count: [], digits: 0 };
+  }
+
+  let zipped = zip(start, stop);
+  let digits = zipped.length;
+  let pattern = '';
+  let count = 0;
+
+  for (let i = 0; i < digits; i++) {
+    let [startDigit, stopDigit] = zipped[i];
+
+    if (startDigit === stopDigit) {
+      pattern += startDigit;
+
+    } else if (startDigit !== '0' || stopDigit !== '9') {
+      pattern += toCharacterClass(startDigit, stopDigit);
+
+    } else {
+      count++;
+    }
+  }
+
+  if (count) {
+    pattern += options.shorthand === true ? '\\d' : '[0-9]';
+  }
+
+  return { pattern, count: [count], digits };
+}
+
+function splitToPatterns(min, max, tok, options) {
+  let ranges = splitToRanges(min, max);
+  let tokens = [];
+  let start = min;
+  let prev;
+
+  for (let i = 0; i < ranges.length; i++) {
+    let max = ranges[i];
+    let obj = rangeToPattern(String(start), String(max), options);
+    let zeros = '';
+
+    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+      if (prev.count.length > 1) {
+        prev.count.pop();
+      }
+
+      prev.count.push(obj.count[0]);
+      prev.string = prev.pattern + toQuantifier(prev.count);
+      start = max + 1;
+      continue;
+    }
+
+    if (tok.isPadded) {
+      zeros = padZeros(max, tok, options);
+    }
+
+    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+    tokens.push(obj);
+    start = max + 1;
+    prev = obj;
+  }
+
+  return tokens;
+}
+
+function filterPatterns(arr, comparison, prefix, intersection, options) {
+  let result = [];
+
+  for (let ele of arr) {
+    let { string } = ele;
+
+    // only push if _both_ are negative...
+    if (!intersection && !contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+
+    // or _both_ are positive
+    if (intersection && contains(comparison, 'string', string)) {
+      result.push(prefix + string);
+    }
+  }
+  return result;
+}
+
+/**
+ * Zip strings
+ */
+
+function zip(a, b) {
+  let arr = [];
+  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
+  return arr;
+}
+
+function compare(a, b) {
+  return a > b ? 1 : b > a ? -1 : 0;
+}
+
+function contains(arr, key, val) {
+  return arr.some(ele => ele[key] === val);
+}
+
+function countNines(min, len) {
+  return Number(String(min).slice(0, -len) + '9'.repeat(len));
+}
+
+function countZeros(integer, zeros) {
+  return integer - (integer % Math.pow(10, zeros));
+}
+
+function toQuantifier(digits) {
+  let [start = 0, stop = ''] = digits;
+  if (stop || start > 1) {
+    return `{${start + (stop ? ',' + stop : '')}}`;
+  }
+  return '';
+}
+
+function toCharacterClass(a, b, options) {
+  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
+}
+
+function hasPadding(str) {
+  return /^-?(0+)\d/.test(str);
+}
+
+function padZeros(value, tok, options) {
+  if (!tok.isPadded) {
+    return value;
+  }
+
+  let diff = Math.abs(tok.maxLen - String(value).length);
+  let relax = options.relaxZeros !== false;
+
+  switch (diff) {
+    case 0:
+      return '';
+    case 1:
+      return relax ? '0?' : '0';
+    case 2:
+      return relax ? '0{0,2}' : '00';
+    default: {
+      return relax ? `0{0,${diff}}` : `0{${diff}}`;
+    }
+  }
+}
+
+/**
+ * Cache
+ */
+
+toRegexRange$1.cache = {};
+toRegexRange$1.clearCache = () => (toRegexRange$1.cache = {});
+
+/**
+ * Expose `toRegexRange`
+ */
+
+var toRegexRange_1 = toRegexRange$1;
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+const util$1 = require$$0$5;
+const toRegexRange = toRegexRange_1;
+
+const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+
+const transform = toNumber => {
+  return value => toNumber === true ? Number(value) : String(value);
+};
+
+const isValidValue = value => {
+  return typeof value === 'number' || (typeof value === 'string' && value !== '');
+};
+
+const isNumber = num => Number.isInteger(+num);
+
+const zeros = input => {
+  let value = `${input}`;
+  let index = -1;
+  if (value[0] === '-') value = value.slice(1);
+  if (value === '0') return false;
+  while (value[++index] === '0');
+  return index > 0;
+};
+
+const stringify$6 = (start, end, options) => {
+  if (typeof start === 'string' || typeof end === 'string') {
+    return true;
+  }
+  return options.stringify === true;
+};
+
+const pad = (input, maxLength, toNumber) => {
+  if (maxLength > 0) {
+    let dash = input[0] === '-' ? '-' : '';
+    if (dash) input = input.slice(1);
+    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
+  }
+  if (toNumber === false) {
+    return String(input);
+  }
+  return input;
+};
+
+const toMaxLen = (input, maxLength) => {
+  let negative = input[0] === '-' ? '-' : '';
+  if (negative) {
+    input = input.slice(1);
+    maxLength--;
+  }
+  while (input.length < maxLength) input = '0' + input;
+  return negative ? ('-' + input) : input;
+};
+
+const toSequence = (parts, options, maxLen) => {
+  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+
+  let prefix = options.capture ? '' : '?:';
+  let positives = '';
+  let negatives = '';
+  let result;
+
+  if (parts.positives.length) {
+    positives = parts.positives.map(v => toMaxLen(String(v), maxLen)).join('|');
+  }
+
+  if (parts.negatives.length) {
+    negatives = `-(${prefix}${parts.negatives.map(v => toMaxLen(String(v), maxLen)).join('|')})`;
+  }
+
+  if (positives && negatives) {
+    result = `${positives}|${negatives}`;
+  } else {
+    result = positives || negatives;
+  }
+
+  if (options.wrap) {
+    return `(${prefix}${result})`;
+  }
+
+  return result;
+};
+
+const toRange = (a, b, isNumbers, options) => {
+  if (isNumbers) {
+    return toRegexRange(a, b, { wrap: false, ...options });
+  }
+
+  let start = String.fromCharCode(a);
+  if (a === b) return start;
+
+  let stop = String.fromCharCode(b);
+  return `[${start}-${stop}]`;
+};
+
+const toRegex = (start, end, options) => {
+  if (Array.isArray(start)) {
+    let wrap = options.wrap === true;
+    let prefix = options.capture ? '' : '?:';
+    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+  }
+  return toRegexRange(start, end, options);
+};
+
+const rangeError = (...args) => {
+  return new RangeError('Invalid range arguments: ' + util$1.inspect(...args));
+};
+
+const invalidRange = (start, end, options) => {
+  if (options.strictRanges === true) throw rangeError([start, end]);
+  return [];
+};
+
+const invalidStep = (step, options) => {
+  if (options.strictRanges === true) {
+    throw new TypeError(`Expected step "${step}" to be a number`);
+  }
+  return [];
+};
+
+const fillNumbers = (start, end, step = 1, options = {}) => {
+  let a = Number(start);
+  let b = Number(end);
+
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    if (options.strictRanges === true) throw rangeError([start, end]);
+    return [];
+  }
+
+  // fix negative zero
+  if (a === 0) a = 0;
+  if (b === 0) b = 0;
+
+  let descending = a > b;
+  let startString = String(start);
+  let endString = String(end);
+  let stepString = String(step);
+  step = Math.max(Math.abs(step), 1);
+
+  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+  let toNumber = padded === false && stringify$6(start, end, options) === false;
+  let format = options.transform || transform(toNumber);
+
+  if (options.toRegex && step === 1) {
+    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+  }
+
+  let parts = { negatives: [], positives: [] };
+  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    if (options.toRegex === true && step > 1) {
+      push(a);
+    } else {
+      range.push(pad(format(a, index), maxLen, toNumber));
+    }
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return step > 1
+      ? toSequence(parts, options, maxLen)
+      : toRegex(range, null, { wrap: false, ...options });
+  }
+
+  return range;
+};
+
+const fillLetters = (start, end, step = 1, options = {}) => {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
+    return invalidRange(start, end, options);
+  }
+
+  let format = options.transform || (val => String.fromCharCode(val));
+  let a = `${start}`.charCodeAt(0);
+  let b = `${end}`.charCodeAt(0);
+
+  let descending = a > b;
+  let min = Math.min(a, b);
+  let max = Math.max(a, b);
+
+  if (options.toRegex && step === 1) {
+    return toRange(min, max, false, options);
+  }
+
+  let range = [];
+  let index = 0;
+
+  while (descending ? a >= b : a <= b) {
+    range.push(format(a, index));
+    a = descending ? a - step : a + step;
+    index++;
+  }
+
+  if (options.toRegex === true) {
+    return toRegex(range, null, { wrap: false, options });
+  }
+
+  return range;
+};
+
+const fill$2 = (start, end, step, options = {}) => {
+  if (end == null && isValidValue(start)) {
+    return [start];
+  }
+
+  if (!isValidValue(start) || !isValidValue(end)) {
+    return invalidRange(start, end, options);
+  }
+
+  if (typeof step === 'function') {
+    return fill$2(start, end, 1, { transform: step });
+  }
+
+  if (isObject(step)) {
+    return fill$2(start, end, 0, step);
+  }
+
+  let opts = { ...options };
+  if (opts.capture === true) opts.wrap = true;
+  step = step || opts.step || 1;
+
+  if (!isNumber(step)) {
+    if (step != null && !isObject(step)) return invalidStep(step, opts);
+    return fill$2(start, end, 1, step);
+  }
+
+  if (isNumber(start) && isNumber(end)) {
+    return fillNumbers(start, end, step, opts);
+  }
+
+  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+};
+
+var fillRange = fill$2;
+
+const fill$1 = fillRange;
+const utils$d = utils$f;
+
+const compile$1 = (ast, options = {}) => {
+  const walk = (node, parent = {}) => {
+    const invalidBlock = utils$d.isInvalidBrace(parent);
+    const invalidNode = node.invalid === true && options.escapeInvalid === true;
+    const invalid = invalidBlock === true || invalidNode === true;
+    const prefix = options.escapeInvalid === true ? '\\' : '';
+    let output = '';
+
+    if (node.isOpen === true) {
+      return prefix + node.value;
+    }
+
+    if (node.isClose === true) {
+      console.log('node.isClose', prefix, node.value);
+      return prefix + node.value;
+    }
+
+    if (node.type === 'open') {
+      return invalid ? prefix + node.value : '(';
+    }
+
+    if (node.type === 'close') {
+      return invalid ? prefix + node.value : ')';
+    }
+
+    if (node.type === 'comma') {
+      return node.prev.type === 'comma' ? '' : invalid ? node.value : '|';
+    }
+
+    if (node.value) {
+      return node.value;
+    }
+
+    if (node.nodes && node.ranges > 0) {
+      const args = utils$d.reduce(node.nodes);
+      const range = fill$1(...args, { ...options, wrap: false, toRegex: true, strictZeros: true });
+
+      if (range.length !== 0) {
+        return args.length > 1 && range.length > 1 ? `(${range})` : range;
+      }
+    }
+
+    if (node.nodes) {
+      for (const child of node.nodes) {
+        output += walk(child, node);
+      }
+    }
+
+    return output;
+  };
+
+  return walk(ast);
+};
+
+var compile_1 = compile$1;
+
+const fill = fillRange;
+const stringify$5 = stringify$7;
+const utils$c = utils$f;
+
+const append$1 = (queue = '', stash = '', enclose = false) => {
+  const result = [];
+
+  queue = [].concat(queue);
+  stash = [].concat(stash);
+
+  if (!stash.length) return queue;
+  if (!queue.length) {
+    return enclose ? utils$c.flatten(stash).map(ele => `{${ele}}`) : stash;
+  }
+
+  for (const item of queue) {
+    if (Array.isArray(item)) {
+      for (const value of item) {
+        result.push(append$1(value, stash, enclose));
+      }
+    } else {
+      for (let ele of stash) {
+        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
+        result.push(Array.isArray(ele) ? append$1(item, ele, enclose) : item + ele);
+      }
+    }
+  }
+  return utils$c.flatten(result);
+};
+
+const expand$2 = (ast, options = {}) => {
+  const rangeLimit = options.rangeLimit === undefined ? 1000 : options.rangeLimit;
+
+  const walk = (node, parent = {}) => {
+    node.queue = [];
+
+    let p = parent;
+    let q = parent.queue;
+
+    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
+      p = p.parent;
+      q = p.queue;
+    }
+
+    if (node.invalid || node.dollar) {
+      q.push(append$1(q.pop(), stringify$5(node, options)));
+      return;
+    }
+
+    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
+      q.push(append$1(q.pop(), ['{}']));
+      return;
+    }
+
+    if (node.nodes && node.ranges > 0) {
+      const args = utils$c.reduce(node.nodes);
+
+      if (utils$c.exceedsLimit(...args, options.step, rangeLimit)) {
+        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+      }
+
+      let range = fill(...args, options);
+      if (range.length === 0) {
+        range = stringify$5(node, options);
+      }
+
+      q.push(append$1(q.pop(), range));
+      node.nodes = [];
+      return;
+    }
+
+    const enclose = utils$c.encloseBrace(node);
+    let queue = node.queue;
+    let block = node;
+
+    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
+      block = block.parent;
+      queue = block.queue;
+    }
+
+    for (let i = 0; i < node.nodes.length; i++) {
+      const child = node.nodes[i];
+
+      if (child.type === 'comma' && node.type === 'brace') {
+        if (i === 1) queue.push('');
+        queue.push('');
+        continue;
+      }
+
+      if (child.type === 'close') {
+        q.push(append$1(q.pop(), queue, enclose));
+        continue;
+      }
+
+      if (child.value && child.type !== 'open') {
+        queue.push(append$1(queue.pop(), child.value));
+        continue;
+      }
+
+      if (child.nodes) {
+        walk(child, node);
+      }
+    }
+
+    return queue;
+  };
+
+  return utils$c.flatten(walk(ast));
+};
+
+var expand_1$1 = expand$2;
+
+var constants$3 = {
+  MAX_LENGTH: 10000,
+
+  // Digits
+  CHAR_0: '0', /* 0 */
+  CHAR_9: '9', /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 'A', /* A */
+  CHAR_LOWERCASE_A: 'a', /* a */
+  CHAR_UPPERCASE_Z: 'Z', /* Z */
+  CHAR_LOWERCASE_Z: 'z', /* z */
+
+  CHAR_LEFT_PARENTHESES: '(', /* ( */
+  CHAR_RIGHT_PARENTHESES: ')', /* ) */
+
+  CHAR_ASTERISK: '*', /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: '&', /* & */
+  CHAR_AT: '@', /* @ */
+  CHAR_BACKSLASH: '\\', /* \ */
+  CHAR_BACKTICK: '`', /* ` */
+  CHAR_CARRIAGE_RETURN: '\r', /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
+  CHAR_COLON: ':', /* : */
+  CHAR_COMMA: ',', /* , */
+  CHAR_DOLLAR: '$', /* . */
+  CHAR_DOT: '.', /* . */
+  CHAR_DOUBLE_QUOTE: '"', /* " */
+  CHAR_EQUAL: '=', /* = */
+  CHAR_EXCLAMATION_MARK: '!', /* ! */
+  CHAR_FORM_FEED: '\f', /* \f */
+  CHAR_FORWARD_SLASH: '/', /* / */
+  CHAR_HASH: '#', /* # */
+  CHAR_HYPHEN_MINUS: '-', /* - */
+  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
+  CHAR_LEFT_CURLY_BRACE: '{', /* { */
+  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
+  CHAR_LINE_FEED: '\n', /* \n */
+  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
+  CHAR_PERCENT: '%', /* % */
+  CHAR_PLUS: '+', /* + */
+  CHAR_QUESTION_MARK: '?', /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
+  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
+  CHAR_SEMICOLON: ';', /* ; */
+  CHAR_SINGLE_QUOTE: '\'', /* ' */
+  CHAR_SPACE: ' ', /*   */
+  CHAR_TAB: '\t', /* \t */
+  CHAR_UNDERSCORE: '_', /* _ */
+  CHAR_VERTICAL_LINE: '|', /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
+};
+
+const stringify$4 = stringify$7;
+
+/**
+ * Constants
+ */
+
+const {
+  MAX_LENGTH,
+  CHAR_BACKSLASH, /* \ */
+  CHAR_BACKTICK, /* ` */
+  CHAR_COMMA, /* , */
+  CHAR_DOT, /* . */
+  CHAR_LEFT_PARENTHESES, /* ( */
+  CHAR_RIGHT_PARENTHESES, /* ) */
+  CHAR_LEFT_CURLY_BRACE, /* { */
+  CHAR_RIGHT_CURLY_BRACE, /* } */
+  CHAR_LEFT_SQUARE_BRACKET, /* [ */
+  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+  CHAR_DOUBLE_QUOTE, /* " */
+  CHAR_SINGLE_QUOTE, /* ' */
+  CHAR_NO_BREAK_SPACE,
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE
+} = constants$3;
+
+/**
+ * parse
+ */
+
+const parse$c = (input, options = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  const opts = options || {};
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  if (input.length > max) {
+    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+  }
+
+  const ast = { type: 'root', input, nodes: [] };
+  const stack = [ast];
+  let block = ast;
+  let prev = ast;
+  let brackets = 0;
+  const length = input.length;
+  let index = 0;
+  let depth = 0;
+  let value;
+
+  /**
+   * Helpers
+   */
+
+  const advance = () => input[index++];
+  const push = node => {
+    if (node.type === 'text' && prev.type === 'dot') {
+      prev.type = 'text';
+    }
+
+    if (prev && prev.type === 'text' && node.type === 'text') {
+      prev.value += node.value;
+      return;
+    }
+
+    block.nodes.push(node);
+    node.parent = block;
+    node.prev = prev;
+    prev = node;
+    return node;
+  };
+
+  push({ type: 'bos' });
+
+  while (index < length) {
+    block = stack[stack.length - 1];
+    value = advance();
+
+    /**
+     * Invalid chars
+     */
+
+    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
+      continue;
+    }
+
+    /**
+     * Escaped chars
+     */
+
+    if (value === CHAR_BACKSLASH) {
+      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
+      continue;
+    }
+
+    /**
+     * Right square bracket (literal): ']'
+     */
+
+    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+      push({ type: 'text', value: '\\' + value });
+      continue;
+    }
+
+    /**
+     * Left square bracket: '['
+     */
+
+    if (value === CHAR_LEFT_SQUARE_BRACKET) {
+      brackets++;
+
+      let next;
+
+      while (index < length && (next = advance())) {
+        value += next;
+
+        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+          brackets++;
+          continue;
+        }
+
+        if (next === CHAR_BACKSLASH) {
+          value += advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+          brackets--;
+
+          if (brackets === 0) {
+            break;
+          }
+        }
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Parentheses
+     */
+
+    if (value === CHAR_LEFT_PARENTHESES) {
+      block = push({ type: 'paren', nodes: [] });
+      stack.push(block);
+      push({ type: 'text', value });
+      continue;
+    }
+
+    if (value === CHAR_RIGHT_PARENTHESES) {
+      if (block.type !== 'paren') {
+        push({ type: 'text', value });
+        continue;
+      }
+      block = stack.pop();
+      push({ type: 'text', value });
+      block = stack[stack.length - 1];
+      continue;
+    }
+
+    /**
+     * Quotes: '|"|`
+     */
+
+    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+      const open = value;
+      let next;
+
+      if (options.keepQuotes !== true) {
+        value = '';
+      }
+
+      while (index < length && (next = advance())) {
+        if (next === CHAR_BACKSLASH) {
+          value += next + advance();
+          continue;
+        }
+
+        if (next === open) {
+          if (options.keepQuotes === true) value += next;
+          break;
+        }
+
+        value += next;
+      }
+
+      push({ type: 'text', value });
+      continue;
+    }
+
+    /**
+     * Left curly brace: '{'
+     */
+
+    if (value === CHAR_LEFT_CURLY_BRACE) {
+      depth++;
+
+      const dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
+      const brace = {
+        type: 'brace',
+        open: true,
+        close: false,
+        dollar,
+        depth,
+        commas: 0,
+        ranges: 0,
+        nodes: []
+      };
+
+      block = push(brace);
+      stack.push(block);
+      push({ type: 'open', value });
+      continue;
+    }
+
+    /**
+     * Right curly brace: '}'
+     */
+
+    if (value === CHAR_RIGHT_CURLY_BRACE) {
+      if (block.type !== 'brace') {
+        push({ type: 'text', value });
+        continue;
+      }
+
+      const type = 'close';
+      block = stack.pop();
+      block.close = true;
+
+      push({ type, value });
+      depth--;
+
+      block = stack[stack.length - 1];
+      continue;
+    }
+
+    /**
+     * Comma: ','
+     */
+
+    if (value === CHAR_COMMA && depth > 0) {
+      if (block.ranges > 0) {
+        block.ranges = 0;
+        const open = block.nodes.shift();
+        block.nodes = [open, { type: 'text', value: stringify$4(block) }];
+      }
+
+      push({ type: 'comma', value });
+      block.commas++;
+      continue;
+    }
+
+    /**
+     * Dot: '.'
+     */
+
+    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+      const siblings = block.nodes;
+
+      if (depth === 0 || siblings.length === 0) {
+        push({ type: 'text', value });
+        continue;
+      }
+
+      if (prev.type === 'dot') {
+        block.range = [];
+        prev.value += value;
+        prev.type = 'range';
+
+        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
+          block.invalid = true;
+          block.ranges = 0;
+          prev.type = 'text';
+          continue;
+        }
+
+        block.ranges++;
+        block.args = [];
+        continue;
+      }
+
+      if (prev.type === 'range') {
+        siblings.pop();
+
+        const before = siblings[siblings.length - 1];
+        before.value += prev.value + value;
+        prev = before;
+        block.ranges--;
+        continue;
+      }
+
+      push({ type: 'dot', value });
+      continue;
+    }
+
+    /**
+     * Text
+     */
+
+    push({ type: 'text', value });
+  }
+
+  // Mark imbalanced braces and brackets as invalid
+  do {
+    block = stack.pop();
+
+    if (block.type !== 'root') {
+      block.nodes.forEach(node => {
+        if (!node.nodes) {
+          if (node.type === 'open') node.isOpen = true;
+          if (node.type === 'close') node.isClose = true;
+          if (!node.nodes) node.type = 'text';
+          node.invalid = true;
+        }
+      });
+
+      // get the location of the block on parent.nodes (block's siblings)
+      const parent = stack[stack.length - 1];
+      const index = parent.nodes.indexOf(block);
+      // replace the (invalid) block with it's nodes
+      parent.nodes.splice(index, 1, ...block.nodes);
+    }
+  } while (stack.length > 0);
+
+  push({ type: 'eos' });
+  return ast;
+};
+
+var parse_1$2 = parse$c;
+
+const stringify$3 = stringify$7;
+const compile = compile_1;
+const expand$1 = expand_1$1;
+const parse$b = parse_1$2;
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces$2 = (input, options = {}) => {
+  let output = [];
+
+  if (Array.isArray(input)) {
+    for (const pattern of input) {
+      const result = braces$2.create(pattern, options);
+      if (Array.isArray(result)) {
+        output.push(...result);
+      } else {
+        output.push(result);
+      }
+    }
+  } else {
+    output = [].concat(braces$2.create(input, options));
+  }
+
+  if (options && options.expand === true && options.nodupes === true) {
+    output = [...new Set(output)];
+  }
+  return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces$2.parse = (input, options = {}) => parse$b(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$2.stringify = (input, options = {}) => {
+  if (typeof input === 'string') {
+    return stringify$3(braces$2.parse(input, options), options);
+  }
+  return stringify$3(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$2.compile = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$2.parse(input, options);
+  }
+  return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$2.expand = (input, options = {}) => {
+  if (typeof input === 'string') {
+    input = braces$2.parse(input, options);
+  }
+
+  let result = expand$1(input, options);
+
+  // filter out empty strings if specified
+  if (options.noempty === true) {
+    result = result.filter(Boolean);
+  }
+
+  // filter out duplicates if specified
+  if (options.nodupes === true) {
+    result = [...new Set(result)];
+  }
+
+  return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces$2.create = (input, options = {}) => {
+  if (input === '' || input.length < 3) {
+    return [input];
+  }
+
+  return options.expand !== true
+    ? braces$2.compile(input, options)
+    : braces$2.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+var braces_1 = braces$2;
+
+const util = require$$0$5;
+const braces$1 = braces_1;
+const picomatch$2 = picomatch$3;
+const utils$b = utils$k;
+
+const isEmptyString = v => v === '' || v === './';
+const hasBraces = v => {
+  const index = v.indexOf('{');
+  return index > -1 && v.indexOf('}', index) > -1;
+};
+
+/**
+ * Returns an array of strings that match one or more glob patterns.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm(list, patterns[, options]);
+ *
+ * console.log(mm(['a.js', 'a.txt'], ['*.js']));
+ * //=> [ 'a.js' ]
+ * ```
+ * @param {String|Array<string>} `list` List of strings to match.
+ * @param {String|Array<string>} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options)
+ * @return {Array} Returns an array of matches
+ * @summary false
+ * @api public
+ */
+
+const micromatch$1 = (list, patterns, options) => {
+  patterns = [].concat(patterns);
+  list = [].concat(list);
+
+  let omit = new Set();
+  let keep = new Set();
+  let items = new Set();
+  let negatives = 0;
+
+  let onResult = state => {
+    items.add(state.output);
+    if (options && options.onResult) {
+      options.onResult(state);
+    }
+  };
+
+  for (let i = 0; i < patterns.length; i++) {
+    let isMatch = picomatch$2(String(patterns[i]), { ...options, onResult }, true);
+    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+    if (negated) negatives++;
+
+    for (let item of list) {
+      let matched = isMatch(item, true);
+
+      let match = negated ? !matched.isMatch : matched.isMatch;
+      if (!match) continue;
+
+      if (negated) {
+        omit.add(matched.output);
+      } else {
+        omit.delete(matched.output);
+        keep.add(matched.output);
+      }
+    }
+  }
+
+  let result = negatives === patterns.length ? [...items] : [...keep];
+  let matches = result.filter(item => !omit.has(item));
+
+  if (options && matches.length === 0) {
+    if (options.failglob === true) {
+      throw new Error(`No matches found for "${patterns.join(', ')}"`);
+    }
+
+    if (options.nonull === true || options.nullglob === true) {
+      return options.unescape ? patterns.map(p => p.replace(/\\/g, '')) : patterns;
+    }
+  }
+
+  return matches;
+};
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch$1.match = micromatch$1;
+
+/**
+ * Returns a matcher function from the given glob `pattern` and `options`.
+ * The returned function takes a string to match as its only argument and returns
+ * true if the string is a match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matcher(pattern[, options]);
+ *
+ * const isMatch = mm.matcher('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @param {String} `pattern` Glob pattern
+ * @param {Object} `options`
+ * @return {Function} Returns a matcher function.
+ * @api public
+ */
+
+micromatch$1.matcher = (pattern, options) => picomatch$2(pattern, options);
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.isMatch(string, patterns[, options]);
+ *
+ * console.log(mm.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(mm.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `[options]` See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch$1.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
+
+/**
+ * Backwards compatibility
+ */
+
+micromatch$1.any = micromatch$1.isMatch;
+
+/**
+ * Returns a list of strings that _**do not match any**_ of the given `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.not(list, patterns[, options]);
+ *
+ * console.log(mm.not(['a.a', 'b.b', 'c.c'], '*.a'));
+ * //=> ['b.b', 'c.c']
+ * ```
+ * @param {Array} `list` Array of strings to match.
+ * @param {String|Array} `patterns` One or more glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array} Returns an array of strings that **do not match** the given patterns.
+ * @api public
+ */
+
+micromatch$1.not = (list, patterns, options = {}) => {
+  patterns = [].concat(patterns).map(String);
+  let result = new Set();
+  let items = [];
+
+  let onResult = state => {
+    if (options.onResult) options.onResult(state);
+    items.push(state.output);
+  };
+
+  let matches = new Set(micromatch$1(list, patterns, { ...options, onResult }));
+
+  for (let item of items) {
+    if (!matches.has(item)) {
+      result.add(item);
+    }
+  }
+  return [...result];
+};
+
+/**
+ * Returns true if the given `string` contains the given pattern. Similar
+ * to [.isMatch](#isMatch) but the pattern can match any part of the string.
+ *
+ * ```js
+ * var mm = require('micromatch');
+ * // mm.contains(string, pattern[, options]);
+ *
+ * console.log(mm.contains('aa/bb/cc', '*b'));
+ * //=> true
+ * console.log(mm.contains('aa/bb/cc', '*d'));
+ * //=> false
+ * ```
+ * @param {String} `str` The string to match.
+ * @param {String|Array} `patterns` Glob pattern to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any of the patterns matches any part of `str`.
+ * @api public
+ */
+
+micromatch$1.contains = (str, pattern, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  if (Array.isArray(pattern)) {
+    return pattern.some(p => micromatch$1.contains(str, p, options));
+  }
+
+  if (typeof pattern === 'string') {
+    if (isEmptyString(str) || isEmptyString(pattern)) {
+      return false;
+    }
+
+    if (str.includes(pattern) || (str.startsWith('./') && str.slice(2).includes(pattern))) {
+      return true;
+    }
+  }
+
+  return micromatch$1.isMatch(str, pattern, { ...options, contains: true });
+};
+
+/**
+ * Filter the keys of the given object with the given `glob` pattern
+ * and `options`. Does not attempt to match nested keys. If you need this feature,
+ * use [glob-object][] instead.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.matchKeys(object, patterns[, options]);
+ *
+ * const obj = { aa: 'a', ab: 'b', ac: 'c' };
+ * console.log(mm.matchKeys(obj, '*b'));
+ * //=> { ab: 'b' }
+ * ```
+ * @param {Object} `object` The object with keys to filter.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Object} Returns an object with only keys that match the given patterns.
+ * @api public
+ */
+
+micromatch$1.matchKeys = (obj, patterns, options) => {
+  if (!utils$b.isObject(obj)) {
+    throw new TypeError('Expected the first argument to be an object');
+  }
+  let keys = micromatch$1(Object.keys(obj), patterns, options);
+  let res = {};
+  for (let key of keys) res[key] = obj[key];
+  return res;
+};
+
+/**
+ * Returns true if some of the strings in the given `list` match any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.some(list, patterns[, options]);
+ *
+ * console.log(mm.some(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // true
+ * console.log(mm.some(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test. Returns as soon as the first match is found.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any `patterns` matches any of the strings in `list`
+ * @api public
+ */
+
+micromatch$1.some = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch$2(String(pattern), options);
+    if (items.some(item => isMatch(item))) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Returns true if every string in the given `list` matches
+ * any of the given glob `patterns`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.every(list, patterns[, options]);
+ *
+ * console.log(mm.every('foo.js', ['foo.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js']));
+ * // true
+ * console.log(mm.every(['foo.js', 'bar.js'], ['*.js', '!foo.js']));
+ * // false
+ * console.log(mm.every(['foo.js'], ['*.js', '!foo.js']));
+ * // false
+ * ```
+ * @param {String|Array} `list` The string or array of strings to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if all `patterns` matches all of the strings in `list`
+ * @api public
+ */
+
+micromatch$1.every = (list, patterns, options) => {
+  let items = [].concat(list);
+
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch$2(String(pattern), options);
+    if (!items.every(item => isMatch(item))) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * Returns true if **all** of the given `patterns` match
+ * the specified string.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.all(string, patterns[, options]);
+ *
+ * console.log(mm.all('foo.js', ['foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', '!foo.js']));
+ * // false
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'foo.js']));
+ * // true
+ *
+ * console.log(mm.all('foo.js', ['*.js', 'f*', '*o*', '*o.js']));
+ * // true
+ * ```
+ * @param {String|Array} `str` The string to test.
+ * @param {String|Array} `patterns` One or more glob patterns to use for matching.
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+micromatch$1.all = (str, patterns, options) => {
+  if (typeof str !== 'string') {
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+  }
+
+  return [].concat(patterns).every(p => picomatch$2(p, options)(str));
+};
+
+/**
+ * Returns an array of matches captured by `pattern` in `string, or `null` if the pattern did not match.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.capture(pattern, string[, options]);
+ *
+ * console.log(mm.capture('test/*.js', 'test/foo.js'));
+ * //=> ['foo']
+ * console.log(mm.capture('test/*.js', 'foo/bar.css'));
+ * //=> null
+ * ```
+ * @param {String} `glob` Glob pattern to use for matching.
+ * @param {String} `input` String to match
+ * @param {Object} `options` See available [options](#options) for changing how matches are performed
+ * @return {Array|null} Returns an array of captures if the input matches the glob pattern, otherwise `null`.
+ * @api public
+ */
+
+micromatch$1.capture = (glob, input, options) => {
+  let posix = utils$b.isWindows(options);
+  let regex = picomatch$2.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils$b.toPosixSlashes(input) : input);
+
+  if (match) {
+    return match.slice(1).map(v => v === void 0 ? '' : v);
+  }
+};
+
+/**
+ * Create a regular expression from the given glob `pattern`.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * // mm.makeRe(pattern[, options]);
+ *
+ * console.log(mm.makeRe('*.js'));
+ * //=> /^(?:(\.[\\\/])?(?!\.)(?=.)[^\/]*?\.js)$/
+ * ```
+ * @param {String} `pattern` A glob pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+micromatch$1.makeRe = (...args) => picomatch$2.makeRe(...args);
+
+/**
+ * Scan a glob pattern to separate the pattern into segments. Used
+ * by the [split](#split) method.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.scan(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+micromatch$1.scan = (...args) => picomatch$2.scan(...args);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const mm = require('micromatch');
+ * const state = mm.parse(pattern[, options]);
+ * ```
+ * @param {String} `glob`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as regex source string.
+ * @api public
+ */
+
+micromatch$1.parse = (patterns, options) => {
+  let res = [];
+  for (let pattern of [].concat(patterns || [])) {
+    for (let str of braces$1(String(pattern), options)) {
+      res.push(picomatch$2.parse(str, options));
+    }
+  }
+  return res;
+};
+
+/**
+ * Process the given brace `pattern`.
+ *
+ * ```js
+ * const { braces } = require('micromatch');
+ * console.log(braces('foo/{a,b,c}/bar'));
+ * //=> [ 'foo/(a|b|c)/bar' ]
+ *
+ * console.log(braces('foo/{a,b,c}/bar', { expand: true }));
+ * //=> [ 'foo/a/bar', 'foo/b/bar', 'foo/c/bar' ]
+ * ```
+ * @param {String} `pattern` String with brace pattern to process.
+ * @param {Object} `options` Any [options](#options) to change how expansion is performed. See the [braces][] library for all available options.
+ * @return {Array}
+ * @api public
+ */
+
+micromatch$1.braces = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
+    return [pattern];
+  }
+  return braces$1(pattern, options);
+};
+
+/**
+ * Expand braces
+ */
+
+micromatch$1.braceExpand = (pattern, options) => {
+  if (typeof pattern !== 'string') throw new TypeError('Expected a string');
+  return micromatch$1.braces(pattern, { ...options, expand: true });
+};
+
+/**
+ * Expose micromatch
+ */
+
+// exposed for tests
+micromatch$1.hasBraces = hasBraces;
+var micromatch_1 = micromatch$1;
+
+var micromatch$2 = /*@__PURE__*/getDefaultExportFromCjs(micromatch_1);
+
+Object.defineProperty(pattern$1, "__esModule", { value: true });
+pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
+const path$g = require$$0$4;
+const globParent$1 = globParent$2;
+const micromatch = micromatch_1;
+const GLOBSTAR$1 = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ */
+const DOUBLE_SLASH_RE$1 = /(?!^)\/{2,}/g;
+function isStaticPattern(pattern, options = {}) {
+    return !isDynamicPattern(pattern, options);
+}
+pattern$1.isStaticPattern = isStaticPattern;
+function isDynamicPattern(pattern, options = {}) {
+    /**
+     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+     * An empty string cannot be a dynamic pattern.
+     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+     */
+    if (pattern === '') {
+        return false;
+    }
+    /**
+     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+     * filepath directly (without read directory).
+     */
+    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+        return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+        return true;
+    }
+    return false;
+}
+pattern$1.isDynamicPattern = isDynamicPattern;
+function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+        return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+        return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
+function convertToPositivePattern(pattern) {
+    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+pattern$1.convertToPositivePattern = convertToPositivePattern;
+function convertToNegativePattern(pattern) {
+    return '!' + pattern;
+}
+pattern$1.convertToNegativePattern = convertToNegativePattern;
+function isNegativePattern(pattern) {
+    return pattern.startsWith('!') && pattern[1] !== '(';
+}
+pattern$1.isNegativePattern = isNegativePattern;
+function isPositivePattern(pattern) {
+    return !isNegativePattern(pattern);
+}
+pattern$1.isPositivePattern = isPositivePattern;
+function getNegativePatterns(patterns) {
+    return patterns.filter(isNegativePattern);
+}
+pattern$1.getNegativePatterns = getNegativePatterns;
+function getPositivePatterns$1(patterns) {
+    return patterns.filter(isPositivePattern);
+}
+pattern$1.getPositivePatterns = getPositivePatterns$1;
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+}
+pattern$1.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter(isPatternRelatedToParentDirectory);
+}
+pattern$1.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+function isPatternRelatedToParentDirectory(pattern) {
+    return pattern.startsWith('..') || pattern.startsWith('./..');
+}
+pattern$1.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+function getBaseDirectory(pattern) {
+    return globParent$1(pattern, { flipBackslashes: false });
+}
+pattern$1.getBaseDirectory = getBaseDirectory;
+function hasGlobStar(pattern) {
+    return pattern.includes(GLOBSTAR$1);
+}
+pattern$1.hasGlobStar = hasGlobStar;
+function endsWithSlashGlobStar(pattern) {
+    return pattern.endsWith('/' + GLOBSTAR$1);
+}
+pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
+function isAffectDepthOfReadingPattern(pattern) {
+    const basename = path$g.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern) => {
+        return collection.concat(expandBraceExpansion(pattern));
+    }, []);
+}
+pattern$1.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+function expandBraceExpansion(pattern) {
+    const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: true });
+    /**
+     * Sort the patterns by length so that the same depth patterns are processed side by side.
+     * `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
+     */
+    patterns.sort((a, b) => a.length - b.length);
+    /**
+     * Micromatch can return an empty string in the case of patterns like `{a,}`.
+     */
+    return patterns.filter((pattern) => pattern !== '');
+}
+pattern$1.expandBraceExpansion = expandBraceExpansion;
+function getPatternParts(pattern, options) {
+    let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+    /**
+     * The scan method returns an empty array in some cases.
+     * See micromatch/picomatch#58 for more details.
+     */
+    if (parts.length === 0) {
+        parts = [pattern];
+    }
+    /**
+     * The scan method does not return an empty part for the pattern with a forward slash.
+     * This is another part of micromatch/picomatch#58.
+     */
+    if (parts[0].startsWith('/')) {
+        parts[0] = parts[0].slice(1);
+        parts.unshift('');
+    }
+    return parts;
+}
+pattern$1.getPatternParts = getPatternParts;
+function makeRe(pattern, options) {
+    return micromatch.makeRe(pattern, options);
+}
+pattern$1.makeRe = makeRe;
+function convertPatternsToRe(patterns, options) {
+    return patterns.map((pattern) => makeRe(pattern, options));
+}
+pattern$1.convertPatternsToRe = convertPatternsToRe;
+function matchAny(entry, patternsRe) {
+    return patternsRe.some((patternRe) => patternRe.test(entry));
+}
+pattern$1.matchAny = matchAny;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE$1, '/');
+}
+pattern$1.removeDuplicateSlashes = removeDuplicateSlashes;
+
+var stream$4 = {};
+
+/*
+ * merge2
+ * https://github.com/teambition/merge2
+ *
+ * Copyright (c) 2014-2020 Teambition
+ * Licensed under the MIT license.
+ */
+const Stream = require$$0$6;
+const PassThrough = Stream.PassThrough;
+const slice = Array.prototype.slice;
+
+var merge2_1 = merge2$1;
+
+function merge2$1 () {
+  const streamsQueue = [];
+  const args = slice.call(arguments);
+  let merging = false;
+  let options = args[args.length - 1];
+
+  if (options && !Array.isArray(options) && options.pipe == null) {
+    args.pop();
+  } else {
+    options = {};
+  }
+
+  const doEnd = options.end !== false;
+  const doPipeError = options.pipeError === true;
+  if (options.objectMode == null) {
+    options.objectMode = true;
+  }
+  if (options.highWaterMark == null) {
+    options.highWaterMark = 64 * 1024;
+  }
+  const mergedStream = PassThrough(options);
+
+  function addStream () {
+    for (let i = 0, len = arguments.length; i < len; i++) {
+      streamsQueue.push(pauseStreams(arguments[i], options));
+    }
+    mergeStream();
+    return this
+  }
+
+  function mergeStream () {
+    if (merging) {
+      return
+    }
+    merging = true;
+
+    let streams = streamsQueue.shift();
+    if (!streams) {
+      process.nextTick(endStream);
+      return
+    }
+    if (!Array.isArray(streams)) {
+      streams = [streams];
+    }
+
+    let pipesCount = streams.length + 1;
+
+    function next () {
+      if (--pipesCount > 0) {
+        return
+      }
+      merging = false;
+      mergeStream();
+    }
+
+    function pipe (stream) {
+      function onend () {
+        stream.removeListener('merge2UnpipeEnd', onend);
+        stream.removeListener('end', onend);
+        if (doPipeError) {
+          stream.removeListener('error', onerror);
+        }
+        next();
+      }
+      function onerror (err) {
+        mergedStream.emit('error', err);
+      }
+      // skip ended stream
+      if (stream._readableState.endEmitted) {
+        return next()
+      }
+
+      stream.on('merge2UnpipeEnd', onend);
+      stream.on('end', onend);
+
+      if (doPipeError) {
+        stream.on('error', onerror);
+      }
+
+      stream.pipe(mergedStream, { end: false });
+      // compatible for old stream
+      stream.resume();
+    }
+
+    for (let i = 0; i < streams.length; i++) {
+      pipe(streams[i]);
+    }
+
+    next();
+  }
+
+  function endStream () {
+    merging = false;
+    // emit 'queueDrain' when all streams merged.
+    mergedStream.emit('queueDrain');
+    if (doEnd) {
+      mergedStream.end();
+    }
+  }
+
+  mergedStream.setMaxListeners(0);
+  mergedStream.add = addStream;
+  mergedStream.on('unpipe', function (stream) {
+    stream.emit('merge2UnpipeEnd');
+  });
+
+  if (args.length) {
+    addStream.apply(null, args);
+  }
+  return mergedStream
+}
+
+// check and pause streams for pipe.
+function pauseStreams (streams, options) {
+  if (!Array.isArray(streams)) {
+    // Backwards-compat with old-style streams
+    if (!streams._readableState && streams.pipe) {
+      streams = streams.pipe(PassThrough(options));
+    }
+    if (!streams._readableState || !streams.pause || !streams.pipe) {
+      throw new Error('Only readable stream can be merged.')
+    }
+    streams.pause();
+  } else {
+    for (let i = 0, len = streams.length; i < len; i++) {
+      streams[i] = pauseStreams(streams[i], options);
+    }
+  }
+  return streams
+}
+
+Object.defineProperty(stream$4, "__esModule", { value: true });
+stream$4.merge = void 0;
+const merge2 = merge2_1;
+function merge$1(streams) {
+    const mergedStream = merge2(streams);
+    streams.forEach((stream) => {
+        stream.once('error', (error) => mergedStream.emit('error', error));
+    });
+    mergedStream.once('close', () => propagateCloseEventToSources(streams));
+    mergedStream.once('end', () => propagateCloseEventToSources(streams));
+    return mergedStream;
+}
+stream$4.merge = merge$1;
+function propagateCloseEventToSources(streams) {
+    streams.forEach((stream) => stream.emit('close'));
+}
+
+var string$2 = {};
+
+Object.defineProperty(string$2, "__esModule", { value: true });
+string$2.isEmpty = string$2.isString = void 0;
+function isString$1(input) {
+    return typeof input === 'string';
+}
+string$2.isString = isString$1;
+function isEmpty$1(input) {
+    return input === '';
+}
+string$2.isEmpty = isEmpty$1;
+
+Object.defineProperty(utils$g, "__esModule", { value: true });
+utils$g.string = utils$g.stream = utils$g.pattern = utils$g.path = utils$g.fs = utils$g.errno = utils$g.array = void 0;
+const array = array$1;
+utils$g.array = array;
+const errno = errno$1;
+utils$g.errno = errno;
+const fs$h = fs$i;
+utils$g.fs = fs$h;
+const path$f = path$i;
+utils$g.path = path$f;
+const pattern = pattern$1;
+utils$g.pattern = pattern;
+const stream$3 = stream$4;
+utils$g.stream = stream$3;
+const string$1 = string$2;
+utils$g.string = string$1;
+
+Object.defineProperty(tasks, "__esModule", { value: true });
+tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+const utils$a = utils$g;
+function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
+    const staticPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isStaticPattern(pattern, settings));
+    const dynamicPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isDynamicPattern(pattern, settings));
+    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+    return staticTasks.concat(dynamicTasks);
+}
+tasks.generate = generate;
+function processPatterns(input, settings) {
+    let patterns = input;
+    /**
+     * The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
+     * and some problems with the micromatch package (see fast-glob issues: #365, #394).
+     *
+     * To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
+     * in matching in the case of a large set of patterns after expansion.
+     */
+    if (settings.braceExpansion) {
+        patterns = utils$a.pattern.expandPatternsWithBraceExpansion(patterns);
+    }
+    /**
+     * If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
+     * at any nesting level.
+     *
+     * We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
+     * the pattern in the filter before creating a regular expression. There is no need to change the patterns
+     * in the application. Only on the input.
+     */
+    if (settings.baseNameMatch) {
+        patterns = patterns.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`);
+    }
+    /**
+     * This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
+     */
+    return patterns.map((pattern) => utils$a.pattern.removeDuplicateSlashes(pattern));
+}
+/**
+ * Returns tasks grouped by basic pattern directories.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks = [];
+    const patternsOutsideCurrentDirectory = utils$a.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils$a.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    /*
+     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+     */
+    if ('.' in insideCurrentDirectoryGroup) {
+        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
+    }
+    else {
+        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+    }
+    return tasks;
+}
+tasks.convertPatternsToTasks = convertPatternsToTasks;
+function getPositivePatterns(patterns) {
+    return utils$a.pattern.getPositivePatterns(patterns);
+}
+tasks.getPositivePatterns = getPositivePatterns;
+function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils$a.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils$a.pattern.convertToPositivePattern);
+    return positive;
+}
+tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+        const base = utils$a.pattern.getBaseDirectory(pattern);
+        if (base in collection) {
+            collection[base].push(pattern);
+        }
+        else {
+            collection[base] = [pattern];
+        }
+        return collection;
+    }, group);
+}
+tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+}
+tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+        dynamic,
+        positive,
+        negative,
+        base,
+        patterns: [].concat(positive, negative.map(utils$a.pattern.convertToNegativePattern))
+    };
+}
+tasks.convertPatternGroupToTask = convertPatternGroupToTask;
+
+var async$7 = {};
+
+var async$6 = {};
+
+var out$3 = {};
+
+var async$5 = {};
+
+var async$4 = {};
+
+var out$2 = {};
+
+var async$3 = {};
+
+var out$1 = {};
+
+var async$2 = {};
+
+Object.defineProperty(async$2, "__esModule", { value: true });
+async$2.read = void 0;
+function read$3(path, settings, callback) {
+    settings.fs.lstat(path, (lstatError, lstat) => {
+        if (lstatError !== null) {
+            callFailureCallback$2(callback, lstatError);
+            return;
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            callSuccessCallback$2(callback, lstat);
+            return;
+        }
+        settings.fs.stat(path, (statError, stat) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    callFailureCallback$2(callback, statError);
+                    return;
+                }
+                callSuccessCallback$2(callback, lstat);
+                return;
+            }
+            if (settings.markSymbolicLink) {
+                stat.isSymbolicLink = () => true;
+            }
+            callSuccessCallback$2(callback, stat);
+        });
+    });
+}
+async$2.read = read$3;
+function callFailureCallback$2(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$2(callback, result) {
+    callback(null, result);
+}
+
+var sync$8 = {};
+
+Object.defineProperty(sync$8, "__esModule", { value: true });
+sync$8.read = void 0;
+function read$2(path, settings) {
+    const lstat = settings.fs.lstatSync(path);
+    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+        return lstat;
+    }
+    try {
+        const stat = settings.fs.statSync(path);
+        if (settings.markSymbolicLink) {
+            stat.isSymbolicLink = () => true;
+        }
+        return stat;
+    }
+    catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink) {
+            return lstat;
+        }
+        throw error;
+    }
+}
+sync$8.read = read$2;
+
+var settings$3 = {};
+
+var fs$g = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = require$$0__default;
+	exports.FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    stat: fs.stat,
+	    lstatSync: fs.lstatSync,
+	    statSync: fs.statSync
+	};
+	function createFileSystemAdapter(fsMethods) {
+	    if (fsMethods === undefined) {
+	        return exports.FILE_SYSTEM_ADAPTER;
+	    }
+	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+	}
+	exports.createFileSystemAdapter = createFileSystemAdapter; 
+} (fs$g));
+
+Object.defineProperty(settings$3, "__esModule", { value: true });
+const fs$f = fs$g;
+let Settings$2 = class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = fs$f.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+};
+settings$3.default = Settings$2;
+
+Object.defineProperty(out$1, "__esModule", { value: true });
+out$1.statSync = out$1.stat = out$1.Settings = void 0;
+const async$1 = async$2;
+const sync$7 = sync$8;
+const settings_1$3 = settings$3;
+out$1.Settings = settings_1$3.default;
+function stat$4(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        async$1.read(path, getSettings$2(), optionsOrSettingsOrCallback);
+        return;
+    }
+    async$1.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
+}
+out$1.stat = stat$4;
+function statSync(path, optionsOrSettings) {
+    const settings = getSettings$2(optionsOrSettings);
+    return sync$7.read(path, settings);
+}
+out$1.statSync = statSync;
+function getSettings$2(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$3.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$3.default(settingsOrOptions);
+}
+
+/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+let promise;
+
+var queueMicrotask_1 = typeof queueMicrotask === 'function'
+  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : commonjsGlobal)
+  // reuse resolved promise, and allocate it lazily
+  : cb => (promise || (promise = Promise.resolve()))
+    .then(cb)
+    .catch(err => setTimeout(() => { throw err }, 0));
+
+/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+var runParallel_1 = runParallel;
+
+const queueMicrotask$1 = queueMicrotask_1;
+
+function runParallel (tasks, cb) {
+  let results, pending, keys;
+  let isSync = true;
+
+  if (Array.isArray(tasks)) {
+    results = [];
+    pending = tasks.length;
+  } else {
+    keys = Object.keys(tasks);
+    results = {};
+    pending = keys.length;
+  }
+
+  function done (err) {
+    function end () {
+      if (cb) cb(err, results);
+      cb = null;
+    }
+    if (isSync) queueMicrotask$1(end);
+    else end();
+  }
+
+  function each (i, err, result) {
+    results[i] = result;
+    if (--pending === 0 || err) {
+      done(err);
+    }
+  }
+
+  if (!pending) {
+    // empty
+    done(null);
+  } else if (keys) {
+    // object
+    keys.forEach(function (key) {
+      tasks[key](function (err, result) { each(key, err, result); });
+    });
+  } else {
+    // array
+    tasks.forEach(function (task, i) {
+      task(function (err, result) { each(i, err, result); });
+    });
+  }
+
+  isSync = false;
+}
+
+var constants$2 = {};
+
+Object.defineProperty(constants$2, "__esModule", { value: true });
+constants$2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+if (NODE_PROCESS_VERSION_PARTS[0] === undefined || NODE_PROCESS_VERSION_PARTS[1] === undefined) {
+    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
+}
+const MAJOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = Number.parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+constants$2.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
+
+var utils$9 = {};
+
+var fs$e = {};
+
+Object.defineProperty(fs$e, "__esModule", { value: true });
+fs$e.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+fs$e.createDirentFromStats = createDirentFromStats;
+
+Object.defineProperty(utils$9, "__esModule", { value: true });
+utils$9.fs = void 0;
+const fs$d = fs$e;
+utils$9.fs = fs$d;
+
+var common$a = {};
+
+Object.defineProperty(common$a, "__esModule", { value: true });
+common$a.joinPathSegments = void 0;
+function joinPathSegments$1(a, b, separator) {
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+common$a.joinPathSegments = joinPathSegments$1;
+
+Object.defineProperty(async$3, "__esModule", { value: true });
+async$3.readdir = async$3.readdirWithFileTypes = async$3.read = void 0;
+const fsStat$5 = out$1;
+const rpl = runParallel_1;
+const constants_1$1 = constants$2;
+const utils$8 = utils$9;
+const common$9 = common$a;
+function read$1(directory, settings, callback) {
+    if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        readdirWithFileTypes$1(directory, settings, callback);
+        return;
+    }
+    readdir$3(directory, settings, callback);
+}
+async$3.read = read$1;
+function readdirWithFileTypes$1(directory, settings, callback) {
+    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+            callFailureCallback$1(callback, readdirError);
+            return;
+        }
+        const entries = dirents.map((dirent) => ({
+            dirent,
+            name: dirent.name,
+            path: common$9.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        }));
+        if (!settings.followSymbolicLinks) {
+            callSuccessCallback$1(callback, entries);
+            return;
+        }
+        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+            if (rplError !== null) {
+                callFailureCallback$1(callback, rplError);
+                return;
+            }
+            callSuccessCallback$1(callback, rplEntries);
+        });
+    });
+}
+async$3.readdirWithFileTypes = readdirWithFileTypes$1;
+function makeRplTaskEntry(entry, settings) {
+    return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+            done(null, entry);
+            return;
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    done(statError);
+                    return;
+                }
+                done(null, entry);
+                return;
+            }
+            entry.dirent = utils$8.fs.createDirentFromStats(entry.name, stats);
+            done(null, entry);
+        });
+    };
+}
+function readdir$3(directory, settings, callback) {
+    settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+            callFailureCallback$1(callback, readdirError);
+            return;
+        }
+        const tasks = names.map((name) => {
+            const path = common$9.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+            return (done) => {
+                fsStat$5.stat(path, settings.fsStatSettings, (error, stats) => {
+                    if (error !== null) {
+                        done(error);
+                        return;
+                    }
+                    const entry = {
+                        name,
+                        path,
+                        dirent: utils$8.fs.createDirentFromStats(name, stats)
+                    };
+                    if (settings.stats) {
+                        entry.stats = stats;
+                    }
+                    done(null, entry);
+                });
+            };
+        });
+        rpl(tasks, (rplError, entries) => {
+            if (rplError !== null) {
+                callFailureCallback$1(callback, rplError);
+                return;
+            }
+            callSuccessCallback$1(callback, entries);
+        });
+    });
+}
+async$3.readdir = readdir$3;
+function callFailureCallback$1(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$1(callback, result) {
+    callback(null, result);
+}
+
+var sync$6 = {};
+
+Object.defineProperty(sync$6, "__esModule", { value: true });
+sync$6.readdir = sync$6.readdirWithFileTypes = sync$6.read = void 0;
+const fsStat$4 = out$1;
+const constants_1 = constants$2;
+const utils$7 = utils$9;
+const common$8 = common$a;
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir$2(directory, settings);
+}
+sync$6.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: common$8.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils$7.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+sync$6.readdirWithFileTypes = readdirWithFileTypes;
+function readdir$2(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = common$8.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+        const stats = fsStat$4.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils$7.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
+sync$6.readdir = readdir$2;
+
+var settings$2 = {};
+
+var fs$c = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+	const fs = require$$0__default;
+	exports.FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    stat: fs.stat,
+	    lstatSync: fs.lstatSync,
+	    statSync: fs.statSync,
+	    readdir: fs.readdir,
+	    readdirSync: fs.readdirSync
+	};
+	function createFileSystemAdapter(fsMethods) {
+	    if (fsMethods === undefined) {
+	        return exports.FILE_SYSTEM_ADAPTER;
+	    }
+	    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+	}
+	exports.createFileSystemAdapter = createFileSystemAdapter; 
+} (fs$c));
+
+Object.defineProperty(settings$2, "__esModule", { value: true });
+const path$e = require$$0$4;
+const fsStat$3 = out$1;
+const fs$b = fs$c;
+let Settings$1 = class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs$b.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$e.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat$3.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+};
+settings$2.default = Settings$1;
+
+Object.defineProperty(out$2, "__esModule", { value: true });
+out$2.Settings = out$2.scandirSync = out$2.scandir = void 0;
+const async = async$3;
+const sync$5 = sync$6;
+const settings_1$2 = settings$2;
+out$2.Settings = settings_1$2.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        async.read(path, getSettings$1(), optionsOrSettingsOrCallback);
+        return;
+    }
+    async.read(path, getSettings$1(optionsOrSettingsOrCallback), callback);
+}
+out$2.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings$1(optionsOrSettings);
+    return sync$5.read(path, settings);
+}
+out$2.scandirSync = scandirSync;
+function getSettings$1(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$2.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$2.default(settingsOrOptions);
+}
+
+var queue = {exports: {}};
+
+function reusify$1 (Constructor) {
+  var head = new Constructor();
+  var tail = head;
+
+  function get () {
+    var current = head;
+
+    if (current.next) {
+      head = current.next;
+    } else {
+      head = new Constructor();
+      tail = head;
+    }
+
+    current.next = null;
+
+    return current
+  }
+
+  function release (obj) {
+    tail.next = obj;
+    tail = obj;
+  }
+
+  return {
+    get: get,
+    release: release
+  }
+}
+
+var reusify_1 = reusify$1;
+
+/* eslint-disable no-var */
+
+var reusify = reusify_1;
+
+function fastqueue (context, worker, _concurrency) {
+  if (typeof context === 'function') {
+    _concurrency = worker;
+    worker = context;
+    context = null;
+  }
+
+  if (!(_concurrency >= 1)) {
+    throw new Error('fastqueue concurrency must be equal to or greater than 1')
+  }
+
+  var cache = reusify(Task);
+  var queueHead = null;
+  var queueTail = null;
+  var _running = 0;
+  var errorHandler = null;
+
+  var self = {
+    push: push,
+    drain: noop$4,
+    saturated: noop$4,
+    pause: pause,
+    paused: false,
+
+    get concurrency () {
+      return _concurrency
+    },
+    set concurrency (value) {
+      if (!(value >= 1)) {
+        throw new Error('fastqueue concurrency must be equal to or greater than 1')
+      }
+      _concurrency = value;
+
+      if (self.paused) return
+      for (; queueHead && _running < _concurrency;) {
+        _running++;
+        release();
+      }
+    },
+
+    running: running,
+    resume: resume,
+    idle: idle,
+    length: length,
+    getQueue: getQueue,
+    unshift: unshift,
+    empty: noop$4,
+    kill: kill,
+    killAndDrain: killAndDrain,
+    error: error
+  };
+
+  return self
+
+  function running () {
+    return _running
+  }
+
+  function pause () {
+    self.paused = true;
+  }
+
+  function length () {
+    var current = queueHead;
+    var counter = 0;
+
+    while (current) {
+      current = current.next;
+      counter++;
+    }
+
+    return counter
+  }
+
+  function getQueue () {
+    var current = queueHead;
+    var tasks = [];
+
+    while (current) {
+      tasks.push(current.value);
+      current = current.next;
+    }
+
+    return tasks
+  }
+
+  function resume () {
+    if (!self.paused) return
+    self.paused = false;
+    if (queueHead === null) {
+      _running++;
+      release();
+      return
+    }
+    for (; queueHead && _running < _concurrency;) {
+      _running++;
+      release();
+    }
+  }
+
+  function idle () {
+    return _running === 0 && self.length() === 0
+  }
+
+  function push (value, done) {
+    var current = cache.get();
+
+    current.context = context;
+    current.release = release;
+    current.value = value;
+    current.callback = done || noop$4;
+    current.errorHandler = errorHandler;
+
+    if (_running >= _concurrency || self.paused) {
+      if (queueTail) {
+        queueTail.next = current;
+        queueTail = current;
+      } else {
+        queueHead = current;
+        queueTail = current;
+        self.saturated();
+      }
+    } else {
+      _running++;
+      worker.call(context, current.value, current.worked);
+    }
+  }
+
+  function unshift (value, done) {
+    var current = cache.get();
+
+    current.context = context;
+    current.release = release;
+    current.value = value;
+    current.callback = done || noop$4;
+    current.errorHandler = errorHandler;
+
+    if (_running >= _concurrency || self.paused) {
+      if (queueHead) {
+        current.next = queueHead;
+        queueHead = current;
+      } else {
+        queueHead = current;
+        queueTail = current;
+        self.saturated();
+      }
+    } else {
+      _running++;
+      worker.call(context, current.value, current.worked);
+    }
+  }
+
+  function release (holder) {
+    if (holder) {
+      cache.release(holder);
+    }
+    var next = queueHead;
+    if (next && _running <= _concurrency) {
+      if (!self.paused) {
+        if (queueTail === queueHead) {
+          queueTail = null;
+        }
+        queueHead = next.next;
+        next.next = null;
+        worker.call(context, next.value, next.worked);
+        if (queueTail === null) {
+          self.empty();
+        }
+      } else {
+        _running--;
+      }
+    } else if (--_running === 0) {
+      self.drain();
+    }
+  }
+
+  function kill () {
+    queueHead = null;
+    queueTail = null;
+    self.drain = noop$4;
+  }
+
+  function killAndDrain () {
+    queueHead = null;
+    queueTail = null;
+    self.drain();
+    self.drain = noop$4;
+  }
+
+  function error (handler) {
+    errorHandler = handler;
+  }
+}
+
+function noop$4 () {}
+
+function Task () {
+  this.value = null;
+  this.callback = noop$4;
+  this.next = null;
+  this.release = noop$4;
+  this.context = null;
+  this.errorHandler = null;
+
+  var self = this;
+
+  this.worked = function worked (err, result) {
+    var callback = self.callback;
+    var errorHandler = self.errorHandler;
+    var val = self.value;
+    self.value = null;
+    self.callback = noop$4;
+    if (self.errorHandler) {
+      errorHandler(err, val);
+    }
+    callback.call(self.context, err, result);
+    self.release(self);
+  };
+}
+
+function queueAsPromised (context, worker, _concurrency) {
+  if (typeof context === 'function') {
+    _concurrency = worker;
+    worker = context;
+    context = null;
+  }
+
+  function asyncWrapper (arg, cb) {
+    worker.call(this, arg)
+      .then(function (res) {
+        cb(null, res);
+      }, cb);
+  }
+
+  var queue = fastqueue(context, asyncWrapper, _concurrency);
+
+  var pushCb = queue.push;
+  var unshiftCb = queue.unshift;
+
+  queue.push = push;
+  queue.unshift = unshift;
+  queue.drained = drained;
+
+  return queue
+
+  function push (value) {
+    var p = new Promise(function (resolve, reject) {
+      pushCb(value, function (err, result) {
+        if (err) {
+          reject(err);
+          return
+        }
+        resolve(result);
+      });
+    });
+
+    // Let's fork the promise chain to
+    // make the error bubble up to the user but
+    // not lead to a unhandledRejection
+    p.catch(noop$4);
+
+    return p
+  }
+
+  function unshift (value) {
+    var p = new Promise(function (resolve, reject) {
+      unshiftCb(value, function (err, result) {
+        if (err) {
+          reject(err);
+          return
+        }
+        resolve(result);
+      });
+    });
+
+    // Let's fork the promise chain to
+    // make the error bubble up to the user but
+    // not lead to a unhandledRejection
+    p.catch(noop$4);
+
+    return p
+  }
+
+  function drained () {
+    if (queue.idle()) {
+      return new Promise(function (resolve) {
+        resolve();
+      })
+    }
+
+    var previousDrain = queue.drain;
+
+    var p = new Promise(function (resolve) {
+      queue.drain = function () {
+        previousDrain();
+        resolve();
+      };
+    });
+
+    return p
+  }
+}
+
+queue.exports = fastqueue;
+queue.exports.promise = queueAsPromised;
+
+var queueExports = queue.exports;
+
+var common$7 = {};
+
+Object.defineProperty(common$7, "__esModule", { value: true });
+common$7.joinPathSegments = common$7.replacePathSegmentSeparator = common$7.isAppliedFilter = common$7.isFatalError = void 0;
+function isFatalError(settings, error) {
+    if (settings.errorFilter === null) {
+        return true;
+    }
+    return !settings.errorFilter(error);
+}
+common$7.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+}
+common$7.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[/\\]/).join(separator);
+}
+common$7.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+    if (a === '') {
+        return b;
+    }
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+common$7.joinPathSegments = joinPathSegments;
+
+var reader$1 = {};
+
+Object.defineProperty(reader$1, "__esModule", { value: true });
+const common$6 = common$7;
+let Reader$1 = class Reader {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._root = common$6.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
+};
+reader$1.default = Reader$1;
+
+Object.defineProperty(async$4, "__esModule", { value: true });
+const events_1 = require$$0$7;
+const fsScandir$2 = out$2;
+const fastq = queueExports;
+const common$5 = common$7;
+const reader_1$4 = reader$1;
+class AsyncReader extends reader_1$4.default {
+    constructor(_root, _settings) {
+        super(_root, _settings);
+        this._settings = _settings;
+        this._scandir = fsScandir$2.scandir;
+        this._emitter = new events_1.EventEmitter();
+        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit('end');
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error('The reader is already destroyed');
+        }
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(callback) {
+        this._emitter.on('entry', callback);
+    }
+    onError(callback) {
+        this._emitter.once('error', callback);
+    }
+    onEnd(callback) {
+        this._emitter.once('end', callback);
+    }
+    _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+            if (error !== null) {
+                this._handleError(error);
+            }
+        });
+    }
+    _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+            if (error !== null) {
+                done(error, undefined);
+                return;
+            }
+            for (const entry of entries) {
+                this._handleEntry(entry, item.base);
+            }
+            done(null, undefined);
+        });
+    }
+    _handleError(error) {
+        if (this._isDestroyed || !common$5.isFatalError(this._settings, error)) {
+            return;
+        }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit('error', error);
+    }
+    _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
+        }
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common$5.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common$5.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._emitEntry(entry);
+        }
+        if (entry.dirent.isDirectory() && common$5.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
+        }
+    }
+    _emitEntry(entry) {
+        this._emitter.emit('entry', entry);
+    }
+}
+async$4.default = AsyncReader;
+
+Object.defineProperty(async$5, "__esModule", { value: true });
+const async_1$4 = async$4;
+class AsyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$4.default(this._root, this._settings);
+        this._storage = [];
+    }
+    read(callback) {
+        this._reader.onError((error) => {
+            callFailureCallback(callback, error);
+        });
+        this._reader.onEntry((entry) => {
+            this._storage.push(entry);
+        });
+        this._reader.onEnd(() => {
+            callSuccessCallback(callback, this._storage);
+        });
+        this._reader.read();
+    }
+}
+async$5.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, entries) {
+    callback(null, entries);
+}
+
+var stream$2 = {};
+
+Object.defineProperty(stream$2, "__esModule", { value: true });
+const stream_1$5 = require$$0$6;
+const async_1$3 = async$4;
+class StreamProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$3.default(this._root, this._settings);
+        this._stream = new stream_1$5.Readable({
+            objectMode: true,
+            read: () => { },
+            destroy: () => {
+                if (!this._reader.isDestroyed) {
+                    this._reader.destroy();
+                }
+            }
+        });
+    }
+    read() {
+        this._reader.onError((error) => {
+            this._stream.emit('error', error);
+        });
+        this._reader.onEntry((entry) => {
+            this._stream.push(entry);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
+    }
+}
+stream$2.default = StreamProvider;
+
+var sync$4 = {};
+
+var sync$3 = {};
+
+Object.defineProperty(sync$3, "__esModule", { value: true });
+const fsScandir$1 = out$2;
+const common$4 = common$7;
+const reader_1$3 = reader$1;
+class SyncReader extends reader_1$3.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = fsScandir$1.scandirSync;
+        this._storage = [];
+        this._queue = new Set();
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return this._storage;
+    }
+    _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+        for (const item of this._queue.values()) {
+            this._handleDirectory(item.directory, item.base);
+        }
+    }
+    _handleDirectory(directory, base) {
+        try {
+            const entries = this._scandir(directory, this._settings.fsScandirSettings);
+            for (const entry of entries) {
+                this._handleEntry(entry, base);
+            }
+        }
+        catch (error) {
+            this._handleError(error);
+        }
+    }
+    _handleError(error) {
+        if (!common$4.isFatalError(this._settings, error)) {
+            return;
+        }
+        throw error;
+    }
+    _handleEntry(entry, base) {
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common$4.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common$4.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._pushToStorage(entry);
+        }
+        if (entry.dirent.isDirectory() && common$4.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, base === undefined ? undefined : entry.path);
+        }
+    }
+    _pushToStorage(entry) {
+        this._storage.push(entry);
+    }
+}
+sync$3.default = SyncReader;
+
+Object.defineProperty(sync$4, "__esModule", { value: true });
+const sync_1$3 = sync$3;
+class SyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new sync_1$3.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
+sync$4.default = SyncProvider;
+
+var settings$1 = {};
+
+Object.defineProperty(settings$1, "__esModule", { value: true });
+const path$d = require$$0$4;
+const fsScandir = out$2;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$d.sep);
+        this.fsScandirSettings = new fsScandir.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+settings$1.default = Settings;
+
+Object.defineProperty(out$3, "__esModule", { value: true });
+out$3.Settings = out$3.walkStream = out$3.walkSync = out$3.walk = void 0;
+const async_1$2 = async$5;
+const stream_1$4 = stream$2;
+const sync_1$2 = sync$4;
+const settings_1$1 = settings$1;
+out$3.Settings = settings_1$1.default;
+function walk$2(directory, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        new async_1$2.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+        return;
+    }
+    new async_1$2.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+out$3.walk = walk$2;
+function walkSync(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new sync_1$2.default(directory, settings);
+    return provider.read();
+}
+out$3.walkSync = walkSync;
+function walkStream(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new stream_1$4.default(directory, settings);
+    return provider.read();
+}
+out$3.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$1.default(settingsOrOptions);
+}
+
+var reader = {};
+
+Object.defineProperty(reader, "__esModule", { value: true });
+const path$c = require$$0$4;
+const fsStat$2 = out$1;
+const utils$6 = utils$g;
+class Reader {
+    constructor(_settings) {
+        this._settings = _settings;
+        this._fsStatSettings = new fsStat$2.Settings({
+            followSymbolicLink: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
+    }
+    _getFullEntryPath(filepath) {
+        return path$c.resolve(this._settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+        const entry = {
+            name: pattern,
+            path: pattern,
+            dirent: utils$6.fs.createDirentFromStats(pattern, stats)
+        };
+        if (this._settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    }
+    _isFatalError(error) {
+        return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+    }
+}
+reader.default = Reader;
+
+var stream$1 = {};
+
+Object.defineProperty(stream$1, "__esModule", { value: true });
+const stream_1$3 = require$$0$6;
+const fsStat$1 = out$1;
+const fsWalk$2 = out$3;
+const reader_1$2 = reader;
+class ReaderStream extends reader_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._walkStream = fsWalk$2.walkStream;
+        this._stat = fsStat$1.stat;
+    }
+    dynamic(root, options) {
+        return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+        const filepaths = patterns.map(this._getFullEntryPath, this);
+        const stream = new stream_1$3.PassThrough({ objectMode: true });
+        stream._write = (index, _enc, done) => {
+            return this._getEntry(filepaths[index], patterns[index], options)
+                .then((entry) => {
+                if (entry !== null && options.entryFilter(entry)) {
+                    stream.push(entry);
+                }
+                if (index === filepaths.length - 1) {
+                    stream.end();
+                }
+                done();
+            })
+                .catch(done);
+        };
+        for (let i = 0; i < filepaths.length; i++) {
+            stream.write(i);
+        }
+        return stream;
+    }
+    _getEntry(filepath, pattern, options) {
+        return this._getStat(filepath)
+            .then((stats) => this._makeEntry(stats, pattern))
+            .catch((error) => {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        });
+    }
+    _getStat(filepath) {
+        return new Promise((resolve, reject) => {
+            this._stat(filepath, this._fsStatSettings, (error, stats) => {
+                return error === null ? resolve(stats) : reject(error);
+            });
+        });
+    }
+}
+stream$1.default = ReaderStream;
+
+Object.defineProperty(async$6, "__esModule", { value: true });
+const fsWalk$1 = out$3;
+const reader_1$1 = reader;
+const stream_1$2 = stream$1;
+class ReaderAsync extends reader_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._walkAsync = fsWalk$1.walk;
+        this._readerStream = new stream_1$2.default(this._settings);
+    }
+    dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+            this._walkAsync(root, options, (error, entries) => {
+                if (error === null) {
+                    resolve(entries);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async static(patterns, options) {
+        const entries = [];
+        const stream = this._readerStream.static(patterns, options);
+        // After #235, replace it with an asynchronous iterator.
+        return new Promise((resolve, reject) => {
+            stream.once('error', reject);
+            stream.on('data', (entry) => entries.push(entry));
+            stream.once('end', () => resolve(entries));
+        });
+    }
+}
+async$6.default = ReaderAsync;
+
+var provider = {};
+
+var deep = {};
+
+var partial = {};
+
+var matcher = {};
+
+Object.defineProperty(matcher, "__esModule", { value: true });
+const utils$5 = utils$g;
+class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+        this._patterns = _patterns;
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this._storage = [];
+        this._fillStorage();
+    }
+    _fillStorage() {
+        for (const pattern of this._patterns) {
+            const segments = this._getPatternSegments(pattern);
+            const sections = this._splitSegmentsIntoSections(segments);
+            this._storage.push({
+                complete: sections.length <= 1,
+                pattern,
+                segments,
+                sections
+            });
+        }
+    }
+    _getPatternSegments(pattern) {
+        const parts = utils$5.pattern.getPatternParts(pattern, this._micromatchOptions);
+        return parts.map((part) => {
+            const dynamic = utils$5.pattern.isDynamicPattern(part, this._settings);
+            if (!dynamic) {
+                return {
+                    dynamic: false,
+                    pattern: part
+                };
+            }
+            return {
+                dynamic: true,
+                pattern: part,
+                patternRe: utils$5.pattern.makeRe(part, this._micromatchOptions)
+            };
+        });
+    }
+    _splitSegmentsIntoSections(segments) {
+        return utils$5.array.splitWhen(segments, (segment) => segment.dynamic && utils$5.pattern.hasGlobStar(segment.pattern));
+    }
+}
+matcher.default = Matcher;
+
+Object.defineProperty(partial, "__esModule", { value: true });
+const matcher_1 = matcher;
+class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+        const parts = filepath.split('/');
+        const levels = parts.length;
+        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+        for (const pattern of patterns) {
+            const section = pattern.sections[0];
+            /**
+             * In this case, the pattern has a globstar and we must read all directories unconditionally,
+             * but only if the level has reached the end of the first group.
+             *
+             * fixtures/{a,b}/**
+             *  ^ true/false  ^ always true
+            */
+            if (!pattern.complete && levels > section.length) {
+                return true;
+            }
+            const match = parts.every((part, index) => {
+                const segment = pattern.segments[index];
+                if (segment.dynamic && segment.patternRe.test(part)) {
+                    return true;
+                }
+                if (!segment.dynamic && segment.pattern === part) {
+                    return true;
+                }
+                return false;
+            });
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+partial.default = PartialMatcher;
+
+Object.defineProperty(deep, "__esModule", { value: true });
+const utils$4 = utils$g;
+const partial_1 = partial;
+class DeepFilter {
+    constructor(_settings, _micromatchOptions) {
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+    }
+    getFilter(basePath, positive, negative) {
+        const matcher = this._getMatcher(positive);
+        const negativeRe = this._getNegativePatternsRe(negative);
+        return (entry) => this._filter(basePath, entry, matcher, negativeRe);
+    }
+    _getMatcher(patterns) {
+        return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(patterns) {
+        const affectDepthOfReadingPatterns = patterns.filter(utils$4.pattern.isAffectDepthOfReadingPattern);
+        return utils$4.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+    }
+    _filter(basePath, entry, matcher, negativeRe) {
+        if (this._isSkippedByDeep(basePath, entry.path)) {
+            return false;
+        }
+        if (this._isSkippedSymbolicLink(entry)) {
+            return false;
+        }
+        const filepath = utils$4.path.removeLeadingDotSegment(entry.path);
+        if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+            return false;
+        }
+        return this._isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    _isSkippedByDeep(basePath, entryPath) {
+        /**
+         * Avoid unnecessary depth calculations when it doesn't matter.
+         */
+        if (this._settings.deep === Infinity) {
+            return false;
+        }
+        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+    }
+    _getEntryLevel(basePath, entryPath) {
+        const entryPathDepth = entryPath.split('/').length;
+        if (basePath === '') {
+            return entryPathDepth;
+        }
+        const basePathDepth = basePath.split('/').length;
+        return entryPathDepth - basePathDepth;
+    }
+    _isSkippedSymbolicLink(entry) {
+        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(entryPath, matcher) {
+        return !this._settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    _isSkippedByNegativePatterns(entryPath, patternsRe) {
+        return !utils$4.pattern.matchAny(entryPath, patternsRe);
+    }
+}
+deep.default = DeepFilter;
+
+var entry$1 = {};
+
+Object.defineProperty(entry$1, "__esModule", { value: true });
+const utils$3 = utils$g;
+class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this.index = new Map();
+    }
+    getFilter(positive, negative) {
+        const positiveRe = utils$3.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+        const negativeRe = utils$3.pattern.convertPatternsToRe(negative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }));
+        return (entry) => this._filter(entry, positiveRe, negativeRe);
+    }
+    _filter(entry, positiveRe, negativeRe) {
+        const filepath = utils$3.path.removeLeadingDotSegment(entry.path);
+        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
+            return false;
+        }
+        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+            return false;
+        }
+        if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
+            return false;
+        }
+        const isDirectory = entry.dirent.isDirectory();
+        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
+        if (this._settings.unique && isMatched) {
+            this._createIndexRecord(filepath);
+        }
+        return isMatched;
+    }
+    _isDuplicateEntry(filepath) {
+        return this.index.has(filepath);
+    }
+    _createIndexRecord(filepath) {
+        this.index.set(filepath, undefined);
+    }
+    _onlyFileFilter(entry) {
+        return this._settings.onlyFiles && !entry.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry) {
+        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+    }
+    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+        if (!this._settings.absolute) {
+            return false;
+        }
+        const fullpath = utils$3.path.makeAbsolute(this._settings.cwd, entryPath);
+        return utils$3.pattern.matchAny(fullpath, patternsRe);
+    }
+    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+        // Trying to match files and directories by patterns.
+        const isMatched = utils$3.pattern.matchAny(filepath, patternsRe);
+        // A pattern with a trailling slash can be used for directory matching.
+        // To apply such pattern, we need to add a tralling slash to the path.
+        if (!isMatched && isDirectory) {
+            return utils$3.pattern.matchAny(filepath + '/', patternsRe);
+        }
+        return isMatched;
+    }
+}
+entry$1.default = EntryFilter;
+
+var error$1 = {};
+
+Object.defineProperty(error$1, "__esModule", { value: true });
+const utils$2 = utils$g;
+class ErrorFilter {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getFilter() {
+        return (error) => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+        return utils$2.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
+}
+error$1.default = ErrorFilter;
+
+var entry = {};
+
+Object.defineProperty(entry, "__esModule", { value: true });
+const utils$1 = utils$g;
+class EntryTransformer {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getTransformer() {
+        return (entry) => this._transform(entry);
+    }
+    _transform(entry) {
+        let filepath = entry.path;
+        if (this._settings.absolute) {
+            filepath = utils$1.path.makeAbsolute(this._settings.cwd, filepath);
+            filepath = utils$1.path.unixify(filepath);
+        }
+        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+            filepath += '/';
+        }
+        if (!this._settings.objectMode) {
+            return filepath;
+        }
+        return Object.assign(Object.assign({}, entry), { path: filepath });
+    }
+}
+entry.default = EntryTransformer;
+
+Object.defineProperty(provider, "__esModule", { value: true });
+const path$b = require$$0$4;
+const deep_1 = deep;
+const entry_1 = entry$1;
+const error_1 = error$1;
+const entry_2 = entry;
+class Provider {
+    constructor(_settings) {
+        this._settings = _settings;
+        this.errorFilter = new error_1.default(this._settings);
+        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+        this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+        return path$b.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+        const basePath = task.base === '.' ? '' : task.base;
+        return {
+            basePath,
+            pathSegmentSeparator: '/',
+            concurrency: this._settings.concurrency,
+            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            stats: this._settings.stats,
+            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer()
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this._settings.dot,
+            matchBase: this._settings.baseNameMatch,
+            nobrace: !this._settings.braceExpansion,
+            nocase: !this._settings.caseSensitiveMatch,
+            noext: !this._settings.extglob,
+            noglobstar: !this._settings.globstar,
+            posix: true,
+            strictSlashes: false
+        };
+    }
+}
+provider.default = Provider;
+
+Object.defineProperty(async$7, "__esModule", { value: true });
+const async_1$1 = async$6;
+const provider_1$2 = provider;
+class ProviderAsync extends provider_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new async_1$1.default(this._settings);
+    }
+    async read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = await this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+async$7.default = ProviderAsync;
+
+var stream = {};
+
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1$1 = require$$0$6;
+const stream_2 = stream$1;
+const provider_1$1 = provider;
+class ProviderStream extends provider_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new stream_1$1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+stream.default = ProviderStream;
+
+var sync$2 = {};
+
+var sync$1 = {};
+
+Object.defineProperty(sync$1, "__esModule", { value: true });
+const fsStat = out$1;
+const fsWalk = out$3;
+const reader_1 = reader;
+class ReaderSync extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkSync = fsWalk.walkSync;
+        this._statSync = fsStat.statSync;
+    }
+    dynamic(root, options) {
+        return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+        const entries = [];
+        for (const pattern of patterns) {
+            const filepath = this._getFullEntryPath(pattern);
+            const entry = this._getEntry(filepath, pattern, options);
+            if (entry === null || !options.entryFilter(entry)) {
+                continue;
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+    _getEntry(filepath, pattern, options) {
+        try {
+            const stats = this._getStat(filepath);
+            return this._makeEntry(stats, pattern);
+        }
+        catch (error) {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    _getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+    }
+}
+sync$1.default = ReaderSync;
+
+Object.defineProperty(sync$2, "__esModule", { value: true });
+const sync_1$1 = sync$1;
+const provider_1 = provider;
+class ProviderSync extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new sync_1$1.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = this.api(root, task, options);
+        return entries.map(options.transform);
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+sync$2.default = ProviderSync;
+
+var settings = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+	const fs = require$$0__default;
+	const os = require$$2;
+	/**
+	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
+	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
+	 */
+	const CPU_COUNT = Math.max(os.cpus().length, 1);
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    lstatSync: fs.lstatSync,
+	    stat: fs.stat,
+	    statSync: fs.statSync,
+	    readdir: fs.readdir,
+	    readdirSync: fs.readdirSync
+	};
+	class Settings {
+	    constructor(_options = {}) {
+	        this._options = _options;
+	        this.absolute = this._getValue(this._options.absolute, false);
+	        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+	        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+	        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+	        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+	        this.cwd = this._getValue(this._options.cwd, process.cwd());
+	        this.deep = this._getValue(this._options.deep, Infinity);
+	        this.dot = this._getValue(this._options.dot, false);
+	        this.extglob = this._getValue(this._options.extglob, true);
+	        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+	        this.fs = this._getFileSystemMethods(this._options.fs);
+	        this.globstar = this._getValue(this._options.globstar, true);
+	        this.ignore = this._getValue(this._options.ignore, []);
+	        this.markDirectories = this._getValue(this._options.markDirectories, false);
+	        this.objectMode = this._getValue(this._options.objectMode, false);
+	        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+	        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+	        this.stats = this._getValue(this._options.stats, false);
+	        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+	        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+	        this.unique = this._getValue(this._options.unique, true);
+	        if (this.onlyDirectories) {
+	            this.onlyFiles = false;
+	        }
+	        if (this.stats) {
+	            this.objectMode = true;
+	        }
+	        // Remove the cast to the array in the next major (#404).
+	        this.ignore = [].concat(this.ignore);
+	    }
+	    _getValue(option, value) {
+	        return option === undefined ? value : option;
+	    }
+	    _getFileSystemMethods(methods = {}) {
+	        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+	    }
+	}
+	exports.default = Settings; 
+} (settings));
+
+const taskManager = tasks;
+const async_1 = async$7;
+const stream_1 = stream;
+const sync_1 = sync$2;
+const settings_1 = settings;
+const utils = utils$g;
+async function FastGlob(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
+}
+// https://github.com/typescript-eslint/typescript-eslint/issues/60
+// eslint-disable-next-line no-redeclare
+(function (FastGlob) {
+    FastGlob.glob = FastGlob;
+    FastGlob.globSync = sync;
+    FastGlob.globStream = stream;
+    FastGlob.async = FastGlob;
+    function sync(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, sync_1.default, options);
+        return utils.array.flatten(works);
+    }
+    FastGlob.sync = sync;
+    function stream(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, stream_1.default, options);
+        /**
+         * The stream returned by the provider cannot work with an asynchronous iterator.
+         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+         * This affects performance (+25%). I don't see best solution right now.
+         */
+        return utils.stream.merge(works);
+    }
+    FastGlob.stream = stream;
+    function generateTasks(source, options) {
+        assertPatternsInput(source);
+        const patterns = [].concat(source);
+        const settings = new settings_1.default(options);
+        return taskManager.generate(patterns, settings);
+    }
+    FastGlob.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+        assertPatternsInput(source);
+        const settings = new settings_1.default(options);
+        return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escape(source);
+    }
+    FastGlob.escapePath = escapePath;
+    function convertPathToPattern(source) {
+        assertPatternsInput(source);
+        return utils.path.convertPathToPattern(source);
+    }
+    FastGlob.convertPathToPattern = convertPathToPattern;
+    (function (posix) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapePosixPath(source);
+        }
+        posix.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertPosixPathToPattern(source);
+        }
+        posix.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.posix || (FastGlob.posix = {}));
+    (function (win32) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapeWindowsPath(source);
+        }
+        win32.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertWindowsPathToPattern(source);
+        }
+        win32.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.win32 || (FastGlob.win32 = {}));
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+    const patterns = [].concat(source);
+    const settings = new settings_1.default(options);
+    const tasks = taskManager.generate(patterns, settings);
+    const provider = new _Provider(settings);
+    return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
+}
+var out = FastGlob;
+
+var glob = /*@__PURE__*/getDefaultExportFromCjs(out);
+
+var src$2 = {};
+
+// @ts-check
+const path$a = require$$0$4;
+const fs$a = require$$0__default;
+const os$3 = require$$2;
+
+const fsReadFileAsync = fs$a.promises.readFile;
+
+/** @type {(name: string, sync: boolean) => string[]} */
+function getDefaultSearchPlaces(name, sync) {
+	return [
+		'package.json',
+		`.${name}rc.json`,
+		`.${name}rc.js`,
+		`.${name}rc.cjs`,
+		...(sync ? [] : [`.${name}rc.mjs`]),
+		`.config/${name}rc`,
+		`.config/${name}rc.json`,
+		`.config/${name}rc.js`,
+		`.config/${name}rc.cjs`,
+		...(sync ? [] : [`.config/${name}rc.mjs`]),
+		`${name}.config.js`,
+		`${name}.config.cjs`,
+		...(sync ? [] : [`${name}.config.mjs`]),
+	];
+}
+
+/**
+ * @type {(p: string) => string}
+ *
+ * see #17
+ * On *nix, if cwd is not under homedir,
+ * the last path will be '', ('/build' -> '')
+ * but it should be '/' actually.
+ * And on Windows, this will never happen. ('C:\build' -> 'C:')
+ */
+function parentDir(p) {
+	return path$a.dirname(p) || path$a.sep;
+}
+
+/** @type {import('./index').LoaderSync} */
+const jsonLoader = (_, content) => JSON.parse(content);
+// Use plain require in webpack context for dynamic import
+const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+/** @type {import('./index').LoadersSync} */
+const defaultLoadersSync = Object.freeze({
+	'.js': requireFunc,
+	'.json': requireFunc,
+	'.cjs': requireFunc,
+	noExt: jsonLoader,
+});
+src$2.defaultLoadersSync = defaultLoadersSync;
+
+/** @type {import('./index').Loader} */
+const dynamicImport = async id => {
+	try {
+		const mod = await import(/* webpackIgnore: true */ id);
+
+		return mod.default;
+	} catch (e) {
+		try {
+			return requireFunc(id);
+		} catch (/** @type {any} */ requireE) {
+			if (
+				requireE.code === 'ERR_REQUIRE_ESM' ||
+				(requireE instanceof SyntaxError &&
+					requireE
+						.toString()
+						.includes('Cannot use import statement outside a module'))
+			) {
+				throw e;
+			}
+			throw requireE;
+		}
+	}
+};
+
+/** @type {import('./index').Loaders} */
+const defaultLoaders = Object.freeze({
+	'.js': dynamicImport,
+	'.mjs': dynamicImport,
+	'.cjs': dynamicImport,
+	'.json': jsonLoader,
+	noExt: jsonLoader,
+});
+src$2.defaultLoaders = defaultLoaders;
+
+/**
+ * @param {string} name
+ * @param {import('./index').Options | import('./index').OptionsSync} options
+ * @param {boolean} sync
+ * @returns {Required<import('./index').Options | import('./index').OptionsSync>}
+ */
+function getOptions(name, options, sync) {
+	/** @type {Required<import('./index').Options>} */
+	const conf = {
+		stopDir: os$3.homedir(),
+		searchPlaces: getDefaultSearchPlaces(name, sync),
+		ignoreEmptySearchPlaces: true,
+		cache: true,
+		transform: x => x,
+		packageProp: [name],
+		...options,
+		loaders: {
+			...(sync ? defaultLoadersSync : defaultLoaders),
+			...options.loaders,
+		},
+	};
+	conf.searchPlaces.forEach(place => {
+		const key = path$a.extname(place) || 'noExt';
+		const loader = conf.loaders[key];
+		if (!loader) {
+			throw new Error(`Missing loader for extension "${place}"`);
+		}
+
+		if (typeof loader !== 'function') {
+			throw new Error(
+				`Loader for extension "${place}" is not a function: Received ${typeof loader}.`,
+			);
+		}
+	});
+
+	return conf;
+}
+
+/** @type {(props: string | string[], obj: Record<string, any>) => unknown} */
+function getPackageProp(props, obj) {
+	if (typeof props === 'string' && props in obj) return obj[props];
+	return (
+		(Array.isArray(props) ? props : props.split('.')).reduce(
+			(acc, prop) => (acc === undefined ? acc : acc[prop]),
+			obj,
+		) || null
+	);
+}
+
+/** @param {string} filepath */
+function validateFilePath(filepath) {
+	if (!filepath) throw new Error('load must pass a non-empty string');
+}
+
+/** @type {(loader: import('./index').Loader, ext: string) => void} */
+function validateLoader(loader, ext) {
+	if (!loader) throw new Error(`No loader specified for extension "${ext}"`);
+	if (typeof loader !== 'function') throw new Error('loader is not a function');
+}
+
+/** @type {(enableCache: boolean) => <T>(c: Map<string, T>, filepath: string, res: T) => T} */
+const makeEmplace = enableCache => (c, filepath, res) => {
+	if (enableCache) c.set(filepath, res);
+	return res;
+};
+
+/** @type {import('./index').lilconfig} */
+src$2.lilconfig = function lilconfig(name, options) {
+	const {
+		ignoreEmptySearchPlaces,
+		loaders,
+		packageProp,
+		searchPlaces,
+		stopDir,
+		transform,
+		cache,
+	} = getOptions(name, options ?? {}, false);
+	const searchCache = new Map();
+	const loadCache = new Map();
+	const emplace = makeEmplace(cache);
+
+	return {
+		async search(searchFrom = process.cwd()) {
+			/** @type {import('./index').LilconfigResult} */
+			const result = {
+				config: null,
+				filepath: '',
+			};
+
+			/** @type {Set<string>} */
+			const visited = new Set();
+			let dir = searchFrom;
+			dirLoop: while (true) {
+				if (cache) {
+					const r = searchCache.get(dir);
+					if (r !== undefined) {
+						for (const p of visited) searchCache.set(p, r);
+						return r;
+					}
+					visited.add(dir);
+				}
+
+				for (const searchPlace of searchPlaces) {
+					const filepath = path$a.join(dir, searchPlace);
+					try {
+						await fs$a.promises.access(filepath);
+					} catch {
+						continue;
+					}
+					const content = String(await fsReadFileAsync(filepath));
+					const loaderKey = path$a.extname(searchPlace) || 'noExt';
+					const loader = loaders[loaderKey];
+
+					// handle package.json
+					if (searchPlace === 'package.json') {
+						const pkg = await loader(filepath, content);
+						const maybeConfig = getPackageProp(packageProp, pkg);
+						if (maybeConfig != null) {
+							result.config = maybeConfig;
+							result.filepath = filepath;
+							break dirLoop;
+						}
+
+						continue;
+					}
+
+					// handle other type of configs
+					const isEmpty = content.trim() === '';
+					if (isEmpty && ignoreEmptySearchPlaces) continue;
+
+					if (isEmpty) {
+						result.isEmpty = true;
+						result.config = undefined;
+					} else {
+						validateLoader(loader, loaderKey);
+						result.config = await loader(filepath, content);
+					}
+					result.filepath = filepath;
+					break dirLoop;
+				}
+				if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+				dir = parentDir(dir);
+			}
+
+			const transformed =
+				// not found
+				result.filepath === '' && result.config === null
+					? transform(null)
+					: transform(result);
+
+			if (cache) {
+				for (const p of visited) searchCache.set(p, transformed);
+			}
+
+			return transformed;
+		},
+		async load(filepath) {
+			validateFilePath(filepath);
+			const absPath = path$a.resolve(process.cwd(), filepath);
+			if (cache && loadCache.has(absPath)) {
+				return loadCache.get(absPath);
+			}
+			const {base, ext} = path$a.parse(absPath);
+			const loaderKey = ext || 'noExt';
+			const loader = loaders[loaderKey];
+			validateLoader(loader, loaderKey);
+			const content = String(await fsReadFileAsync(absPath));
+
+			if (base === 'package.json') {
+				const pkg = await loader(absPath, content);
+				return emplace(
+					loadCache,
+					absPath,
+					transform({
+						config: getPackageProp(packageProp, pkg),
+						filepath: absPath,
+					}),
+				);
+			}
+			/** @type {import('./index').LilconfigResult} */
+			const result = {
+				config: null,
+				filepath: absPath,
+			};
+			// handle other type of configs
+			const isEmpty = content.trim() === '';
+			if (isEmpty && ignoreEmptySearchPlaces)
+				return emplace(
+					loadCache,
+					absPath,
+					transform({
+						config: undefined,
+						filepath: absPath,
+						isEmpty: true,
+					}),
+				);
+
+			// cosmiconfig returns undefined for empty files
+			result.config = isEmpty ? undefined : await loader(absPath, content);
+
+			return emplace(
+				loadCache,
+				absPath,
+				transform(isEmpty ? {...result, isEmpty, config: undefined} : result),
+			);
+		},
+		clearLoadCache() {
+			if (cache) loadCache.clear();
+		},
+		clearSearchCache() {
+			if (cache) searchCache.clear();
+		},
+		clearCaches() {
+			if (cache) {
+				loadCache.clear();
+				searchCache.clear();
+			}
+		},
+	};
+};
+
+/** @type {import('./index').lilconfigSync} */
+src$2.lilconfigSync = function lilconfigSync(name, options) {
+	const {
+		ignoreEmptySearchPlaces,
+		loaders,
+		packageProp,
+		searchPlaces,
+		stopDir,
+		transform,
+		cache,
+	} = getOptions(name, options ?? {}, true);
+	const searchCache = new Map();
+	const loadCache = new Map();
+	const emplace = makeEmplace(cache);
+
+	return {
+		search(searchFrom = process.cwd()) {
+			/** @type {import('./index').LilconfigResult} */
+			const result = {
+				config: null,
+				filepath: '',
+			};
+
+			/** @type {Set<string>} */
+			const visited = new Set();
+			let dir = searchFrom;
+			dirLoop: while (true) {
+				if (cache) {
+					const r = searchCache.get(dir);
+					if (r !== undefined) {
+						for (const p of visited) searchCache.set(p, r);
+						return r;
+					}
+					visited.add(dir);
+				}
+
+				for (const searchPlace of searchPlaces) {
+					const filepath = path$a.join(dir, searchPlace);
+					try {
+						fs$a.accessSync(filepath);
+					} catch {
+						continue;
+					}
+					const loaderKey = path$a.extname(searchPlace) || 'noExt';
+					const loader = loaders[loaderKey];
+					const content = String(fs$a.readFileSync(filepath));
+
+					// handle package.json
+					if (searchPlace === 'package.json') {
+						const pkg = loader(filepath, content);
+						const maybeConfig = getPackageProp(packageProp, pkg);
+						if (maybeConfig != null) {
+							result.config = maybeConfig;
+							result.filepath = filepath;
+							break dirLoop;
+						}
+
+						continue;
+					}
+
+					// handle other type of configs
+					const isEmpty = content.trim() === '';
+					if (isEmpty && ignoreEmptySearchPlaces) continue;
+
+					if (isEmpty) {
+						result.isEmpty = true;
+						result.config = undefined;
+					} else {
+						validateLoader(loader, loaderKey);
+						result.config = loader(filepath, content);
+					}
+					result.filepath = filepath;
+					break dirLoop;
+				}
+				if (dir === stopDir || dir === parentDir(dir)) break dirLoop;
+				dir = parentDir(dir);
+			}
+
+			const transformed =
+				// not found
+				result.filepath === '' && result.config === null
+					? transform(null)
+					: transform(result);
+
+			if (cache) {
+				for (const p of visited) searchCache.set(p, transformed);
+			}
+
+			return transformed;
+		},
+		load(filepath) {
+			validateFilePath(filepath);
+			const absPath = path$a.resolve(process.cwd(), filepath);
+			if (cache && loadCache.has(absPath)) {
+				return loadCache.get(absPath);
+			}
+			const {base, ext} = path$a.parse(absPath);
+			const loaderKey = ext || 'noExt';
+			const loader = loaders[loaderKey];
+			validateLoader(loader, loaderKey);
+
+			const content = String(fs$a.readFileSync(absPath));
+
+			if (base === 'package.json') {
+				const pkg = loader(absPath, content);
+				return transform({
+					config: getPackageProp(packageProp, pkg),
+					filepath: absPath,
+				});
+			}
+			const result = {
+				config: null,
+				filepath: absPath,
+			};
+			// handle other type of configs
+			const isEmpty = content.trim() === '';
+			if (isEmpty && ignoreEmptySearchPlaces)
+				return emplace(
+					loadCache,
+					absPath,
+					transform({
+						filepath: absPath,
+						config: undefined,
+						isEmpty: true,
+					}),
+				);
+
+			// cosmiconfig returns undefined for empty files
+			result.config = isEmpty ? undefined : loader(absPath, content);
+
+			return emplace(
+				loadCache,
+				absPath,
+				transform(isEmpty ? {...result, isEmpty, config: undefined} : result),
+			);
+		},
+		clearLoadCache() {
+			if (cache) loadCache.clear();
+		},
+		clearSearchCache() {
+			if (cache) searchCache.clear();
+		},
+		clearCaches() {
+			if (cache) {
+				loadCache.clear();
+				searchCache.clear();
+			}
+		},
+	};
+};
+
+const ALIAS = Symbol.for('yaml.alias');
+const DOC = Symbol.for('yaml.document');
+const MAP = Symbol.for('yaml.map');
+const PAIR = Symbol.for('yaml.pair');
+const SCALAR$1 = Symbol.for('yaml.scalar');
+const SEQ = Symbol.for('yaml.seq');
+const NODE_TYPE = Symbol.for('yaml.node.type');
+const isAlias = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === ALIAS;
+const isDocument = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === DOC;
+const isMap = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === MAP;
+const isPair = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === PAIR;
+const isScalar$1 = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SCALAR$1;
+const isSeq = (node) => !!node && typeof node === 'object' && node[NODE_TYPE] === SEQ;
+function isCollection$1(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case MAP:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+function isNode$1(node) {
+    if (node && typeof node === 'object')
+        switch (node[NODE_TYPE]) {
+            case ALIAS:
+            case MAP:
+            case SCALAR$1:
+            case SEQ:
+                return true;
+        }
+    return false;
+}
+const hasAnchor = (node) => (isScalar$1(node) || isCollection$1(node)) && !!node.anchor;
+
+const BREAK$1 = Symbol('break visit');
+const SKIP$1 = Symbol('skip children');
+const REMOVE$1 = Symbol('remove node');
+/**
+ * Apply a visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+function visit$1(node, visitor) {
+    const visitor_ = initVisitor(visitor);
+    if (isDocument(node)) {
+        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
+        if (cd === REMOVE$1)
+            node.contents = null;
+    }
+    else
+        visit_(null, node, visitor_, Object.freeze([]));
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visit$1.BREAK = BREAK$1;
+/** Do not visit the children of the current node */
+visit$1.SKIP = SKIP$1;
+/** Remove the current node */
+visit$1.REMOVE = REMOVE$1;
+function visit_(key, node, visitor, path) {
+    const ctrl = callVisitor(key, node, visitor, path);
+    if (isNode$1(ctrl) || isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visit_(key, ctrl, visitor, path);
+    }
+    if (typeof ctrl !== 'symbol') {
+        if (isCollection$1(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = visit_(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK$1)
+                    return BREAK$1;
+                else if (ci === REMOVE$1) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = visit_('key', node.key, visitor, path);
+            if (ck === BREAK$1)
+                return BREAK$1;
+            else if (ck === REMOVE$1)
+                node.key = null;
+            const cv = visit_('value', node.value, visitor, path);
+            if (cv === BREAK$1)
+                return BREAK$1;
+            else if (cv === REMOVE$1)
+                node.value = null;
+        }
+    }
+    return ctrl;
+}
+/**
+ * Apply an async visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `Promise`: Must resolve to one of the following values
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+async function visitAsync(node, visitor) {
+    const visitor_ = initVisitor(visitor);
+    if (isDocument(node)) {
+        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));
+        if (cd === REMOVE$1)
+            node.contents = null;
+    }
+    else
+        await visitAsync_(null, node, visitor_, Object.freeze([]));
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visitAsync.BREAK = BREAK$1;
+/** Do not visit the children of the current node */
+visitAsync.SKIP = SKIP$1;
+/** Remove the current node */
+visitAsync.REMOVE = REMOVE$1;
+async function visitAsync_(key, node, visitor, path) {
+    const ctrl = await callVisitor(key, node, visitor, path);
+    if (isNode$1(ctrl) || isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visitAsync_(key, ctrl, visitor, path);
+    }
+    if (typeof ctrl !== 'symbol') {
+        if (isCollection$1(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = await visitAsync_(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK$1)
+                    return BREAK$1;
+                else if (ci === REMOVE$1) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = await visitAsync_('key', node.key, visitor, path);
+            if (ck === BREAK$1)
+                return BREAK$1;
+            else if (ck === REMOVE$1)
+                node.key = null;
+            const cv = await visitAsync_('value', node.value, visitor, path);
+            if (cv === BREAK$1)
+                return BREAK$1;
+            else if (cv === REMOVE$1)
+                node.value = null;
+        }
+    }
+    return ctrl;
+}
+function initVisitor(visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        return Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
+    }
+    return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+    if (typeof visitor === 'function')
+        return visitor(key, node, path);
+    if (isMap(node))
+        return visitor.Map?.(key, node, path);
+    if (isSeq(node))
+        return visitor.Seq?.(key, node, path);
+    if (isPair(node))
+        return visitor.Pair?.(key, node, path);
+    if (isScalar$1(node))
+        return visitor.Scalar?.(key, node, path);
+    if (isAlias(node))
+        return visitor.Alias?.(key, node, path);
+    return undefined;
+}
+function replaceNode(key, path, node) {
+    const parent = path[path.length - 1];
+    if (isCollection$1(parent)) {
+        parent.items[key] = node;
+    }
+    else if (isPair(parent)) {
+        if (key === 'key')
+            parent.key = node;
+        else
+            parent.value = node;
+    }
+    else if (isDocument(parent)) {
+        parent.contents = node;
+    }
+    else {
+        const pt = isAlias(parent) ? 'alias' : 'scalar';
+        throw new Error(`Cannot replace node with ${pt} parent`);
+    }
+}
+
+const escapeChars = {
+    '!': '%21',
+    ',': '%2C',
+    '[': '%5B',
+    ']': '%5D',
+    '{': '%7B',
+    '}': '%7D'
+};
+const escapeTagName = (tn) => tn.replace(/[!,[\]{}]/g, ch => escapeChars[ch]);
+class Directives {
+    constructor(yaml, tags) {
+        /**
+         * The directives-end/doc-start marker `---`. If `null`, a marker may still be
+         * included in the document's stringified representation.
+         */
+        this.docStart = null;
+        /** The doc-end marker `...`.  */
+        this.docEnd = false;
+        this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
+        this.tags = Object.assign({}, Directives.defaultTags, tags);
+    }
+    clone() {
+        const copy = new Directives(this.yaml, this.tags);
+        copy.docStart = this.docStart;
+        return copy;
+    }
+    /**
+     * During parsing, get a Directives instance for the current document and
+     * update the stream state according to the current version's spec.
+     */
+    atDocument() {
+        const res = new Directives(this.yaml, this.tags);
+        switch (this.yaml.version) {
+            case '1.1':
+                this.atNextDocument = true;
+                break;
+            case '1.2':
+                this.atNextDocument = false;
+                this.yaml = {
+                    explicit: Directives.defaultYaml.explicit,
+                    version: '1.2'
+                };
+                this.tags = Object.assign({}, Directives.defaultTags);
+                break;
+        }
+        return res;
+    }
+    /**
+     * @param onError - May be called even if the action was successful
+     * @returns `true` on success
+     */
+    add(line, onError) {
+        if (this.atNextDocument) {
+            this.yaml = { explicit: Directives.defaultYaml.explicit, version: '1.1' };
+            this.tags = Object.assign({}, Directives.defaultTags);
+            this.atNextDocument = false;
+        }
+        const parts = line.trim().split(/[ \t]+/);
+        const name = parts.shift();
+        switch (name) {
+            case '%TAG': {
+                if (parts.length !== 2) {
+                    onError(0, '%TAG directive should contain exactly two parts');
+                    if (parts.length < 2)
+                        return false;
+                }
+                const [handle, prefix] = parts;
+                this.tags[handle] = prefix;
+                return true;
+            }
+            case '%YAML': {
+                this.yaml.explicit = true;
+                if (parts.length !== 1) {
+                    onError(0, '%YAML directive should contain exactly one part');
+                    return false;
+                }
+                const [version] = parts;
+                if (version === '1.1' || version === '1.2') {
+                    this.yaml.version = version;
+                    return true;
+                }
+                else {
+                    const isValid = /^\d+\.\d+$/.test(version);
+                    onError(6, `Unsupported YAML version ${version}`, isValid);
+                    return false;
+                }
+            }
+            default:
+                onError(0, `Unknown directive ${name}`, true);
+                return false;
+        }
+    }
+    /**
+     * Resolves a tag, matching handles to those defined in %TAG directives.
+     *
+     * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+     *   `'!local'` tag, or `null` if unresolvable.
+     */
+    tagName(source, onError) {
+        if (source === '!')
+            return '!'; // non-specific tag
+        if (source[0] !== '!') {
+            onError(`Not a valid tag: ${source}`);
+            return null;
+        }
+        if (source[1] === '<') {
+            const verbatim = source.slice(2, -1);
+            if (verbatim === '!' || verbatim === '!!') {
+                onError(`Verbatim tags aren't resolved, so ${source} is invalid.`);
+                return null;
+            }
+            if (source[source.length - 1] !== '>')
+                onError('Verbatim tags must end with a >');
+            return verbatim;
+        }
+        const [, handle, suffix] = source.match(/^(.*!)([^!]*)$/s);
+        if (!suffix)
+            onError(`The ${source} tag has no suffix`);
+        const prefix = this.tags[handle];
+        if (prefix) {
+            try {
+                return prefix + decodeURIComponent(suffix);
+            }
+            catch (error) {
+                onError(String(error));
+                return null;
+            }
+        }
+        if (handle === '!')
+            return source; // local tag
+        onError(`Could not resolve tag: ${source}`);
+        return null;
+    }
+    /**
+     * Given a fully resolved tag, returns its printable string form,
+     * taking into account current tag prefixes and defaults.
+     */
+    tagString(tag) {
+        for (const [handle, prefix] of Object.entries(this.tags)) {
+            if (tag.startsWith(prefix))
+                return handle + escapeTagName(tag.substring(prefix.length));
+        }
+        return tag[0] === '!' ? tag : `!<${tag}>`;
+    }
+    toString(doc) {
+        const lines = this.yaml.explicit
+            ? [`%YAML ${this.yaml.version || '1.2'}`]
+            : [];
+        const tagEntries = Object.entries(this.tags);
+        let tagNames;
+        if (doc && tagEntries.length > 0 && isNode$1(doc.contents)) {
+            const tags = {};
+            visit$1(doc.contents, (_key, node) => {
+                if (isNode$1(node) && node.tag)
+                    tags[node.tag] = true;
+            });
+            tagNames = Object.keys(tags);
+        }
+        else
+            tagNames = [];
+        for (const [handle, prefix] of tagEntries) {
+            if (handle === '!!' && prefix === 'tag:yaml.org,2002:')
+                continue;
+            if (!doc || tagNames.some(tn => tn.startsWith(prefix)))
+                lines.push(`%TAG ${handle} ${prefix}`);
+        }
+        return lines.join('\n');
+    }
+}
+Directives.defaultYaml = { explicit: false, version: '1.2' };
+Directives.defaultTags = { '!!': 'tag:yaml.org,2002:' };
+
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+function anchorIsValid(anchor) {
+    if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+        const sa = JSON.stringify(anchor);
+        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;
+        throw new Error(msg);
+    }
+    return true;
+}
+function anchorNames(root) {
+    const anchors = new Set();
+    visit$1(root, {
+        Value(_key, node) {
+            if (node.anchor)
+                anchors.add(node.anchor);
+        }
+    });
+    return anchors;
+}
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+function findNewAnchor(prefix, exclude) {
+    for (let i = 1; true; ++i) {
+        const name = `${prefix}${i}`;
+        if (!exclude.has(name))
+            return name;
+    }
+}
+function createNodeAnchors(doc, prefix) {
+    const aliasObjects = [];
+    const sourceObjects = new Map();
+    let prevAnchors = null;
+    return {
+        onAnchor: (source) => {
+            aliasObjects.push(source);
+            if (!prevAnchors)
+                prevAnchors = anchorNames(doc);
+            const anchor = findNewAnchor(prefix, prevAnchors);
+            prevAnchors.add(anchor);
+            return anchor;
+        },
+        /**
+         * With circular references, the source node is only resolved after all
+         * of its child nodes are. This is why anchors are set only after all of
+         * the nodes have been created.
+         */
+        setAnchors: () => {
+            for (const source of aliasObjects) {
+                const ref = sourceObjects.get(source);
+                if (typeof ref === 'object' &&
+                    ref.anchor &&
+                    (isScalar$1(ref.node) || isCollection$1(ref.node))) {
+                    ref.node.anchor = ref.anchor;
+                }
+                else {
+                    const error = new Error('Failed to resolve repeated object (this should not happen)');
+                    error.source = source;
+                    throw error;
+                }
+            }
+        },
+        sourceObjects
+    };
+}
+
+/**
+ * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+ * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+ * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+ *
+ * Includes extensions for handling Map and Set objects.
+ */
+function applyReviver(reviver, obj, key, val) {
+    if (val && typeof val === 'object') {
+        if (Array.isArray(val)) {
+            for (let i = 0, len = val.length; i < len; ++i) {
+                const v0 = val[i];
+                const v1 = applyReviver(reviver, val, String(i), v0);
+                if (v1 === undefined)
+                    delete val[i];
+                else if (v1 !== v0)
+                    val[i] = v1;
+            }
+        }
+        else if (val instanceof Map) {
+            for (const k of Array.from(val.keys())) {
+                const v0 = val.get(k);
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    val.delete(k);
+                else if (v1 !== v0)
+                    val.set(k, v1);
+            }
+        }
+        else if (val instanceof Set) {
+            for (const v0 of Array.from(val)) {
+                const v1 = applyReviver(reviver, val, v0, v0);
+                if (v1 === undefined)
+                    val.delete(v0);
+                else if (v1 !== v0) {
+                    val.delete(v0);
+                    val.add(v1);
+                }
+            }
+        }
+        else {
+            for (const [k, v0] of Object.entries(val)) {
+                const v1 = applyReviver(reviver, val, k, v0);
+                if (v1 === undefined)
+                    delete val[k];
+                else if (v1 !== v0)
+                    val[k] = v1;
+            }
+        }
+    }
+    return reviver.call(obj, key, val);
+}
+
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    if (Array.isArray(value))
+        return value.map((v, i) => toJS(v, String(i), ctx));
+    if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        if (!ctx || !hasAnchor(value))
+            return value.toJSON(arg, ctx);
+        const data = { aliasCount: 0, count: 1, res: undefined };
+        ctx.anchors.set(value, data);
+        ctx.onCreate = res => {
+            data.res = res;
+            delete ctx.onCreate;
+        };
+        const res = value.toJSON(arg, ctx);
+        if (ctx.onCreate)
+            ctx.onCreate(res);
+        return res;
+    }
+    if (typeof value === 'bigint' && !ctx?.keep)
+        return Number(value);
+    return value;
+}
+
+class NodeBase {
+    constructor(type) {
+        Object.defineProperty(this, NODE_TYPE, { value: type });
+    }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** A plain JavaScript representation of this node. */
+    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        if (!isDocument(doc))
+            throw new TypeError('A document argument is required');
+        const ctx = {
+            anchors: new Map(),
+            doc,
+            keep: true,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS(this, '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+}
+
+class Alias extends NodeBase {
+    constructor(source) {
+        super(ALIAS);
+        this.source = source;
+        Object.defineProperty(this, 'tag', {
+            set() {
+                throw new Error('Alias nodes cannot have tags');
+            }
+        });
+    }
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc) {
+        let found = undefined;
+        visit$1(doc, {
+            Node: (_key, node) => {
+                if (node === this)
+                    return visit$1.BREAK;
+                if (node.anchor === this.source)
+                    found = node;
+            }
+        });
+        return found;
+    }
+    toJSON(_arg, ctx) {
+        if (!ctx)
+            return { source: this.source };
+        const { anchors, doc, maxAliasCount } = ctx;
+        const source = this.resolve(doc);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        let data = anchors.get(source);
+        if (!data) {
+            // Resolve anchors for Node.prototype.toJS()
+            toJS(source, null, ctx);
+            data = anchors.get(source);
+        }
+        /* istanbul ignore if */
+        if (!data || data.res === undefined) {
+            const msg = 'This should not happen: Alias anchor was not resolved?';
+            throw new ReferenceError(msg);
+        }
+        if (maxAliasCount >= 0) {
+            data.count += 1;
+            if (data.aliasCount === 0)
+                data.aliasCount = getAliasCount(doc, source, anchors);
+            if (data.count * data.aliasCount > maxAliasCount) {
+                const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                throw new ReferenceError(msg);
+            }
+        }
+        return data.res;
+    }
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
+    }
+}
+function getAliasCount(doc, node, anchors) {
+    if (isAlias(node)) {
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
+        return anchor ? anchor.count * anchor.aliasCount : 0;
+    }
+    else if (isCollection$1(node)) {
+        let count = 0;
+        for (const item of node.items) {
+            const c = getAliasCount(doc, item, anchors);
+            if (c > count)
+                count = c;
+        }
+        return count;
+    }
+    else if (isPair(node)) {
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
+        return Math.max(kc, vc);
+    }
+    return 1;
+}
+
+const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
+class Scalar extends NodeBase {
+    constructor(value) {
+        super(SCALAR$1);
+        this.value = value;
+    }
+    toJSON(arg, ctx) {
+        return ctx?.keep ? this.value : toJS(this.value, arg, ctx);
+    }
+    toString() {
+        return String(this.value);
+    }
+}
+Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar.PLAIN = 'PLAIN';
+Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+const defaultTagPrefix = 'tag:yaml.org,2002:';
+function findTagObject(value, tagName, tags) {
+    if (tagName) {
+        const match = tags.filter(t => t.tag === tagName);
+        const tagObj = match.find(t => !t.format) ?? match[0];
+        if (!tagObj)
+            throw new Error(`Tag ${tagName} not found`);
+        return tagObj;
+    }
+    return tags.find(t => t.identify?.(value) && !t.format);
+}
+function createNode(value, tagName, ctx) {
+    if (isDocument(value))
+        value = value.contents;
+    if (isNode$1(value))
+        return value;
+    if (isPair(value)) {
+        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);
+        map.items.push(value);
+        return map;
+    }
+    if (value instanceof String ||
+        value instanceof Number ||
+        value instanceof Boolean ||
+        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere
+    ) {
+        // https://tc39.es/ecma262/#sec-serializejsonproperty
+        value = value.valueOf();
+    }
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    // Detect duplicate references to the same object & use Alias nodes for all
+    // after first. The `ref` wrapper allows for circular references to resolve.
+    let ref = undefined;
+    if (aliasDuplicateObjects && value && typeof value === 'object') {
+        ref = sourceObjects.get(value);
+        if (ref) {
+            if (!ref.anchor)
+                ref.anchor = onAnchor(value);
+            return new Alias(ref.anchor);
+        }
+        else {
+            ref = { anchor: null, node: null };
+            sourceObjects.set(value, ref);
+        }
+    }
+    if (tagName?.startsWith('!!'))
+        tagName = defaultTagPrefix + tagName.slice(2);
+    let tagObj = findTagObject(value, tagName, schema.tags);
+    if (!tagObj) {
+        if (value && typeof value.toJSON === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            value = value.toJSON();
+        }
+        if (!value || typeof value !== 'object') {
+            const node = new Scalar(value);
+            if (ref)
+                ref.node = node;
+            return node;
+        }
+        tagObj =
+            value instanceof Map
+                ? schema[MAP]
+                : Symbol.iterator in Object(value)
+                    ? schema[SEQ]
+                    : schema[MAP];
+    }
+    if (onTagObj) {
+        onTagObj(tagObj);
+        delete ctx.onTagObj;
+    }
+    const node = tagObj?.createNode
+        ? tagObj.createNode(ctx.schema, value, ctx)
+        : typeof tagObj?.nodeClass?.from === 'function'
+            ? tagObj.nodeClass.from(ctx.schema, value, ctx)
+            : new Scalar(value);
+    if (tagName)
+        node.tag = tagName;
+    else if (!tagObj.default)
+        node.tag = tagObj.tag;
+    if (ref)
+        ref.node = node;
+    return node;
+}
+
+function collectionFromPath(schema, path, value) {
+    let v = value;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
+        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+            const a = [];
+            a[k] = v;
+            v = a;
+        }
+        else {
+            v = new Map([[k, v]]);
+        }
+    }
+    return createNode(v, undefined, {
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
+        },
+        schema,
+        sourceObjects: new Map()
+    });
+}
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
+const isEmptyPath = (path) => path == null ||
+    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
+class Collection extends NodeBase {
+    constructor(type, schema) {
+        super(type);
+        Object.defineProperty(this, 'schema', {
+            value: schema,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+    }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => isNode$1(it) || isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path, value) {
+        if (isEmptyPath(path))
+            this.add(value);
+        else {
+            const [key, ...rest] = path;
+            const node = this.get(key, true);
+            if (isCollection$1(node))
+                node.addIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.delete(key);
+        const node = this.get(key, true);
+        if (isCollection$1(node))
+            return node.deleteIn(rest);
+        else
+            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
+        const node = this.get(key, true);
+        if (rest.length === 0)
+            return !keepScalar && isScalar$1(node) ? node.value : node;
+        else
+            return isCollection$1(node) ? node.getIn(rest, keepScalar) : undefined;
+    }
+    hasAllNullValues(allowScalar) {
+        return this.items.every(node => {
+            if (!isPair(node))
+                return false;
+            const n = node.value;
+            return (n == null ||
+                (allowScalar &&
+                    isScalar$1(n) &&
+                    n.value == null &&
+                    !n.commentBefore &&
+                    !n.comment &&
+                    !n.tag));
+        });
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.has(key);
+        const node = this.get(key, true);
+        return isCollection$1(node) ? node.hasIn(rest) : false;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        const [key, ...rest] = path;
+        if (rest.length === 0) {
+            this.set(key, value);
+        }
+        else {
+            const node = this.get(key, true);
+            if (isCollection$1(node))
+                node.setIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+}
+
+/**
+ * Stringifies a comment.
+ *
+ * Empty comment lines are left empty,
+ * lines consisting of a single space are replaced by `#`,
+ * and all other lines are prefixed with a `#`.
+ */
+const stringifyComment = (str) => str.replace(/^(?!$)(?: $)?/gm, '#');
+function indentComment(comment, indent) {
+    if (/^\n+$/.test(comment))
+        return comment.substring(1);
+    return indent ? comment.replace(/^(?! *$)/gm, indent) : comment;
+}
+const lineComment = (str, indent, comment) => str.endsWith('\n')
+    ? indentComment(comment, indent)
+    : comment.includes('\n')
+        ? '\n' + indentComment(comment, indent)
+        : (str.endsWith(' ') ? '' : ' ') + comment;
+
+const FOLD_FLOW = 'flow';
+const FOLD_BLOCK = 'block';
+const FOLD_QUOTED = 'quoted';
+/**
+ * Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+ * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+ * terminated with `\n` and started with `indent`.
+ */
+function foldFlowLines(text, indent, mode = 'flow', { indentAtStart, lineWidth = 80, minContentWidth = 20, onFold, onOverflow } = {}) {
+    if (!lineWidth || lineWidth < 0)
+        return text;
+    if (lineWidth < minContentWidth)
+        minContentWidth = 0;
+    const endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length);
+    if (text.length <= endStep)
+        return text;
+    const folds = [];
+    const escapedFolds = {};
+    let end = lineWidth - indent.length;
+    if (typeof indentAtStart === 'number') {
+        if (indentAtStart > lineWidth - Math.max(2, minContentWidth))
+            folds.push(0);
+        else
+            end = lineWidth - indentAtStart;
+    }
+    let split = undefined;
+    let prev = undefined;
+    let overflow = false;
+    let i = -1;
+    let escStart = -1;
+    let escEnd = -1;
+    if (mode === FOLD_BLOCK) {
+        i = consumeMoreIndentedLines(text, i, indent.length);
+        if (i !== -1)
+            end = i + endStep;
+    }
+    for (let ch; (ch = text[(i += 1)]);) {
+        if (mode === FOLD_QUOTED && ch === '\\') {
+            escStart = i;
+            switch (text[i + 1]) {
+                case 'x':
+                    i += 3;
+                    break;
+                case 'u':
+                    i += 5;
+                    break;
+                case 'U':
+                    i += 9;
+                    break;
+                default:
+                    i += 1;
+            }
+            escEnd = i;
+        }
+        if (ch === '\n') {
+            if (mode === FOLD_BLOCK)
+                i = consumeMoreIndentedLines(text, i, indent.length);
+            end = i + indent.length + endStep;
+            split = undefined;
+        }
+        else {
+            if (ch === ' ' &&
+                prev &&
+                prev !== ' ' &&
+                prev !== '\n' &&
+                prev !== '\t') {
+                // space surrounded by non-space can be replaced with newline + indent
+                const next = text[i + 1];
+                if (next && next !== ' ' && next !== '\n' && next !== '\t')
+                    split = i;
+            }
+            if (i >= end) {
+                if (split) {
+                    folds.push(split);
+                    end = split + endStep;
+                    split = undefined;
+                }
+                else if (mode === FOLD_QUOTED) {
+                    // white-space collected at end may stretch past lineWidth
+                    while (prev === ' ' || prev === '\t') {
+                        prev = ch;
+                        ch = text[(i += 1)];
+                        overflow = true;
+                    }
+                    // Account for newline escape, but don't break preceding escape
+                    const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+                    // Bail out if lineWidth & minContentWidth are shorter than an escape string
+                    if (escapedFolds[j])
+                        return text;
+                    folds.push(j);
+                    escapedFolds[j] = true;
+                    end = j + endStep;
+                    split = undefined;
+                }
+                else {
+                    overflow = true;
+                }
+            }
+        }
+        prev = ch;
+    }
+    if (overflow && onOverflow)
+        onOverflow();
+    if (folds.length === 0)
+        return text;
+    if (onFold)
+        onFold();
+    let res = text.slice(0, folds[0]);
+    for (let i = 0; i < folds.length; ++i) {
+        const fold = folds[i];
+        const end = folds[i + 1] || text.length;
+        if (fold === 0)
+            res = `\n${indent}${text.slice(0, end)}`;
+        else {
+            if (mode === FOLD_QUOTED && escapedFolds[fold])
+                res += `${text[fold]}\\`;
+            res += `\n${indent}${text.slice(fold + 1, end)}`;
+        }
+    }
+    return res;
+}
+/**
+ * Presumes `i + 1` is at the start of a line
+ * @returns index of last newline in more-indented block
+ */
+function consumeMoreIndentedLines(text, i, indent) {
+    let end = i;
+    let start = i + 1;
+    let ch = text[start];
+    while (ch === ' ' || ch === '\t') {
+        if (i < start + indent) {
+            ch = text[++i];
+        }
+        else {
+            do {
+                ch = text[++i];
+            } while (ch && ch !== '\n');
+            end = i;
+            start = i + 1;
+            ch = text[start];
+        }
+    }
+    return end;
+}
+
+const getFoldOptions = (ctx, isBlock) => ({
+    indentAtStart: isBlock ? ctx.indent.length : ctx.indentAtStart,
+    lineWidth: ctx.options.lineWidth,
+    minContentWidth: ctx.options.minContentWidth
+});
+// Also checks for lines starting with %, as parsing the output as YAML 1.1 will
+// presume that's starting a new document.
+const containsDocumentMarker = (str) => /^(%|---|\.\.\.)/m.test(str);
+function lineLengthOverLimit(str, lineWidth, indentLength) {
+    if (!lineWidth || lineWidth < 0)
+        return false;
+    const limit = lineWidth - indentLength;
+    const strLen = str.length;
+    if (strLen <= limit)
+        return false;
+    for (let i = 0, start = 0; i < strLen; ++i) {
+        if (str[i] === '\n') {
+            if (i - start > limit)
+                return true;
+            start = i + 1;
+            if (strLen - start <= limit)
+                return false;
+        }
+    }
+    return true;
+}
+function doubleQuotedString(value, ctx) {
+    const json = JSON.stringify(value);
+    if (ctx.options.doubleQuotedAsJSON)
+        return json;
+    const { implicitKey } = ctx;
+    const minMultiLineLength = ctx.options.doubleQuotedMinMultiLineLength;
+    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
+    let str = '';
+    let start = 0;
+    for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
+        if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') {
+            // space before newline needs to be escaped to not be folded
+            str += json.slice(start, i) + '\\ ';
+            i += 1;
+            start = i;
+            ch = '\\';
+        }
+        if (ch === '\\')
+            switch (json[i + 1]) {
+                case 'u':
+                    {
+                        str += json.slice(start, i);
+                        const code = json.substr(i + 2, 4);
+                        switch (code) {
+                            case '0000':
+                                str += '\\0';
+                                break;
+                            case '0007':
+                                str += '\\a';
+                                break;
+                            case '000b':
+                                str += '\\v';
+                                break;
+                            case '001b':
+                                str += '\\e';
+                                break;
+                            case '0085':
+                                str += '\\N';
+                                break;
+                            case '00a0':
+                                str += '\\_';
+                                break;
+                            case '2028':
+                                str += '\\L';
+                                break;
+                            case '2029':
+                                str += '\\P';
+                                break;
+                            default:
+                                if (code.substr(0, 2) === '00')
+                                    str += '\\x' + code.substr(2);
+                                else
+                                    str += json.substr(i, 6);
+                        }
+                        i += 5;
+                        start = i + 1;
+                    }
+                    break;
+                case 'n':
+                    if (implicitKey ||
+                        json[i + 2] === '"' ||
+                        json.length < minMultiLineLength) {
+                        i += 1;
+                    }
+                    else {
+                        // folding will eat first newline
+                        str += json.slice(start, i) + '\n\n';
+                        while (json[i + 2] === '\\' &&
+                            json[i + 3] === 'n' &&
+                            json[i + 4] !== '"') {
+                            str += '\n';
+                            i += 2;
+                        }
+                        str += indent;
+                        // space after newline needs to be escaped to not be folded
+                        if (json[i + 2] === ' ')
+                            str += '\\';
+                        i += 1;
+                        start = i + 1;
+                    }
+                    break;
+                default:
+                    i += 1;
+            }
+    }
+    str = start ? str + json.slice(start) : json;
+    return implicitKey
+        ? str
+        : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx, false));
+}
+function singleQuotedString(value, ctx) {
+    if (ctx.options.singleQuote === false ||
+        (ctx.implicitKey && value.includes('\n')) ||
+        /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline
+    )
+        return doubleQuotedString(value, ctx);
+    const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
+    const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
+    return ctx.implicitKey
+        ? res
+        : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function quotedString(value, ctx) {
+    const { singleQuote } = ctx.options;
+    let qs;
+    if (singleQuote === false)
+        qs = doubleQuotedString;
+    else {
+        const hasDouble = value.includes('"');
+        const hasSingle = value.includes("'");
+        if (hasDouble && !hasSingle)
+            qs = singleQuotedString;
+        else if (hasSingle && !hasDouble)
+            qs = doubleQuotedString;
+        else
+            qs = singleQuote ? singleQuotedString : doubleQuotedString;
+    }
+    return qs(value, ctx);
+}
+// The negative lookbehind avoids a polynomial search,
+// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind
+let blockEndNewlines;
+try {
+    blockEndNewlines = new RegExp('(^|(?<!\n))\n+(?!\n|$)', 'g');
+}
+catch {
+    blockEndNewlines = /\n+(?!\n|$)/g;
+}
+function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
+    const { blockQuote, commentString, lineWidth } = ctx.options;
+    // 1. Block can't end in whitespace unless the last line is non-empty.
+    // 2. Strings consisting of only whitespace are best rendered explicitly.
+    if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
+        return quotedString(value, ctx);
+    }
+    const indent = ctx.indent ||
+        (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
+    const literal = blockQuote === 'literal'
+        ? true
+        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED
+            ? false
+            : type === Scalar.BLOCK_LITERAL
+                ? true
+                : !lineLengthOverLimit(value, lineWidth, indent.length);
+    if (!value)
+        return literal ? '|\n' : '>\n';
+    // determine chomping from whitespace at value end
+    let chomp;
+    let endStart;
+    for (endStart = value.length; endStart > 0; --endStart) {
+        const ch = value[endStart - 1];
+        if (ch !== '\n' && ch !== '\t' && ch !== ' ')
+            break;
+    }
+    let end = value.substring(endStart);
+    const endNlPos = end.indexOf('\n');
+    if (endNlPos === -1) {
+        chomp = '-'; // strip
+    }
+    else if (value === end || endNlPos !== end.length - 1) {
+        chomp = '+'; // keep
+        if (onChompKeep)
+            onChompKeep();
+    }
+    else {
+        chomp = ''; // clip
+    }
+    if (end) {
+        value = value.slice(0, -end.length);
+        if (end[end.length - 1] === '\n')
+            end = end.slice(0, -1);
+        end = end.replace(blockEndNewlines, `$&${indent}`);
+    }
+    // determine indent indicator from whitespace at value start
+    let startWithSpace = false;
+    let startEnd;
+    let startNlPos = -1;
+    for (startEnd = 0; startEnd < value.length; ++startEnd) {
+        const ch = value[startEnd];
+        if (ch === ' ')
+            startWithSpace = true;
+        else if (ch === '\n')
+            startNlPos = startEnd;
+        else
+            break;
+    }
+    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+    if (start) {
+        value = value.substring(start.length);
+        start = start.replace(/\n+/g, `$&${indent}`);
+    }
+    const indentSize = indent ? '2' : '1'; // root is at -1
+    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
+    if (comment) {
+        header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
+        if (onComment)
+            onComment();
+    }
+    if (literal) {
+        value = value.replace(/\n+/g, `$&${indent}`);
+        return `${header}\n${indent}${start}${value}${end}`;
+    }
+    value = value
+        .replace(/\n+/g, '\n$&')
+        .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
+        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
+        .replace(/\n+/g, `$&${indent}`);
+    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx, true));
+    return `${header}\n${indent}${body}`;
+}
+function plainString(item, ctx, onComment, onChompKeep) {
+    const { type, value } = item;
+    const { actualString, implicitKey, indent, indentStep, inFlow } = ctx;
+    if ((implicitKey && value.includes('\n')) ||
+        (inFlow && /[[\]{},]/.test(value))) {
+        return quotedString(value, ctx);
+    }
+    if (!value ||
+        /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
+        // not allowed:
+        // - empty string, '-' or '?'
+        // - start with an indicator character (except [?:-]) or /[?-] /
+        // - '\n ', ': ' or ' \n' anywhere
+        // - '#' not preceded by a non-space char
+        // - end with ' ' or ':'
+        return implicitKey || inFlow || !value.includes('\n')
+            ? quotedString(value, ctx)
+            : blockString(item, ctx, onComment, onChompKeep);
+    }
+    if (!implicitKey &&
+        !inFlow &&
+        type !== Scalar.PLAIN &&
+        value.includes('\n')) {
+        // Where allowed & type not set explicitly, prefer block style for multiline strings
+        return blockString(item, ctx, onComment, onChompKeep);
+    }
+    if (containsDocumentMarker(value)) {
+        if (indent === '') {
+            ctx.forceBlockIndent = true;
+            return blockString(item, ctx, onComment, onChompKeep);
+        }
+        else if (implicitKey && indent === indentStep) {
+            return quotedString(value, ctx);
+        }
+    }
+    const str = value.replace(/\n+/g, `$&\n${indent}`);
+    // Verify that output will be parsed as a string, as e.g. plain numbers and
+    // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
+    // and others in v1.1.
+    if (actualString) {
+        const test = (tag) => tag.default && tag.tag !== 'tag:yaml.org,2002:str' && tag.test?.test(str);
+        const { compat, tags } = ctx.doc.schema;
+        if (tags.some(test) || compat?.some(test))
+            return quotedString(value, ctx);
+    }
+    return implicitKey
+        ? str
+        : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx, false));
+}
+function stringifyString(item, ctx, onComment, onChompKeep) {
+    const { implicitKey, inFlow } = ctx;
+    const ss = typeof item.value === 'string'
+        ? item
+        : Object.assign({}, item, { value: String(item.value) });
+    let { type } = item;
+    if (type !== Scalar.QUOTE_DOUBLE) {
+        // force double quotes on control characters & unpaired surrogates
+        if (/[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(ss.value))
+            type = Scalar.QUOTE_DOUBLE;
+    }
+    const _stringify = (_type) => {
+        switch (_type) {
+            case Scalar.BLOCK_FOLDED:
+            case Scalar.BLOCK_LITERAL:
+                return implicitKey || inFlow
+                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
+                    : blockString(ss, ctx, onComment, onChompKeep);
+            case Scalar.QUOTE_DOUBLE:
+                return doubleQuotedString(ss.value, ctx);
+            case Scalar.QUOTE_SINGLE:
+                return singleQuotedString(ss.value, ctx);
+            case Scalar.PLAIN:
+                return plainString(ss, ctx, onComment, onChompKeep);
+            default:
+                return null;
+        }
+    };
+    let res = _stringify(type);
+    if (res === null) {
+        const { defaultKeyType, defaultStringType } = ctx.options;
+        const t = (implicitKey && defaultKeyType) || defaultStringType;
+        res = _stringify(t);
+        if (res === null)
+            throw new Error(`Unsupported default string type ${t}`);
+    }
+    return res;
+}
+
+function createStringifyContext(doc, options) {
+    const opt = Object.assign({
+        blockQuote: true,
+        commentString: stringifyComment,
+        defaultKeyType: null,
+        defaultStringType: 'PLAIN',
+        directives: null,
+        doubleQuotedAsJSON: false,
+        doubleQuotedMinMultiLineLength: 40,
+        falseStr: 'false',
+        flowCollectionPadding: true,
+        indentSeq: true,
+        lineWidth: 80,
+        minContentWidth: 20,
+        nullStr: 'null',
+        simpleKeys: false,
+        singleQuote: null,
+        trueStr: 'true',
+        verifyAliasOrder: true
+    }, doc.schema.toStringOptions, options);
+    let inFlow;
+    switch (opt.collectionStyle) {
+        case 'block':
+            inFlow = false;
+            break;
+        case 'flow':
+            inFlow = true;
+            break;
+        default:
+            inFlow = null;
+    }
+    return {
+        anchors: new Set(),
+        doc,
+        flowCollectionPadding: opt.flowCollectionPadding ? ' ' : '',
+        indent: '',
+        indentStep: typeof opt.indent === 'number' ? ' '.repeat(opt.indent) : '  ',
+        inFlow,
+        options: opt
+    };
+}
+function getTagObject(tags, item) {
+    if (item.tag) {
+        const match = tags.filter(t => t.tag === item.tag);
+        if (match.length > 0)
+            return match.find(t => t.format === item.format) ?? match[0];
+    }
+    let tagObj = undefined;
+    let obj;
+    if (isScalar$1(item)) {
+        obj = item.value;
+        const match = tags.filter(t => t.identify?.(obj));
+        tagObj =
+            match.find(t => t.format === item.format) ?? match.find(t => !t.format);
+    }
+    else {
+        obj = item;
+        tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
+    }
+    if (!tagObj) {
+        const name = obj?.constructor?.name ?? typeof obj;
+        throw new Error(`Tag not resolved for ${name} value`);
+    }
+    return tagObj;
+}
+// needs to be called before value stringifier to allow for circular anchor refs
+function stringifyProps(node, tagObj, { anchors, doc }) {
+    if (!doc.directives)
+        return '';
+    const props = [];
+    const anchor = (isScalar$1(node) || isCollection$1(node)) && node.anchor;
+    if (anchor && anchorIsValid(anchor)) {
+        anchors.add(anchor);
+        props.push(`&${anchor}`);
+    }
+    const tag = node.tag ? node.tag : tagObj.default ? null : tagObj.tag;
+    if (tag)
+        props.push(doc.directives.tagString(tag));
+    return props.join(' ');
+}
+function stringify$2(item, ctx, onComment, onChompKeep) {
+    if (isPair(item))
+        return item.toString(ctx, onComment, onChompKeep);
+    if (isAlias(item)) {
+        if (ctx.doc.directives)
+            return item.toString(ctx);
+        if (ctx.resolvedAliases?.has(item)) {
+            throw new TypeError(`Cannot stringify circular structure without alias nodes`);
+        }
+        else {
+            if (ctx.resolvedAliases)
+                ctx.resolvedAliases.add(item);
+            else
+                ctx.resolvedAliases = new Set([item]);
+            item = item.resolve(ctx.doc);
+        }
+    }
+    let tagObj = undefined;
+    const node = isNode$1(item)
+        ? item
+        : ctx.doc.createNode(item, { onTagObj: o => (tagObj = o) });
+    if (!tagObj)
+        tagObj = getTagObject(ctx.doc.schema.tags, node);
+    const props = stringifyProps(node, tagObj, ctx);
+    if (props.length > 0)
+        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
+    const str = typeof tagObj.stringify === 'function'
+        ? tagObj.stringify(node, ctx, onComment, onChompKeep)
+        : isScalar$1(node)
+            ? stringifyString(node, ctx, onComment, onChompKeep)
+            : node.toString(ctx, onComment, onChompKeep);
+    if (!props)
+        return str;
+    return isScalar$1(node) || str[0] === '{' || str[0] === '['
+        ? `${props} ${str}`
+        : `${props}\n${ctx.indent}${str}`;
+}
+
+function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+    const { allNullValues, doc, indent, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
+    let keyComment = (isNode$1(key) && key.comment) || null;
+    if (simpleKeys) {
+        if (keyComment) {
+            throw new Error('With simple keys, key nodes cannot have comments');
+        }
+        if (isCollection$1(key) || (!isNode$1(key) && typeof key === 'object')) {
+            const msg = 'With simple keys, collection cannot be used as a key value';
+            throw new Error(msg);
+        }
+    }
+    let explicitKey = !simpleKeys &&
+        (!key ||
+            (keyComment && value == null && !ctx.inFlow) ||
+            isCollection$1(key) ||
+            (isScalar$1(key)
+                ? key.type === Scalar.BLOCK_FOLDED || key.type === Scalar.BLOCK_LITERAL
+                : typeof key === 'object'));
+    ctx = Object.assign({}, ctx, {
+        allNullValues: false,
+        implicitKey: !explicitKey && (simpleKeys || !allNullValues),
+        indent: indent + indentStep
+    });
+    let keyCommentDone = false;
+    let chompKeep = false;
+    let str = stringify$2(key, ctx, () => (keyCommentDone = true), () => (chompKeep = true));
+    if (!explicitKey && !ctx.inFlow && str.length > 1024) {
+        if (simpleKeys)
+            throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
+        explicitKey = true;
+    }
+    if (ctx.inFlow) {
+        if (allNullValues || value == null) {
+            if (keyCommentDone && onComment)
+                onComment();
+            return str === '' ? '?' : explicitKey ? `? ${str}` : str;
+        }
+    }
+    else if ((allNullValues && !simpleKeys) || (value == null && explicitKey)) {
+        str = `? ${str}`;
+        if (keyComment && !keyCommentDone) {
+            str += lineComment(str, ctx.indent, commentString(keyComment));
+        }
+        else if (chompKeep && onChompKeep)
+            onChompKeep();
+        return str;
+    }
+    if (keyCommentDone)
+        keyComment = null;
+    if (explicitKey) {
+        if (keyComment)
+            str += lineComment(str, ctx.indent, commentString(keyComment));
+        str = `? ${str}\n${indent}:`;
+    }
+    else {
+        str = `${str}:`;
+        if (keyComment)
+            str += lineComment(str, ctx.indent, commentString(keyComment));
+    }
+    let vsb, vcb, valueComment;
+    if (isNode$1(value)) {
+        vsb = !!value.spaceBefore;
+        vcb = value.commentBefore;
+        valueComment = value.comment;
+    }
+    else {
+        vsb = false;
+        vcb = null;
+        valueComment = null;
+        if (value && typeof value === 'object')
+            value = doc.createNode(value);
+    }
+    ctx.implicitKey = false;
+    if (!explicitKey && !keyComment && isScalar$1(value))
+        ctx.indentAtStart = str.length + 1;
+    chompKeep = false;
+    if (!indentSeq &&
+        indentStep.length >= 2 &&
+        !ctx.inFlow &&
+        !explicitKey &&
+        isSeq(value) &&
+        !value.flow &&
+        !value.tag &&
+        !value.anchor) {
+        // If indentSeq === false, consider '- ' as part of indentation where possible
+        ctx.indent = ctx.indent.substring(2);
+    }
+    let valueCommentDone = false;
+    const valueStr = stringify$2(value, ctx, () => (valueCommentDone = true), () => (chompKeep = true));
+    let ws = ' ';
+    if (keyComment || vsb || vcb) {
+        ws = vsb ? '\n' : '';
+        if (vcb) {
+            const cs = commentString(vcb);
+            ws += `\n${indentComment(cs, ctx.indent)}`;
+        }
+        if (valueStr === '' && !ctx.inFlow) {
+            if (ws === '\n')
+                ws = '\n\n';
+        }
+        else {
+            ws += `\n${ctx.indent}`;
+        }
+    }
+    else if (!explicitKey && isCollection$1(value)) {
+        const vs0 = valueStr[0];
+        const nl0 = valueStr.indexOf('\n');
+        const hasNewline = nl0 !== -1;
+        const flow = ctx.inFlow ?? value.flow ?? value.items.length === 0;
+        if (hasNewline || !flow) {
+            let hasPropsLine = false;
+            if (hasNewline && (vs0 === '&' || vs0 === '!')) {
+                let sp0 = valueStr.indexOf(' ');
+                if (vs0 === '&' &&
+                    sp0 !== -1 &&
+                    sp0 < nl0 &&
+                    valueStr[sp0 + 1] === '!') {
+                    sp0 = valueStr.indexOf(' ', sp0 + 1);
+                }
+                if (sp0 === -1 || nl0 < sp0)
+                    hasPropsLine = true;
+            }
+            if (!hasPropsLine)
+                ws = `\n${ctx.indent}`;
+        }
+    }
+    else if (valueStr === '' || valueStr[0] === '\n') {
+        ws = '';
+    }
+    str += ws + valueStr;
+    if (ctx.inFlow) {
+        if (valueCommentDone && onComment)
+            onComment();
+    }
+    else if (valueComment && !valueCommentDone) {
+        str += lineComment(str, ctx.indent, commentString(valueComment));
+    }
+    else if (chompKeep && onChompKeep) {
+        onChompKeep();
+    }
+    return str;
+}
+
+function warn(logLevel, warning) {
+    if (logLevel === 'debug' || logLevel === 'warn') {
+        // https://github.com/typescript-eslint/typescript-eslint/issues/7478
+        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+        if (typeof process !== 'undefined' && process.emitWarning)
+            process.emitWarning(warning);
+        else
+            console.warn(warning);
+    }
+}
+
+const MERGE_KEY = '<<';
+function addPairToJSMap(ctx, map, { key, value }) {
+    if (ctx?.doc.schema.merge && isMergeKey(key)) {
+        value = isAlias(value) ? value.resolve(ctx.doc) : value;
+        if (isSeq(value))
+            for (const it of value.items)
+                mergeToJSMap(ctx, map, it);
+        else if (Array.isArray(value))
+            for (const it of value)
+                mergeToJSMap(ctx, map, it);
+        else
+            mergeToJSMap(ctx, map, value);
+    }
+    else {
+        const jsKey = toJS(key, '', ctx);
+        if (map instanceof Map) {
+            map.set(jsKey, toJS(value, jsKey, ctx));
+        }
+        else if (map instanceof Set) {
+            map.add(jsKey);
+        }
+        else {
+            const stringKey = stringifyKey(key, jsKey, ctx);
+            const jsValue = toJS(value, stringKey, ctx);
+            if (stringKey in map)
+                Object.defineProperty(map, stringKey, {
+                    value: jsValue,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            else
+                map[stringKey] = jsValue;
+        }
+    }
+    return map;
+}
+const isMergeKey = (key) => key === MERGE_KEY ||
+    (isScalar$1(key) &&
+        key.value === MERGE_KEY &&
+        (!key.type || key.type === Scalar.PLAIN));
+// If the value associated with a merge key is a single mapping node, each of
+// its key/value pairs is inserted into the current mapping, unless the key
+// already exists in it. If the value associated with the merge key is a
+// sequence, then this sequence is expected to contain mapping nodes and each
+// of these nodes is merged in turn according to its order in the sequence.
+// Keys in mapping nodes earlier in the sequence override keys specified in
+// later mapping nodes. -- http://yaml.org/type/merge.html
+function mergeToJSMap(ctx, map, value) {
+    const source = ctx && isAlias(value) ? value.resolve(ctx.doc) : value;
+    if (!isMap(source))
+        throw new Error('Merge sources must be maps or map aliases');
+    const srcMap = source.toJSON(null, ctx, Map);
+    for (const [key, value] of srcMap) {
+        if (map instanceof Map) {
+            if (!map.has(key))
+                map.set(key, value);
+        }
+        else if (map instanceof Set) {
+            map.add(key);
+        }
+        else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+            Object.defineProperty(map, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
+    return map;
+}
+function stringifyKey(key, jsKey, ctx) {
+    if (jsKey === null)
+        return '';
+    if (typeof jsKey !== 'object')
+        return String(jsKey);
+    if (isNode$1(key) && ctx?.doc) {
+        const strCtx = createStringifyContext(ctx.doc, {});
+        strCtx.anchors = new Set();
+        for (const node of ctx.anchors.keys())
+            strCtx.anchors.add(node.anchor);
+        strCtx.inFlow = true;
+        strCtx.inStringifyKey = true;
+        const strKey = key.toString(strCtx);
+        if (!ctx.mapKeyWarned) {
+            let jsonStr = JSON.stringify(strKey);
+            if (jsonStr.length > 40)
+                jsonStr = jsonStr.substring(0, 36) + '..."';
+            warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+            ctx.mapKeyWarned = true;
+        }
+        return strKey;
+    }
+    return JSON.stringify(jsKey);
+}
+
+function createPair(key, value, ctx) {
+    const k = createNode(key, undefined, ctx);
+    const v = createNode(value, undefined, ctx);
+    return new Pair(k, v);
+}
+class Pair {
+    constructor(key, value = null) {
+        Object.defineProperty(this, NODE_TYPE, { value: PAIR });
+        this.key = key;
+        this.value = value;
+    }
+    clone(schema) {
+        let { key, value } = this;
+        if (isNode$1(key))
+            key = key.clone(schema);
+        if (isNode$1(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
+    toJSON(_, ctx) {
+        const pair = ctx?.mapAsMap ? new Map() : {};
+        return addPairToJSMap(ctx, pair, this);
+    }
+    toString(ctx, onComment, onChompKeep) {
+        return ctx?.doc
+            ? stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
+    }
+}
+
+function stringifyCollection(collection, ctx, options) {
+    const flow = ctx.inFlow ?? collection.flow;
+    const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;
+    return stringify(collection, ctx, options);
+}
+function stringifyBlockCollection({ comment, items }, ctx, { blockItemPrefix, flowChars, itemIndent, onChompKeep, onComment }) {
+    const { indent, options: { commentString } } = ctx;
+    const itemCtx = Object.assign({}, ctx, { indent: itemIndent, type: null });
+    let chompKeep = false; // flag for the preceding node's status
+    const lines = [];
+    for (let i = 0; i < items.length; ++i) {
+        const item = items[i];
+        let comment = null;
+        if (isNode$1(item)) {
+            if (!chompKeep && item.spaceBefore)
+                lines.push('');
+            addCommentBefore(ctx, lines, item.commentBefore, chompKeep);
+            if (item.comment)
+                comment = item.comment;
+        }
+        else if (isPair(item)) {
+            const ik = isNode$1(item.key) ? item.key : null;
+            if (ik) {
+                if (!chompKeep && ik.spaceBefore)
+                    lines.push('');
+                addCommentBefore(ctx, lines, ik.commentBefore, chompKeep);
+            }
+        }
+        chompKeep = false;
+        let str = stringify$2(item, itemCtx, () => (comment = null), () => (chompKeep = true));
+        if (comment)
+            str += lineComment(str, itemIndent, commentString(comment));
+        if (chompKeep && comment)
+            chompKeep = false;
+        lines.push(blockItemPrefix + str);
+    }
+    let str;
+    if (lines.length === 0) {
+        str = flowChars.start + flowChars.end;
+    }
+    else {
+        str = lines[0];
+        for (let i = 1; i < lines.length; ++i) {
+            const line = lines[i];
+            str += line ? `\n${indent}${line}` : '\n';
+        }
+    }
+    if (comment) {
+        str += '\n' + indentComment(commentString(comment), indent);
+        if (onComment)
+            onComment();
+    }
+    else if (chompKeep && onChompKeep)
+        onChompKeep();
+    return str;
+}
+function stringifyFlowCollection({ items }, ctx, { flowChars, itemIndent }) {
+    const { indent, indentStep, flowCollectionPadding: fcPadding, options: { commentString } } = ctx;
+    itemIndent += indentStep;
+    const itemCtx = Object.assign({}, ctx, {
+        indent: itemIndent,
+        inFlow: true,
+        type: null
+    });
+    let reqNewline = false;
+    let linesAtValue = 0;
+    const lines = [];
+    for (let i = 0; i < items.length; ++i) {
+        const item = items[i];
+        let comment = null;
+        if (isNode$1(item)) {
+            if (item.spaceBefore)
+                lines.push('');
+            addCommentBefore(ctx, lines, item.commentBefore, false);
+            if (item.comment)
+                comment = item.comment;
+        }
+        else if (isPair(item)) {
+            const ik = isNode$1(item.key) ? item.key : null;
+            if (ik) {
+                if (ik.spaceBefore)
+                    lines.push('');
+                addCommentBefore(ctx, lines, ik.commentBefore, false);
+                if (ik.comment)
+                    reqNewline = true;
+            }
+            const iv = isNode$1(item.value) ? item.value : null;
+            if (iv) {
+                if (iv.comment)
+                    comment = iv.comment;
+                if (iv.commentBefore)
+                    reqNewline = true;
+            }
+            else if (item.value == null && ik?.comment) {
+                comment = ik.comment;
+            }
+        }
+        if (comment)
+            reqNewline = true;
+        let str = stringify$2(item, itemCtx, () => (comment = null));
+        if (i < items.length - 1)
+            str += ',';
+        if (comment)
+            str += lineComment(str, itemIndent, commentString(comment));
+        if (!reqNewline && (lines.length > linesAtValue || str.includes('\n')))
+            reqNewline = true;
+        lines.push(str);
+        linesAtValue = lines.length;
+    }
+    const { start, end } = flowChars;
+    if (lines.length === 0) {
+        return start + end;
+    }
+    else {
+        if (!reqNewline) {
+            const len = lines.reduce((sum, line) => sum + line.length + 2, 2);
+            reqNewline = ctx.options.lineWidth > 0 && len > ctx.options.lineWidth;
+        }
+        if (reqNewline) {
+            let str = start;
+            for (const line of lines)
+                str += line ? `\n${indentStep}${indent}${line}` : '\n';
+            return `${str}\n${indent}${end}`;
+        }
+        else {
+            return `${start}${fcPadding}${lines.join(' ')}${fcPadding}${end}`;
+        }
+    }
+}
+function addCommentBefore({ indent, options: { commentString } }, lines, comment, chompKeep) {
+    if (comment && chompKeep)
+        comment = comment.replace(/^\n+/, '');
+    if (comment) {
+        const ic = indentComment(commentString(comment), indent);
+        lines.push(ic.trimStart()); // Avoid double indent on first line
+    }
+}
+
+function findPair(items, key) {
+    const k = isScalar$1(key) ? key.value : key;
+    for (const it of items) {
+        if (isPair(it)) {
+            if (it.key === key || it.key === k)
+                return it;
+            if (isScalar$1(it.key) && it.key.value === k)
+                return it;
+        }
+    }
+    return undefined;
+}
+class YAMLMap extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:map';
+    }
+    constructor(schema) {
+        super(MAP, schema);
+        this.items = [];
+    }
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema, obj, ctx) {
+        const { keepUndefined, replacer } = ctx;
+        const map = new this(schema);
+        const add = (key, value) => {
+            if (typeof replacer === 'function')
+                value = replacer.call(obj, key, value);
+            else if (Array.isArray(replacer) && !replacer.includes(key))
+                return;
+            if (value !== undefined || keepUndefined)
+                map.items.push(createPair(key, value, ctx));
+        };
+        if (obj instanceof Map) {
+            for (const [key, value] of obj)
+                add(key, value);
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const key of Object.keys(obj))
+                add(key, obj[key]);
+        }
+        if (typeof schema.sortMapEntries === 'function') {
+            map.items.sort(schema.sortMapEntries);
+        }
+        return map;
+    }
+    /**
+     * Adds a value to the collection.
+     *
+     * @param overwrite - If not set `true`, using a key that is already in the
+     *   collection will throw. Otherwise, overwrites the previous value.
+     */
+    add(pair, overwrite) {
+        let _pair;
+        if (isPair(pair))
+            _pair = pair;
+        else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
+            // In TypeScript, this never happens.
+            _pair = new Pair(pair, pair?.value);
+        }
+        else
+            _pair = new Pair(pair.key, pair.value);
+        const prev = findPair(this.items, _pair.key);
+        const sortEntries = this.schema?.sortMapEntries;
+        if (prev) {
+            if (!overwrite)
+                throw new Error(`Key ${_pair.key} already set`);
+            // For scalars, keep the old node & its comments and anchors
+            if (isScalar$1(prev.value) && isScalarValue(_pair.value))
+                prev.value.value = _pair.value;
+            else
+                prev.value = _pair.value;
+        }
+        else if (sortEntries) {
+            const i = this.items.findIndex(item => sortEntries(_pair, item) < 0);
+            if (i === -1)
+                this.items.push(_pair);
+            else
+                this.items.splice(i, 0, _pair);
+        }
+        else {
+            this.items.push(_pair);
+        }
+    }
+    delete(key) {
+        const it = findPair(this.items, key);
+        if (!it)
+            return false;
+        const del = this.items.splice(this.items.indexOf(it), 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const it = findPair(this.items, key);
+        const node = it?.value;
+        return (!keepScalar && isScalar$1(node) ? node.value : node) ?? undefined;
+    }
+    has(key) {
+        return !!findPair(this.items, key);
+    }
+    set(key, value) {
+        this.add(new Pair(key, value), true);
+    }
+    /**
+     * @param ctx - Conversion context, originally set in Document#toJS()
+     * @param {Class} Type - If set, forces the returned collection type
+     * @returns Instance of Type, Map, or Object
+     */
+    toJSON(_, ctx, Type) {
+        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+        if (ctx?.onCreate)
+            ctx.onCreate(map);
+        for (const item of this.items)
+            addPairToJSMap(ctx, map, item);
+        return map;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        for (const item of this.items) {
+            if (!isPair(item))
+                throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
+        }
+        if (!ctx.allNullValues && this.hasAllNullValues(false))
+            ctx = Object.assign({}, ctx, { allNullValues: true });
+        return stringifyCollection(this, ctx, {
+            blockItemPrefix: '',
+            flowChars: { start: '{', end: '}' },
+            itemIndent: ctx.indent || '',
+            onChompKeep,
+            onComment
+        });
+    }
+}
+
+const map$1 = {
+    collection: 'map',
+    default: true,
+    nodeClass: YAMLMap,
+    tag: 'tag:yaml.org,2002:map',
+    resolve(map, onError) {
+        if (!isMap(map))
+            onError('Expected a mapping for this tag');
+        return map;
+    },
+    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
+};
+
+class YAMLSeq extends Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:seq';
+    }
+    constructor(schema) {
+        super(SEQ, schema);
+        this.items = [];
+    }
+    add(value) {
+        this.items.push(value);
+    }
+    /**
+     * Removes a value from the collection.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     *
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return false;
+        const del = this.items.splice(idx, 1);
+        return del.length > 0;
+    }
+    get(key, keepScalar) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            return undefined;
+        const it = this.items[idx];
+        return !keepScalar && isScalar$1(it) ? it.value : it;
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     *
+     * `key` must contain a representation of an integer for this to succeed.
+     * It may be wrapped in a `Scalar`.
+     */
+    has(key) {
+        const idx = asItemIndex(key);
+        return typeof idx === 'number' && idx < this.items.length;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     *
+     * If `key` does not contain a representation of an integer, this will throw.
+     * It may be wrapped in a `Scalar`.
+     */
+    set(key, value) {
+        const idx = asItemIndex(key);
+        if (typeof idx !== 'number')
+            throw new Error(`Expected a valid index, not ${key}.`);
+        const prev = this.items[idx];
+        if (isScalar$1(prev) && isScalarValue(value))
+            prev.value = value;
+        else
+            this.items[idx] = value;
+    }
+    toJSON(_, ctx) {
+        const seq = [];
+        if (ctx?.onCreate)
+            ctx.onCreate(seq);
+        let i = 0;
+        for (const item of this.items)
+            seq.push(toJS(item, String(i++), ctx));
+        return seq;
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        return stringifyCollection(this, ctx, {
+            blockItemPrefix: '- ',
+            flowChars: { start: '[', end: ']' },
+            itemIndent: (ctx.indent || '') + '  ',
+            onChompKeep,
+            onComment
+        });
+    }
+    static from(schema, obj, ctx) {
+        const { replacer } = ctx;
+        const seq = new this(schema);
+        if (obj && Symbol.iterator in Object(obj)) {
+            let i = 0;
+            for (let it of obj) {
+                if (typeof replacer === 'function') {
+                    const key = obj instanceof Set ? it : String(i++);
+                    it = replacer.call(obj, key, it);
+                }
+                seq.items.push(createNode(it, undefined, ctx));
+            }
+        }
+        return seq;
+    }
+}
+function asItemIndex(key) {
+    let idx = isScalar$1(key) ? key.value : key;
+    if (idx && typeof idx === 'string')
+        idx = Number(idx);
+    return typeof idx === 'number' && Number.isInteger(idx) && idx >= 0
+        ? idx
+        : null;
+}
+
+const seq = {
+    collection: 'seq',
+    default: true,
+    nodeClass: YAMLSeq,
+    tag: 'tag:yaml.org,2002:seq',
+    resolve(seq, onError) {
+        if (!isSeq(seq))
+            onError('Expected a sequence for this tag');
+        return seq;
+    },
+    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
+};
+
+const string = {
+    identify: value => typeof value === 'string',
+    default: true,
+    tag: 'tag:yaml.org,2002:str',
+    resolve: str => str,
+    stringify(item, ctx, onComment, onChompKeep) {
+        ctx = Object.assign({ actualString: true }, ctx);
+        return stringifyString(item, ctx, onComment, onChompKeep);
+    }
+};
+
+const nullTag = {
+    identify: value => value == null,
+    createNode: () => new Scalar(null),
+    default: true,
+    tag: 'tag:yaml.org,2002:null',
+    test: /^(?:~|[Nn]ull|NULL)?$/,
+    resolve: () => new Scalar(null),
+    stringify: ({ source }, ctx) => typeof source === 'string' && nullTag.test.test(source)
+        ? source
+        : ctx.options.nullStr
+};
+
+const boolTag = {
+    identify: value => typeof value === 'boolean',
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),
+    stringify({ source, value }, ctx) {
+        if (source && boolTag.test.test(source)) {
+            const sv = source[0] === 't' || source[0] === 'T';
+            if (value === sv)
+                return source;
+        }
+        return value ? ctx.options.trueStr : ctx.options.falseStr;
+    }
+};
+
+function stringifyNumber({ format, minFractionDigits, tag, value }) {
+    if (typeof value === 'bigint')
+        return String(value);
+    const num = typeof value === 'number' ? value : Number(value);
+    if (!isFinite(num))
+        return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';
+    let n = JSON.stringify(value);
+    if (!format &&
+        minFractionDigits &&
+        (!tag || tag === 'tag:yaml.org,2002:float') &&
+        /^\d/.test(n)) {
+        let i = n.indexOf('.');
+        if (i < 0) {
+            i = n.length;
+            n += '.';
+        }
+        let d = minFractionDigits - (n.length - i - 1);
+        while (d-- > 0)
+            n += '0';
+    }
+    return n;
+}
+
+const floatNaN$1 = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+    resolve: str => str.slice(-3).toLowerCase() === 'nan'
+        ? NaN
+        : str[0] === '-'
+            ? Number.NEGATIVE_INFINITY
+            : Number.POSITIVE_INFINITY,
+    stringify: stringifyNumber
+};
+const floatExp$1 = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'EXP',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+    resolve: str => parseFloat(str),
+    stringify(node) {
+        const num = Number(node.value);
+        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+    }
+};
+const float$1 = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+    resolve(str) {
+        const node = new Scalar(parseFloat(str));
+        const dot = str.indexOf('.');
+        if (dot !== -1 && str[str.length - 1] === '0')
+            node.minFractionDigits = str.length - dot - 1;
+        return node;
+    },
+    stringify: stringifyNumber
+};
+
+const intIdentify$2 = (value) => typeof value === 'bigint' || Number.isInteger(value);
+const intResolve$1 = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));
+function intStringify$1(node, radix, prefix) {
+    const { value } = node;
+    if (intIdentify$2(value) && value >= 0)
+        return prefix + value.toString(radix);
+    return stringifyNumber(node);
+}
+const intOct$1 = {
+    identify: value => intIdentify$2(value) && value >= 0,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'OCT',
+    test: /^0o[0-7]+$/,
+    resolve: (str, _onError, opt) => intResolve$1(str, 2, 8, opt),
+    stringify: node => intStringify$1(node, 8, '0o')
+};
+const int$1 = {
+    identify: intIdentify$2,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    test: /^[-+]?[0-9]+$/,
+    resolve: (str, _onError, opt) => intResolve$1(str, 0, 10, opt),
+    stringify: stringifyNumber
+};
+const intHex$1 = {
+    identify: value => intIdentify$2(value) && value >= 0,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'HEX',
+    test: /^0x[0-9a-fA-F]+$/,
+    resolve: (str, _onError, opt) => intResolve$1(str, 2, 16, opt),
+    stringify: node => intStringify$1(node, 16, '0x')
+};
+
+const schema$2 = [
+    map$1,
+    seq,
+    string,
+    nullTag,
+    boolTag,
+    intOct$1,
+    int$1,
+    intHex$1,
+    floatNaN$1,
+    floatExp$1,
+    float$1
+];
+
+function intIdentify$1(value) {
+    return typeof value === 'bigint' || Number.isInteger(value);
+}
+const stringifyJSON = ({ value }) => JSON.stringify(value);
+const jsonScalars = [
+    {
+        identify: value => typeof value === 'string',
+        default: true,
+        tag: 'tag:yaml.org,2002:str',
+        resolve: str => str,
+        stringify: stringifyJSON
+    },
+    {
+        identify: value => value == null,
+        createNode: () => new Scalar(null),
+        default: true,
+        tag: 'tag:yaml.org,2002:null',
+        test: /^null$/,
+        resolve: () => null,
+        stringify: stringifyJSON
+    },
+    {
+        identify: value => typeof value === 'boolean',
+        default: true,
+        tag: 'tag:yaml.org,2002:bool',
+        test: /^true|false$/,
+        resolve: str => str === 'true',
+        stringify: stringifyJSON
+    },
+    {
+        identify: intIdentify$1,
+        default: true,
+        tag: 'tag:yaml.org,2002:int',
+        test: /^-?(?:0|[1-9][0-9]*)$/,
+        resolve: (str, _onError, { intAsBigInt }) => intAsBigInt ? BigInt(str) : parseInt(str, 10),
+        stringify: ({ value }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
+    },
+    {
+        identify: value => typeof value === 'number',
+        default: true,
+        tag: 'tag:yaml.org,2002:float',
+        test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+        resolve: str => parseFloat(str),
+        stringify: stringifyJSON
+    }
+];
+const jsonError = {
+    default: true,
+    tag: '',
+    test: /^/,
+    resolve(str, onError) {
+        onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+        return str;
+    }
+};
+const schema$1 = [map$1, seq].concat(jsonScalars, jsonError);
+
+const binary = {
+    identify: value => value instanceof Uint8Array, // Buffer inherits from Uint8Array
+    default: false,
+    tag: 'tag:yaml.org,2002:binary',
+    /**
+     * Returns a Buffer in node and an Uint8Array in browsers
+     *
+     * To use the resulting buffer as an image, you'll want to do something like:
+     *
+     *   const blob = new Blob([buffer], { type: 'image/jpeg' })
+     *   document.querySelector('#photo').src = URL.createObjectURL(blob)
+     */
+    resolve(src, onError) {
+        if (typeof Buffer === 'function') {
+            return Buffer.from(src, 'base64');
+        }
+        else if (typeof atob === 'function') {
+            // On IE 11, atob() can't handle newlines
+            const str = atob(src.replace(/[\n\r]/g, ''));
+            const buffer = new Uint8Array(str.length);
+            for (let i = 0; i < str.length; ++i)
+                buffer[i] = str.charCodeAt(i);
+            return buffer;
+        }
+        else {
+            onError('This environment does not support reading binary tags; either Buffer or atob is required');
+            return src;
+        }
+    },
+    stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
+        const buf = value; // checked earlier by binary.identify()
+        let str;
+        if (typeof Buffer === 'function') {
+            str =
+                buf instanceof Buffer
+                    ? buf.toString('base64')
+                    : Buffer.from(buf.buffer).toString('base64');
+        }
+        else if (typeof btoa === 'function') {
+            let s = '';
+            for (let i = 0; i < buf.length; ++i)
+                s += String.fromCharCode(buf[i]);
+            str = btoa(s);
+        }
+        else {
+            throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
+        }
+        if (!type)
+            type = Scalar.BLOCK_LITERAL;
+        if (type !== Scalar.QUOTE_DOUBLE) {
+            const lineWidth = Math.max(ctx.options.lineWidth - ctx.indent.length, ctx.options.minContentWidth);
+            const n = Math.ceil(str.length / lineWidth);
+            const lines = new Array(n);
+            for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
+                lines[i] = str.substr(o, lineWidth);
+            }
+            str = lines.join(type === Scalar.BLOCK_LITERAL ? '\n' : ' ');
+        }
+        return stringifyString({ comment, type, value: str }, ctx, onComment, onChompKeep);
+    }
+};
+
+function resolvePairs(seq, onError) {
+    if (isSeq(seq)) {
+        for (let i = 0; i < seq.items.length; ++i) {
+            let item = seq.items[i];
+            if (isPair(item))
+                continue;
+            else if (isMap(item)) {
+                if (item.items.length > 1)
+                    onError('Each pair must have its own sequence indicator');
+                const pair = item.items[0] || new Pair(new Scalar(null));
+                if (item.commentBefore)
+                    pair.key.commentBefore = pair.key.commentBefore
+                        ? `${item.commentBefore}\n${pair.key.commentBefore}`
+                        : item.commentBefore;
+                if (item.comment) {
+                    const cn = pair.value ?? pair.key;
+                    cn.comment = cn.comment
+                        ? `${item.comment}\n${cn.comment}`
+                        : item.comment;
+                }
+                item = pair;
+            }
+            seq.items[i] = isPair(item) ? item : new Pair(item);
+        }
+    }
+    else
+        onError('Expected a sequence for this tag');
+    return seq;
+}
+function createPairs(schema, iterable, ctx) {
+    const { replacer } = ctx;
+    const pairs = new YAMLSeq(schema);
+    pairs.tag = 'tag:yaml.org,2002:pairs';
+    let i = 0;
+    if (iterable && Symbol.iterator in Object(iterable))
+        for (let it of iterable) {
+            if (typeof replacer === 'function')
+                it = replacer.call(iterable, String(i++), it);
+            let key, value;
+            if (Array.isArray(it)) {
+                if (it.length === 2) {
+                    key = it[0];
+                    value = it[1];
+                }
+                else
+                    throw new TypeError(`Expected [key, value] tuple: ${it}`);
+            }
+            else if (it && it instanceof Object) {
+                const keys = Object.keys(it);
+                if (keys.length === 1) {
+                    key = keys[0];
+                    value = it[key];
+                }
+                else {
+                    throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
+                }
+            }
+            else {
+                key = it;
+            }
+            pairs.items.push(createPair(key, value, ctx));
+        }
+    return pairs;
+}
+const pairs = {
+    collection: 'seq',
+    default: false,
+    tag: 'tag:yaml.org,2002:pairs',
+    resolve: resolvePairs,
+    createNode: createPairs
+};
+
+class YAMLOMap extends YAMLSeq {
+    constructor() {
+        super();
+        this.add = YAMLMap.prototype.add.bind(this);
+        this.delete = YAMLMap.prototype.delete.bind(this);
+        this.get = YAMLMap.prototype.get.bind(this);
+        this.has = YAMLMap.prototype.has.bind(this);
+        this.set = YAMLMap.prototype.set.bind(this);
+        this.tag = YAMLOMap.tag;
+    }
+    /**
+     * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+     * but TypeScript won't allow widening the signature of a child method.
+     */
+    toJSON(_, ctx) {
+        if (!ctx)
+            return super.toJSON(_);
+        const map = new Map();
+        if (ctx?.onCreate)
+            ctx.onCreate(map);
+        for (const pair of this.items) {
+            let key, value;
+            if (isPair(pair)) {
+                key = toJS(pair.key, '', ctx);
+                value = toJS(pair.value, key, ctx);
+            }
+            else {
+                key = toJS(pair, '', ctx);
+            }
+            if (map.has(key))
+                throw new Error('Ordered maps must not include duplicate keys');
+            map.set(key, value);
+        }
+        return map;
+    }
+    static from(schema, iterable, ctx) {
+        const pairs = createPairs(schema, iterable, ctx);
+        const omap = new this();
+        omap.items = pairs.items;
+        return omap;
+    }
+}
+YAMLOMap.tag = 'tag:yaml.org,2002:omap';
+const omap = {
+    collection: 'seq',
+    identify: value => value instanceof Map,
+    nodeClass: YAMLOMap,
+    default: false,
+    tag: 'tag:yaml.org,2002:omap',
+    resolve(seq, onError) {
+        const pairs = resolvePairs(seq, onError);
+        const seenKeys = [];
+        for (const { key } of pairs.items) {
+            if (isScalar$1(key)) {
+                if (seenKeys.includes(key.value)) {
+                    onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+                }
+                else {
+                    seenKeys.push(key.value);
+                }
+            }
+        }
+        return Object.assign(new YAMLOMap(), pairs);
+    },
+    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
+};
+
+function boolStringify({ value, source }, ctx) {
+    const boolObj = value ? trueTag : falseTag;
+    if (source && boolObj.test.test(source))
+        return source;
+    return value ? ctx.options.trueStr : ctx.options.falseStr;
+}
+const trueTag = {
+    identify: value => value === true,
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+    resolve: () => new Scalar(true),
+    stringify: boolStringify
+};
+const falseTag = {
+    identify: value => value === false,
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
+    resolve: () => new Scalar(false),
+    stringify: boolStringify
+};
+
+const floatNaN = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^(?:[-+]?\.(?:inf|Inf|INF)|\.nan|\.NaN|\.NAN)$/,
+    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'
+        ? NaN
+        : str[0] === '-'
+            ? Number.NEGATIVE_INFINITY
+            : Number.POSITIVE_INFINITY,
+    stringify: stringifyNumber
+};
+const floatExp = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'EXP',
+    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
+    resolve: (str) => parseFloat(str.replace(/_/g, '')),
+    stringify(node) {
+        const num = Number(node.value);
+        return isFinite(num) ? num.toExponential() : stringifyNumber(node);
+    }
+};
+const float = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
+    resolve(str) {
+        const node = new Scalar(parseFloat(str.replace(/_/g, '')));
+        const dot = str.indexOf('.');
+        if (dot !== -1) {
+            const f = str.substring(dot + 1).replace(/_/g, '');
+            if (f[f.length - 1] === '0')
+                node.minFractionDigits = f.length;
+        }
+        return node;
+    },
+    stringify: stringifyNumber
+};
+
+const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
+function intResolve(str, offset, radix, { intAsBigInt }) {
+    const sign = str[0];
+    if (sign === '-' || sign === '+')
+        offset += 1;
+    str = str.substring(offset).replace(/_/g, '');
+    if (intAsBigInt) {
+        switch (radix) {
+            case 2:
+                str = `0b${str}`;
+                break;
+            case 8:
+                str = `0o${str}`;
+                break;
+            case 16:
+                str = `0x${str}`;
+                break;
+        }
+        const n = BigInt(str);
+        return sign === '-' ? BigInt(-1) * n : n;
+    }
+    const n = parseInt(str, radix);
+    return sign === '-' ? -1 * n : n;
+}
+function intStringify(node, radix, prefix) {
+    const { value } = node;
+    if (intIdentify(value)) {
+        const str = value.toString(radix);
+        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
+    }
+    return stringifyNumber(node);
+}
+const intBin = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'BIN',
+    test: /^[-+]?0b[0-1_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+    stringify: node => intStringify(node, 2, '0b')
+};
+const intOct = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'OCT',
+    test: /^[-+]?0[0-7_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+    stringify: node => intStringify(node, 8, '0')
+};
+const int = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    test: /^[-+]?[0-9][0-9_]*$/,
+    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+    stringify: stringifyNumber
+};
+const intHex = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'HEX',
+    test: /^[-+]?0x[0-9a-fA-F_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+    stringify: node => intStringify(node, 16, '0x')
+};
+
+class YAMLSet extends YAMLMap {
+    constructor(schema) {
+        super(schema);
+        this.tag = YAMLSet.tag;
+    }
+    add(key) {
+        let pair;
+        if (isPair(key))
+            pair = key;
+        else if (key &&
+            typeof key === 'object' &&
+            'key' in key &&
+            'value' in key &&
+            key.value === null)
+            pair = new Pair(key.key, null);
+        else
+            pair = new Pair(key, null);
+        const prev = findPair(this.items, pair.key);
+        if (!prev)
+            this.items.push(pair);
+    }
+    /**
+     * If `keepPair` is `true`, returns the Pair matching `key`.
+     * Otherwise, returns the value of that Pair's key.
+     */
+    get(key, keepPair) {
+        const pair = findPair(this.items, key);
+        return !keepPair && isPair(pair)
+            ? isScalar$1(pair.key)
+                ? pair.key.value
+                : pair.key
+            : pair;
+    }
+    set(key, value) {
+        if (typeof value !== 'boolean')
+            throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
+        const prev = findPair(this.items, key);
+        if (prev && !value) {
+            this.items.splice(this.items.indexOf(prev), 1);
+        }
+        else if (!prev && value) {
+            this.items.push(new Pair(key));
+        }
+    }
+    toJSON(_, ctx) {
+        return super.toJSON(_, ctx, Set);
+    }
+    toString(ctx, onComment, onChompKeep) {
+        if (!ctx)
+            return JSON.stringify(this);
+        if (this.hasAllNullValues(true))
+            return super.toString(Object.assign({}, ctx, { allNullValues: true }), onComment, onChompKeep);
+        else
+            throw new Error('Set items must all have null values');
+    }
+    static from(schema, iterable, ctx) {
+        const { replacer } = ctx;
+        const set = new this(schema);
+        if (iterable && Symbol.iterator in Object(iterable))
+            for (let value of iterable) {
+                if (typeof replacer === 'function')
+                    value = replacer.call(iterable, value, value);
+                set.items.push(createPair(value, null, ctx));
+            }
+        return set;
+    }
+}
+YAMLSet.tag = 'tag:yaml.org,2002:set';
+const set = {
+    collection: 'map',
+    identify: value => value instanceof Set,
+    nodeClass: YAMLSet,
+    default: false,
+    tag: 'tag:yaml.org,2002:set',
+    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
+    resolve(map, onError) {
+        if (isMap(map)) {
+            if (map.hasAllNullValues(true))
+                return Object.assign(new YAMLSet(), map);
+            else
+                onError('Set items must all have null values');
+        }
+        else
+            onError('Expected a mapping for this tag');
+        return map;
+    }
+};
+
+/** Internal types handle bigint as number, because TS can't figure it out. */
+function parseSexagesimal(str, asBigInt) {
+    const sign = str[0];
+    const parts = sign === '-' || sign === '+' ? str.substring(1) : str;
+    const num = (n) => asBigInt ? BigInt(n) : Number(n);
+    const res = parts
+        .replace(/_/g, '')
+        .split(':')
+        .reduce((res, p) => res * num(60) + num(p), num(0));
+    return (sign === '-' ? num(-1) * res : res);
+}
+/**
+ * hhhh:mm:ss.sss
+ *
+ * Internal types handle bigint as number, because TS can't figure it out.
+ */
+function stringifySexagesimal(node) {
+    let { value } = node;
+    let num = (n) => n;
+    if (typeof value === 'bigint')
+        num = n => BigInt(n);
+    else if (isNaN(value) || !isFinite(value))
+        return stringifyNumber(node);
+    let sign = '';
+    if (value < 0) {
+        sign = '-';
+        value *= num(-1);
+    }
+    const _60 = num(60);
+    const parts = [value % _60]; // seconds, including ms
+    if (value < 60) {
+        parts.unshift(0); // at least one : is required
+    }
+    else {
+        value = (value - parts[0]) / _60;
+        parts.unshift(value % _60); // minutes
+        if (value >= 60) {
+            value = (value - parts[0]) / _60;
+            parts.unshift(value); // hours
+        }
+    }
+    return (sign +
+        parts
+            .map(n => String(n).padStart(2, '0'))
+            .join(':')
+            .replace(/000000\d*$/, '') // % 60 may introduce error
+    );
+}
+const intTime = {
+    identify: value => typeof value === 'bigint' || Number.isInteger(value),
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'TIME',
+    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+    resolve: (str, _onError, { intAsBigInt }) => parseSexagesimal(str, intAsBigInt),
+    stringify: stringifySexagesimal
+};
+const floatTime = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'TIME',
+    test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+    resolve: str => parseSexagesimal(str, false),
+    stringify: stringifySexagesimal
+};
+const timestamp = {
+    identify: value => value instanceof Date,
+    default: true,
+    tag: 'tag:yaml.org,2002:timestamp',
+    // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
+    // may be omitted altogether, resulting in a date format. In such a case, the time part is
+    // assumed to be 00:00:00Z (start of day, UTC).
+    test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd
+        '(?:' + // time is optional
+        '(?:t|T|[ \\t]+)' + // t | T | whitespace
+        '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?
+        '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30
+        ')?$'),
+    resolve(str) {
+        const match = str.match(timestamp.test);
+        if (!match)
+            throw new Error('!!timestamp expects a date, starting with yyyy-mm-dd');
+        const [, year, month, day, hour, minute, second] = match.map(Number);
+        const millisec = match[7] ? Number((match[7] + '00').substr(1, 3)) : 0;
+        let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec);
+        const tz = match[8];
+        if (tz && tz !== 'Z') {
+            let d = parseSexagesimal(tz, false);
+            if (Math.abs(d) < 30)
+                d *= 60;
+            date -= 60000 * d;
+        }
+        return new Date(date);
+    },
+    stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '')
+};
+
+const schema = [
+    map$1,
+    seq,
+    string,
+    nullTag,
+    trueTag,
+    falseTag,
+    intBin,
+    intOct,
+    int,
+    intHex,
+    floatNaN,
+    floatExp,
+    float,
+    binary,
+    omap,
+    pairs,
+    set,
+    intTime,
+    floatTime,
+    timestamp
+];
+
+const schemas = new Map([
+    ['core', schema$2],
+    ['failsafe', [map$1, seq, string]],
+    ['json', schema$1],
+    ['yaml11', schema],
+    ['yaml-1.1', schema]
+]);
+const tagsByName = {
+    binary,
+    bool: boolTag,
+    float: float$1,
+    floatExp: floatExp$1,
+    floatNaN: floatNaN$1,
+    floatTime,
+    int: int$1,
+    intHex: intHex$1,
+    intOct: intOct$1,
+    intTime,
+    map: map$1,
+    null: nullTag,
+    omap,
+    pairs,
+    seq,
+    set,
+    timestamp
+};
+const coreKnownTags = {
+    'tag:yaml.org,2002:binary': binary,
+    'tag:yaml.org,2002:omap': omap,
+    'tag:yaml.org,2002:pairs': pairs,
+    'tag:yaml.org,2002:set': set,
+    'tag:yaml.org,2002:timestamp': timestamp
+};
+function getTags(customTags, schemaName) {
+    let tags = schemas.get(schemaName);
+    if (!tags) {
+        if (Array.isArray(customTags))
+            tags = [];
+        else {
+            const keys = Array.from(schemas.keys())
+                .filter(key => key !== 'yaml11')
+                .map(key => JSON.stringify(key))
+                .join(', ');
+            throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
+        }
+    }
+    if (Array.isArray(customTags)) {
+        for (const tag of customTags)
+            tags = tags.concat(tag);
+    }
+    else if (typeof customTags === 'function') {
+        tags = customTags(tags.slice());
+    }
+    return tags.map(tag => {
+        if (typeof tag !== 'string')
+            return tag;
+        const tagObj = tagsByName[tag];
+        if (tagObj)
+            return tagObj;
+        const keys = Object.keys(tagsByName)
+            .map(key => JSON.stringify(key))
+            .join(', ');
+        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
+    });
+}
+
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+class Schema {
+    constructor({ compat, customTags, merge, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+        this.compat = Array.isArray(compat)
+            ? getTags(compat, 'compat')
+            : compat
+                ? getTags(null, compat)
+                : null;
+        this.merge = !!merge;
+        this.name = (typeof schema === 'string' && schema) || 'core';
+        this.knownTags = resolveKnownTags ? coreKnownTags : {};
+        this.tags = getTags(customTags, this.name);
+        this.toStringOptions = toStringDefaults ?? null;
+        Object.defineProperty(this, MAP, { value: map$1 });
+        Object.defineProperty(this, SCALAR$1, { value: string });
+        Object.defineProperty(this, SEQ, { value: seq });
+        // Used by createMap()
+        this.sortMapEntries =
+            typeof sortMapEntries === 'function'
+                ? sortMapEntries
+                : sortMapEntries === true
+                    ? sortMapEntriesByKey
+                    : null;
+    }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
+    }
+}
+
+function stringifyDocument(doc, options) {
+    const lines = [];
+    let hasDirectives = options.directives === true;
+    if (options.directives !== false && doc.directives) {
+        const dir = doc.directives.toString(doc);
+        if (dir) {
+            lines.push(dir);
+            hasDirectives = true;
+        }
+        else if (doc.directives.docStart)
+            hasDirectives = true;
+    }
+    if (hasDirectives)
+        lines.push('---');
+    const ctx = createStringifyContext(doc, options);
+    const { commentString } = ctx.options;
+    if (doc.commentBefore) {
+        if (lines.length !== 1)
+            lines.unshift('');
+        const cs = commentString(doc.commentBefore);
+        lines.unshift(indentComment(cs, ''));
+    }
+    let chompKeep = false;
+    let contentComment = null;
+    if (doc.contents) {
+        if (isNode$1(doc.contents)) {
+            if (doc.contents.spaceBefore && hasDirectives)
+                lines.push('');
+            if (doc.contents.commentBefore) {
+                const cs = commentString(doc.contents.commentBefore);
+                lines.push(indentComment(cs, ''));
+            }
+            // top-level block scalars need to be indented if followed by a comment
+            ctx.forceBlockIndent = !!doc.comment;
+            contentComment = doc.contents.comment;
+        }
+        const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
+        let body = stringify$2(doc.contents, ctx, () => (contentComment = null), onChompKeep);
+        if (contentComment)
+            body += lineComment(body, '', commentString(contentComment));
+        if ((body[0] === '|' || body[0] === '>') &&
+            lines[lines.length - 1] === '---') {
+            // Top-level block scalars with a preceding doc marker ought to use the
+            // same line for their header.
+            lines[lines.length - 1] = `--- ${body}`;
+        }
+        else
+            lines.push(body);
+    }
+    else {
+        lines.push(stringify$2(doc.contents, ctx));
+    }
+    if (doc.directives?.docEnd) {
+        if (doc.comment) {
+            const cs = commentString(doc.comment);
+            if (cs.includes('\n')) {
+                lines.push('...');
+                lines.push(indentComment(cs, ''));
+            }
+            else {
+                lines.push(`... ${cs}`);
+            }
+        }
+        else {
+            lines.push('...');
+        }
+    }
+    else {
+        let dc = doc.comment;
+        if (dc && chompKeep)
+            dc = dc.replace(/^\n+/, '');
+        if (dc) {
+            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
+                lines.push('');
+            lines.push(indentComment(commentString(dc), ''));
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+
+class Document {
+    constructor(value, replacer, options) {
+        /** A comment before this Document */
+        this.commentBefore = null;
+        /** A comment immediately after this Document */
+        this.comment = null;
+        /** Errors encountered during parsing. */
+        this.errors = [];
+        /** Warnings encountered during parsing. */
+        this.warnings = [];
+        Object.defineProperty(this, NODE_TYPE, { value: DOC });
+        let _replacer = null;
+        if (typeof replacer === 'function' || Array.isArray(replacer)) {
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const opt = Object.assign({
+            intAsBigInt: false,
+            keepSourceTokens: false,
+            logLevel: 'warn',
+            prettyErrors: true,
+            strict: true,
+            uniqueKeys: true,
+            version: '1.2'
+        }, options);
+        this.options = opt;
+        let { version } = opt;
+        if (options?._directives) {
+            this.directives = options._directives.atDocument();
+            if (this.directives.yaml.explicit)
+                version = this.directives.yaml.version;
+        }
+        else
+            this.directives = new Directives({ version });
+        this.setSchema(version, options);
+        // @ts-expect-error We can't really know that this matches Contents.
+        this.contents =
+            value === undefined ? null : this.createNode(value, _replacer, options);
+    }
+    /**
+     * Create a deep copy of this Document and its contents.
+     *
+     * Custom Node values that inherit from `Object` still refer to their original instances.
+     */
+    clone() {
+        const copy = Object.create(Document.prototype, {
+            [NODE_TYPE]: { value: DOC }
+        });
+        copy.commentBefore = this.commentBefore;
+        copy.comment = this.comment;
+        copy.errors = this.errors.slice();
+        copy.warnings = this.warnings.slice();
+        copy.options = Object.assign({}, this.options);
+        if (this.directives)
+            copy.directives = this.directives.clone();
+        copy.schema = this.schema.clone();
+        // @ts-expect-error We can't really know that this matches Contents.
+        copy.contents = isNode$1(this.contents)
+            ? this.contents.clone(copy.schema)
+            : this.contents;
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** Adds a value to the document. */
+    add(value) {
+        if (assertCollection(this.contents))
+            this.contents.add(value);
+    }
+    /** Adds a value to the document. */
+    addIn(path, value) {
+        if (assertCollection(this.contents))
+            this.contents.addIn(path, value);
+    }
+    /**
+     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+     *
+     * If `node` already has an anchor, `name` is ignored.
+     * Otherwise, the `node.anchor` value will be set to `name`,
+     * or if an anchor with that name is already present in the document,
+     * `name` will be used as a prefix for a new unique anchor.
+     * If `name` is undefined, the generated anchor will use 'a' as a prefix.
+     */
+    createAlias(node, name) {
+        if (!node.anchor) {
+            const prev = anchorNames(this);
+            node.anchor =
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+                !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;
+        }
+        return new Alias(node.anchor);
+    }
+    createNode(value, replacer, options) {
+        let _replacer = undefined;
+        if (typeof replacer === 'function') {
+            value = replacer.call({ '': value }, '', value);
+            _replacer = replacer;
+        }
+        else if (Array.isArray(replacer)) {
+            const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;
+            const asStr = replacer.filter(keyToStr).map(String);
+            if (asStr.length > 0)
+                replacer = replacer.concat(asStr);
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
+        }
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};
+        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, 
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        anchorPrefix || 'a');
+        const ctx = {
+            aliasDuplicateObjects: aliasDuplicateObjects ?? true,
+            keepUndefined: keepUndefined ?? false,
+            onAnchor,
+            onTagObj,
+            replacer: _replacer,
+            schema: this.schema,
+            sourceObjects
+        };
+        const node = createNode(value, tag, ctx);
+        if (flow && isCollection$1(node))
+            node.flow = true;
+        setAnchors();
+        return node;
+    }
+    /**
+     * Convert a key and a value into a `Pair` using the current schema,
+     * recursively wrapping all values as `Scalar` or `Collection` nodes.
+     */
+    createPair(key, value, options = {}) {
+        const k = this.createNode(key, null, options);
+        const v = this.createNode(value, null, options);
+        return new Pair(k, v);
+    }
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    delete(key) {
+        return assertCollection(this.contents) ? this.contents.delete(key) : false;
+    }
+    /**
+     * Removes a value from the document.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        if (isEmptyPath(path)) {
+            if (this.contents == null)
+                return false;
+            // @ts-expect-error Presumed impossible if Strict extends false
+            this.contents = null;
+            return true;
+        }
+        return assertCollection(this.contents)
+            ? this.contents.deleteIn(path)
+            : false;
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    get(key, keepScalar) {
+        return isCollection$1(this.contents)
+            ? this.contents.get(key, keepScalar)
+            : undefined;
+    }
+    /**
+     * Returns item at `path`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        if (isEmptyPath(path))
+            return !keepScalar && isScalar$1(this.contents)
+                ? this.contents.value
+                : this.contents;
+        return isCollection$1(this.contents)
+            ? this.contents.getIn(path, keepScalar)
+            : undefined;
+    }
+    /**
+     * Checks if the document includes a value with the key `key`.
+     */
+    has(key) {
+        return isCollection$1(this.contents) ? this.contents.has(key) : false;
+    }
+    /**
+     * Checks if the document includes a value at `path`.
+     */
+    hasIn(path) {
+        if (isEmptyPath(path))
+            return this.contents !== undefined;
+        return isCollection$1(this.contents) ? this.contents.hasIn(path) : false;
+    }
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    set(key, value) {
+        if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = collectionFromPath(this.schema, [key], value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.set(key, value);
+        }
+    }
+    /**
+     * Sets a value in this document. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        if (isEmptyPath(path)) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = value;
+        }
+        else if (this.contents == null) {
+            // @ts-expect-error We can't really know that this matches Contents.
+            this.contents = collectionFromPath(this.schema, Array.from(path), value);
+        }
+        else if (assertCollection(this.contents)) {
+            this.contents.setIn(path, value);
+        }
+    }
+    /**
+     * Change the YAML version and schema used by the document.
+     * A `null` version disables support for directives, explicit tags, anchors, and aliases.
+     * It also requires the `schema` option to be given as a `Schema` instance value.
+     *
+     * Overrides all previously set schema options.
+     */
+    setSchema(version, options = {}) {
+        if (typeof version === 'number')
+            version = String(version);
+        let opt;
+        switch (version) {
+            case '1.1':
+                if (this.directives)
+                    this.directives.yaml.version = '1.1';
+                else
+                    this.directives = new Directives({ version: '1.1' });
+                opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };
+                break;
+            case '1.2':
+            case 'next':
+                if (this.directives)
+                    this.directives.yaml.version = version;
+                else
+                    this.directives = new Directives({ version });
+                opt = { merge: false, resolveKnownTags: true, schema: 'core' };
+                break;
+            case null:
+                if (this.directives)
+                    delete this.directives;
+                opt = null;
+                break;
+            default: {
+                const sv = JSON.stringify(version);
+                throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
+            }
+        }
+        // Not using `instanceof Schema` to allow for duck typing
+        if (options.schema instanceof Object)
+            this.schema = options.schema;
+        else if (opt)
+            this.schema = new Schema(Object.assign(opt, options));
+        else
+            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+    }
+    // json & jsonArg are only used from toJSON()
+    toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        const ctx = {
+            anchors: new Map(),
+            doc: this,
+            keep: !json,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS(this.contents, jsonArg ?? '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+    /**
+     * A JSON representation of the document `contents`.
+     *
+     * @param jsonArg Used by `JSON.stringify` to indicate the array index or
+     *   property name.
+     */
+    toJSON(jsonArg, onAnchor) {
+        return this.toJS({ json: true, jsonArg, mapAsMap: false, onAnchor });
+    }
+    /** A YAML representation of the document. */
+    toString(options = {}) {
+        if (this.errors.length > 0)
+            throw new Error('Document with errors cannot be stringified');
+        if ('indent' in options &&
+            (!Number.isInteger(options.indent) || Number(options.indent) <= 0)) {
+            const s = JSON.stringify(options.indent);
+            throw new Error(`"indent" option must be a positive integer, not ${s}`);
+        }
+        return stringifyDocument(this, options);
+    }
+}
+function assertCollection(contents) {
+    if (isCollection$1(contents))
+        return true;
+    throw new Error('Expected a YAML collection as document contents');
+}
+
+class YAMLError extends Error {
+    constructor(name, pos, code, message) {
+        super();
+        this.name = name;
+        this.code = code;
+        this.message = message;
+        this.pos = pos;
+    }
+}
+class YAMLParseError extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
+    }
+}
+class YAMLWarning extends YAMLError {
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
+    }
+}
+const prettifyError = (src, lc) => (error) => {
+    if (error.pos[0] === -1)
+        return;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
+    error.message += ` at line ${line}, column ${col}`;
+    let ci = col - 1;
+    let lineStr = src
+        .substring(lc.lineStarts[line - 1], lc.lineStarts[line])
+        .replace(/[\n\r]+$/, '');
+    // Trim to max 80 chars, keeping col position near the middle
+    if (ci >= 60 && lineStr.length > 80) {
+        const trimStart = Math.min(ci - 39, lineStr.length - 79);
+        lineStr = '…' + lineStr.substring(trimStart);
+        ci -= trimStart - 1;
+    }
+    if (lineStr.length > 80)
+        lineStr = lineStr.substring(0, 79) + '…';
+    // Include previous line in context if pointing at line start
+    if (line > 1 && /^ *$/.test(lineStr.substring(0, ci))) {
+        // Regexp won't match if start is trimmed
+        let prev = src.substring(lc.lineStarts[line - 2], lc.lineStarts[line - 1]);
+        if (prev.length > 80)
+            prev = prev.substring(0, 79) + '…\n';
+        lineStr = prev + lineStr;
+    }
+    if (/[^ ]/.test(lineStr)) {
+        let count = 1;
+        const end = error.linePos[1];
+        if (end && end.line === line && end.col > col) {
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
+        error.message += `:\n\n${lineStr}\n${pointer}\n`;
+    }
+};
+
+function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
+    let spaceBefore = false;
+    let atNewline = startOnNewline;
+    let hasSpace = startOnNewline;
+    let comment = '';
+    let commentSep = '';
+    let hasNewline = false;
+    let reqSpace = false;
+    let tab = null;
+    let anchor = null;
+    let tag = null;
+    let newlineAfterProp = null;
+    let comma = null;
+    let found = null;
+    let start = null;
+    for (const token of tokens) {
+        if (reqSpace) {
+            if (token.type !== 'space' &&
+                token.type !== 'newline' &&
+                token.type !== 'comma')
+                onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+            reqSpace = false;
+        }
+        if (tab) {
+            if (atNewline && token.type !== 'comment' && token.type !== 'newline') {
+                onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+            }
+            tab = null;
+        }
+        switch (token.type) {
+            case 'space':
+                // At the doc level, tabs at line start may be parsed
+                // as leading white space rather than indentation.
+                // In a flow collection, only the parser handles indent.
+                if (!flow &&
+                    (indicator !== 'doc-start' || next?.type !== 'flow-collection') &&
+                    token.source.includes('\t')) {
+                    tab = token;
+                }
+                hasSpace = true;
+                break;
+            case 'comment': {
+                if (!hasSpace)
+                    onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                const cb = token.source.substring(1) || ' ';
+                if (!comment)
+                    comment = cb;
+                else
+                    comment += commentSep + cb;
+                commentSep = '';
+                atNewline = false;
+                break;
+            }
+            case 'newline':
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
+                atNewline = true;
+                hasNewline = true;
+                if (anchor || tag)
+                    newlineAfterProp = token;
+                hasSpace = true;
+                break;
+            case 'anchor':
+                if (anchor)
+                    onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor');
+                if (token.source.endsWith(':'))
+                    onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
+                anchor = token;
+                if (start === null)
+                    start = token.offset;
+                atNewline = false;
+                hasSpace = false;
+                reqSpace = true;
+                break;
+            case 'tag': {
+                if (tag)
+                    onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
+                tag = token;
+                if (start === null)
+                    start = token.offset;
+                atNewline = false;
+                hasSpace = false;
+                reqSpace = true;
+                break;
+            }
+            case indicator:
+                // Could here handle preceding comments differently
+                if (anchor || tag)
+                    onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`);
+                if (found)
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow ?? 'collection'}`);
+                found = token;
+                atNewline =
+                    indicator === 'seq-item-ind' || indicator === 'explicit-key-ind';
+                hasSpace = false;
+                break;
+            case 'comma':
+                if (flow) {
+                    if (comma)
+                        onError(token, 'UNEXPECTED_TOKEN', `Unexpected , in ${flow}`);
+                    comma = token;
+                    atNewline = false;
+                    hasSpace = false;
+                    break;
+                }
+            // else fallthrough
+            default:
+                onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.type} token`);
+                atNewline = false;
+                hasSpace = false;
+        }
+    }
+    const last = tokens[tokens.length - 1];
+    const end = last ? last.offset + last.source.length : offset;
+    if (reqSpace &&
+        next &&
+        next.type !== 'space' &&
+        next.type !== 'newline' &&
+        next.type !== 'comma' &&
+        (next.type !== 'scalar' || next.source !== '')) {
+        onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+    }
+    if (tab &&
+        ((atNewline && tab.indent <= parentIndent) ||
+            next?.type === 'block-map' ||
+            next?.type === 'block-seq'))
+        onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+    return {
+        comma,
+        found,
+        spaceBefore,
+        comment,
+        hasNewline,
+        anchor,
+        tag,
+        newlineAfterProp,
+        end,
+        start: start ?? end
+    };
+}
+
+function containsNewline(key) {
+    if (!key)
+        return null;
+    switch (key.type) {
+        case 'alias':
+        case 'scalar':
+        case 'double-quoted-scalar':
+        case 'single-quoted-scalar':
+            if (key.source.includes('\n'))
+                return true;
+            if (key.end)
+                for (const st of key.end)
+                    if (st.type === 'newline')
+                        return true;
+            return false;
+        case 'flow-collection':
+            for (const it of key.items) {
+                for (const st of it.start)
+                    if (st.type === 'newline')
+                        return true;
+                if (it.sep)
+                    for (const st of it.sep)
+                        if (st.type === 'newline')
+                            return true;
+                if (containsNewline(it.key) || containsNewline(it.value))
+                    return true;
+            }
+            return false;
+        default:
+            return true;
+    }
+}
+
+function flowIndentCheck(indent, fc, onError) {
+    if (fc?.type === 'flow-collection') {
+        const end = fc.end[0];
+        if (end.indent === indent &&
+            (end.source === ']' || end.source === '}') &&
+            containsNewline(fc)) {
+            const msg = 'Flow end indicator should be more indented than parent';
+            onError(end, 'BAD_INDENT', msg, true);
+        }
+    }
+}
+
+function mapIncludes(ctx, items, search) {
+    const { uniqueKeys } = ctx.options;
+    if (uniqueKeys === false)
+        return false;
+    const isEqual = typeof uniqueKeys === 'function'
+        ? uniqueKeys
+        : (a, b) => a === b ||
+            (isScalar$1(a) &&
+                isScalar$1(b) &&
+                a.value === b.value &&
+                !(a.value === '<<' && ctx.schema.merge));
+    return items.some(pair => isEqual(pair.key, search));
+}
+
+const startColMsg = 'All mapping items must start at the same column';
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap;
+    const map = new NodeClass(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
+    let offset = bm.offset;
+    let commentEnd = null;
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
+        // key properties
+        const keyProps = resolveProps(start, {
+            indicator: 'explicit-key-ind',
+            next: key ?? sep?.[0],
+            offset,
+            onError,
+            parentIndent: bm.indent,
+            startOnNewline: true
+        });
+        const implicitKey = !keyProps.found;
+        if (implicitKey) {
+            if (key) {
+                if (key.type === 'block-seq')
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'A block sequence may not be used as an implicit map key');
+                else if ('indent' in key && key.indent !== bm.indent)
+                    onError(offset, 'BAD_INDENT', startColMsg);
+            }
+            if (!keyProps.anchor && !keyProps.tag && !sep) {
+                commentEnd = keyProps.end;
+                if (keyProps.comment) {
+                    if (map.comment)
+                        map.comment += '\n' + keyProps.comment;
+                    else
+                        map.comment = keyProps.comment;
+                }
+                continue;
+            }
+            if (keyProps.newlineAfterProp || containsNewline(key)) {
+                onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
+            }
+        }
+        else if (keyProps.found?.indent !== bm.indent) {
+            onError(offset, 'BAD_INDENT', startColMsg);
+        }
+        // key value
+        const keyStart = keyProps.end;
+        const keyNode = key
+            ? composeNode(ctx, key, keyProps, onError)
+            : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bm.indent, key, onError);
+        if (mapIncludes(ctx, map.items, keyNode))
+            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+        // value properties
+        const valueProps = resolveProps(sep ?? [], {
+            indicator: 'map-value-ind',
+            next: value,
+            offset: keyNode.range[2],
+            onError,
+            parentIndent: bm.indent,
+            startOnNewline: !key || key.type === 'block-scalar'
+        });
+        offset = valueProps.end;
+        if (valueProps.found) {
+            if (implicitKey) {
+                if (value?.type === 'block-map' && !valueProps.hasNewline)
+                    onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings');
+                if (ctx.options.strict &&
+                    keyProps.start < valueProps.found.offset - 1024)
+                    onError(keyNode.range, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit block mapping key');
+            }
+            // value value
+            const valueNode = value
+                ? composeNode(ctx, value, valueProps, onError)
+                : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+            if (ctx.schema.compat)
+                flowIndentCheck(bm.indent, value, onError);
+            offset = valueNode.range[2];
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
+        }
+        else {
+            // key with no value
+            if (implicitKey)
+                onError(keyNode.range, 'MISSING_CHAR', 'Implicit map keys need to be followed by map values');
+            if (valueProps.comment) {
+                if (keyNode.comment)
+                    keyNode.comment += '\n' + valueProps.comment;
+                else
+                    keyNode.comment = valueProps.comment;
+            }
+            const pair = new Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
+        }
+    }
+    if (commentEnd && commentEnd < offset)
+        onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content');
+    map.range = [bm.offset, offset, commentEnd ?? offset];
+    return map;
+}
+
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
+    let offset = bs.offset;
+    let commentEnd = null;
+    for (const { start, value } of bs.items) {
+        const props = resolveProps(start, {
+            indicator: 'seq-item-ind',
+            next: value,
+            offset,
+            onError,
+            parentIndent: bs.indent,
+            startOnNewline: true
+        });
+        if (!props.found) {
+            if (props.anchor || props.tag || value) {
+                if (value && value.type === 'block-seq')
+                    onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
+                else
+                    onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
+            }
+            else {
+                commentEnd = props.end;
+                if (props.comment)
+                    seq.comment = props.comment;
+                continue;
+            }
+        }
+        const node = value
+            ? composeNode(ctx, value, props, onError)
+            : composeEmptyNode(ctx, props.end, start, null, props, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bs.indent, value, onError);
+        offset = node.range[2];
+        seq.items.push(node);
+    }
+    seq.range = [bs.offset, offset, commentEnd ?? offset];
+    return seq;
+}
+
+function resolveEnd(end, offset, reqSpace, onError) {
+    let comment = '';
+    if (end) {
+        let hasSpace = false;
+        let sep = '';
+        for (const token of end) {
+            const { source, type } = token;
+            switch (type) {
+                case 'space':
+                    hasSpace = true;
+                    break;
+                case 'comment': {
+                    if (reqSpace && !hasSpace)
+                        onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
+                    const cb = source.substring(1) || ' ';
+                    if (!comment)
+                        comment = cb;
+                    else
+                        comment += sep + cb;
+                    sep = '';
+                    break;
+                }
+                case 'newline':
+                    if (comment)
+                        sep += source;
+                    hasSpace = true;
+                    break;
+                default:
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${type} at node end`);
+            }
+            offset += source.length;
+        }
+    }
+    return { comment, offset };
+}
+
+const blockMsg = 'Block collections are not allowed within flow collections';
+const isBlock$1 = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
+    const isMap = fc.start.source === '{';
+    const fcName = isMap ? 'flow map' : 'flow sequence';
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
+    coll.flow = true;
+    const atRoot = ctx.atRoot;
+    if (atRoot)
+        ctx.atRoot = false;
+    let offset = fc.offset + fc.start.source.length;
+    for (let i = 0; i < fc.items.length; ++i) {
+        const collItem = fc.items[i];
+        const { start, key, sep, value } = collItem;
+        const props = resolveProps(start, {
+            flow: fcName,
+            indicator: 'explicit-key-ind',
+            next: key ?? sep?.[0],
+            offset,
+            onError,
+            parentIndent: fc.indent,
+            startOnNewline: false
+        });
+        if (!props.found) {
+            if (!props.anchor && !props.tag && !sep && !value) {
+                if (i === 0 && props.comma)
+                    onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+                else if (i < fc.items.length - 1)
+                    onError(props.start, 'UNEXPECTED_TOKEN', `Unexpected empty item in ${fcName}`);
+                if (props.comment) {
+                    if (coll.comment)
+                        coll.comment += '\n' + props.comment;
+                    else
+                        coll.comment = props.comment;
+                }
+                offset = props.end;
+                continue;
+            }
+            if (!isMap && ctx.options.strict && containsNewline(key))
+                onError(key, // checked by containsNewline()
+                'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+        }
+        if (i === 0) {
+            if (props.comma)
+                onError(props.comma, 'UNEXPECTED_TOKEN', `Unexpected , in ${fcName}`);
+        }
+        else {
+            if (!props.comma)
+                onError(props.start, 'MISSING_CHAR', `Missing , between ${fcName} items`);
+            if (props.comment) {
+                let prevItemComment = '';
+                loop: for (const st of start) {
+                    switch (st.type) {
+                        case 'comma':
+                        case 'space':
+                            break;
+                        case 'comment':
+                            prevItemComment = st.source.substring(1);
+                            break loop;
+                        default:
+                            break loop;
+                    }
+                }
+                if (prevItemComment) {
+                    let prev = coll.items[coll.items.length - 1];
+                    if (isPair(prev))
+                        prev = prev.value ?? prev.key;
+                    if (prev.comment)
+                        prev.comment += '\n' + prevItemComment;
+                    else
+                        prev.comment = prevItemComment;
+                    props.comment = props.comment.substring(prevItemComment.length + 1);
+                }
+            }
+        }
+        if (!isMap && !sep && !props.found) {
+            // item is a value in a seq
+            // → key & sep are empty, start does not include ? or :
+            const valueNode = value
+                ? composeNode(ctx, value, props, onError)
+                : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+            coll.items.push(valueNode);
+            offset = valueNode.range[2];
+            if (isBlock$1(value))
+                onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+        }
+        else {
+            // item is a key+value pair
+            // key value
+            const keyStart = props.end;
+            const keyNode = key
+                ? composeNode(ctx, key, props, onError)
+                : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+            if (isBlock$1(key))
+                onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            // value properties
+            const valueProps = resolveProps(sep ?? [], {
+                flow: fcName,
+                indicator: 'map-value-ind',
+                next: value,
+                offset: keyNode.range[2],
+                onError,
+                parentIndent: fc.indent,
+                startOnNewline: false
+            });
+            if (valueProps.found) {
+                if (!isMap && !props.found && ctx.options.strict) {
+                    if (sep)
+                        for (const st of sep) {
+                            if (st === valueProps.found)
+                                break;
+                            if (st.type === 'newline') {
+                                onError(st, 'MULTILINE_IMPLICIT_KEY', 'Implicit keys of flow sequence pairs need to be on a single line');
+                                break;
+                            }
+                        }
+                    if (props.start < valueProps.found.offset - 1024)
+                        onError(valueProps.found, 'KEY_OVER_1024_CHARS', 'The : indicator must be at most 1024 chars after the start of an implicit flow sequence key');
+                }
+            }
+            else if (value) {
+                if ('source' in value && value.source && value.source[0] === ':')
+                    onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);
+                else
+                    onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
+            }
+            // value value
+            const valueNode = value
+                ? composeNode(ctx, value, valueProps, onError)
+                : valueProps.found
+                    ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError)
+                    : null;
+            if (valueNode) {
+                if (isBlock$1(value))
+                    onError(valueNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            }
+            else if (valueProps.comment) {
+                if (keyNode.comment)
+                    keyNode.comment += '\n' + valueProps.comment;
+                else
+                    keyNode.comment = valueProps.comment;
+            }
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            if (isMap) {
+                const map = coll;
+                if (mapIncludes(ctx, map.items, keyNode))
+                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+                map.items.push(pair);
+            }
+            else {
+                const map = new YAMLMap(ctx.schema);
+                map.flow = true;
+                map.items.push(pair);
+                coll.items.push(map);
+            }
+            offset = valueNode ? valueNode.range[2] : valueProps.end;
+        }
+    }
+    const expectedEnd = isMap ? '}' : ']';
+    const [ce, ...ee] = fc.end;
+    let cePos = offset;
+    if (ce && ce.source === expectedEnd)
+        cePos = ce.offset + ce.source.length;
+    else {
+        const name = fcName[0].toUpperCase() + fcName.substring(1);
+        const msg = atRoot
+            ? `${name} must end with a ${expectedEnd}`
+            : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+        onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg);
+        if (ce && ce.source.length !== 1)
+            ee.unshift(ce);
+    }
+    if (ee.length > 0) {
+        const end = resolveEnd(ee, cePos, ctx.options.strict, onError);
+        if (end.comment) {
+            if (coll.comment)
+                coll.comment += '\n' + end.comment;
+            else
+                coll.comment = end.comment;
+        }
+        coll.range = [fc.offset, cePos, end.offset];
+    }
+    else {
+        coll.range = [fc.offset, cePos, cePos];
+    }
+    return coll;
+}
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt && kt.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt?.collection) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode$1(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+function resolveBlockScalar(ctx, scalar, onError) {
+    const start = scalar.offset;
+    const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+    if (!header)
+        return { value: '', type: null, comment: '', range: [start, start, start] };
+    const type = header.mode === '>' ? Scalar.BLOCK_FOLDED : Scalar.BLOCK_LITERAL;
+    const lines = scalar.source ? splitLines(scalar.source) : [];
+    // determine the end of content & start of chomping
+    let chompStart = lines.length;
+    for (let i = lines.length - 1; i >= 0; --i) {
+        const content = lines[i][1];
+        if (content === '' || content === '\r')
+            chompStart = i;
+        else
+            break;
+    }
+    // shortcut for empty contents
+    if (chompStart === 0) {
+        const value = header.chomp === '+' && lines.length > 0
+            ? '\n'.repeat(Math.max(1, lines.length - 1))
+            : '';
+        let end = start + header.length;
+        if (scalar.source)
+            end += scalar.source.length;
+        return { value, type, comment: header.comment, range: [start, end, end] };
+    }
+    // find the indentation level to trim from start
+    let trimIndent = scalar.indent + header.indent;
+    let offset = scalar.offset + header.length;
+    let contentStart = 0;
+    for (let i = 0; i < chompStart; ++i) {
+        const [indent, content] = lines[i];
+        if (content === '' || content === '\r') {
+            if (header.indent === 0 && indent.length > trimIndent)
+                trimIndent = indent.length;
+        }
+        else {
+            if (indent.length < trimIndent) {
+                const message = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
+                onError(offset + indent.length, 'MISSING_CHAR', message);
+            }
+            if (header.indent === 0)
+                trimIndent = indent.length;
+            contentStart = i;
+            if (trimIndent === 0 && !ctx.atRoot) {
+                const message = 'Block scalar values in collections must be indented';
+                onError(offset, 'BAD_INDENT', message);
+            }
+            break;
+        }
+        offset += indent.length + content.length + 1;
+    }
+    // include trailing more-indented empty lines in content
+    for (let i = lines.length - 1; i >= chompStart; --i) {
+        if (lines[i][0].length > trimIndent)
+            chompStart = i + 1;
+    }
+    let value = '';
+    let sep = '';
+    let prevMoreIndented = false;
+    // leading whitespace is kept intact
+    for (let i = 0; i < contentStart; ++i)
+        value += lines[i][0].slice(trimIndent) + '\n';
+    for (let i = contentStart; i < chompStart; ++i) {
+        let [indent, content] = lines[i];
+        offset += indent.length + content.length + 1;
+        const crlf = content[content.length - 1] === '\r';
+        if (crlf)
+            content = content.slice(0, -1);
+        /* istanbul ignore if already caught in lexer */
+        if (content && indent.length < trimIndent) {
+            const src = header.indent
+                ? 'explicit indentation indicator'
+                : 'first line';
+            const message = `Block scalar lines must not be less indented than their ${src}`;
+            onError(offset - content.length - (crlf ? 2 : 1), 'BAD_INDENT', message);
+            indent = '';
+        }
+        if (type === Scalar.BLOCK_LITERAL) {
+            value += sep + indent.slice(trimIndent) + content;
+            sep = '\n';
+        }
+        else if (indent.length > trimIndent || content[0] === '\t') {
+            // more-indented content within a folded block
+            if (sep === ' ')
+                sep = '\n';
+            else if (!prevMoreIndented && sep === '\n')
+                sep = '\n\n';
+            value += sep + indent.slice(trimIndent) + content;
+            sep = '\n';
+            prevMoreIndented = true;
+        }
+        else if (content === '') {
+            // empty line
+            if (sep === '\n')
+                value += '\n';
+            else
+                sep = '\n';
+        }
+        else {
+            value += sep + content;
+            sep = ' ';
+            prevMoreIndented = false;
+        }
+    }
+    switch (header.chomp) {
+        case '-':
+            break;
+        case '+':
+            for (let i = chompStart; i < lines.length; ++i)
+                value += '\n' + lines[i][0].slice(trimIndent);
+            if (value[value.length - 1] !== '\n')
+                value += '\n';
+            break;
+        default:
+            value += '\n';
+    }
+    const end = start + header.length + scalar.source.length;
+    return { value, type, comment: header.comment, range: [start, end, end] };
+}
+function parseBlockScalarHeader({ offset, props }, strict, onError) {
+    /* istanbul ignore if should not happen */
+    if (props[0].type !== 'block-scalar-header') {
+        onError(props[0], 'IMPOSSIBLE', 'Block scalar header not found');
+        return null;
+    }
+    const { source } = props[0];
+    const mode = source[0];
+    let indent = 0;
+    let chomp = '';
+    let error = -1;
+    for (let i = 1; i < source.length; ++i) {
+        const ch = source[i];
+        if (!chomp && (ch === '-' || ch === '+'))
+            chomp = ch;
+        else {
+            const n = Number(ch);
+            if (!indent && n)
+                indent = n;
+            else if (error === -1)
+                error = offset + i;
+        }
+    }
+    if (error !== -1)
+        onError(error, 'UNEXPECTED_TOKEN', `Block scalar header includes extra characters: ${source}`);
+    let hasSpace = false;
+    let comment = '';
+    let length = source.length;
+    for (let i = 1; i < props.length; ++i) {
+        const token = props[i];
+        switch (token.type) {
+            case 'space':
+                hasSpace = true;
+            // fallthrough
+            case 'newline':
+                length += token.source.length;
+                break;
+            case 'comment':
+                if (strict && !hasSpace) {
+                    const message = 'Comments must be separated from other tokens by white space characters';
+                    onError(token, 'MISSING_CHAR', message);
+                }
+                length += token.source.length;
+                comment = token.source.substring(1);
+                break;
+            case 'error':
+                onError(token, 'UNEXPECTED_TOKEN', token.message);
+                length += token.source.length;
+                break;
+            /* istanbul ignore next should not happen */
+            default: {
+                const message = `Unexpected token in block scalar header: ${token.type}`;
+                onError(token, 'UNEXPECTED_TOKEN', message);
+                const ts = token.source;
+                if (ts && typeof ts === 'string')
+                    length += ts.length;
+            }
+        }
+    }
+    return { mode, indent, chomp, comment, length };
+}
+/** @returns Array of lines split up as `[indent, content]` */
+function splitLines(source) {
+    const split = source.split(/\n( *)/);
+    const first = split[0];
+    const m = first.match(/^( *)/);
+    const line0 = m?.[1]
+        ? [m[1], first.slice(m[1].length)]
+        : ['', first];
+    const lines = [line0];
+    for (let i = 1; i < split.length; i += 2)
+        lines.push([split[i], split[i + 1]]);
+    return lines;
+}
+
+function resolveFlowScalar(scalar, strict, onError) {
+    const { offset, type, source, end } = scalar;
+    let _type;
+    let value;
+    const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
+    switch (type) {
+        case 'scalar':
+            _type = Scalar.PLAIN;
+            value = plainValue(source, _onError);
+            break;
+        case 'single-quoted-scalar':
+            _type = Scalar.QUOTE_SINGLE;
+            value = singleQuotedValue(source, _onError);
+            break;
+        case 'double-quoted-scalar':
+            _type = Scalar.QUOTE_DOUBLE;
+            value = doubleQuotedValue(source, _onError);
+            break;
+        /* istanbul ignore next should not happen */
+        default:
+            onError(scalar, 'UNEXPECTED_TOKEN', `Expected a flow scalar value, but found: ${type}`);
+            return {
+                value: '',
+                type: null,
+                comment: '',
+                range: [offset, offset + source.length, offset + source.length]
+            };
+    }
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, strict, onError);
+    return {
+        value,
+        type: _type,
+        comment: re.comment,
+        range: [offset, valueEnd, re.offset]
+    };
+}
+function plainValue(source, onError) {
+    let badChar = '';
+    switch (source[0]) {
+        /* istanbul ignore next should not happen */
+        case '\t':
+            badChar = 'a tab character';
+            break;
+        case ',':
+            badChar = 'flow indicator character ,';
+            break;
+        case '%':
+            badChar = 'directive indicator character %';
+            break;
+        case '|':
+        case '>': {
+            badChar = `block scalar indicator ${source[0]}`;
+            break;
+        }
+        case '@':
+        case '`': {
+            badChar = `reserved character ${source[0]}`;
+            break;
+        }
+    }
+    if (badChar)
+        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+    return foldLines(source);
+}
+function singleQuotedValue(source, onError) {
+    if (source[source.length - 1] !== "'" || source.length === 1)
+        onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
+    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+}
+function foldLines(source) {
+    /**
+     * The negative lookbehind here and in the `re` RegExp is to
+     * prevent causing a polynomial search time in certain cases.
+     *
+     * The try-catch is for Safari, which doesn't support this yet:
+     * https://caniuse.com/js-regexp-lookbehind
+     */
+    let first, line;
+    try {
+        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
+        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+    }
+    catch (_) {
+        first = /(.*?)[ \t]*\r?\n/sy;
+        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+    }
+    let match = first.exec(source);
+    if (!match)
+        return source;
+    let res = match[1];
+    let sep = ' ';
+    let pos = first.lastIndex;
+    line.lastIndex = pos;
+    while ((match = line.exec(source))) {
+        if (match[1] === '') {
+            if (sep === '\n')
+                res += sep;
+            else
+                sep = '\n';
+        }
+        else {
+            res += sep + match[1];
+            sep = ' ';
+        }
+        pos = line.lastIndex;
+    }
+    const last = /[ \t]*(.*)/sy;
+    last.lastIndex = pos;
+    match = last.exec(source);
+    return res + sep + (match?.[1] ?? '');
+}
+function doubleQuotedValue(source, onError) {
+    let res = '';
+    for (let i = 1; i < source.length - 1; ++i) {
+        const ch = source[i];
+        if (ch === '\r' && source[i + 1] === '\n')
+            continue;
+        if (ch === '\n') {
+            const { fold, offset } = foldNewline(source, i);
+            res += fold;
+            i = offset;
+        }
+        else if (ch === '\\') {
+            let next = source[++i];
+            const cc = escapeCodes[next];
+            if (cc)
+                res += cc;
+            else if (next === '\n') {
+                // skip escaped newlines, but still trim the following line
+                next = source[i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
+            else if (next === '\r' && source[i + 1] === '\n') {
+                // skip escaped CRLF newlines, but still trim the following line
+                next = source[++i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
+            else if (next === 'x' || next === 'u' || next === 'U') {
+                const length = { x: 2, u: 4, U: 8 }[next];
+                res += parseCharCode(source, i + 1, length, onError);
+                i += length;
+            }
+            else {
+                const raw = source.substr(i - 1, 2);
+                onError(i - 1, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+                res += raw;
+            }
+        }
+        else if (ch === ' ' || ch === '\t') {
+            // trim trailing whitespace
+            const wsStart = i;
+            let next = source[i + 1];
+            while (next === ' ' || next === '\t')
+                next = source[++i + 1];
+            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
+                res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
+        }
+        else {
+            res += ch;
+        }
+    }
+    if (source[source.length - 1] !== '"' || source.length === 1)
+        onError(source.length, 'MISSING_CHAR', 'Missing closing "quote');
+    return res;
+}
+/**
+ * Fold a single newline into a space, multiple newlines to N - 1 newlines.
+ * Presumes `source[offset] === '\n'`
+ */
+function foldNewline(source, offset) {
+    let fold = '';
+    let ch = source[offset + 1];
+    while (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+        if (ch === '\r' && source[offset + 2] !== '\n')
+            break;
+        if (ch === '\n')
+            fold += '\n';
+        offset += 1;
+        ch = source[offset + 1];
+    }
+    if (!fold)
+        fold = ' ';
+    return { fold, offset };
+}
+const escapeCodes = {
+    '0': '\0', // null character
+    a: '\x07', // bell character
+    b: '\b', // backspace
+    e: '\x1b', // escape character
+    f: '\f', // form feed
+    n: '\n', // line feed
+    r: '\r', // carriage return
+    t: '\t', // horizontal tab
+    v: '\v', // vertical tab
+    N: '\u0085', // Unicode next line
+    _: '\u00a0', // Unicode non-breaking space
+    L: '\u2028', // Unicode line separator
+    P: '\u2029', // Unicode paragraph separator
+    ' ': ' ',
+    '"': '"',
+    '/': '/',
+    '\\': '\\',
+    '\t': '\t'
+};
+function parseCharCode(source, offset, length, onError) {
+    const cc = source.substr(offset, length);
+    const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
+    const code = ok ? parseInt(cc, 16) : NaN;
+    if (isNaN(code)) {
+        const raw = source.substr(offset - 2, length + 2);
+        onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
+        return raw;
+    }
+    return String.fromCodePoint(code);
+}
+
+function composeScalar(ctx, token, tagToken, onError) {
+    const { value, type, comment, range } = token.type === 'block-scalar'
+        ? resolveBlockScalar(ctx, token, onError)
+        : resolveFlowScalar(token, ctx.options.strict, onError);
+    const tagName = tagToken
+        ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
+        : null;
+    const tag = tagToken && tagName
+        ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
+        : token.type === 'scalar'
+            ? findScalarTagByTest(ctx, value, token, onError)
+            : ctx.schema[SCALAR$1];
+    let scalar;
+    try {
+        const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+        scalar = isScalar$1(res) ? res : new Scalar(res);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg);
+        scalar = new Scalar(value);
+    }
+    scalar.range = range;
+    scalar.source = value;
+    if (type)
+        scalar.type = type;
+    if (tagName)
+        scalar.tag = tagName;
+    if (tag.format)
+        scalar.format = tag.format;
+    if (comment)
+        scalar.comment = comment;
+    return scalar;
+}
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+    if (tagName === '!')
+        return schema[SCALAR$1]; // non-specific tag
+    const matchWithTest = [];
+    for (const tag of schema.tags) {
+        if (!tag.collection && tag.tag === tagName) {
+            if (tag.default && tag.test)
+                matchWithTest.push(tag);
+            else
+                return tag;
+        }
+    }
+    for (const tag of matchWithTest)
+        if (tag.test?.test(value))
+            return tag;
+    const kt = schema.knownTags[tagName];
+    if (kt && !kt.collection) {
+        // Ensure that the known tag is available for stringifying,
+        // but does not get used by default.
+        schema.tags.push(Object.assign({}, kt, { default: false, test: undefined }));
+        return kt;
+    }
+    onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
+    return schema[SCALAR$1];
+}
+function findScalarTagByTest({ directives, schema }, value, token, onError) {
+    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[SCALAR$1];
+    if (schema.compat) {
+        const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
+            schema[SCALAR$1];
+        if (tag.tag !== compat.tag) {
+            const ts = directives.tagString(tag.tag);
+            const cs = directives.tagString(compat.tag);
+            const msg = `Value may be parsed as either ${ts} or ${cs}`;
+            onError(token, 'TAG_RESOLVE_FAILED', msg, true);
+        }
+    }
+    return tag;
+}
+
+function emptyScalarPosition(offset, before, pos) {
+    if (before) {
+        if (pos === null)
+            pos = before.length;
+        for (let i = pos - 1; i >= 0; --i) {
+            let st = before[i];
+            switch (st.type) {
+                case 'space':
+                case 'comment':
+                case 'newline':
+                    offset -= st.source.length;
+                    continue;
+            }
+            // Technically, an empty scalar is immediately after the last non-empty
+            // node, but it's more useful to place it after any whitespace.
+            st = before[++i];
+            while (st?.type === 'space') {
+                offset += st.source.length;
+                st = before[++i];
+            }
+            break;
+        }
+    }
+    return offset;
+}
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+    const { spaceBefore, comment, anchor, tag } = props;
+    let node;
+    let isSrcToken = true;
+    switch (token.type) {
+        case 'alias':
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
+            break;
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'block-scalar':
+            node = composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        case 'block-map':
+        case 'block-seq':
+        case 'flow-collection':
+            node = composeCollection(CN, ctx, token, props, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
+            isSrcToken = false;
+        }
+    }
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        if (token.type === 'scalar' && token.source === '')
+            node.comment = comment;
+        else
+            node.commentBefore = comment;
+    }
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
+        node.srcToken = token;
+    return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    const token = {
+        type: 'scalar',
+        offset: emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar(ctx, token, tag, onError);
+    if (anchor) {
+        node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        node.comment = comment;
+        node.range[2] = end;
+    }
+    return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document(undefined, opts);
+    const ctx = {
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+function getErrorPos(src) {
+    if (typeof src === 'number')
+        return [src, src + 1];
+    if (Array.isArray(src))
+        return src.length === 2 ? src : [src[0], src[1]];
+    const { offset, source } = src;
+    return [offset, offset + (typeof source === 'string' ? source.length : 1)];
+}
+function parsePrelude(prelude) {
+    let comment = '';
+    let atComment = false;
+    let afterEmptyLine = false;
+    for (let i = 0; i < prelude.length; ++i) {
+        const source = prelude[i];
+        switch (source[0]) {
+            case '#':
+                comment +=
+                    (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
+                        (source.substring(1) || ' ');
+                atComment = true;
+                afterEmptyLine = false;
+                break;
+            case '%':
+                if (prelude[i + 1]?.[0] !== '#')
+                    i += 1;
+                atComment = false;
+                break;
+            default:
+                // This may be wrong after doc-end, but in that case it doesn't matter
+                if (!atComment)
+                    afterEmptyLine = true;
+                atComment = false;
+        }
+    }
+    return { comment, afterEmptyLine };
+}
+/**
+ * Compose a stream of CST nodes into a stream of YAML Documents.
+ *
+ * ```ts
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
+ * ```
+ */
+class Composer {
+    constructor(options = {}) {
+        this.doc = null;
+        this.atDirectives = false;
+        this.prelude = [];
+        this.errors = [];
+        this.warnings = [];
+        this.onError = (source, code, message, warning) => {
+            const pos = getErrorPos(source);
+            if (warning)
+                this.warnings.push(new YAMLWarning(pos, code, message));
+            else
+                this.errors.push(new YAMLParseError(pos, code, message));
+        };
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        this.directives = new Directives({ version: options.version || '1.2' });
+        this.options = options;
+    }
+    decorate(doc, afterDoc) {
+        const { comment, afterEmptyLine } = parsePrelude(this.prelude);
+        //console.log({ dc: doc.comment, prelude, comment })
+        if (comment) {
+            const dc = doc.contents;
+            if (afterDoc) {
+                doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment;
+            }
+            else if (afterEmptyLine || doc.directives.docStart || !dc) {
+                doc.commentBefore = comment;
+            }
+            else if (isCollection$1(dc) && !dc.flow && dc.items.length > 0) {
+                let it = dc.items[0];
+                if (isPair(it))
+                    it = it.key;
+                const cb = it.commentBefore;
+                it.commentBefore = cb ? `${comment}\n${cb}` : comment;
+            }
+            else {
+                const cb = dc.commentBefore;
+                dc.commentBefore = cb ? `${comment}\n${cb}` : comment;
+            }
+        }
+        if (afterDoc) {
+            Array.prototype.push.apply(doc.errors, this.errors);
+            Array.prototype.push.apply(doc.warnings, this.warnings);
+        }
+        else {
+            doc.errors = this.errors;
+            doc.warnings = this.warnings;
+        }
+        this.prelude = [];
+        this.errors = [];
+        this.warnings = [];
+    }
+    /**
+     * Current stream status information.
+     *
+     * Mostly useful at the end of input for an empty stream.
+     */
+    streamInfo() {
+        return {
+            comment: parsePrelude(this.prelude).comment,
+            directives: this.directives,
+            errors: this.errors,
+            warnings: this.warnings
+        };
+    }
+    /**
+     * Compose tokens into documents.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *compose(tokens, forceDoc = false, endOffset = -1) {
+        for (const token of tokens)
+            yield* this.next(token);
+        yield* this.end(forceDoc, endOffset);
+    }
+    /** Advance the composer by one CST token. */
+    *next(token) {
+        switch (token.type) {
+            case 'directive':
+                this.directives.add(token.source, (offset, message, warning) => {
+                    const pos = getErrorPos(token);
+                    pos[0] += offset;
+                    this.onError(pos, 'BAD_DIRECTIVE', message, warning);
+                });
+                this.prelude.push(token.source);
+                this.atDirectives = true;
+                break;
+            case 'document': {
+                const doc = composeDoc(this.options, this.directives, token, this.onError);
+                if (this.atDirectives && !doc.directives.docStart)
+                    this.onError(token, 'MISSING_CHAR', 'Missing directives-end/doc-start indicator line');
+                this.decorate(doc, false);
+                if (this.doc)
+                    yield this.doc;
+                this.doc = doc;
+                this.atDirectives = false;
+                break;
+            }
+            case 'byte-order-mark':
+            case 'space':
+                break;
+            case 'comment':
+            case 'newline':
+                this.prelude.push(token.source);
+                break;
+            case 'error': {
+                const msg = token.source
+                    ? `${token.message}: ${JSON.stringify(token.source)}`
+                    : token.message;
+                const error = new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg);
+                if (this.atDirectives || !this.doc)
+                    this.errors.push(error);
+                else
+                    this.doc.errors.push(error);
+                break;
+            }
+            case 'doc-end': {
+                if (!this.doc) {
+                    const msg = 'Unexpected doc-end without preceding document';
+                    this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', msg));
+                    break;
+                }
+                this.doc.directives.docEnd = true;
+                const end = resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+                this.decorate(this.doc, true);
+                if (end.comment) {
+                    const dc = this.doc.comment;
+                    this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
+                }
+                this.doc.range[2] = end.offset;
+                break;
+            }
+            default:
+                this.errors.push(new YAMLParseError(getErrorPos(token), 'UNEXPECTED_TOKEN', `Unsupported token ${token.type}`));
+        }
+    }
+    /**
+     * Call at end of input to yield any remaining document.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    *end(forceDoc = false, endOffset = -1) {
+        if (this.doc) {
+            this.decorate(this.doc, true);
+            yield this.doc;
+            this.doc = null;
+        }
+        else if (forceDoc) {
+            const opts = Object.assign({ _directives: this.directives }, this.options);
+            const doc = new Document(undefined, opts);
+            if (this.atDirectives)
+                this.onError(endOffset, 'MISSING_CHAR', 'Missing directives-end indicator line');
+            doc.range = [0, endOffset, endOffset];
+            this.decorate(doc, false);
+            yield doc;
+        }
+    }
+}
+
+function resolveAsScalar(token, strict = true, onError) {
+    if (token) {
+        const _onError = (pos, code, message) => {
+            const offset = typeof pos === 'number' ? pos : Array.isArray(pos) ? pos[0] : pos.offset;
+            if (onError)
+                onError(offset, code, message);
+            else
+                throw new YAMLParseError([offset, offset + 1], code, message);
+        };
+        switch (token.type) {
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return resolveFlowScalar(token, strict, _onError);
+            case 'block-scalar':
+                return resolveBlockScalar({ options: { strict } }, token, _onError);
+        }
+    }
+    return null;
+}
+/**
+ * Create a new scalar token with `value`
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.indent The indent level of the token.
+ * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+ * @param context.offset The offset position of the token.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+function createScalarToken(value, context) {
+    const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
+    const source = stringifyString({ type, value }, {
+        implicitKey,
+        indent: indent > 0 ? ' '.repeat(indent) : '',
+        inFlow,
+        options: { blockQuote: true, lineWidth: -1 }
+    });
+    const end = context.end ?? [
+        { type: 'newline', offset: -1, indent, source: '\n' }
+    ];
+    switch (source[0]) {
+        case '|':
+        case '>': {
+            const he = source.indexOf('\n');
+            const head = source.substring(0, he);
+            const body = source.substring(he + 1) + '\n';
+            const props = [
+                { type: 'block-scalar-header', offset, indent, source: head }
+            ];
+            if (!addEndtoBlockProps(props, end))
+                props.push({ type: 'newline', offset: -1, indent, source: '\n' });
+            return { type: 'block-scalar', offset, indent, props, source: body };
+        }
+        case '"':
+            return { type: 'double-quoted-scalar', offset, indent, source, end };
+        case "'":
+            return { type: 'single-quoted-scalar', offset, indent, source, end };
+        default:
+            return { type: 'scalar', offset, indent, source, end };
+    }
+}
+/**
+ * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
+ *
+ * Best efforts are made to retain any comments previously associated with the `token`,
+ * though all contents within a collection's `items` will be overwritten.
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+function setScalarValue(token, value, context = {}) {
+    let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+    let indent = 'indent' in token ? token.indent : null;
+    if (afterKey && typeof indent === 'number')
+        indent += 2;
+    if (!type)
+        switch (token.type) {
+            case 'single-quoted-scalar':
+                type = 'QUOTE_SINGLE';
+                break;
+            case 'double-quoted-scalar':
+                type = 'QUOTE_DOUBLE';
+                break;
+            case 'block-scalar': {
+                const header = token.props[0];
+                if (header.type !== 'block-scalar-header')
+                    throw new Error('Invalid block scalar header');
+                type = header.source[0] === '>' ? 'BLOCK_FOLDED' : 'BLOCK_LITERAL';
+                break;
+            }
+            default:
+                type = 'PLAIN';
+        }
+    const source = stringifyString({ type, value }, {
+        implicitKey: implicitKey || indent === null,
+        indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
+        inFlow,
+        options: { blockQuote: true, lineWidth: -1 }
+    });
+    switch (source[0]) {
+        case '|':
+        case '>':
+            setBlockScalarValue(token, source);
+            break;
+        case '"':
+            setFlowScalarValue(token, source, 'double-quoted-scalar');
+            break;
+        case "'":
+            setFlowScalarValue(token, source, 'single-quoted-scalar');
+            break;
+        default:
+            setFlowScalarValue(token, source, 'scalar');
+    }
+}
+function setBlockScalarValue(token, source) {
+    const he = source.indexOf('\n');
+    const head = source.substring(0, he);
+    const body = source.substring(he + 1) + '\n';
+    if (token.type === 'block-scalar') {
+        const header = token.props[0];
+        if (header.type !== 'block-scalar-header')
+            throw new Error('Invalid block scalar header');
+        header.source = head;
+        token.source = body;
+    }
+    else {
+        const { offset } = token;
+        const indent = 'indent' in token ? token.indent : -1;
+        const props = [
+            { type: 'block-scalar-header', offset, indent, source: head }
+        ];
+        if (!addEndtoBlockProps(props, 'end' in token ? token.end : undefined))
+            props.push({ type: 'newline', offset: -1, indent, source: '\n' });
+        for (const key of Object.keys(token))
+            if (key !== 'type' && key !== 'offset')
+                delete token[key];
+        Object.assign(token, { type: 'block-scalar', indent, props, source: body });
+    }
+}
+/** @returns `true` if last token is a newline */
+function addEndtoBlockProps(props, end) {
+    if (end)
+        for (const st of end)
+            switch (st.type) {
+                case 'space':
+                case 'comment':
+                    props.push(st);
+                    break;
+                case 'newline':
+                    props.push(st);
+                    return true;
+            }
+    return false;
+}
+function setFlowScalarValue(token, source, type) {
+    switch (token.type) {
+        case 'scalar':
+        case 'double-quoted-scalar':
+        case 'single-quoted-scalar':
+            token.type = type;
+            token.source = source;
+            break;
+        case 'block-scalar': {
+            const end = token.props.slice(1);
+            let oa = source.length;
+            if (token.props[0].type === 'block-scalar-header')
+                oa -= token.props[0].source.length;
+            for (const tok of end)
+                tok.offset += oa;
+            delete token.props;
+            Object.assign(token, { type, source, end });
+            break;
+        }
+        case 'block-map':
+        case 'block-seq': {
+            const offset = token.offset + source.length;
+            const nl = { type: 'newline', offset, indent: token.indent, source: '\n' };
+            delete token.items;
+            Object.assign(token, { type, source, end: [nl] });
+            break;
+        }
+        default: {
+            const indent = 'indent' in token ? token.indent : -1;
+            const end = 'end' in token && Array.isArray(token.end)
+                ? token.end.filter(st => st.type === 'space' ||
+                    st.type === 'comment' ||
+                    st.type === 'newline')
+                : [];
+            for (const key of Object.keys(token))
+                if (key !== 'type' && key !== 'offset')
+                    delete token[key];
+            Object.assign(token, { type, indent, source, end });
+        }
+    }
+}
+
+/**
+ * Stringify a CST document, token, or collection item
+ *
+ * Fair warning: This applies no validation whatsoever, and
+ * simply concatenates the sources in their logical order.
+ */
+const stringify$1 = (cst) => 'type' in cst ? stringifyToken(cst) : stringifyItem(cst);
+function stringifyToken(token) {
+    switch (token.type) {
+        case 'block-scalar': {
+            let res = '';
+            for (const tok of token.props)
+                res += stringifyToken(tok);
+            return res + token.source;
+        }
+        case 'block-map':
+        case 'block-seq': {
+            let res = '';
+            for (const item of token.items)
+                res += stringifyItem(item);
+            return res;
+        }
+        case 'flow-collection': {
+            let res = token.start.source;
+            for (const item of token.items)
+                res += stringifyItem(item);
+            for (const st of token.end)
+                res += st.source;
+            return res;
+        }
+        case 'document': {
+            let res = stringifyItem(token);
+            if (token.end)
+                for (const st of token.end)
+                    res += st.source;
+            return res;
+        }
+        default: {
+            let res = token.source;
+            if ('end' in token && token.end)
+                for (const st of token.end)
+                    res += st.source;
+            return res;
+        }
+    }
+}
+function stringifyItem({ start, key, sep, value }) {
+    let res = '';
+    for (const st of start)
+        res += st.source;
+    if (key)
+        res += stringifyToken(key);
+    if (sep)
+        for (const st of sep)
+            res += st.source;
+    if (value)
+        res += stringifyToken(value);
+    return res;
+}
+
+const BREAK = Symbol('break visit');
+const SKIP = Symbol('skip children');
+const REMOVE = Symbol('remove item');
+/**
+ * Apply a visitor to a CST document or item.
+ *
+ * Walks through the tree (depth-first) starting from the root, calling a
+ * `visitor` function with two arguments when entering each item:
+ *   - `item`: The current item, which included the following members:
+ *     - `start: SourceToken[]` – Source tokens before the key or value,
+ *       possibly including its anchor or tag.
+ *     - `key?: Token | null` – Set for pair values. May then be `null`, if
+ *       the key before the `:` separator is empty.
+ *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+ *       which should include the `:` map value indicator if `value` is set.
+ *     - `value?: Token` – The value of a sequence item, or of a map pair.
+ *   - `path`: The steps from the root to the current node, as an array of
+ *     `['key' | 'value', number]` tuples.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this token, continue with
+ *      next sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current item, then continue with the next one
+ *   - `number`: Set the index of the next step. This is useful especially if
+ *     the index of the current token has changed.
+ *   - `function`: Define the next visitor for this item. After the original
+ *     visitor is called on item entry, next visitors are called after handling
+ *     a non-empty `key` and when exiting the item.
+ */
+function visit(cst, visitor) {
+    if ('type' in cst && cst.type === 'document')
+        cst = { start: cst.start, value: cst.value };
+    _visit(Object.freeze([]), cst, visitor);
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current item */
+visit.SKIP = SKIP;
+/** Remove the current item */
+visit.REMOVE = REMOVE;
+/** Find the item at `path` from `cst` as the root */
+visit.itemAtPath = (cst, path) => {
+    let item = cst;
+    for (const [field, index] of path) {
+        const tok = item?.[field];
+        if (tok && 'items' in tok) {
+            item = tok.items[index];
+        }
+        else
+            return undefined;
+    }
+    return item;
+};
+/**
+ * Get the immediate parent collection of the item at `path` from `cst` as the root.
+ *
+ * Throws an error if the collection is not found, which should never happen if the item itself exists.
+ */
+visit.parentCollection = (cst, path) => {
+    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+    const field = path[path.length - 1][0];
+    const coll = parent?.[field];
+    if (coll && 'items' in coll)
+        return coll;
+    throw new Error('Parent collection not found');
+};
+function _visit(path, item, visitor) {
+    let ctrl = visitor(item, path);
+    if (typeof ctrl === 'symbol')
+        return ctrl;
+    for (const field of ['key', 'value']) {
+        const token = item[field];
+        if (token && 'items' in token) {
+            for (let i = 0; i < token.items.length; ++i) {
+                const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    token.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+            if (typeof ctrl === 'function' && field === 'key')
+                ctrl = ctrl(item, path);
+        }
+    }
+    return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
+}
+
+/** The byte order mark */
+const BOM = '\u{FEFF}';
+/** Start of doc-mode */
+const DOCUMENT = '\x02'; // C0: Start of Text
+/** Unexpected end of flow-mode */
+const FLOW_END = '\x18'; // C0: Cancel
+/** Next token is a scalar value */
+const SCALAR = '\x1f'; // C0: Unit Separator
+/** @returns `true` if `token` is a flow or block collection */
+const isCollection = (token) => !!token && 'items' in token;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+const isScalar = (token) => !!token &&
+    (token.type === 'scalar' ||
+        token.type === 'single-quoted-scalar' ||
+        token.type === 'double-quoted-scalar' ||
+        token.type === 'block-scalar');
+/* istanbul ignore next */
+/** Get a printable representation of a lexer token */
+function prettyToken(token) {
+    switch (token) {
+        case BOM:
+            return '<BOM>';
+        case DOCUMENT:
+            return '<DOC>';
+        case FLOW_END:
+            return '<FLOW_END>';
+        case SCALAR:
+            return '<SCALAR>';
+        default:
+            return JSON.stringify(token);
+    }
+}
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+function tokenType(source) {
+    switch (source) {
+        case BOM:
+            return 'byte-order-mark';
+        case DOCUMENT:
+            return 'doc-mode';
+        case FLOW_END:
+            return 'flow-error-end';
+        case SCALAR:
+            return 'scalar';
+        case '---':
+            return 'doc-start';
+        case '...':
+            return 'doc-end';
+        case '':
+        case '\n':
+        case '\r\n':
+            return 'newline';
+        case '-':
+            return 'seq-item-ind';
+        case '?':
+            return 'explicit-key-ind';
+        case ':':
+            return 'map-value-ind';
+        case '{':
+            return 'flow-map-start';
+        case '}':
+            return 'flow-map-end';
+        case '[':
+            return 'flow-seq-start';
+        case ']':
+            return 'flow-seq-end';
+        case ',':
+            return 'comma';
+    }
+    switch (source[0]) {
+        case ' ':
+        case '\t':
+            return 'space';
+        case '#':
+            return 'comment';
+        case '%':
+            return 'directive-line';
+        case '*':
+            return 'alias';
+        case '&':
+            return 'anchor';
+        case '!':
+            return 'tag';
+        case "'":
+            return 'single-quoted-scalar';
+        case '"':
+            return 'double-quoted-scalar';
+        case '|':
+        case '>':
+            return 'block-scalar-header';
+    }
+    return null;
+}
+
+var cst = {
+	__proto__: null,
+	BOM: BOM,
+	DOCUMENT: DOCUMENT,
+	FLOW_END: FLOW_END,
+	SCALAR: SCALAR,
+	createScalarToken: createScalarToken,
+	isCollection: isCollection,
+	isScalar: isScalar,
+	prettyToken: prettyToken,
+	resolveAsScalar: resolveAsScalar,
+	setScalarValue: setScalarValue,
+	stringify: stringify$1,
+	tokenType: tokenType,
+	visit: visit
+};
+
+/*
+START -> stream
+
+stream
+  directive -> line-end -> stream
+  indent + line-end -> stream
+  [else] -> line-start
+
+line-end
+  comment -> line-end
+  newline -> .
+  input-end -> END
+
+line-start
+  doc-start -> doc
+  doc-end -> stream
+  [else] -> indent -> block-start
+
+block-start
+  seq-item-start -> block-start
+  explicit-key-start -> block-start
+  map-value-start -> block-start
+  [else] -> doc
+
+doc
+  line-end -> line-start
+  spaces -> doc
+  anchor -> doc
+  tag -> doc
+  flow-start -> flow -> doc
+  flow-end -> error -> doc
+  seq-item-start -> error -> doc
+  explicit-key-start -> error -> doc
+  map-value-start -> doc
+  alias -> doc
+  quote-start -> quoted-scalar -> doc
+  block-scalar-header -> line-end -> block-scalar(min) -> line-start
+  [else] -> plain-scalar(false, min) -> doc
+
+flow
+  line-end -> flow
+  spaces -> flow
+  anchor -> flow
+  tag -> flow
+  flow-start -> flow -> flow
+  flow-end -> .
+  seq-item-start -> error -> flow
+  explicit-key-start -> flow
+  map-value-start -> flow
+  alias -> flow
+  quote-start -> quoted-scalar -> flow
+  comma -> flow
+  [else] -> plain-scalar(true, 0) -> flow
+
+quoted-scalar
+  quote-end -> .
+  [else] -> quoted-scalar
+
+block-scalar(min)
+  newline + peek(indent < min) -> .
+  [else] -> block-scalar(min)
+
+plain-scalar(is-flow, min)
+  scalar-end(is-flow) -> .
+  peek(newline + (indent < min)) -> .
+  [else] -> plain-scalar(min)
+*/
+function isEmpty(ch) {
+    switch (ch) {
+        case undefined:
+        case ' ':
+        case '\n':
+        case '\r':
+        case '\t':
+            return true;
+        default:
+            return false;
+    }
+}
+const hexDigits = new Set('0123456789ABCDEFabcdef');
+const tagChars = new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
+const flowIndicatorChars = new Set(',[]{}');
+const invalidAnchorChars = new Set(' ,[]{}\n\r\t');
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
+/**
+ * Splits an input string into lexical tokens, i.e. smaller strings that are
+ * easily identifiable by `tokens.tokenType()`.
+ *
+ * Lexing starts always in a "stream" context. Incomplete input may be buffered
+ * until a complete token can be emitted.
+ *
+ * In addition to slices of the original input, the following control characters
+ * may also be emitted:
+ *
+ * - `\x02` (Start of Text): A document starts with the next token
+ * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+ * - `\x1f` (Unit Separator): Next token is a scalar value
+ * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+ */
+class Lexer {
+    constructor() {
+        /**
+         * Flag indicating whether the end of the current buffer marks the end of
+         * all input
+         */
+        this.atEnd = false;
+        /**
+         * Explicit indent set in block scalar header, as an offset from the current
+         * minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
+         * explicitly set.
+         */
+        this.blockScalarIndent = -1;
+        /**
+         * Block scalars that include a + (keep) chomping indicator in their header
+         * include trailing empty lines, which are otherwise excluded from the
+         * scalar's contents.
+         */
+        this.blockScalarKeep = false;
+        /** Current input */
+        this.buffer = '';
+        /**
+         * Flag noting whether the map value indicator : can immediately follow this
+         * node within a flow context.
+         */
+        this.flowKey = false;
+        /** Count of surrounding flow collection levels. */
+        this.flowLevel = 0;
+        /**
+         * Minimum level of indentation required for next lines to be parsed as a
+         * part of the current scalar value.
+         */
+        this.indentNext = 0;
+        /** Indentation level of the current line. */
+        this.indentValue = 0;
+        /** Position of the next \n character. */
+        this.lineEndPos = null;
+        /** Stores the state of the lexer if reaching the end of incpomplete input */
+        this.next = null;
+        /** A pointer to `buffer`; the current position of the lexer. */
+        this.pos = 0;
+    }
+    /**
+     * Generate YAML tokens from the `source` string. If `incomplete`,
+     * a part of the last line may be left as a buffer for the next call.
+     *
+     * @returns A generator of lexical tokens
+     */
+    *lex(source, incomplete = false) {
+        if (source) {
+            if (typeof source !== 'string')
+                throw TypeError('source is not a string');
+            this.buffer = this.buffer ? this.buffer + source : source;
+            this.lineEndPos = null;
+        }
+        this.atEnd = !incomplete;
+        let next = this.next ?? 'stream';
+        while (next && (incomplete || this.hasChars(1)))
+            next = yield* this.parseNext(next);
+    }
+    atLineEnd() {
+        let i = this.pos;
+        let ch = this.buffer[i];
+        while (ch === ' ' || ch === '\t')
+            ch = this.buffer[++i];
+        if (!ch || ch === '#' || ch === '\n')
+            return true;
+        if (ch === '\r')
+            return this.buffer[i + 1] === '\n';
+        return false;
+    }
+    charAt(n) {
+        return this.buffer[this.pos + n];
+    }
+    continueScalar(offset) {
+        let ch = this.buffer[offset];
+        if (this.indentNext > 0) {
+            let indent = 0;
+            while (ch === ' ')
+                ch = this.buffer[++indent + offset];
+            if (ch === '\r') {
+                const next = this.buffer[indent + offset + 1];
+                if (next === '\n' || (!next && !this.atEnd))
+                    return offset + indent + 1;
+            }
+            return ch === '\n' || indent >= this.indentNext || (!ch && !this.atEnd)
+                ? offset + indent
+                : -1;
+        }
+        if (ch === '-' || ch === '.') {
+            const dt = this.buffer.substr(offset, 3);
+            if ((dt === '---' || dt === '...') && isEmpty(this.buffer[offset + 3]))
+                return -1;
+        }
+        return offset;
+    }
+    getLine() {
+        let end = this.lineEndPos;
+        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
+            end = this.buffer.indexOf('\n', this.pos);
+            this.lineEndPos = end;
+        }
+        if (end === -1)
+            return this.atEnd ? this.buffer.substring(this.pos) : null;
+        if (this.buffer[end - 1] === '\r')
+            end -= 1;
+        return this.buffer.substring(this.pos, end);
+    }
+    hasChars(n) {
+        return this.pos + n <= this.buffer.length;
+    }
+    setNext(state) {
+        this.buffer = this.buffer.substring(this.pos);
+        this.pos = 0;
+        this.lineEndPos = null;
+        this.next = state;
+        return null;
+    }
+    peek(n) {
+        return this.buffer.substr(this.pos, n);
+    }
+    *parseNext(next) {
+        switch (next) {
+            case 'stream':
+                return yield* this.parseStream();
+            case 'line-start':
+                return yield* this.parseLineStart();
+            case 'block-start':
+                return yield* this.parseBlockStart();
+            case 'doc':
+                return yield* this.parseDocument();
+            case 'flow':
+                return yield* this.parseFlowCollection();
+            case 'quoted-scalar':
+                return yield* this.parseQuotedScalar();
+            case 'block-scalar':
+                return yield* this.parseBlockScalar();
+            case 'plain-scalar':
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseStream() {
+        let line = this.getLine();
+        if (line === null)
+            return this.setNext('stream');
+        if (line[0] === BOM) {
+            yield* this.pushCount(1);
+            line = line.substring(1);
+        }
+        if (line[0] === '%') {
+            let dirEnd = line.length;
+            let cs = line.indexOf('#');
+            while (cs !== -1) {
+                const ch = line[cs - 1];
+                if (ch === ' ' || ch === '\t') {
+                    dirEnd = cs - 1;
+                    break;
+                }
+                else {
+                    cs = line.indexOf('#', cs + 1);
+                }
+            }
+            while (true) {
+                const ch = line[dirEnd - 1];
+                if (ch === ' ' || ch === '\t')
+                    dirEnd -= 1;
+                else
+                    break;
+            }
+            const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));
+            yield* this.pushCount(line.length - n); // possible comment
+            this.pushNewline();
+            return 'stream';
+        }
+        if (this.atLineEnd()) {
+            const sp = yield* this.pushSpaces(true);
+            yield* this.pushCount(line.length - sp);
+            yield* this.pushNewline();
+            return 'stream';
+        }
+        yield DOCUMENT;
+        return yield* this.parseLineStart();
+    }
+    *parseLineStart() {
+        const ch = this.charAt(0);
+        if (!ch && !this.atEnd)
+            return this.setNext('line-start');
+        if (ch === '-' || ch === '.') {
+            if (!this.atEnd && !this.hasChars(4))
+                return this.setNext('line-start');
+            const s = this.peek(3);
+            if ((s === '---' || s === '...') && isEmpty(this.charAt(3))) {
+                yield* this.pushCount(3);
+                this.indentValue = 0;
+                this.indentNext = 0;
+                return s === '---' ? 'doc' : 'stream';
+            }
+        }
+        this.indentValue = yield* this.pushSpaces(false);
+        if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1)))
+            this.indentNext = this.indentValue;
+        return yield* this.parseBlockStart();
+    }
+    *parseBlockStart() {
+        const [ch0, ch1] = this.peek(2);
+        if (!ch1 && !this.atEnd)
+            return this.setNext('block-start');
+        if ((ch0 === '-' || ch0 === '?' || ch0 === ':') && isEmpty(ch1)) {
+            const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+            this.indentNext = this.indentValue + 1;
+            this.indentValue += n;
+            return yield* this.parseBlockStart();
+        }
+        return 'doc';
+    }
+    *parseDocument() {
+        yield* this.pushSpaces(true);
+        const line = this.getLine();
+        if (line === null)
+            return this.setNext('doc');
+        let n = yield* this.pushIndicators();
+        switch (line[n]) {
+            case '#':
+                yield* this.pushCount(line.length - n);
+            // fallthrough
+            case undefined:
+                yield* this.pushNewline();
+                return yield* this.parseLineStart();
+            case '{':
+            case '[':
+                yield* this.pushCount(1);
+                this.flowKey = false;
+                this.flowLevel = 1;
+                return 'flow';
+            case '}':
+            case ']':
+                // this is an error
+                yield* this.pushCount(1);
+                return 'doc';
+            case '*':
+                yield* this.pushUntil(isNotAnchorChar);
+                return 'doc';
+            case '"':
+            case "'":
+                return yield* this.parseQuotedScalar();
+            case '|':
+            case '>':
+                n += yield* this.parseBlockScalarHeader();
+                n += yield* this.pushSpaces(true);
+                yield* this.pushCount(line.length - n);
+                yield* this.pushNewline();
+                return yield* this.parseBlockScalar();
+            default:
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseFlowCollection() {
+        let nl, sp;
+        let indent = -1;
+        do {
+            nl = yield* this.pushNewline();
+            if (nl > 0) {
+                sp = yield* this.pushSpaces(false);
+                this.indentValue = indent = sp;
+            }
+            else {
+                sp = 0;
+            }
+            sp += yield* this.pushSpaces(true);
+        } while (nl + sp > 0);
+        const line = this.getLine();
+        if (line === null)
+            return this.setNext('flow');
+        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
+            (indent === 0 &&
+                (line.startsWith('---') || line.startsWith('...')) &&
+                isEmpty(line[3]))) {
+            // Allowing for the terminal ] or } at the same (rather than greater)
+            // indent level as the initial [ or { is technically invalid, but
+            // failing here would be surprising to users.
+            const atFlowEndMarker = indent === this.indentNext - 1 &&
+                this.flowLevel === 1 &&
+                (line[0] === ']' || line[0] === '}');
+            if (!atFlowEndMarker) {
+                // this is an error
+                this.flowLevel = 0;
+                yield FLOW_END;
+                return yield* this.parseLineStart();
+            }
+        }
+        let n = 0;
+        while (line[n] === ',') {
+            n += yield* this.pushCount(1);
+            n += yield* this.pushSpaces(true);
+            this.flowKey = false;
+        }
+        n += yield* this.pushIndicators();
+        switch (line[n]) {
+            case undefined:
+                return 'flow';
+            case '#':
+                yield* this.pushCount(line.length - n);
+                return 'flow';
+            case '{':
+            case '[':
+                yield* this.pushCount(1);
+                this.flowKey = false;
+                this.flowLevel += 1;
+                return 'flow';
+            case '}':
+            case ']':
+                yield* this.pushCount(1);
+                this.flowKey = true;
+                this.flowLevel -= 1;
+                return this.flowLevel ? 'flow' : 'doc';
+            case '*':
+                yield* this.pushUntil(isNotAnchorChar);
+                return 'flow';
+            case '"':
+            case "'":
+                this.flowKey = true;
+                return yield* this.parseQuotedScalar();
+            case ':': {
+                const next = this.charAt(1);
+                if (this.flowKey || isEmpty(next) || next === ',') {
+                    this.flowKey = false;
+                    yield* this.pushCount(1);
+                    yield* this.pushSpaces(true);
+                    return 'flow';
+                }
+            }
+            // fallthrough
+            default:
+                this.flowKey = false;
+                return yield* this.parsePlainScalar();
+        }
+    }
+    *parseQuotedScalar() {
+        const quote = this.charAt(0);
+        let end = this.buffer.indexOf(quote, this.pos + 1);
+        if (quote === "'") {
+            while (end !== -1 && this.buffer[end + 1] === "'")
+                end = this.buffer.indexOf("'", end + 2);
+        }
+        else {
+            // double-quote
+            while (end !== -1) {
+                let n = 0;
+                while (this.buffer[end - 1 - n] === '\\')
+                    n += 1;
+                if (n % 2 === 0)
+                    break;
+                end = this.buffer.indexOf('"', end + 1);
+            }
+        }
+        // Only looking for newlines within the quotes
+        const qb = this.buffer.substring(0, end);
+        let nl = qb.indexOf('\n', this.pos);
+        if (nl !== -1) {
+            while (nl !== -1) {
+                const cs = this.continueScalar(nl + 1);
+                if (cs === -1)
+                    break;
+                nl = qb.indexOf('\n', cs);
+            }
+            if (nl !== -1) {
+                // this is an error caused by an unexpected unindent
+                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
+            }
+        }
+        if (end === -1) {
+            if (!this.atEnd)
+                return this.setNext('quoted-scalar');
+            end = this.buffer.length;
+        }
+        yield* this.pushToIndex(end + 1, false);
+        return this.flowLevel ? 'flow' : 'doc';
+    }
+    *parseBlockScalarHeader() {
+        this.blockScalarIndent = -1;
+        this.blockScalarKeep = false;
+        let i = this.pos;
+        while (true) {
+            const ch = this.buffer[++i];
+            if (ch === '+')
+                this.blockScalarKeep = true;
+            else if (ch > '0' && ch <= '9')
+                this.blockScalarIndent = Number(ch) - 1;
+            else if (ch !== '-')
+                break;
+        }
+        return yield* this.pushUntil(ch => isEmpty(ch) || ch === '#');
+    }
+    *parseBlockScalar() {
+        let nl = this.pos - 1; // may be -1 if this.pos === 0
+        let indent = 0;
+        let ch;
+        loop: for (let i = this.pos; (ch = this.buffer[i]); ++i) {
+            switch (ch) {
+                case ' ':
+                    indent += 1;
+                    break;
+                case '\n':
+                    nl = i;
+                    indent = 0;
+                    break;
+                case '\r': {
+                    const next = this.buffer[i + 1];
+                    if (!next && !this.atEnd)
+                        return this.setNext('block-scalar');
+                    if (next === '\n')
+                        break;
+                } // fallthrough
+                default:
+                    break loop;
+            }
+        }
+        if (!ch && !this.atEnd)
+            return this.setNext('block-scalar');
+        if (indent >= this.indentNext) {
+            if (this.blockScalarIndent === -1)
+                this.indentNext = indent;
+            else {
+                this.indentNext =
+                    this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);
+            }
+            do {
+                const cs = this.continueScalar(nl + 1);
+                if (cs === -1)
+                    break;
+                nl = this.buffer.indexOf('\n', cs);
+            } while (nl !== -1);
+            if (nl === -1) {
+                if (!this.atEnd)
+                    return this.setNext('block-scalar');
+                nl = this.buffer.length;
+            }
+        }
+        // Trailing insufficiently indented tabs are invalid.
+        // To catch that during parsing, we include them in the block scalar value.
+        let i = nl + 1;
+        ch = this.buffer[i];
+        while (ch === ' ')
+            ch = this.buffer[++i];
+        if (ch === '\t') {
+            while (ch === '\t' || ch === ' ' || ch === '\r' || ch === '\n')
+                ch = this.buffer[++i];
+            nl = i - 1;
+        }
+        else if (!this.blockScalarKeep) {
+            do {
+                let i = nl - 1;
+                let ch = this.buffer[i];
+                if (ch === '\r')
+                    ch = this.buffer[--i];
+                const lastChar = i; // Drop the line if last char not more indented
+                while (ch === ' ')
+                    ch = this.buffer[--i];
+                if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar)
+                    nl = i;
+                else
+                    break;
+            } while (true);
+        }
+        yield SCALAR;
+        yield* this.pushToIndex(nl + 1, true);
+        return yield* this.parseLineStart();
+    }
+    *parsePlainScalar() {
+        const inFlow = this.flowLevel > 0;
+        let end = this.pos - 1;
+        let i = this.pos - 1;
+        let ch;
+        while ((ch = this.buffer[++i])) {
+            if (ch === ':') {
+                const next = this.buffer[i + 1];
+                if (isEmpty(next) || (inFlow && flowIndicatorChars.has(next)))
+                    break;
+                end = i;
+            }
+            else if (isEmpty(ch)) {
+                let next = this.buffer[i + 1];
+                if (ch === '\r') {
+                    if (next === '\n') {
+                        i += 1;
+                        ch = '\n';
+                        next = this.buffer[i + 1];
+                    }
+                    else
+                        end = i;
+                }
+                if (next === '#' || (inFlow && flowIndicatorChars.has(next)))
+                    break;
+                if (ch === '\n') {
+                    const cs = this.continueScalar(i + 1);
+                    if (cs === -1)
+                        break;
+                    i = Math.max(i, cs - 2); // to advance, but still account for ' #'
+                }
+            }
+            else {
+                if (inFlow && flowIndicatorChars.has(ch))
+                    break;
+                end = i;
+            }
+        }
+        if (!ch && !this.atEnd)
+            return this.setNext('plain-scalar');
+        yield SCALAR;
+        yield* this.pushToIndex(end + 1, true);
+        return inFlow ? 'flow' : 'doc';
+    }
+    *pushCount(n) {
+        if (n > 0) {
+            yield this.buffer.substr(this.pos, n);
+            this.pos += n;
+            return n;
+        }
+        return 0;
+    }
+    *pushToIndex(i, allowEmpty) {
+        const s = this.buffer.slice(this.pos, i);
+        if (s) {
+            yield s;
+            this.pos += s.length;
+            return s.length;
+        }
+        else if (allowEmpty)
+            yield '';
+        return 0;
+    }
+    *pushIndicators() {
+        switch (this.charAt(0)) {
+            case '!':
+                return ((yield* this.pushTag()) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
+            case '&':
+                return ((yield* this.pushUntil(isNotAnchorChar)) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
+            case '-': // this is an error
+            case '?': // this is an error outside flow collections
+            case ':': {
+                const inFlow = this.flowLevel > 0;
+                const ch1 = this.charAt(1);
+                if (isEmpty(ch1) || (inFlow && flowIndicatorChars.has(ch1))) {
+                    if (!inFlow)
+                        this.indentNext = this.indentValue + 1;
+                    else if (this.flowKey)
+                        this.flowKey = false;
+                    return ((yield* this.pushCount(1)) +
+                        (yield* this.pushSpaces(true)) +
+                        (yield* this.pushIndicators()));
+                }
+            }
+        }
+        return 0;
+    }
+    *pushTag() {
+        if (this.charAt(1) === '<') {
+            let i = this.pos + 2;
+            let ch = this.buffer[i];
+            while (!isEmpty(ch) && ch !== '>')
+                ch = this.buffer[++i];
+            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+        }
+        else {
+            let i = this.pos + 1;
+            let ch = this.buffer[i];
+            while (ch) {
+                if (tagChars.has(ch))
+                    ch = this.buffer[++i];
+                else if (ch === '%' &&
+                    hexDigits.has(this.buffer[i + 1]) &&
+                    hexDigits.has(this.buffer[i + 2])) {
+                    ch = this.buffer[(i += 3)];
+                }
+                else
+                    break;
+            }
+            return yield* this.pushToIndex(i, false);
+        }
+    }
+    *pushNewline() {
+        const ch = this.buffer[this.pos];
+        if (ch === '\n')
+            return yield* this.pushCount(1);
+        else if (ch === '\r' && this.charAt(1) === '\n')
+            return yield* this.pushCount(2);
+        else
+            return 0;
+    }
+    *pushSpaces(allowTabs) {
+        let i = this.pos - 1;
+        let ch;
+        do {
+            ch = this.buffer[++i];
+        } while (ch === ' ' || (allowTabs && ch === '\t'));
+        const n = i - this.pos;
+        if (n > 0) {
+            yield this.buffer.substr(this.pos, n);
+            this.pos = i;
+        }
+        return n;
+    }
+    *pushUntil(test) {
+        let i = this.pos;
+        let ch = this.buffer[i];
+        while (!test(ch))
+            ch = this.buffer[++i];
+        return yield* this.pushToIndex(i, false);
+    }
+}
+
+/**
+ * Tracks newlines during parsing in order to provide an efficient API for
+ * determining the one-indexed `{ line, col }` position for any offset
+ * within the input.
+ */
+class LineCounter {
+    constructor() {
+        this.lineStarts = [];
+        /**
+         * Should be called in ascending order. Otherwise, call
+         * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+         */
+        this.addNewLine = (offset) => this.lineStarts.push(offset);
+        /**
+         * Performs a binary search and returns the 1-indexed { line, col }
+         * position of `offset`. If `line === 0`, `addNewLine` has never been
+         * called or `offset` is before the first known newline.
+         */
+        this.linePos = (offset) => {
+            let low = 0;
+            let high = this.lineStarts.length;
+            while (low < high) {
+                const mid = (low + high) >> 1; // Math.floor((low + high) / 2)
+                if (this.lineStarts[mid] < offset)
+                    low = mid + 1;
+                else
+                    high = mid;
+            }
+            if (this.lineStarts[low] === offset)
+                return { line: low + 1, col: 1 };
+            if (low === 0)
+                return { line: 0, col: offset };
+            const start = this.lineStarts[low - 1];
+            return { line: low, col: offset - start + 1 };
+        };
+    }
+}
+
+function includesToken(list, type) {
+    for (let i = 0; i < list.length; ++i)
+        if (list[i].type === type)
+            return true;
+    return false;
+}
+function findNonEmptyIndex(list) {
+    for (let i = 0; i < list.length; ++i) {
+        switch (list[i].type) {
+            case 'space':
+            case 'comment':
+            case 'newline':
+                break;
+            default:
+                return i;
+        }
+    }
+    return -1;
+}
+function isFlowToken(token) {
+    switch (token?.type) {
+        case 'alias':
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'flow-collection':
+            return true;
+        default:
+            return false;
+    }
+}
+function getPrevProps(parent) {
+    switch (parent.type) {
+        case 'document':
+            return parent.start;
+        case 'block-map': {
+            const it = parent.items[parent.items.length - 1];
+            return it.sep ?? it.start;
+        }
+        case 'block-seq':
+            return parent.items[parent.items.length - 1].start;
+        /* istanbul ignore next should not happen */
+        default:
+            return [];
+    }
+}
+/** Note: May modify input array */
+function getFirstKeyStartProps(prev) {
+    if (prev.length === 0)
+        return [];
+    let i = prev.length;
+    loop: while (--i >= 0) {
+        switch (prev[i].type) {
+            case 'doc-start':
+            case 'explicit-key-ind':
+            case 'map-value-ind':
+            case 'seq-item-ind':
+            case 'newline':
+                break loop;
+        }
+    }
+    return prev.splice(i, prev.length);
+}
+function fixFlowSeqItems(fc) {
+    if (fc.start.type === 'flow-seq-start') {
+        for (const it of fc.items) {
+            if (it.sep &&
+                !it.value &&
+                !includesToken(it.start, 'explicit-key-ind') &&
+                !includesToken(it.sep, 'map-value-ind')) {
+                if (it.key)
+                    it.value = it.key;
+                delete it.key;
+                if (isFlowToken(it.value)) {
+                    if (it.value.end)
+                        Array.prototype.push.apply(it.value.end, it.sep);
+                    else
+                        it.value.end = it.sep;
+                }
+                else
+                    Array.prototype.push.apply(it.start, it.sep);
+                delete it.sep;
+            }
+        }
+    }
+}
+/**
+ * A YAML concrete syntax tree (CST) parser
+ *
+ * ```ts
+ * const src: string = ...
+ * for (const token of new Parser().parse(src)) {
+ *   // token: Token
+ * }
+ * ```
+ *
+ * To use the parser with a user-provided lexer:
+ *
+ * ```ts
+ * function* parse(source: string, lexer: Lexer) {
+ *   const parser = new Parser()
+ *   for (const lexeme of lexer.lex(source))
+ *     yield* parser.next(lexeme)
+ *   yield* parser.end()
+ * }
+ *
+ * const src: string = ...
+ * const lexer = new Lexer()
+ * for (const token of parse(src, lexer)) {
+ *   // token: Token
+ * }
+ * ```
+ */
+class Parser {
+    /**
+     * @param onNewLine - If defined, called separately with the start position of
+     *   each new line (in `parse()`, including the start of input).
+     */
+    constructor(onNewLine) {
+        /** If true, space and sequence indicators count as indentation */
+        this.atNewLine = true;
+        /** If true, next token is a scalar value */
+        this.atScalar = false;
+        /** Current indentation level */
+        this.indent = 0;
+        /** Current offset since the start of parsing */
+        this.offset = 0;
+        /** On the same line with a block map key */
+        this.onKeyLine = false;
+        /** Top indicates the node that's currently being built */
+        this.stack = [];
+        /** The source of the current token, set in parse() */
+        this.source = '';
+        /** The type of the current token, set in parse() */
+        this.type = '';
+        // Must be defined after `next()`
+        this.lexer = new Lexer();
+        this.onNewLine = onNewLine;
+    }
+    /**
+     * Parse `source` as a YAML stream.
+     * If `incomplete`, a part of the last line may be left as a buffer for the next call.
+     *
+     * Errors are not thrown, but yielded as `{ type: 'error', message }` tokens.
+     *
+     * @returns A generator of tokens representing each directive, document, and other structure.
+     */
+    *parse(source, incomplete = false) {
+        if (this.onNewLine && this.offset === 0)
+            this.onNewLine(0);
+        for (const lexeme of this.lexer.lex(source, incomplete))
+            yield* this.next(lexeme);
+        if (!incomplete)
+            yield* this.end();
+    }
+    /**
+     * Advance the parser by the `source` of one lexical token.
+     */
+    *next(source) {
+        this.source = source;
+        if (this.atScalar) {
+            this.atScalar = false;
+            yield* this.step();
+            this.offset += source.length;
+            return;
+        }
+        const type = tokenType(source);
+        if (!type) {
+            const message = `Not a YAML token: ${source}`;
+            yield* this.pop({ type: 'error', offset: this.offset, message, source });
+            this.offset += source.length;
+        }
+        else if (type === 'scalar') {
+            this.atNewLine = false;
+            this.atScalar = true;
+            this.type = 'scalar';
+        }
+        else {
+            this.type = type;
+            yield* this.step();
+            switch (type) {
+                case 'newline':
+                    this.atNewLine = true;
+                    this.indent = 0;
+                    if (this.onNewLine)
+                        this.onNewLine(this.offset + source.length);
+                    break;
+                case 'space':
+                    if (this.atNewLine && source[0] === ' ')
+                        this.indent += source.length;
+                    break;
+                case 'explicit-key-ind':
+                case 'map-value-ind':
+                case 'seq-item-ind':
+                    if (this.atNewLine)
+                        this.indent += source.length;
+                    break;
+                case 'doc-mode':
+                case 'flow-error-end':
+                    return;
+                default:
+                    this.atNewLine = false;
+            }
+            this.offset += source.length;
+        }
+    }
+    /** Call at end of input to push out any remaining constructions */
+    *end() {
+        while (this.stack.length > 0)
+            yield* this.pop();
+    }
+    get sourceToken() {
+        const st = {
+            type: this.type,
+            offset: this.offset,
+            indent: this.indent,
+            source: this.source
+        };
+        return st;
+    }
+    *step() {
+        const top = this.peek(1);
+        if (this.type === 'doc-end' && (!top || top.type !== 'doc-end')) {
+            while (this.stack.length > 0)
+                yield* this.pop();
+            this.stack.push({
+                type: 'doc-end',
+                offset: this.offset,
+                source: this.source
+            });
+            return;
+        }
+        if (!top)
+            return yield* this.stream();
+        switch (top.type) {
+            case 'document':
+                return yield* this.document(top);
+            case 'alias':
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return yield* this.scalar(top);
+            case 'block-scalar':
+                return yield* this.blockScalar(top);
+            case 'block-map':
+                return yield* this.blockMap(top);
+            case 'block-seq':
+                return yield* this.blockSequence(top);
+            case 'flow-collection':
+                return yield* this.flowCollection(top);
+            case 'doc-end':
+                return yield* this.documentEnd(top);
+        }
+        /* istanbul ignore next should not happen */
+        yield* this.pop();
+    }
+    peek(n) {
+        return this.stack[this.stack.length - n];
+    }
+    *pop(error) {
+        const token = error ?? this.stack.pop();
+        /* istanbul ignore if should not happen */
+        if (!token) {
+            const message = 'Tried to pop an empty stack';
+            yield { type: 'error', offset: this.offset, source: '', message };
+        }
+        else if (this.stack.length === 0) {
+            yield token;
+        }
+        else {
+            const top = this.peek(1);
+            if (token.type === 'block-scalar') {
+                // Block scalars use their parent rather than header indent
+                token.indent = 'indent' in top ? top.indent : 0;
+            }
+            else if (token.type === 'flow-collection' && top.type === 'document') {
+                // Ignore all indent for top-level flow collections
+                token.indent = 0;
+            }
+            if (token.type === 'flow-collection')
+                fixFlowSeqItems(token);
+            switch (top.type) {
+                case 'document':
+                    top.value = token;
+                    break;
+                case 'block-scalar':
+                    top.props.push(token); // error
+                    break;
+                case 'block-map': {
+                    const it = top.items[top.items.length - 1];
+                    if (it.value) {
+                        top.items.push({ start: [], key: token, sep: [] });
+                        this.onKeyLine = true;
+                        return;
+                    }
+                    else if (it.sep) {
+                        it.value = token;
+                    }
+                    else {
+                        Object.assign(it, { key: token, sep: [] });
+                        this.onKeyLine = !it.explicitKey;
+                        return;
+                    }
+                    break;
+                }
+                case 'block-seq': {
+                    const it = top.items[top.items.length - 1];
+                    if (it.value)
+                        top.items.push({ start: [], value: token });
+                    else
+                        it.value = token;
+                    break;
+                }
+                case 'flow-collection': {
+                    const it = top.items[top.items.length - 1];
+                    if (!it || it.value)
+                        top.items.push({ start: [], key: token, sep: [] });
+                    else if (it.sep)
+                        it.value = token;
+                    else
+                        Object.assign(it, { key: token, sep: [] });
+                    return;
+                }
+                /* istanbul ignore next should not happen */
+                default:
+                    yield* this.pop();
+                    yield* this.pop(token);
+            }
+            if ((top.type === 'document' ||
+                top.type === 'block-map' ||
+                top.type === 'block-seq') &&
+                (token.type === 'block-map' || token.type === 'block-seq')) {
+                const last = token.items[token.items.length - 1];
+                if (last &&
+                    !last.sep &&
+                    !last.value &&
+                    last.start.length > 0 &&
+                    findNonEmptyIndex(last.start) === -1 &&
+                    (token.indent === 0 ||
+                        last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) {
+                    if (top.type === 'document')
+                        top.end = last.start;
+                    else
+                        top.items.push({ start: last.start });
+                    token.items.splice(-1, 1);
+                }
+            }
+        }
+    }
+    *stream() {
+        switch (this.type) {
+            case 'directive-line':
+                yield { type: 'directive', offset: this.offset, source: this.source };
+                return;
+            case 'byte-order-mark':
+            case 'space':
+            case 'comment':
+            case 'newline':
+                yield this.sourceToken;
+                return;
+            case 'doc-mode':
+            case 'doc-start': {
+                const doc = {
+                    type: 'document',
+                    offset: this.offset,
+                    start: []
+                };
+                if (this.type === 'doc-start')
+                    doc.start.push(this.sourceToken);
+                this.stack.push(doc);
+                return;
+            }
+        }
+        yield {
+            type: 'error',
+            offset: this.offset,
+            message: `Unexpected ${this.type} token in YAML stream`,
+            source: this.source
+        };
+    }
+    *document(doc) {
+        if (doc.value)
+            return yield* this.lineEnd(doc);
+        switch (this.type) {
+            case 'doc-start': {
+                if (findNonEmptyIndex(doc.start) !== -1) {
+                    yield* this.pop();
+                    yield* this.step();
+                }
+                else
+                    doc.start.push(this.sourceToken);
+                return;
+            }
+            case 'anchor':
+            case 'tag':
+            case 'space':
+            case 'comment':
+            case 'newline':
+                doc.start.push(this.sourceToken);
+                return;
+        }
+        const bv = this.startBlockValue(doc);
+        if (bv)
+            this.stack.push(bv);
+        else {
+            yield {
+                type: 'error',
+                offset: this.offset,
+                message: `Unexpected ${this.type} token in YAML document`,
+                source: this.source
+            };
+        }
+    }
+    *scalar(scalar) {
+        if (this.type === 'map-value-ind') {
+            const prev = getPrevProps(this.peek(2));
+            const start = getFirstKeyStartProps(prev);
+            let sep;
+            if (scalar.end) {
+                sep = scalar.end;
+                sep.push(this.sourceToken);
+                delete scalar.end;
+            }
+            else
+                sep = [this.sourceToken];
+            const map = {
+                type: 'block-map',
+                offset: scalar.offset,
+                indent: scalar.indent,
+                items: [{ start, key: scalar, sep }]
+            };
+            this.onKeyLine = true;
+            this.stack[this.stack.length - 1] = map;
+        }
+        else
+            yield* this.lineEnd(scalar);
+    }
+    *blockScalar(scalar) {
+        switch (this.type) {
+            case 'space':
+            case 'comment':
+            case 'newline':
+                scalar.props.push(this.sourceToken);
+                return;
+            case 'scalar':
+                scalar.source = this.source;
+                // block-scalar source includes trailing newline
+                this.atNewLine = true;
+                this.indent = 0;
+                if (this.onNewLine) {
+                    let nl = this.source.indexOf('\n') + 1;
+                    while (nl !== 0) {
+                        this.onNewLine(this.offset + nl);
+                        nl = this.source.indexOf('\n', nl) + 1;
+                    }
+                }
+                yield* this.pop();
+                break;
+            /* istanbul ignore next should not happen */
+            default:
+                yield* this.pop();
+                yield* this.step();
+        }
+    }
+    *blockMap(map) {
+        const it = map.items[map.items.length - 1];
+        // it.sep is true-ish if pair already has key or : separator
+        switch (this.type) {
+            case 'newline':
+                this.onKeyLine = false;
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
+                    else
+                        map.items.push({ start: [this.sourceToken] });
+                }
+                else if (it.sep) {
+                    it.sep.push(this.sourceToken);
+                }
+                else {
+                    it.start.push(this.sourceToken);
+                }
+                return;
+            case 'space':
+            case 'comment':
+                if (it.value) {
+                    map.items.push({ start: [this.sourceToken] });
+                }
+                else if (it.sep) {
+                    it.sep.push(this.sourceToken);
+                }
+                else {
+                    if (this.atIndentedComment(it.start, map.indent)) {
+                        const prev = map.items[map.items.length - 2];
+                        const end = prev?.value?.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            map.items.pop();
+                            return;
+                        }
+                    }
+                    it.start.push(this.sourceToken);
+                }
+                return;
+        }
+        if (this.indent >= map.indent) {
+            const atMapIndent = !this.onKeyLine && this.indent === map.indent;
+            const atNextItem = atMapIndent &&
+                (it.sep || it.explicitKey) &&
+                this.type !== 'seq-item-ind';
+            // For empty nodes, assign newline-separated not indented empty tokens to following node
+            let start = [];
+            if (atNextItem && it.sep && !it.value) {
+                const nl = [];
+                for (let i = 0; i < it.sep.length; ++i) {
+                    const st = it.sep[i];
+                    switch (st.type) {
+                        case 'newline':
+                            nl.push(i);
+                            break;
+                        case 'space':
+                            break;
+                        case 'comment':
+                            if (st.indent > map.indent)
+                                nl.length = 0;
+                            break;
+                        default:
+                            nl.length = 0;
+                    }
+                }
+                if (nl.length >= 2)
+                    start = it.sep.splice(nl[1]);
+            }
+            switch (this.type) {
+                case 'anchor':
+                case 'tag':
+                    if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
+                        this.onKeyLine = true;
+                    }
+                    else if (it.sep) {
+                        it.sep.push(this.sourceToken);
+                    }
+                    else {
+                        it.start.push(this.sourceToken);
+                    }
+                    return;
+                case 'explicit-key-ind':
+                    if (!it.sep && !it.explicitKey) {
+                        it.start.push(this.sourceToken);
+                        it.explicitKey = true;
+                    }
+                    else if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start, explicitKey: true });
+                    }
+                    else {
+                        this.stack.push({
+                            type: 'block-map',
+                            offset: this.offset,
+                            indent: this.indent,
+                            items: [{ start: [this.sourceToken], explicitKey: true }]
+                        });
+                    }
+                    this.onKeyLine = true;
+                    return;
+                case 'map-value-ind':
+                    if (it.explicitKey) {
+                        if (!it.sep) {
+                            if (includesToken(it.start, 'newline')) {
+                                Object.assign(it, { key: null, sep: [this.sourceToken] });
+                            }
+                            else {
+                                const start = getFirstKeyStartProps(it.start);
+                                this.stack.push({
+                                    type: 'block-map',
+                                    offset: this.offset,
+                                    indent: this.indent,
+                                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                                });
+                            }
+                        }
+                        else if (it.value) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else if (isFlowToken(it.key) &&
+                            !includesToken(it.sep, 'newline')) {
+                            const start = getFirstKeyStartProps(it.start);
+                            const key = it.key;
+                            const sep = it.sep;
+                            sep.push(this.sourceToken);
+                            // @ts-expect-error type guard is wrong here
+                            delete it.key, delete it.sep;
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key, sep }]
+                            });
+                        }
+                        else if (start.length > 0) {
+                            // Not actually at next item
+                            it.sep = it.sep.concat(start, this.sourceToken);
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    else {
+                        if (!it.sep) {
+                            Object.assign(it, { key: null, sep: [this.sourceToken] });
+                        }
+                        else if (it.value || atNextItem) {
+                            map.items.push({ start, key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    this.onKeyLine = true;
+                    return;
+                case 'alias':
+                case 'scalar':
+                case 'single-quoted-scalar':
+                case 'double-quoted-scalar': {
+                    const fs = this.flowScalar(this.type);
+                    if (atNextItem || it.value) {
+                        map.items.push({ start, key: fs, sep: [] });
+                        this.onKeyLine = true;
+                    }
+                    else if (it.sep) {
+                        this.stack.push(fs);
+                    }
+                    else {
+                        Object.assign(it, { key: fs, sep: [] });
+                        this.onKeyLine = true;
+                    }
+                    return;
+                }
+                default: {
+                    const bv = this.startBlockValue(map);
+                    if (bv) {
+                        if (atMapIndent && bv.type !== 'block-seq') {
+                            map.items.push({ start });
+                        }
+                        this.stack.push(bv);
+                        return;
+                    }
+                }
+            }
+        }
+        yield* this.pop();
+        yield* this.step();
+    }
+    *blockSequence(seq) {
+        const it = seq.items[seq.items.length - 1];
+        switch (this.type) {
+            case 'newline':
+                if (it.value) {
+                    const end = 'end' in it.value ? it.value.end : undefined;
+                    const last = Array.isArray(end) ? end[end.length - 1] : undefined;
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
+                    else
+                        seq.items.push({ start: [this.sourceToken] });
+                }
+                else
+                    it.start.push(this.sourceToken);
+                return;
+            case 'space':
+            case 'comment':
+                if (it.value)
+                    seq.items.push({ start: [this.sourceToken] });
+                else {
+                    if (this.atIndentedComment(it.start, seq.indent)) {
+                        const prev = seq.items[seq.items.length - 2];
+                        const end = prev?.value?.end;
+                        if (Array.isArray(end)) {
+                            Array.prototype.push.apply(end, it.start);
+                            end.push(this.sourceToken);
+                            seq.items.pop();
+                            return;
+                        }
+                    }
+                    it.start.push(this.sourceToken);
+                }
+                return;
+            case 'anchor':
+            case 'tag':
+                if (it.value || this.indent <= seq.indent)
+                    break;
+                it.start.push(this.sourceToken);
+                return;
+            case 'seq-item-ind':
+                if (this.indent !== seq.indent)
+                    break;
+                if (it.value || includesToken(it.start, 'seq-item-ind'))
+                    seq.items.push({ start: [this.sourceToken] });
+                else
+                    it.start.push(this.sourceToken);
+                return;
+        }
+        if (this.indent > seq.indent) {
+            const bv = this.startBlockValue(seq);
+            if (bv) {
+                this.stack.push(bv);
+                return;
+            }
+        }
+        yield* this.pop();
+        yield* this.step();
+    }
+    *flowCollection(fc) {
+        const it = fc.items[fc.items.length - 1];
+        if (this.type === 'flow-error-end') {
+            let top;
+            do {
+                yield* this.pop();
+                top = this.peek(1);
+            } while (top && top.type === 'flow-collection');
+        }
+        else if (fc.end.length === 0) {
+            switch (this.type) {
+                case 'comma':
+                case 'explicit-key-ind':
+                    if (!it || it.sep)
+                        fc.items.push({ start: [this.sourceToken] });
+                    else
+                        it.start.push(this.sourceToken);
+                    return;
+                case 'map-value-ind':
+                    if (!it || it.value)
+                        fc.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                    else if (it.sep)
+                        it.sep.push(this.sourceToken);
+                    else
+                        Object.assign(it, { key: null, sep: [this.sourceToken] });
+                    return;
+                case 'space':
+                case 'comment':
+                case 'newline':
+                case 'anchor':
+                case 'tag':
+                    if (!it || it.value)
+                        fc.items.push({ start: [this.sourceToken] });
+                    else if (it.sep)
+                        it.sep.push(this.sourceToken);
+                    else
+                        it.start.push(this.sourceToken);
+                    return;
+                case 'alias':
+                case 'scalar':
+                case 'single-quoted-scalar':
+                case 'double-quoted-scalar': {
+                    const fs = this.flowScalar(this.type);
+                    if (!it || it.value)
+                        fc.items.push({ start: [], key: fs, sep: [] });
+                    else if (it.sep)
+                        this.stack.push(fs);
+                    else
+                        Object.assign(it, { key: fs, sep: [] });
+                    return;
+                }
+                case 'flow-map-end':
+                case 'flow-seq-end':
+                    fc.end.push(this.sourceToken);
+                    return;
+            }
+            const bv = this.startBlockValue(fc);
+            /* istanbul ignore else should not happen */
+            if (bv)
+                this.stack.push(bv);
+            else {
+                yield* this.pop();
+                yield* this.step();
+            }
+        }
+        else {
+            const parent = this.peek(2);
+            if (parent.type === 'block-map' &&
+                ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
+                    (this.type === 'newline' &&
+                        !parent.items[parent.items.length - 1].sep))) {
+                yield* this.pop();
+                yield* this.step();
+            }
+            else if (this.type === 'map-value-ind' &&
+                parent.type !== 'flow-collection') {
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                fixFlowSeqItems(fc);
+                const sep = fc.end.splice(1, fc.end.length);
+                sep.push(this.sourceToken);
+                const map = {
+                    type: 'block-map',
+                    offset: fc.offset,
+                    indent: fc.indent,
+                    items: [{ start, key: fc, sep }]
+                };
+                this.onKeyLine = true;
+                this.stack[this.stack.length - 1] = map;
+            }
+            else {
+                yield* this.lineEnd(fc);
+            }
+        }
+    }
+    flowScalar(type) {
+        if (this.onNewLine) {
+            let nl = this.source.indexOf('\n') + 1;
+            while (nl !== 0) {
+                this.onNewLine(this.offset + nl);
+                nl = this.source.indexOf('\n', nl) + 1;
+            }
+        }
+        return {
+            type,
+            offset: this.offset,
+            indent: this.indent,
+            source: this.source
+        };
+    }
+    startBlockValue(parent) {
+        switch (this.type) {
+            case 'alias':
+            case 'scalar':
+            case 'single-quoted-scalar':
+            case 'double-quoted-scalar':
+                return this.flowScalar(this.type);
+            case 'block-scalar-header':
+                return {
+                    type: 'block-scalar',
+                    offset: this.offset,
+                    indent: this.indent,
+                    props: [this.sourceToken],
+                    source: ''
+                };
+            case 'flow-map-start':
+            case 'flow-seq-start':
+                return {
+                    type: 'flow-collection',
+                    offset: this.offset,
+                    indent: this.indent,
+                    start: this.sourceToken,
+                    items: [],
+                    end: []
+                };
+            case 'seq-item-ind':
+                return {
+                    type: 'block-seq',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start: [this.sourceToken] }]
+                };
+            case 'explicit-key-ind': {
+                this.onKeyLine = true;
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                start.push(this.sourceToken);
+                return {
+                    type: 'block-map',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start, explicitKey: true }]
+                };
+            }
+            case 'map-value-ind': {
+                this.onKeyLine = true;
+                const prev = getPrevProps(parent);
+                const start = getFirstKeyStartProps(prev);
+                return {
+                    type: 'block-map',
+                    offset: this.offset,
+                    indent: this.indent,
+                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                };
+            }
+        }
+        return null;
+    }
+    atIndentedComment(start, indent) {
+        if (this.type !== 'comment')
+            return false;
+        if (this.indent <= indent)
+            return false;
+        return start.every(st => st.type === 'newline' || st.type === 'space');
+    }
+    *documentEnd(docEnd) {
+        if (this.type !== 'doc-mode') {
+            if (docEnd.end)
+                docEnd.end.push(this.sourceToken);
+            else
+                docEnd.end = [this.sourceToken];
+            if (this.type === 'newline')
+                yield* this.pop();
+        }
+    }
+    *lineEnd(token) {
+        switch (this.type) {
+            case 'comma':
+            case 'doc-start':
+            case 'doc-end':
+            case 'flow-seq-end':
+            case 'flow-map-end':
+            case 'map-value-ind':
+                yield* this.pop();
+                yield* this.step();
+                break;
+            case 'newline':
+                this.onKeyLine = false;
+            // fallthrough
+            case 'space':
+            case 'comment':
+            default:
+                // all other values are errors
+                if (token.end)
+                    token.end.push(this.sourceToken);
+                else
+                    token.end = [this.sourceToken];
+                if (this.type === 'newline')
+                    yield* this.pop();
+        }
+    }
+}
+
+function parseOptions(options) {
+    const prettyErrors = options.prettyErrors !== false;
+    const lineCounter = options.lineCounter || (prettyErrors && new LineCounter()) || null;
+    return { lineCounter, prettyErrors };
+}
+/**
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ *
+ * @returns If an empty `docs` array is returned, it will be of type
+ *   EmptyStream and contain additional stream information. In
+ *   TypeScript, you should use `'empty' in docs` as a type guard for it.
+ */
+function parseAllDocuments(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser = new Parser(lineCounter?.addNewLine);
+    const composer = new Composer(options);
+    const docs = Array.from(composer.compose(parser.parse(source)));
+    if (prettyErrors && lineCounter)
+        for (const doc of docs) {
+            doc.errors.forEach(prettifyError(source, lineCounter));
+            doc.warnings.forEach(prettifyError(source, lineCounter));
+        }
+    if (docs.length > 0)
+        return docs;
+    return Object.assign([], { empty: true }, composer.streamInfo());
+}
+/** Parse an input string into a single YAML.Document */
+function parseDocument(source, options = {}) {
+    const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser = new Parser(lineCounter?.addNewLine);
+    const composer = new Composer(options);
+    // `doc` is always set by compose.end(true) at the very latest
+    let doc = null;
+    for (const _doc of composer.compose(parser.parse(source), true, source.length)) {
+        if (!doc)
+            doc = _doc;
+        else if (doc.options.logLevel !== 'silent') {
+            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            break;
+        }
+    }
+    if (prettyErrors && lineCounter) {
+        doc.errors.forEach(prettifyError(source, lineCounter));
+        doc.warnings.forEach(prettifyError(source, lineCounter));
+    }
+    return doc;
+}
+function parse$a(src, reviver, options) {
+    let _reviver = undefined;
+    if (typeof reviver === 'function') {
+        _reviver = reviver;
+    }
+    else if (options === undefined && reviver && typeof reviver === 'object') {
+        options = reviver;
+    }
+    const doc = parseDocument(src, options);
+    if (!doc)
+        return null;
+    doc.warnings.forEach(warning => warn(doc.options.logLevel, warning));
+    if (doc.errors.length > 0) {
+        if (doc.options.logLevel !== 'silent')
+            throw doc.errors[0];
+        else
+            doc.errors = [];
+    }
+    return doc.toJS(Object.assign({ reviver: _reviver }, options));
+}
+function stringify(value, replacer, options) {
+    let _replacer = null;
+    if (typeof replacer === 'function' || Array.isArray(replacer)) {
+        _replacer = replacer;
+    }
+    else if (options === undefined && replacer) {
+        options = replacer;
+    }
+    if (typeof options === 'string')
+        options = options.length;
+    if (typeof options === 'number') {
+        const indent = Math.round(options);
+        options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };
+    }
+    if (value === undefined) {
+        const { keepUndefined } = options ?? replacer ?? {};
+        if (!keepUndefined)
+            return undefined;
+    }
+    return new Document(value, _replacer, options).toString(options);
+}
+
+var YAML = {
+	__proto__: null,
+	Alias: Alias,
+	CST: cst,
+	Composer: Composer,
+	Document: Document,
+	Lexer: Lexer,
+	LineCounter: LineCounter,
+	Pair: Pair,
+	Parser: Parser,
+	Scalar: Scalar,
+	Schema: Schema,
+	YAMLError: YAMLError,
+	YAMLMap: YAMLMap,
+	YAMLParseError: YAMLParseError,
+	YAMLSeq: YAMLSeq,
+	YAMLWarning: YAMLWarning,
+	isAlias: isAlias,
+	isCollection: isCollection$1,
+	isDocument: isDocument,
+	isMap: isMap,
+	isNode: isNode$1,
+	isPair: isPair,
+	isScalar: isScalar$1,
+	isSeq: isSeq,
+	parse: parse$a,
+	parseAllDocuments: parseAllDocuments,
+	parseDocument: parseDocument,
+	stringify: stringify,
+	visit: visit$1,
+	visitAsync: visitAsync
+};
+
+// `export * as default from ...` fails on Webpack v4
+// https://github.com/eemeli/yaml/issues/228
+
+var browser$2 = {
+	__proto__: null,
+	Alias: Alias,
+	CST: cst,
+	Composer: Composer,
+	Document: Document,
+	Lexer: Lexer,
+	LineCounter: LineCounter,
+	Pair: Pair,
+	Parser: Parser,
+	Scalar: Scalar,
+	Schema: Schema,
+	YAMLError: YAMLError,
+	YAMLMap: YAMLMap,
+	YAMLParseError: YAMLParseError,
+	YAMLSeq: YAMLSeq,
+	YAMLWarning: YAMLWarning,
+	default: YAML,
+	isAlias: isAlias,
+	isCollection: isCollection$1,
+	isDocument: isDocument,
+	isMap: isMap,
+	isNode: isNode$1,
+	isPair: isPair,
+	isScalar: isScalar$1,
+	isSeq: isSeq,
+	parse: parse$a,
+	parseAllDocuments: parseAllDocuments,
+	parseDocument: parseDocument,
+	stringify: stringify,
+	visit: visit$1,
+	visitAsync: visitAsync
+};
+
+var require$$3 = /*@__PURE__*/getAugmentedNamespace(browser$2);
+
+// eslint-disable-next-line n/no-deprecated-api
+const { createRequire, createRequireFromPath } = require$$0$8;
+
+function req$2 (name, rootFile) {
+  const create = createRequire || createRequireFromPath;
+  const require = create(rootFile);
+  return require(name)
+}
+
+var req_1 = req$2;
+
+const req$1 = req_1;
+
+/**
+ * Load Options
+ *
+ * @private
+ * @method options
+ *
+ * @param  {Object} config  PostCSS Config
+ *
+ * @return {Object} options PostCSS Options
+ */
+const options = (config, file) => {
+  if (config.parser && typeof config.parser === 'string') {
+    try {
+      config.parser = req$1(config.parser, file);
+    } catch (err) {
+      throw new Error(`Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`)
+    }
+  }
+
+  if (config.syntax && typeof config.syntax === 'string') {
+    try {
+      config.syntax = req$1(config.syntax, file);
+    } catch (err) {
+      throw new Error(`Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`)
+    }
+  }
+
+  if (config.stringifier && typeof config.stringifier === 'string') {
+    try {
+      config.stringifier = req$1(config.stringifier, file);
+    } catch (err) {
+      throw new Error(`Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`)
+    }
+  }
+
+  if (config.plugins) {
+    delete config.plugins;
+  }
+
+  return config
+};
+
+var options_1 = options;
+
+const req = req_1;
+
+/**
+ * Plugin Loader
+ *
+ * @private
+ * @method load
+ *
+ * @param  {String} plugin PostCSS Plugin Name
+ * @param  {Object} options PostCSS Plugin Options
+ *
+ * @return {Function} PostCSS Plugin
+ */
+const load = (plugin, options, file) => {
+  try {
+    if (
+      options === null ||
+      options === undefined ||
+      Object.keys(options).length === 0
+    ) {
+      return req(plugin, file)
+    } else {
+      return req(plugin, file)(options)
+    }
+  } catch (err) {
+    throw new Error(`Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`)
+  }
+};
+
+/**
+ * Load Plugins
+ *
+ * @private
+ * @method plugins
+ *
+ * @param {Object} config PostCSS Config Plugins
+ *
+ * @return {Array} plugins PostCSS Plugins
+ */
+const plugins = (config, file) => {
+  let plugins = [];
+
+  if (Array.isArray(config.plugins)) {
+    plugins = config.plugins.filter(Boolean);
+  } else {
+    plugins = Object.keys(config.plugins)
+      .filter((plugin) => {
+        return config.plugins[plugin] !== false ? plugin : ''
+      })
+      .map((plugin) => {
+        return load(plugin, config.plugins[plugin], file)
+      });
+  }
+
+  if (plugins.length && plugins.length > 0) {
+    plugins.forEach((plugin, i) => {
+      if (plugin.default) {
+        plugin = plugin.default;
+      }
+
+      if (plugin.postcss === true) {
+        plugin = plugin();
+      } else if (plugin.postcss) {
+        plugin = plugin.postcss;
+      }
+
+      if (
+        // eslint-disable-next-line
+        !(
+          (typeof plugin === 'object' && Array.isArray(plugin.plugins)) ||
+          (typeof plugin === 'object' && plugin.postcssPlugin) ||
+          (typeof plugin === 'function')
+        )
+      ) {
+        throw new TypeError(`Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`)
+      }
+    });
+  }
+
+  return plugins
+};
+
+var plugins_1 = plugins;
+
+const resolve = require$$0$4.resolve;
+const url$4 = require$$0$9;
+
+const config$1 = src$2;
+const yaml = require$$3;
+
+const loadOptions = options_1;
+const loadPlugins = plugins_1;
+
+/* istanbul ignore next */
+const interopRequireDefault = (obj) => obj && obj.__esModule ? obj : { default: obj };
+
+/**
+ * Process the result from cosmiconfig
+ *
+ * @param  {Object} ctx Config Context
+ * @param  {Object} result Cosmiconfig result
+ *
+ * @return {Object} PostCSS Config
+ */
+const processResult = (ctx, result) => {
+  const file = result.filepath || '';
+  let config = interopRequireDefault(result.config).default || {};
+
+  if (typeof config === 'function') {
+    config = config(ctx);
+  } else {
+    config = Object.assign({}, config, ctx);
+  }
+
+  if (!config.plugins) {
+    config.plugins = [];
+  }
+
+  return {
+    plugins: loadPlugins(config, file),
+    options: loadOptions(config, file),
+    file
+  }
+};
+
+/**
+ * Builds the Config Context
+ *
+ * @param  {Object} ctx Config Context
+ *
+ * @return {Object} Config Context
+ */
+const createContext = (ctx) => {
+  /**
+   * @type {Object}
+   *
+   * @prop {String} cwd=process.cwd() Config search start location
+   * @prop {String} env=process.env.NODE_ENV Config Enviroment, will be set to `development` by `postcss-load-config` if `process.env.NODE_ENV` is `undefined`
+   */
+  ctx = Object.assign({
+    cwd: process.cwd(),
+    env: process.env.NODE_ENV
+  }, ctx);
+
+  if (!ctx.env) {
+    process.env.NODE_ENV = 'development';
+  }
+
+  return ctx
+};
+
+const importDefault = async filepath => {
+  const module = await import(url$4.pathToFileURL(filepath).href);
+  return module.default
+};
+
+const addTypeScriptLoader = (options = {}, loader) => {
+  const moduleName = 'postcss';
+
+  return {
+    ...options,
+    searchPlaces: [
+      ...(options.searchPlaces || []),
+      'package.json',
+      `.${moduleName}rc`,
+      `.${moduleName}rc.json`,
+      `.${moduleName}rc.yaml`,
+      `.${moduleName}rc.yml`,
+      `.${moduleName}rc.ts`,
+      `.${moduleName}rc.cts`,
+      `.${moduleName}rc.js`,
+      `.${moduleName}rc.cjs`,
+      `.${moduleName}rc.mjs`,
+      `${moduleName}.config.ts`,
+      `${moduleName}.config.cts`,
+      `${moduleName}.config.js`,
+      `${moduleName}.config.cjs`,
+      `${moduleName}.config.mjs`
+    ],
+    loaders: {
+      ...options.loaders,
+      '.yaml': (filepath, content) => yaml.parse(content),
+      '.yml': (filepath, content) => yaml.parse(content),
+      '.js': importDefault,
+      '.cjs': importDefault,
+      '.mjs': importDefault,
+      '.ts': loader,
+      '.cts': loader
+    }
+  }
+};
+
+const withTypeScriptLoader = (rcFunc) => {
+  return (ctx, path, options) => {
+    return rcFunc(ctx, path, addTypeScriptLoader(options, (configFile) => {
+      let registerer = { enabled () {} };
+
+      try {
+        // Register TypeScript compiler instance
+        registerer = __require('ts-node').register({
+          // transpile to cjs even if compilerOptions.module in tsconfig is not Node16/NodeNext.
+          moduleTypes: { '**/*.cts': 'cjs' }
+        });
+
+        return __require(configFile)
+      } catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND') {
+          throw new Error(
+            `'ts-node' is required for the TypeScript configuration files. Make sure it is installed\nError: ${err.message}`
+          )
+        }
+
+        throw err
+      } finally {
+        registerer.enabled(false);
+      }
+    }))
+  }
+};
+
+/**
+ * Load Config
+ *
+ * @method rc
+ *
+ * @param  {Object} ctx Config Context
+ * @param  {String} path Config Path
+ * @param  {Object} options Config Options
+ *
+ * @return {Promise} config PostCSS Config
+ */
+const rc = withTypeScriptLoader((ctx, path, options) => {
+  /**
+   * @type {Object} The full Config Context
+   */
+  ctx = createContext(ctx);
+
+  /**
+   * @type {String} `process.cwd()`
+   */
+  path = path ? resolve(path) : process.cwd();
+
+  return config$1.lilconfig('postcss', options)
+    .search(path)
+    .then((result) => {
+      if (!result) {
+        throw new Error(`No PostCSS Config found in: ${path}`)
+      }
+
+      return processResult(ctx, result)
+    })
+});
+
+/**
+ * Autoload Config for PostCSS
+ *
+ * @author Michael Ciniawsky @michael-ciniawsky <michael.ciniawsky@gmail.com>
+ * @license MIT
+ *
+ * @module postcss-load-config
+ * @version 2.1.0
+ *
+ * @requires comsiconfig
+ * @requires ./options
+ * @requires ./plugins
+ */
+var src$1 = rc;
+
+var postcssrc = /*@__PURE__*/getDefaultExportFromCjs(src$1);
+
+// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
+// License: MIT.
+var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]|[^\/\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
+StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
+NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/yu;
+LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+SingleLineComment = /\/\/.*/y;
+HashbangComment = /^#!.*/;
+JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/yu;
+JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
+JSXText = /[^<>{}]+/y;
+TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+Newline = RegExp(LineTerminatorSequence.source);
+var jsTokens_1 = function*(input, {jsx = false} = {}) {
+	var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+	({length} = input);
+	lastIndex = 0;
+	lastSignificantToken = "";
+	stack = [
+		{tag: "JS"}
+	];
+	braces = [];
+	parenNesting = 0;
+	postfixIncDec = false;
+	if (match = HashbangComment.exec(input)) {
+		yield ({
+			type: "HashbangComment",
+			value: match[0]
+		});
+		lastIndex = match[0].length;
+	}
+	while (lastIndex < length) {
+		mode = stack[stack.length - 1];
+		switch (mode.tag) {
+			case "JS":
+			case "JSNonExpressionParen":
+			case "InterpolationInTemplate":
+			case "InterpolationInJSX":
+				if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+					RegularExpressionLiteral.lastIndex = lastIndex;
+					if (match = RegularExpressionLiteral.exec(input)) {
+						lastIndex = RegularExpressionLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield ({
+							type: "RegularExpressionLiteral",
+							value: match[0],
+							closed: match[1] !== void 0 && match[1] !== "\\"
+						});
+						continue;
+					}
+				}
+				Punctuator.lastIndex = lastIndex;
+				if (match = Punctuator.exec(input)) {
+					punctuator = match[0];
+					nextLastIndex = Punctuator.lastIndex;
+					nextLastSignificantToken = punctuator;
+					switch (punctuator) {
+						case "(":
+							if (lastSignificantToken === "?NonExpressionParenKeyword") {
+								stack.push({
+									tag: "JSNonExpressionParen",
+									nesting: parenNesting
+								});
+							}
+							parenNesting++;
+							postfixIncDec = false;
+							break;
+						case ")":
+							parenNesting--;
+							postfixIncDec = true;
+							if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+								stack.pop();
+								nextLastSignificantToken = "?NonExpressionParenEnd";
+								postfixIncDec = false;
+							}
+							break;
+						case "{":
+							Punctuator.lastIndex = 0;
+							isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+							braces.push(isExpression);
+							postfixIncDec = false;
+							break;
+						case "}":
+							switch (mode.tag) {
+								case "InterpolationInTemplate":
+									if (braces.length === mode.nesting) {
+										Template.lastIndex = lastIndex;
+										match = Template.exec(input);
+										lastIndex = Template.lastIndex;
+										lastSignificantToken = match[0];
+										if (match[1] === "${") {
+											lastSignificantToken = "?InterpolationInTemplate";
+											postfixIncDec = false;
+											yield ({
+												type: "TemplateMiddle",
+												value: match[0]
+											});
+										} else {
+											stack.pop();
+											postfixIncDec = true;
+											yield ({
+												type: "TemplateTail",
+												value: match[0],
+												closed: match[1] === "`"
+											});
+										}
+										continue;
+									}
+									break;
+								case "InterpolationInJSX":
+									if (braces.length === mode.nesting) {
+										stack.pop();
+										lastIndex += 1;
+										lastSignificantToken = "}";
+										yield ({
+											type: "JSXPunctuator",
+											value: "}"
+										});
+										continue;
+									}
+							}
+							postfixIncDec = braces.pop();
+							nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+							break;
+						case "]":
+							postfixIncDec = true;
+							break;
+						case "++":
+						case "--":
+							nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+							break;
+						case "<":
+							if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+								stack.push({tag: "JSXTag"});
+								lastIndex += 1;
+								lastSignificantToken = "<";
+								yield ({
+									type: "JSXPunctuator",
+									value: punctuator
+								});
+								continue;
+							}
+							postfixIncDec = false;
+							break;
+						default:
+							postfixIncDec = false;
+					}
+					lastIndex = nextLastIndex;
+					lastSignificantToken = nextLastSignificantToken;
+					yield ({
+						type: "Punctuator",
+						value: punctuator
+					});
+					continue;
+				}
+				Identifier.lastIndex = lastIndex;
+				if (match = Identifier.exec(input)) {
+					lastIndex = Identifier.lastIndex;
+					nextLastSignificantToken = match[0];
+					switch (match[0]) {
+						case "for":
+						case "if":
+						case "while":
+						case "with":
+							if (lastSignificantToken !== "." && lastSignificantToken !== "?.") {
+								nextLastSignificantToken = "?NonExpressionParenKeyword";
+							}
+					}
+					lastSignificantToken = nextLastSignificantToken;
+					postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+					yield ({
+						type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+						value: match[0]
+					});
+					continue;
+				}
+				StringLiteral.lastIndex = lastIndex;
+				if (match = StringLiteral.exec(input)) {
+					lastIndex = StringLiteral.lastIndex;
+					lastSignificantToken = match[0];
+					postfixIncDec = true;
+					yield ({
+						type: "StringLiteral",
+						value: match[0],
+						closed: match[2] !== void 0
+					});
+					continue;
+				}
+				NumericLiteral.lastIndex = lastIndex;
+				if (match = NumericLiteral.exec(input)) {
+					lastIndex = NumericLiteral.lastIndex;
+					lastSignificantToken = match[0];
+					postfixIncDec = true;
+					yield ({
+						type: "NumericLiteral",
+						value: match[0]
+					});
+					continue;
+				}
+				Template.lastIndex = lastIndex;
+				if (match = Template.exec(input)) {
+					lastIndex = Template.lastIndex;
+					lastSignificantToken = match[0];
+					if (match[1] === "${") {
+						lastSignificantToken = "?InterpolationInTemplate";
+						stack.push({
+							tag: "InterpolationInTemplate",
+							nesting: braces.length
+						});
+						postfixIncDec = false;
+						yield ({
+							type: "TemplateHead",
+							value: match[0]
+						});
+					} else {
+						postfixIncDec = true;
+						yield ({
+							type: "NoSubstitutionTemplate",
+							value: match[0],
+							closed: match[1] === "`"
+						});
+					}
+					continue;
+				}
+				break;
+			case "JSXTag":
+			case "JSXTagEnd":
+				JSXPunctuator.lastIndex = lastIndex;
+				if (match = JSXPunctuator.exec(input)) {
+					lastIndex = JSXPunctuator.lastIndex;
+					nextLastSignificantToken = match[0];
+					switch (match[0]) {
+						case "<":
+							stack.push({tag: "JSXTag"});
+							break;
+						case ">":
+							stack.pop();
+							if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+								nextLastSignificantToken = "?JSX";
+								postfixIncDec = true;
+							} else {
+								stack.push({tag: "JSXChildren"});
+							}
+							break;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							nextLastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							break;
+						case "/":
+							if (lastSignificantToken === "<") {
+								stack.pop();
+								if (stack[stack.length - 1].tag === "JSXChildren") {
+									stack.pop();
+								}
+								stack.push({tag: "JSXTagEnd"});
+							}
+					}
+					lastSignificantToken = nextLastSignificantToken;
+					yield ({
+						type: "JSXPunctuator",
+						value: match[0]
+					});
+					continue;
+				}
+				JSXIdentifier.lastIndex = lastIndex;
+				if (match = JSXIdentifier.exec(input)) {
+					lastIndex = JSXIdentifier.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXIdentifier",
+						value: match[0]
+					});
+					continue;
+				}
+				JSXString.lastIndex = lastIndex;
+				if (match = JSXString.exec(input)) {
+					lastIndex = JSXString.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXString",
+						value: match[0],
+						closed: match[2] !== void 0
+					});
+					continue;
+				}
+				break;
+			case "JSXChildren":
+				JSXText.lastIndex = lastIndex;
+				if (match = JSXText.exec(input)) {
+					lastIndex = JSXText.lastIndex;
+					lastSignificantToken = match[0];
+					yield ({
+						type: "JSXText",
+						value: match[0]
+					});
+					continue;
+				}
+				switch (input[lastIndex]) {
+					case "<":
+						stack.push({tag: "JSXTag"});
+						lastIndex++;
+						lastSignificantToken = "<";
+						yield ({
+							type: "JSXPunctuator",
+							value: "<"
+						});
+						continue;
+					case "{":
+						stack.push({
+							tag: "InterpolationInJSX",
+							nesting: braces.length
+						});
+						lastIndex++;
+						lastSignificantToken = "?InterpolationInJSX";
+						postfixIncDec = false;
+						yield ({
+							type: "JSXPunctuator",
+							value: "{"
+						});
+						continue;
+				}
+		}
+		WhiteSpace.lastIndex = lastIndex;
+		if (match = WhiteSpace.exec(input)) {
+			lastIndex = WhiteSpace.lastIndex;
+			yield ({
+				type: "WhiteSpace",
+				value: match[0]
+			});
+			continue;
+		}
+		LineTerminatorSequence.lastIndex = lastIndex;
+		if (match = LineTerminatorSequence.exec(input)) {
+			lastIndex = LineTerminatorSequence.lastIndex;
+			postfixIncDec = false;
+			if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+				lastSignificantToken = "?NoLineTerminatorHere";
+			}
+			yield ({
+				type: "LineTerminatorSequence",
+				value: match[0]
+			});
+			continue;
+		}
+		MultiLineComment.lastIndex = lastIndex;
+		if (match = MultiLineComment.exec(input)) {
+			lastIndex = MultiLineComment.lastIndex;
+			if (Newline.test(match[0])) {
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) {
+					lastSignificantToken = "?NoLineTerminatorHere";
+				}
+			}
+			yield ({
+				type: "MultiLineComment",
+				value: match[0],
+				closed: match[1] !== void 0
+			});
+			continue;
+		}
+		SingleLineComment.lastIndex = lastIndex;
+		if (match = SingleLineComment.exec(input)) {
+			lastIndex = SingleLineComment.lastIndex;
+			postfixIncDec = false;
+			yield ({
+				type: "SingleLineComment",
+				value: match[0]
+			});
+			continue;
+		}
+		firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+		lastIndex += firstCodePoint.length;
+		lastSignificantToken = firstCodePoint;
+		postfixIncDec = false;
+		yield ({
+			type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+			value: firstCodePoint
+		});
+	}
+	return void 0;
+};
+
+var jsTokens = /*@__PURE__*/getDefaultExportFromCjs(jsTokens_1);
+
+function stripLiteralJsTokens(code, options) {
+  const FILL = " ";
+  const FILL_COMMENT = " ";
+  let result = "";
+  const tokens = [];
+  for (const token of jsTokens(code, { jsx: false })) {
+    tokens.push(token);
+    if (token.type === "SingleLineComment") {
+      result += FILL_COMMENT.repeat(token.value.length);
+      continue;
+    }
+    if (token.type === "MultiLineComment") {
+      result += token.value.replace(/[^\n]/g, FILL_COMMENT);
+      continue;
+    }
+    if (token.type === "StringLiteral") {
+      if (!token.closed) {
+        result += token.value;
+        continue;
+      }
+      const body = token.value.slice(1, -1);
+      {
+        result += token.value[0] + FILL.repeat(body.length) + token.value[token.value.length - 1];
+        continue;
+      }
+    }
+    if (token.type === "NoSubstitutionTemplate") {
+      const body = token.value.slice(1, -1);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "RegularExpressionLiteral") {
+      const body = token.value;
+      {
+        result += body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${FILL.repeat($1.length)}/${$2}`);
+        continue;
+      }
+    }
+    if (token.type === "TemplateHead") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `\`${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    if (token.type === "TemplateTail") {
+      const body = token.value.slice(0, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\``;
+        continue;
+      }
+    }
+    if (token.type === "TemplateMiddle") {
+      const body = token.value.slice(1, -2);
+      {
+        result += `}${body.replace(/[^\n]/g, FILL)}\${`;
+        continue;
+      }
+    }
+    result += token.value;
+  }
+  return {
+    result,
+    tokens
+  };
+}
+
+function stripLiteral(code, options) {
+  return stripLiteralDetailed(code).result;
+}
+function stripLiteralDetailed(code, options) {
+  return stripLiteralJsTokens(code);
+}
+
+var main$1 = {exports: {}};
+
+var name = "dotenv";
+var version$1 = "16.4.5";
+var description = "Loads environment variables from .env file";
+var main = "lib/main.js";
+var types = "lib/main.d.ts";
+var exports = {
+	".": {
+		types: "./lib/main.d.ts",
+		require: "./lib/main.js",
+		"default": "./lib/main.js"
+	},
+	"./config": "./config.js",
+	"./config.js": "./config.js",
+	"./lib/env-options": "./lib/env-options.js",
+	"./lib/env-options.js": "./lib/env-options.js",
+	"./lib/cli-options": "./lib/cli-options.js",
+	"./lib/cli-options.js": "./lib/cli-options.js",
+	"./package.json": "./package.json"
+};
+var scripts = {
+	"dts-check": "tsc --project tests/types/tsconfig.json",
+	lint: "standard",
+	"lint-readme": "standard-markdown",
+	pretest: "npm run lint && npm run dts-check",
+	test: "tap tests/*.js --100 -Rspec",
+	"test:coverage": "tap --coverage-report=lcov",
+	prerelease: "npm test",
+	release: "standard-version"
+};
+var repository = {
+	type: "git",
+	url: "git://github.com/motdotla/dotenv.git"
+};
+var funding = "https://dotenvx.com";
+var keywords = [
+	"dotenv",
+	"env",
+	".env",
+	"environment",
+	"variables",
+	"config",
+	"settings"
+];
+var readmeFilename = "README.md";
+var license = "BSD-2-Clause";
+var devDependencies = {
+	"@definitelytyped/dtslint": "^0.0.133",
+	"@types/node": "^18.11.3",
+	decache: "^4.6.1",
+	sinon: "^14.0.1",
+	standard: "^17.0.0",
+	"standard-markdown": "^7.1.0",
+	"standard-version": "^9.5.0",
+	tap: "^16.3.0",
+	tar: "^6.1.11",
+	typescript: "^4.8.4"
+};
+var engines = {
+	node: ">=12"
+};
+var browser$1 = {
+	fs: false
+};
+var require$$4 = {
+	name: name,
+	version: version$1,
+	description: description,
+	main: main,
+	types: types,
+	exports: exports,
+	scripts: scripts,
+	repository: repository,
+	funding: funding,
+	keywords: keywords,
+	readmeFilename: readmeFilename,
+	license: license,
+	devDependencies: devDependencies,
+	engines: engines,
+	browser: browser$1
+};
+
+const fs$9 = require$$0__default;
+const path$9 = require$$0$4;
+const os$2 = require$$2;
+const crypto$1 = require$$3$1;
+const packageJson = require$$4;
+
+const version = packageJson.version;
+
+const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+// Parse src into an Object
+function parse$9 (src) {
+  const obj = {};
+
+  // Convert buffer to string
+  let lines = src.toString();
+
+  // Convert line breaks to same format
+  lines = lines.replace(/\r\n?/mg, '\n');
+
+  let match;
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1];
+
+    // Default undefined or null to empty string
+    let value = (match[2] || '');
+
+    // Remove whitespace
+    value = value.trim();
+
+    // Check if double quoted
+    const maybeQuote = value[0];
+
+    // Remove surrounding quotes
+    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+    // Expand newlines if double quoted
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, '\n');
+      value = value.replace(/\\r/g, '\r');
+    }
+
+    // Add to object
+    obj[key] = value;
+  }
+
+  return obj
+}
+
+function _parseVault (options) {
+  const vaultPath = _vaultPath(options);
+
+  // Parse .env.vault
+  const result = DotenvModule.configDotenv({ path: vaultPath });
+  if (!result.parsed) {
+    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+    err.code = 'MISSING_DATA';
+    throw err
+  }
+
+  // handle scenario for comma separated keys - for use with key rotation
+  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+  const keys = _dotenvKey(options).split(',');
+  const length = keys.length;
+
+  let decrypted;
+  for (let i = 0; i < length; i++) {
+    try {
+      // Get full key
+      const key = keys[i].trim();
+
+      // Get instructions for decrypt
+      const attrs = _instructions(result, key);
+
+      // Decrypt
+      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+
+      break
+    } catch (error) {
+      // last key
+      if (i + 1 >= length) {
+        throw error
+      }
+      // try next key
+    }
+  }
+
+  // Parse decrypted .env string
+  return DotenvModule.parse(decrypted)
+}
+
+function _log (message) {
+  console.log(`[dotenv@${version}][INFO] ${message}`);
+}
+
+function _warn (message) {
+  console.log(`[dotenv@${version}][WARN] ${message}`);
+}
+
+function _debug (message) {
+  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+}
+
+function _dotenvKey (options) {
+  // prioritize developer directly setting options.DOTENV_KEY
+  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+    return options.DOTENV_KEY
+  }
+
+  // secondary infra already contains a DOTENV_KEY environment variable
+  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+    return process.env.DOTENV_KEY
+  }
+
+  // fallback to empty string
+  return ''
+}
+
+function _instructions (result, dotenvKey) {
+  // Parse DOTENV_KEY. Format is a URI
+  let uri;
+  try {
+    uri = new URL(dotenvKey);
+  } catch (error) {
+    if (error.code === 'ERR_INVALID_URL') {
+      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err
+    }
+
+    throw error
+  }
+
+  // Get decrypt key
+  const key = uri.password;
+  if (!key) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+    err.code = 'INVALID_DOTENV_KEY';
+    throw err
+  }
+
+  // Get environment
+  const environment = uri.searchParams.get('environment');
+  if (!environment) {
+    const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+    err.code = 'INVALID_DOTENV_KEY';
+    throw err
+  }
+
+  // Get ciphertext payload
+  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+  const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+  if (!ciphertext) {
+    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+    throw err
+  }
+
+  return { ciphertext, key }
+}
+
+function _vaultPath (options) {
+  let possibleVaultPath = null;
+
+  if (options && options.path && options.path.length > 0) {
+    if (Array.isArray(options.path)) {
+      for (const filepath of options.path) {
+        if (fs$9.existsSync(filepath)) {
+          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+        }
+      }
+    } else {
+      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+    }
+  } else {
+    possibleVaultPath = path$9.resolve(process.cwd(), '.env.vault');
+  }
+
+  if (fs$9.existsSync(possibleVaultPath)) {
+    return possibleVaultPath
+  }
+
+  return null
+}
+
+function _resolveHome (envPath) {
+  return envPath[0] === '~' ? path$9.join(os$2.homedir(), envPath.slice(1)) : envPath
+}
+
+function _configVault (options) {
+  _log('Loading env from encrypted .env.vault');
+
+  const parsed = DotenvModule._parseVault(options);
+
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  DotenvModule.populate(processEnv, parsed, options);
+
+  return { parsed }
+}
+
+function configDotenv (options) {
+  const dotenvPath = path$9.resolve(process.cwd(), '.env');
+  let encoding = 'utf8';
+  const debug = Boolean(options && options.debug);
+
+  if (options && options.encoding) {
+    encoding = options.encoding;
+  } else {
+    if (debug) {
+      _debug('No encoding is specified. UTF-8 is used by default');
+    }
+  }
+
+  let optionPaths = [dotenvPath]; // default, look for .env
+  if (options && options.path) {
+    if (!Array.isArray(options.path)) {
+      optionPaths = [_resolveHome(options.path)];
+    } else {
+      optionPaths = []; // reset default
+      for (const filepath of options.path) {
+        optionPaths.push(_resolveHome(filepath));
+      }
+    }
+  }
+
+  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+  let lastError;
+  const parsedAll = {};
+  for (const path of optionPaths) {
+    try {
+      // Specifying an encoding returns a string instead of a buffer
+      const parsed = DotenvModule.parse(fs$9.readFileSync(path, { encoding }));
+
+      DotenvModule.populate(parsedAll, parsed, options);
+    } catch (e) {
+      if (debug) {
+        _debug(`Failed to load ${path} ${e.message}`);
+      }
+      lastError = e;
+    }
+  }
+
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  DotenvModule.populate(processEnv, parsedAll, options);
+
+  if (lastError) {
+    return { parsed: parsedAll, error: lastError }
+  } else {
+    return { parsed: parsedAll }
+  }
+}
+
+// Populates process.env from .env file
+function config (options) {
+  // fallback to original dotenv if DOTENV_KEY is not set
+  if (_dotenvKey(options).length === 0) {
+    return DotenvModule.configDotenv(options)
+  }
+
+  const vaultPath = _vaultPath(options);
+
+  // dotenvKey exists but .env.vault file does not exist
+  if (!vaultPath) {
+    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+
+    return DotenvModule.configDotenv(options)
+  }
+
+  return DotenvModule._configVault(options)
+}
+
+function decrypt (encrypted, keyStr) {
+  const key = Buffer.from(keyStr.slice(-64), 'hex');
+  let ciphertext = Buffer.from(encrypted, 'base64');
+
+  const nonce = ciphertext.subarray(0, 12);
+  const authTag = ciphertext.subarray(-16);
+  ciphertext = ciphertext.subarray(12, -16);
+
+  try {
+    const aesgcm = crypto$1.createDecipheriv('aes-256-gcm', key, nonce);
+    aesgcm.setAuthTag(authTag);
+    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+  } catch (error) {
+    const isRange = error instanceof RangeError;
+    const invalidKeyLength = error.message === 'Invalid key length';
+    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
+
+    if (isRange || invalidKeyLength) {
+      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
+      err.code = 'INVALID_DOTENV_KEY';
+      throw err
+    } else if (decryptionFailed) {
+      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
+      err.code = 'DECRYPTION_FAILED';
+      throw err
+    } else {
+      throw error
+    }
+  }
+}
+
+// Populate process.env with parsed values
+function populate (processEnv, parsed, options = {}) {
+  const debug = Boolean(options && options.debug);
+  const override = Boolean(options && options.override);
+
+  if (typeof parsed !== 'object') {
+    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
+    err.code = 'OBJECT_REQUIRED';
+    throw err
+  }
+
+  // Set process.env
+  for (const key of Object.keys(parsed)) {
+    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+      if (override === true) {
+        processEnv[key] = parsed[key];
+      }
+
+      if (debug) {
+        if (override === true) {
+          _debug(`"${key}" is already defined and WAS overwritten`);
+        } else {
+          _debug(`"${key}" is already defined and was NOT overwritten`);
+        }
+      }
+    } else {
+      processEnv[key] = parsed[key];
+    }
+  }
+}
+
+const DotenvModule = {
+  configDotenv,
+  _configVault,
+  _parseVault,
+  config,
+  decrypt,
+  parse: parse$9,
+  populate
+};
+
+main$1.exports.configDotenv = DotenvModule.configDotenv;
+main$1.exports._configVault = DotenvModule._configVault;
+main$1.exports._parseVault = DotenvModule._parseVault;
+main$1.exports.config = DotenvModule.config;
+main$1.exports.decrypt = DotenvModule.decrypt;
+var parse_1$1 = main$1.exports.parse = DotenvModule.parse;
+main$1.exports.populate = DotenvModule.populate;
+
+main$1.exports = DotenvModule;
+
+// * /
+// *   (\\)?            # is it escaped with a backslash?
+// *   (\$)             # literal $
+// *   (?!\()           # shouldnt be followed by parenthesis
+// *   (\{?)            # first brace wrap opening
+// *   ([\w.]+)         # key
+// *   (?::-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))? # optional default nested 3 times
+// *   (\}?)            # last brace warp closing
+// * /xi
+
+const DOTENV_SUBSTITUTION_REGEX = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+
+function _resolveEscapeSequences (value) {
+  return value.replace(/\\\$/g, '$')
+}
+
+function interpolate (value, processEnv, parsed) {
+  return value.replace(DOTENV_SUBSTITUTION_REGEX, (match, escaped, dollarSign, openBrace, key, defaultValue, closeBrace) => {
+    if (escaped === '\\') {
+      return match.slice(1)
+    } else {
+      if (processEnv[key]) {
+        if (processEnv[key] === parsed[key]) {
+          return processEnv[key]
+        } else {
+          // scenario: PASSWORD_EXPAND_NESTED=${PASSWORD_EXPAND}
+          return interpolate(processEnv[key], processEnv, parsed)
+        }
+      }
+
+      if (parsed[key]) {
+        // avoid recursion from EXPAND_SELF=$EXPAND_SELF
+        if (parsed[key] === value) {
+          return parsed[key]
+        } else {
+          return interpolate(parsed[key], processEnv, parsed)
+        }
+      }
+
+      if (defaultValue) {
+        if (defaultValue.startsWith('$')) {
+          return interpolate(defaultValue, processEnv, parsed)
+        } else {
+          return defaultValue
+        }
+      }
+
+      return ''
+    }
+  })
+}
+
+function expand (options) {
+  let processEnv = process.env;
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv;
+  }
+
+  for (const key in options.parsed) {
+    let value = options.parsed[key];
+
+    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key);
+    if (inProcessEnv) {
+      if (processEnv[key] === options.parsed[key]) {
+        // assume was set to processEnv from the .env file if the values match and therefore interpolate
+        value = interpolate(value, processEnv, options.parsed);
+      } else {
+        // do not interpolate - assume processEnv had the intended value even if containing a $.
+        value = processEnv[key];
+      }
+    } else {
+      // not inProcessEnv so assume interpolation for this .env key
+      value = interpolate(value, processEnv, options.parsed);
+    }
+
+    options.parsed[key] = _resolveEscapeSequences(value);
+  }
+
+  for (const processKey in options.parsed) {
+    processEnv[processKey] = options.parsed[processKey];
+  }
+
+  return options
+}
+
+var expand_1 = expand;
+
+function getEnvFilesForMode(mode, envDir) {
+  return [
+    /** default file */
+    `.env`,
+    /** local file */
+    `.env.local`,
+    /** mode file */
+    `.env.${mode}`,
+    /** mode local file */
+    `.env.${mode}.local`
+  ].map((file) => normalizePath$3(path$n.join(envDir, file)));
+}
+function loadEnv(mode, envDir, prefixes = "VITE_") {
+  if (mode === "local") {
+    throw new Error(
+      `"local" cannot be used as a mode name because it conflicts with the .local postfix for .env files.`
+    );
+  }
+  prefixes = arraify(prefixes);
+  const env = {};
+  const envFiles = getEnvFilesForMode(mode, envDir);
+  const parsed = Object.fromEntries(
+    envFiles.flatMap((filePath) => {
+      if (!tryStatSync(filePath)?.isFile()) return [];
+      return Object.entries(parse_1$1(fs__default.readFileSync(filePath)));
+    })
+  );
+  if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === void 0) {
+    process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV;
+  }
+  if (parsed.BROWSER && process.env.BROWSER === void 0) {
+    process.env.BROWSER = parsed.BROWSER;
+  }
+  if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === void 0) {
+    process.env.BROWSER_ARGS = parsed.BROWSER_ARGS;
+  }
+  const processEnv = { ...process.env };
+  expand_1({ parsed, processEnv });
+  for (const [key, value] of Object.entries(parsed)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = value;
+    }
+  }
+  for (const key in process.env) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      env[key] = process.env[key];
+    }
+  }
+  return env;
+}
+function resolveEnvPrefix({
+  envPrefix = "VITE_"
+}) {
+  envPrefix = arraify(envPrefix);
+  if (envPrefix.includes("")) {
+    throw new Error(
+      `envPrefix option contains value '', which could lead unexpected exposure of sensitive information.`
+    );
+  }
+  return envPrefix;
+}
+
+const modulePreloadPolyfillId = "vite/modulepreload-polyfill";
+const resolvedModulePreloadPolyfillId = "\0" + modulePreloadPolyfillId + ".js";
+function modulePreloadPolyfillPlugin(config) {
+  const skip = config.command !== "build" || config.build.ssr;
+  let polyfillString;
+  return {
+    name: "vite:modulepreload-polyfill",
+    resolveId(id) {
+      if (id === modulePreloadPolyfillId) {
+        return resolvedModulePreloadPolyfillId;
+      }
+    },
+    load(id) {
+      if (id === resolvedModulePreloadPolyfillId) {
+        if (skip) {
+          return "";
+        }
+        if (!polyfillString) {
+          polyfillString = `${isModernFlag}&&(${polyfill.toString()}());`;
+        }
+        return { code: polyfillString, moduleSideEffects: true };
+      }
+    }
+  };
+}
+function polyfill() {
+  const relList = document.createElement("link").relList;
+  if (relList && relList.supports && relList.supports("modulepreload")) {
+    return;
+  }
+  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
+    processPreload(link);
+  }
+  new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (mutation.type !== "childList") {
+        continue;
+      }
+      for (const node of mutation.addedNodes) {
+        if (node.tagName === "LINK" && node.rel === "modulepreload")
+          processPreload(node);
+      }
+    }
+  }).observe(document, { childList: true, subtree: true });
+  function getFetchOpts(link) {
+    const fetchOpts = {};
+    if (link.integrity) fetchOpts.integrity = link.integrity;
+    if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
+    if (link.crossOrigin === "use-credentials")
+      fetchOpts.credentials = "include";
+    else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
+    else fetchOpts.credentials = "same-origin";
+    return fetchOpts;
+  }
+  function processPreload(link) {
+    if (link.ep)
+      return;
+    link.ep = true;
+    const fetchOpts = getFetchOpts(link);
+    fetch(link.href, fetchOpts);
+  }
+}
+
+const htmlProxyRE$1 = /\?html-proxy=?(?:&inline-css)?(?:&style-attr)?&index=(\d+)\.(?:js|css)$/;
+const isHtmlProxyRE = /\?html-proxy\b/;
+const inlineCSSRE$1 = /__VITE_INLINE_CSS__([a-z\d]{8}_\d+)__/g;
+const inlineImportRE = /(?<!(?<!\.\.)\.)\bimport\s*\(("(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*')\)/dg;
+const htmlLangRE = /\.(?:html|htm)$/;
+const spaceRe = /[\t\n\f\r ]/;
+const importMapRE = /[ \t]*<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is;
+const moduleScriptRE = /[ \t]*<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i;
+const modulePreloadLinkRE = /[ \t]*<link[^>]*rel\s*=\s*(?:"modulepreload"|'modulepreload'|modulepreload)[\s\S]*?\/>/i;
+const importMapAppendRE = new RegExp(
+  [moduleScriptRE, modulePreloadLinkRE].map((r) => r.source).join("|"),
+  "i"
+);
+const isHTMLProxy = (id) => isHtmlProxyRE.test(id);
+const isHTMLRequest = (request) => htmlLangRE.test(request);
+const htmlProxyMap = /* @__PURE__ */ new WeakMap();
+const htmlProxyResult = /* @__PURE__ */ new Map();
+function htmlInlineProxyPlugin(config) {
+  htmlProxyMap.set(config, /* @__PURE__ */ new Map());
+  return {
+    name: "vite:html-inline-proxy",
+    resolveId(id) {
+      if (isHTMLProxy(id)) {
+        return id;
+      }
+    },
+    load(id) {
+      const proxyMatch = htmlProxyRE$1.exec(id);
+      if (proxyMatch) {
+        const index = Number(proxyMatch[1]);
+        const file = cleanUrl(id);
+        const url = file.replace(normalizePath$3(config.root), "");
+        const result = htmlProxyMap.get(config).get(url)?.[index];
+        if (result) {
+          return result;
+        } else {
+          throw new Error(`No matching HTML proxy module found from ${id}`);
+        }
+      }
+    }
+  };
+}
+function addToHTMLProxyCache(config, filePath, index, result) {
+  if (!htmlProxyMap.get(config)) {
+    htmlProxyMap.set(config, /* @__PURE__ */ new Map());
+  }
+  if (!htmlProxyMap.get(config).get(filePath)) {
+    htmlProxyMap.get(config).set(filePath, []);
+  }
+  htmlProxyMap.get(config).get(filePath)[index] = result;
+}
+function addToHTMLProxyTransformResult(hash, code) {
+  htmlProxyResult.set(hash, code);
+}
+const assetAttrsConfig = {
+  link: ["href"],
+  video: ["src", "poster"],
+  source: ["src", "srcset"],
+  img: ["src", "srcset"],
+  image: ["xlink:href", "href"],
+  use: ["xlink:href", "href"]
+};
+const noInlineLinkRels = /* @__PURE__ */ new Set([
+  "icon",
+  "apple-touch-icon",
+  "apple-touch-startup-image",
+  "manifest"
+]);
+const isAsyncScriptMap = /* @__PURE__ */ new WeakMap();
+function nodeIsElement(node) {
+  return node.nodeName[0] !== "#";
+}
+function traverseNodes(node, visitor) {
+  if (node.nodeName === "template") {
+    node = node.content;
+  }
+  visitor(node);
+  if (nodeIsElement(node) || node.nodeName === "#document" || node.nodeName === "#document-fragment") {
+    node.childNodes.forEach((childNode) => traverseNodes(childNode, visitor));
+  }
+}
+async function traverseHtml(html, filePath, visitor) {
+  const { parse } = await import('./dep-D-7KCb9p.js');
+  const ast = parse(html, {
+    scriptingEnabled: false,
+    // parse inside <noscript>
+    sourceCodeLocationInfo: true,
+    onParseError: (e) => {
+      handleParseError(e, html, filePath);
+    }
+  });
+  traverseNodes(ast, visitor);
+}
+function getScriptInfo(node) {
+  let src;
+  let sourceCodeLocation;
+  let isModule = false;
+  let isAsync = false;
+  for (const p of node.attrs) {
+    if (p.prefix !== void 0) continue;
+    if (p.name === "src") {
+      if (!src) {
+        src = p;
+        sourceCodeLocation = node.sourceCodeLocation?.attrs["src"];
+      }
+    } else if (p.name === "type" && p.value && p.value === "module") {
+      isModule = true;
+    } else if (p.name === "async") {
+      isAsync = true;
+    }
+  }
+  return { src, sourceCodeLocation, isModule, isAsync };
+}
+const attrValueStartRE = /=\s*(.)/;
+function overwriteAttrValue(s, sourceCodeLocation, newValue) {
+  const srcString = s.slice(
+    sourceCodeLocation.startOffset,
+    sourceCodeLocation.endOffset
+  );
+  const valueStart = attrValueStartRE.exec(srcString);
+  if (!valueStart) {
+    throw new Error(
+      `[vite:html] internal error, failed to overwrite attribute value`
+    );
+  }
+  const wrapOffset = valueStart[1] === '"' || valueStart[1] === "'" ? 1 : 0;
+  const valueOffset = valueStart.index + valueStart[0].length - 1;
+  s.update(
+    sourceCodeLocation.startOffset + valueOffset + wrapOffset,
+    sourceCodeLocation.endOffset - wrapOffset,
+    newValue
+  );
+  return s;
+}
+function formatParseError(parserError, id, html) {
+  const formattedError = {
+    code: parserError.code,
+    message: `parse5 error code ${parserError.code}`,
+    frame: generateCodeFrame(
+      html,
+      parserError.startOffset,
+      parserError.endOffset
+    ),
+    loc: {
+      file: id,
+      line: parserError.startLine,
+      column: parserError.startCol
+    }
+  };
+  return formattedError;
+}
+function handleParseError(parserError, html, filePath) {
+  switch (parserError.code) {
+    case "missing-doctype":
+      return;
+    case "abandoned-head-element-child":
+      return;
+    case "duplicate-attribute":
+      return;
+    case "non-void-html-element-start-tag-with-trailing-solidus":
+      return;
+  }
+  const parseError = formatParseError(parserError, filePath, html);
+  throw new Error(
+    `Unable to parse HTML; ${parseError.message}
+ at ${parseError.loc.file}:${parseError.loc.line}:${parseError.loc.column}
+${parseError.frame}`
+  );
+}
+function buildHtmlPlugin(config) {
+  const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(
+    config.plugins,
+    config.logger
+  );
+  preHooks.unshift(injectCspNonceMetaTagHook(config));
+  preHooks.unshift(preImportMapHook(config));
+  preHooks.push(htmlEnvHook(config));
+  postHooks.push(injectNonceAttributeTagHook(config));
+  postHooks.push(postImportMapHook());
+  const processedHtml = /* @__PURE__ */ new Map();
+  const isExcludedUrl = (url) => url[0] === "#" || isExternalUrl(url) || isDataUrl(url);
+  isAsyncScriptMap.set(config, /* @__PURE__ */ new Map());
+  return {
+    name: "vite:build-html",
+    async transform(html, id) {
+      if (id.endsWith(".html")) {
+        id = normalizePath$3(id);
+        const relativeUrlPath = normalizePath$3(path$n.relative(config.root, id));
+        const publicPath = `/${relativeUrlPath}`;
+        const publicBase = getBaseInHTML(relativeUrlPath, config);
+        const publicToRelative = (filename, importer) => publicBase + filename;
+        const toOutputPublicFilePath = (url) => toOutputFilePathInHtml(
+          url.slice(1),
+          "public",
+          relativeUrlPath,
+          "html",
+          config,
+          publicToRelative
+        );
+        const nodeStartWithLeadingWhitespace = (node) => {
+          const startOffset = node.sourceCodeLocation.startOffset;
+          if (startOffset === 0) return 0;
+          const lineStartOffset = startOffset - node.sourceCodeLocation.startCol;
+          let isLineEmpty = false;
+          try {
+            const line = s.slice(Math.max(0, lineStartOffset), startOffset);
+            isLineEmpty = !line.trim();
+          } catch {
+          }
+          return isLineEmpty ? lineStartOffset : startOffset;
+        };
+        html = await applyHtmlTransforms(html, preHooks, {
+          path: publicPath,
+          filename: id
+        });
+        let js = "";
+        const s = new MagicString(html);
+        const scriptUrls = [];
+        const styleUrls = [];
+        let inlineModuleIndex = -1;
+        let everyScriptIsAsync = true;
+        let someScriptsAreAsync = false;
+        let someScriptsAreDefer = false;
+        const assetUrlsPromises = [];
+        const namedOutput = Object.keys(
+          config?.build?.rollupOptions?.input || {}
+        );
+        const processAssetUrl = async (url, shouldInline) => {
+          if (url !== "" && // Empty attribute
+          !namedOutput.includes(url) && // Direct reference to named output
+          !namedOutput.includes(removeLeadingSlash(url))) {
+            try {
+              return await urlToBuiltUrl(url, id, config, this, shouldInline);
+            } catch (e) {
+              if (e.code !== "ENOENT") {
+                throw e;
+              }
+            }
+          }
+          return url;
+        };
+        await traverseHtml(html, id, (node) => {
+          if (!nodeIsElement(node)) {
+            return;
+          }
+          let shouldRemove = false;
+          if (node.nodeName === "script") {
+            const { src, sourceCodeLocation, isModule, isAsync } = getScriptInfo(node);
+            const url = src && src.value;
+            const isPublicFile = !!(url && checkPublicFile(url, config));
+            if (isPublicFile) {
+              overwriteAttrValue(
+                s,
+                sourceCodeLocation,
+                partialEncodeURIPath(toOutputPublicFilePath(url))
+              );
+            }
+            if (isModule) {
+              inlineModuleIndex++;
+              if (url && !isExcludedUrl(url) && !isPublicFile) {
+                js += `
+import ${JSON.stringify(url)}`;
+                shouldRemove = true;
+              } else if (node.childNodes.length) {
+                const scriptNode = node.childNodes.pop();
+                const contents = scriptNode.value;
+                const filePath = id.replace(normalizePath$3(config.root), "");
+                addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
+                  code: contents
+                });
+                js += `
+import "${id}?html-proxy&index=${inlineModuleIndex}.js"`;
+                shouldRemove = true;
+              }
+              everyScriptIsAsync &&= isAsync;
+              someScriptsAreAsync ||= isAsync;
+              someScriptsAreDefer ||= !isAsync;
+            } else if (url && !isPublicFile) {
+              if (!isExcludedUrl(url)) {
+                config.logger.warn(
+                  `<script src="${url}"> in "${publicPath}" can't be bundled without type="module" attribute`
+                );
+              }
+            } else if (node.childNodes.length) {
+              const scriptNode = node.childNodes.pop();
+              scriptUrls.push(
+                ...extractImportExpressionFromClassicScript(scriptNode)
+              );
+            }
+          }
+          const assetAttrs = assetAttrsConfig[node.nodeName];
+          if (assetAttrs) {
+            for (const p of node.attrs) {
+              const attrKey = getAttrKey(p);
+              if (p.value && assetAttrs.includes(attrKey)) {
+                if (attrKey === "srcset") {
+                  assetUrlsPromises.push(
+                    (async () => {
+                      const processedEncodedUrl = await processSrcSet(
+                        p.value,
+                        async ({ url }) => {
+                          const decodedUrl = decodeURI(url);
+                          if (!isExcludedUrl(decodedUrl)) {
+                            const result = await processAssetUrl(url);
+                            return result !== decodedUrl ? encodeURIPath(result) : url;
+                          }
+                          return url;
+                        }
+                      );
+                      if (processedEncodedUrl !== p.value) {
+                        overwriteAttrValue(
+                          s,
+                          getAttrSourceCodeLocation(node, attrKey),
+                          processedEncodedUrl
+                        );
+                      }
+                    })()
+                  );
+                } else {
+                  const url = decodeURI(p.value);
+                  if (checkPublicFile(url, config)) {
+                    overwriteAttrValue(
+                      s,
+                      getAttrSourceCodeLocation(node, attrKey),
+                      partialEncodeURIPath(toOutputPublicFilePath(url))
+                    );
+                  } else if (!isExcludedUrl(url)) {
+                    if (node.nodeName === "link" && isCSSRequest(url) && // should not be converted if following attributes are present (#6748)
+                    !node.attrs.some(
+                      (p2) => p2.prefix === void 0 && (p2.name === "media" || p2.name === "disabled")
+                    )) {
+                      const importExpression = `
+import ${JSON.stringify(url)}`;
+                      styleUrls.push({
+                        url,
+                        start: nodeStartWithLeadingWhitespace(node),
+                        end: node.sourceCodeLocation.endOffset
+                      });
+                      js += importExpression;
+                    } else {
+                      const isNoInlineLink = node.nodeName === "link" && node.attrs.some(
+                        (p2) => p2.name === "rel" && parseRelAttr(p2.value).some(
+                          (v) => noInlineLinkRels.has(v)
+                        )
+                      );
+                      const shouldInline = isNoInlineLink ? false : void 0;
+                      assetUrlsPromises.push(
+                        (async () => {
+                          const processedUrl = await processAssetUrl(
+                            url,
+                            shouldInline
+                          );
+                          if (processedUrl !== url) {
+                            overwriteAttrValue(
+                              s,
+                              getAttrSourceCodeLocation(node, attrKey),
+                              partialEncodeURIPath(processedUrl)
+                            );
+                          }
+                        })()
+                      );
+                    }
+                  }
+                }
+              }
+            }
+          }
+          const inlineStyle = findNeedTransformStyleAttribute(node);
+          if (inlineStyle) {
+            inlineModuleIndex++;
+            const code = inlineStyle.attr.value;
+            const filePath = id.replace(normalizePath$3(config.root), "");
+            addToHTMLProxyCache(config, filePath, inlineModuleIndex, { code });
+            js += `
+import "${id}?html-proxy&inline-css&style-attr&index=${inlineModuleIndex}.css"`;
+            const hash = getHash(cleanUrl(id));
+            overwriteAttrValue(
+              s,
+              inlineStyle.location,
+              `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`
+            );
+          }
+          if (node.nodeName === "style" && node.childNodes.length) {
+            const styleNode = node.childNodes.pop();
+            const filePath = id.replace(normalizePath$3(config.root), "");
+            inlineModuleIndex++;
+            addToHTMLProxyCache(config, filePath, inlineModuleIndex, {
+              code: styleNode.value
+            });
+            js += `
+import "${id}?html-proxy&inline-css&index=${inlineModuleIndex}.css"`;
+            const hash = getHash(cleanUrl(id));
+            s.update(
+              styleNode.sourceCodeLocation.startOffset,
+              styleNode.sourceCodeLocation.endOffset,
+              `__VITE_INLINE_CSS__${hash}_${inlineModuleIndex}__`
+            );
+          }
+          if (shouldRemove) {
+            s.remove(
+              nodeStartWithLeadingWhitespace(node),
+              node.sourceCodeLocation.endOffset
+            );
+          }
+        });
+        isAsyncScriptMap.get(config).set(id, everyScriptIsAsync);
+        if (someScriptsAreAsync && someScriptsAreDefer) {
+          config.logger.warn(
+            `
+Mixed async and defer script modules in ${id}, output script will fallback to defer. Every script, including inline ones, need to be marked as async for your output script to be async.`
+          );
+        }
+        await Promise.all(assetUrlsPromises);
+        for (const { start, end, url } of scriptUrls) {
+          if (checkPublicFile(url, config)) {
+            s.update(
+              start,
+              end,
+              partialEncodeURIPath(toOutputPublicFilePath(url))
+            );
+          } else if (!isExcludedUrl(url)) {
+            s.update(
+              start,
+              end,
+              partialEncodeURIPath(await urlToBuiltUrl(url, id, config, this))
+            );
+          }
+        }
+        const resolvedStyleUrls = await Promise.all(
+          styleUrls.map(async (styleUrl) => ({
+            ...styleUrl,
+            resolved: await this.resolve(styleUrl.url, id)
+          }))
+        );
+        for (const { start, end, url, resolved } of resolvedStyleUrls) {
+          if (resolved == null) {
+            config.logger.warnOnce(
+              `
+${url} doesn't exist at build time, it will remain unchanged to be resolved at runtime`
+            );
+            const importExpression = `
+import ${JSON.stringify(url)}`;
+            js = js.replace(importExpression, "");
+          } else {
+            s.remove(start, end);
+          }
+        }
+        processedHtml.set(id, s.toString());
+        const { modulePreload } = config.build;
+        if (modulePreload !== false && modulePreload.polyfill && (someScriptsAreAsync || someScriptsAreDefer)) {
+          js = `import "${modulePreloadPolyfillId}";
+${js}`;
+        }
+        return { code: js, moduleSideEffects: "no-treeshake" };
+      }
+    },
+    async generateBundle(options, bundle) {
+      const analyzedChunk = /* @__PURE__ */ new Map();
+      const inlineEntryChunk = /* @__PURE__ */ new Set();
+      const getImportedChunks = (chunk, seen = /* @__PURE__ */ new Set()) => {
+        const chunks = [];
+        chunk.imports.forEach((file) => {
+          const importee = bundle[file];
+          if (importee?.type === "chunk" && !seen.has(file)) {
+            seen.add(file);
+            chunks.push(...getImportedChunks(importee, seen));
+            chunks.push(importee);
+          }
+        });
+        return chunks;
+      };
+      const toScriptTag = (chunk, toOutputPath, isAsync) => ({
+        tag: "script",
+        attrs: {
+          ...isAsync ? { async: true } : {},
+          type: "module",
+          // crossorigin must be set not only for serving assets in a different origin
+          // but also to make it possible to preload the script using `<link rel="preload">`.
+          // `<script type="module">` used to fetch the script with credential mode `omit`,
+          // however `crossorigin` attribute cannot specify that value.
+          // https://developer.chrome.com/blog/modulepreload/#ok-so-why-doesnt-link-relpreload-work-for-modules:~:text=For%20%3Cscript%3E,of%20other%20modules.
+          // Now `<script type="module">` uses `same origin`: https://github.com/whatwg/html/pull/3656#:~:text=Module%20scripts%20are%20always%20fetched%20with%20credentials%20mode%20%22same%2Dorigin%22%20by%20default%20and%20can%20no%20longer%0Ause%20%22omit%22
+          crossorigin: true,
+          src: toOutputPath(chunk.fileName)
+        }
+      });
+      const toPreloadTag = (filename, toOutputPath) => ({
+        tag: "link",
+        attrs: {
+          rel: "modulepreload",
+          crossorigin: true,
+          href: toOutputPath(filename)
+        }
+      });
+      const getCssTagsForChunk = (chunk, toOutputPath, seen = /* @__PURE__ */ new Set()) => {
+        const tags = [];
+        if (!analyzedChunk.has(chunk)) {
+          analyzedChunk.set(chunk, 1);
+          chunk.imports.forEach((file) => {
+            const importee = bundle[file];
+            if (importee?.type === "chunk") {
+              tags.push(...getCssTagsForChunk(importee, toOutputPath, seen));
+            }
+          });
+        }
+        chunk.viteMetadata.importedCss.forEach((file) => {
+          if (!seen.has(file)) {
+            seen.add(file);
+            tags.push({
+              tag: "link",
+              attrs: {
+                rel: "stylesheet",
+                crossorigin: true,
+                href: toOutputPath(file)
+              }
+            });
+          }
+        });
+        return tags;
+      };
+      for (const [normalizedId, html] of processedHtml) {
+        const relativeUrlPath = normalizePath$3(
+          path$n.relative(config.root, normalizedId)
+        );
+        const assetsBase = getBaseInHTML(relativeUrlPath, config);
+        const toOutputFilePath = (filename, type) => {
+          if (isExternalUrl(filename)) {
+            return filename;
+          } else {
+            return toOutputFilePathInHtml(
+              filename,
+              type,
+              relativeUrlPath,
+              "html",
+              config,
+              (filename2, importer) => assetsBase + filename2
+            );
+          }
+        };
+        const toOutputAssetFilePath = (filename) => toOutputFilePath(filename, "asset");
+        const toOutputPublicAssetFilePath = (filename) => toOutputFilePath(filename, "public");
+        const isAsync = isAsyncScriptMap.get(config).get(normalizedId);
+        let result = html;
+        const chunk = Object.values(bundle).find(
+          (chunk2) => chunk2.type === "chunk" && chunk2.isEntry && chunk2.facadeModuleId && normalizePath$3(chunk2.facadeModuleId) === normalizedId
+        );
+        let canInlineEntry = false;
+        if (chunk) {
+          if (options.format === "es" && isEntirelyImport(chunk.code)) {
+            canInlineEntry = true;
+          }
+          const imports = getImportedChunks(chunk);
+          let assetTags;
+          if (canInlineEntry) {
+            assetTags = imports.map(
+              (chunk2) => toScriptTag(chunk2, toOutputAssetFilePath, isAsync)
+            );
+          } else {
+            assetTags = [toScriptTag(chunk, toOutputAssetFilePath, isAsync)];
+            const { modulePreload } = config.build;
+            if (modulePreload !== false) {
+              const resolveDependencies = typeof modulePreload === "object" && modulePreload.resolveDependencies;
+              const importsFileNames = imports.map((chunk2) => chunk2.fileName);
+              const resolvedDeps = resolveDependencies ? resolveDependencies(chunk.fileName, importsFileNames, {
+                hostId: relativeUrlPath,
+                hostType: "html"
+              }) : importsFileNames;
+              assetTags.push(
+                ...resolvedDeps.map(
+                  (i) => toPreloadTag(i, toOutputAssetFilePath)
+                )
+              );
+            }
+          }
+          assetTags.push(...getCssTagsForChunk(chunk, toOutputAssetFilePath));
+          result = injectToHead(result, assetTags);
+        }
+        if (!config.build.cssCodeSplit) {
+          const cssChunk = Object.values(bundle).find(
+            (chunk2) => chunk2.type === "asset" && chunk2.name === "style.css"
+          );
+          if (cssChunk) {
+            result = injectToHead(result, [
+              {
+                tag: "link",
+                attrs: {
+                  rel: "stylesheet",
+                  crossorigin: true,
+                  href: toOutputAssetFilePath(cssChunk.fileName)
+                }
+              }
+            ]);
+          }
+        }
+        let match;
+        let s;
+        inlineCSSRE$1.lastIndex = 0;
+        while (match = inlineCSSRE$1.exec(result)) {
+          s ||= new MagicString(result);
+          const { 0: full, 1: scopedName } = match;
+          const cssTransformedCode = htmlProxyResult.get(scopedName);
+          s.update(match.index, match.index + full.length, cssTransformedCode);
+        }
+        if (s) {
+          result = s.toString();
+        }
+        result = await applyHtmlTransforms(
+          result,
+          [...normalHooks, ...postHooks],
+          {
+            path: "/" + relativeUrlPath,
+            filename: normalizedId,
+            bundle,
+            chunk
+          }
+        );
+        result = result.replace(assetUrlRE, (_, fileHash, postfix = "") => {
+          const file = this.getFileName(fileHash);
+          if (chunk) {
+            chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+          }
+          return encodeURIPath(toOutputAssetFilePath(file)) + postfix;
+        });
+        result = result.replace(publicAssetUrlRE, (_, fileHash) => {
+          const publicAssetPath = toOutputPublicAssetFilePath(
+            getPublicAssetFilename(fileHash, config)
+          );
+          return encodeURIPath(
+            urlCanParse(publicAssetPath) ? publicAssetPath : normalizePath$3(publicAssetPath)
+          );
+        });
+        if (chunk && canInlineEntry) {
+          inlineEntryChunk.add(chunk.fileName);
+        }
+        const shortEmitName = normalizePath$3(
+          path$n.relative(config.root, normalizedId)
+        );
+        this.emitFile({
+          type: "asset",
+          originalFileName: normalizedId,
+          fileName: shortEmitName,
+          source: result
+        });
+      }
+      for (const fileName of inlineEntryChunk) {
+        delete bundle[fileName];
+      }
+    }
+  };
+}
+function parseRelAttr(attr) {
+  return attr.split(spaceRe).map((v) => v.toLowerCase());
+}
+function findNeedTransformStyleAttribute(node) {
+  const attr = node.attrs.find(
+    (prop) => prop.prefix === void 0 && prop.name === "style" && // only url(...) or image-set(...) in css need to emit file
+    (prop.value.includes("url(") || prop.value.includes("image-set("))
+  );
+  if (!attr) return void 0;
+  const location = node.sourceCodeLocation?.attrs?.["style"];
+  return { attr, location };
+}
+function extractImportExpressionFromClassicScript(scriptTextNode) {
+  const startOffset = scriptTextNode.sourceCodeLocation.startOffset;
+  const cleanCode = stripLiteral(scriptTextNode.value);
+  const scriptUrls = [];
+  let match;
+  inlineImportRE.lastIndex = 0;
+  while (match = inlineImportRE.exec(cleanCode)) {
+    const [, [urlStart, urlEnd]] = match.indices;
+    const start = urlStart + 1;
+    const end = urlEnd - 1;
+    scriptUrls.push({
+      start: start + startOffset,
+      end: end + startOffset,
+      url: scriptTextNode.value.slice(start, end)
+    });
+  }
+  return scriptUrls;
+}
+function preImportMapHook(config) {
+  return (html, ctx) => {
+    const importMapIndex = html.search(importMapRE);
+    if (importMapIndex < 0) return;
+    const importMapAppendIndex = html.search(importMapAppendRE);
+    if (importMapAppendIndex < 0) return;
+    if (importMapAppendIndex < importMapIndex) {
+      const relativeHtml = normalizePath$3(
+        path$n.relative(config.root, ctx.filename)
+      );
+      config.logger.warnOnce(
+        colors$1.yellow(
+          colors$1.bold(
+            `(!) <script type="importmap"> should come before <script type="module"> and <link rel="modulepreload"> in /${relativeHtml}`
+          )
+        )
+      );
+    }
+  };
+}
+function postImportMapHook() {
+  return (html) => {
+    if (!importMapAppendRE.test(html)) return;
+    let importMap;
+    html = html.replace(importMapRE, (match) => {
+      importMap = match;
+      return "";
+    });
+    if (importMap) {
+      html = html.replace(
+        importMapAppendRE,
+        (match) => `${importMap}
+${match}`
+      );
+    }
+    return html;
+  };
+}
+function injectCspNonceMetaTagHook(config) {
+  return () => {
+    if (!config.html?.cspNonce) return;
+    return [
+      {
+        tag: "meta",
+        injectTo: "head",
+        // use nonce attribute so that it's hidden
+        // https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce#accessing_nonces_and_nonce_hiding
+        attrs: { property: "csp-nonce", nonce: config.html.cspNonce }
+      }
+    ];
+  };
+}
+function htmlEnvHook(config) {
+  const pattern = /%(\S+?)%/g;
+  const envPrefix = resolveEnvPrefix({ envPrefix: config.envPrefix });
+  const env = { ...config.env };
+  for (const key in config.define) {
+    if (key.startsWith(`import.meta.env.`)) {
+      const val = config.define[key];
+      if (typeof val === "string") {
+        try {
+          const parsed = JSON.parse(val);
+          env[key.slice(16)] = typeof parsed === "string" ? parsed : val;
+        } catch {
+          env[key.slice(16)] = val;
+        }
+      } else {
+        env[key.slice(16)] = JSON.stringify(val);
+      }
+    }
+  }
+  return (html, ctx) => {
+    return html.replace(pattern, (text, key) => {
+      if (key in env) {
+        return env[key];
+      } else {
+        if (envPrefix.some((prefix) => key.startsWith(prefix))) {
+          const relativeHtml = normalizePath$3(
+            path$n.relative(config.root, ctx.filename)
+          );
+          config.logger.warn(
+            colors$1.yellow(
+              colors$1.bold(
+                `(!) ${text} is not defined in env variables found in /${relativeHtml}. Is the variable mistyped?`
+              )
+            )
+          );
+        }
+        return text;
+      }
+    });
+  };
+}
+function injectNonceAttributeTagHook(config) {
+  const processRelType = /* @__PURE__ */ new Set(["stylesheet", "modulepreload", "preload"]);
+  return async (html, { filename }) => {
+    const nonce = config.html?.cspNonce;
+    if (!nonce) return;
+    const s = new MagicString(html);
+    await traverseHtml(html, filename, (node) => {
+      if (!nodeIsElement(node)) {
+        return;
+      }
+      const { nodeName, attrs, sourceCodeLocation } = node;
+      if (nodeName === "script" || nodeName === "style" || nodeName === "link" && attrs.some(
+        (attr) => attr.name === "rel" && parseRelAttr(attr.value).some((a) => processRelType.has(a))
+      )) {
+        if (attrs.some(({ name }) => name === "nonce")) {
+          return;
+        }
+        const startTagEndOffset = sourceCodeLocation.startTag.endOffset;
+        const appendOffset = html[startTagEndOffset - 2] === "/" ? 2 : 1;
+        s.appendRight(startTagEndOffset - appendOffset, ` nonce="${nonce}"`);
+      }
+    });
+    return s.toString();
+  };
+}
+function resolveHtmlTransforms(plugins, logger) {
+  const preHooks = [];
+  const normalHooks = [];
+  const postHooks = [];
+  for (const plugin of plugins) {
+    const hook = plugin.transformIndexHtml;
+    if (!hook) continue;
+    if (typeof hook === "function") {
+      normalHooks.push(hook);
+    } else {
+      if (!("order" in hook) && "enforce" in hook) {
+        logger.warnOnce(
+          colors$1.yellow(
+            `plugin '${plugin.name}' uses deprecated 'enforce' option. Use 'order' option instead.`
+          )
+        );
+      }
+      if (!("handler" in hook) && "transform" in hook) {
+        logger.warnOnce(
+          colors$1.yellow(
+            `plugin '${plugin.name}' uses deprecated 'transform' option. Use 'handler' option instead.`
+          )
+        );
+      }
+      const order = hook.order ?? (hook.enforce === "pre" ? "pre" : void 0);
+      const handler = hook.handler ?? hook.transform;
+      if (order === "pre") {
+        preHooks.push(handler);
+      } else if (order === "post") {
+        postHooks.push(handler);
+      } else {
+        normalHooks.push(handler);
+      }
+    }
+  }
+  return [preHooks, normalHooks, postHooks];
+}
+const elementsAllowedInHead = /* @__PURE__ */ new Set([
+  "title",
+  "base",
+  "link",
+  "style",
+  "meta",
+  "script",
+  "noscript",
+  "template"
+]);
+function headTagInsertCheck(tags, ctx) {
+  if (!tags.length) return;
+  const { logger } = ctx.server?.config || {};
+  const disallowedTags = tags.filter(
+    (tagDescriptor) => !elementsAllowedInHead.has(tagDescriptor.tag)
+  );
+  if (disallowedTags.length) {
+    const dedupedTags = unique(
+      disallowedTags.map((tagDescriptor) => `<${tagDescriptor.tag}>`)
+    );
+    logger?.warn(
+      colors$1.yellow(
+        colors$1.bold(
+          `[${dedupedTags.join(",")}] can not be used inside the <head> Element, please check the 'injectTo' value`
+        )
+      )
+    );
+  }
+}
+async function applyHtmlTransforms(html, hooks, ctx) {
+  for (const hook of hooks) {
+    const res = await hook(html, ctx);
+    if (!res) {
+      continue;
+    }
+    if (typeof res === "string") {
+      html = res;
+    } else {
+      let tags;
+      if (Array.isArray(res)) {
+        tags = res;
+      } else {
+        html = res.html || html;
+        tags = res.tags;
+      }
+      let headTags;
+      let headPrependTags;
+      let bodyTags;
+      let bodyPrependTags;
+      for (const tag of tags) {
+        switch (tag.injectTo) {
+          case "body":
+            (bodyTags ??= []).push(tag);
+            break;
+          case "body-prepend":
+            (bodyPrependTags ??= []).push(tag);
+            break;
+          case "head":
+            (headTags ??= []).push(tag);
+            break;
+          default:
+            (headPrependTags ??= []).push(tag);
+        }
+      }
+      headTagInsertCheck([...headTags || [], ...headPrependTags || []], ctx);
+      if (headPrependTags) html = injectToHead(html, headPrependTags, true);
+      if (headTags) html = injectToHead(html, headTags);
+      if (bodyPrependTags) html = injectToBody(html, bodyPrependTags, true);
+      if (bodyTags) html = injectToBody(html, bodyTags);
+    }
+  }
+  return html;
+}
+const importRE = /\bimport\s*(?:"[^"]*[^\\]"|'[^']*[^\\]');*/g;
+const commentRE$1 = /\/\*[\s\S]*?\*\/|\/\/.*$/gm;
+function isEntirelyImport(code) {
+  return !code.replace(importRE, "").replace(commentRE$1, "").trim().length;
+}
+function getBaseInHTML(urlRelativePath, config) {
+  return config.base === "./" || config.base === "" ? path$n.posix.join(
+    path$n.posix.relative(urlRelativePath, "").slice(0, -2),
+    "./"
+  ) : config.base;
+}
+const headInjectRE = /([ \t]*)<\/head>/i;
+const headPrependInjectRE = /([ \t]*)<head[^>]*>/i;
+const htmlInjectRE = /<\/html>/i;
+const htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i;
+const bodyInjectRE = /([ \t]*)<\/body>/i;
+const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i;
+const doctypePrependInjectRE = /<!doctype html>/i;
+function injectToHead(html, tags, prepend = false) {
+  if (tags.length === 0) return html;
+  if (prepend) {
+    if (headPrependInjectRE.test(html)) {
+      return html.replace(
+        headPrependInjectRE,
+        (match, p1) => `${match}
+${serializeTags(tags, incrementIndent(p1))}`
+      );
+    }
+  } else {
+    if (headInjectRE.test(html)) {
+      return html.replace(
+        headInjectRE,
+        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
+      );
+    }
+    if (bodyPrependInjectRE.test(html)) {
+      return html.replace(
+        bodyPrependInjectRE,
+        (match, p1) => `${serializeTags(tags, p1)}
+${match}`
+      );
+    }
+  }
+  return prependInjectFallback(html, tags);
+}
+function injectToBody(html, tags, prepend = false) {
+  if (tags.length === 0) return html;
+  if (prepend) {
+    if (bodyPrependInjectRE.test(html)) {
+      return html.replace(
+        bodyPrependInjectRE,
+        (match, p1) => `${match}
+${serializeTags(tags, incrementIndent(p1))}`
+      );
+    }
+    if (headInjectRE.test(html)) {
+      return html.replace(
+        headInjectRE,
+        (match, p1) => `${match}
+${serializeTags(tags, p1)}`
+      );
+    }
+    return prependInjectFallback(html, tags);
+  } else {
+    if (bodyInjectRE.test(html)) {
+      return html.replace(
+        bodyInjectRE,
+        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
+      );
+    }
+    if (htmlInjectRE.test(html)) {
+      return html.replace(htmlInjectRE, `${serializeTags(tags)}
+$&`);
+    }
+    return html + `
+` + serializeTags(tags);
+  }
+}
+function prependInjectFallback(html, tags) {
+  if (htmlPrependInjectRE.test(html)) {
+    return html.replace(htmlPrependInjectRE, `$&
+${serializeTags(tags)}`);
+  }
+  if (doctypePrependInjectRE.test(html)) {
+    return html.replace(doctypePrependInjectRE, `$&
+${serializeTags(tags)}`);
+  }
+  return serializeTags(tags) + html;
+}
+const unaryTags = /* @__PURE__ */ new Set(["link", "meta", "base"]);
+function serializeTag({ tag, attrs, children }, indent = "") {
+  if (unaryTags.has(tag)) {
+    return `<${tag}${serializeAttrs(attrs)}>`;
+  } else {
+    return `<${tag}${serializeAttrs(attrs)}>${serializeTags(
+      children,
+      incrementIndent(indent)
+    )}</${tag}>`;
+  }
+}
+function serializeTags(tags, indent = "") {
+  if (typeof tags === "string") {
+    return tags;
+  } else if (tags && tags.length) {
+    return tags.map((tag) => `${indent}${serializeTag(tag, indent)}
+`).join("");
+  }
+  return "";
+}
+function serializeAttrs(attrs) {
+  let res = "";
+  for (const key in attrs) {
+    if (typeof attrs[key] === "boolean") {
+      res += attrs[key] ? ` ${key}` : ``;
+    } else {
+      res += ` ${key}=${JSON.stringify(attrs[key])}`;
+    }
+  }
+  return res;
+}
+function incrementIndent(indent = "") {
+  return `${indent}${indent[0] === "	" ? "	" : "  "}`;
+}
+function getAttrKey(attr) {
+  return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`;
+}
+function getAttrSourceCodeLocation(node, attrKey) {
+  return node.sourceCodeLocation.attrs[attrKey];
+}
+
+const decoder = new TextDecoder();
+function resolveCSSOptions(options) {
+  if (options?.transformer === "lightningcss") {
+    return {
+      ...options,
+      lightningcss: {
+        ...options.lightningcss,
+        targets: options.lightningcss?.targets ?? convertTargets(ESBUILD_MODULES_TARGET)
+      }
+    };
+  }
+  return { ...options, lightningcss: void 0 };
+}
+const cssModuleRE = new RegExp(`\\.module${CSS_LANGS_RE.source}`);
+const directRequestRE = /[?&]direct\b/;
+const htmlProxyRE = /[?&]html-proxy\b/;
+const htmlProxyIndexRE = /&index=(\d+)/;
+const commonjsProxyRE = /\?commonjs-proxy/;
+const inlineRE$1 = /[?&]inline\b/;
+const inlineCSSRE = /[?&]inline-css\b/;
+const styleAttrRE = /[?&]style-attr\b/;
+const functionCallRE = /^[A-Z_][\w-]*\(/i;
+const transformOnlyRE = /[?&]transform-only\b/;
+const nonEscapedDoubleQuoteRe = /(?<!\\)"/g;
+const cssBundleName = "style.css";
+const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
+const isModuleCSSRequest = (request) => cssModuleRE.test(request);
+const isDirectCSSRequest = (request) => CSS_LANGS_RE.test(request) && directRequestRE.test(request);
+const isDirectRequest = (request) => directRequestRE.test(request);
+const cssModulesCache = /* @__PURE__ */ new WeakMap();
+const removedPureCssFilesCache = /* @__PURE__ */ new WeakMap();
+const postcssConfigCache = /* @__PURE__ */ new WeakMap();
+function encodePublicUrlsInCSS(config) {
+  return config.command === "build";
+}
+const cssUrlAssetRE = /__VITE_CSS_URL__([\da-f]+)__/g;
+function cssPlugin(config) {
+  const isBuild = config.command === "build";
+  let moduleCache;
+  const resolveUrl = config.createResolver({
+    preferRelative: true,
+    tryIndex: false,
+    extensions: []
+  });
+  let preprocessorWorkerController;
+  if (config.css?.transformer !== "lightningcss") {
+    resolvePostcssConfig(config);
+  }
+  return {
+    name: "vite:css",
+    buildStart() {
+      moduleCache = /* @__PURE__ */ new Map();
+      cssModulesCache.set(config, moduleCache);
+      removedPureCssFilesCache.set(config, /* @__PURE__ */ new Map());
+      preprocessorWorkerController = createPreprocessorWorkerController(
+        normalizeMaxWorkers(config.css.preprocessorMaxWorkers)
+      );
+      preprocessorWorkerControllerCache.set(
+        config,
+        preprocessorWorkerController
+      );
+    },
+    buildEnd() {
+      preprocessorWorkerController?.close();
+    },
+    async load(id) {
+      if (!isCSSRequest(id)) return;
+      if (urlRE.test(id)) {
+        if (isModuleCSSRequest(id)) {
+          throw new Error(
+            `?url is not supported with CSS modules. (tried to import ${JSON.stringify(
+              id
+            )})`
+          );
+        }
+        if (isBuild) {
+          id = injectQuery(removeUrlQuery(id), "transform-only");
+          return `import ${JSON.stringify(id)};export default "__VITE_CSS_URL__${Buffer.from(id).toString(
+            "hex"
+          )}__"`;
+        }
+      }
+    },
+    async transform(raw, id) {
+      if (!isCSSRequest(id) || commonjsProxyRE.test(id) || SPECIAL_QUERY_RE.test(id)) {
+        return;
+      }
+      const urlReplacer = async (url, importer) => {
+        const decodedUrl = decodeURI(url);
+        if (checkPublicFile(decodedUrl, config)) {
+          if (encodePublicUrlsInCSS(config)) {
+            return publicFileToBuiltUrl(decodedUrl, config);
+          } else {
+            return joinUrlSegments(config.base, decodedUrl);
+          }
+        }
+        const [id2, fragment] = decodedUrl.split("#");
+        let resolved = await resolveUrl(id2, importer);
+        if (resolved) {
+          if (fragment) resolved += "#" + fragment;
+          return fileToUrl$1(resolved, config, this);
+        }
+        if (config.command === "build") {
+          const isExternal = config.build.rollupOptions.external ? resolveUserExternal(
+            config.build.rollupOptions.external,
+            decodedUrl,
+            // use URL as id since id could not be resolved
+            id2,
+            false
+          ) : false;
+          if (!isExternal) {
+            config.logger.warnOnce(
+              `
+${decodedUrl} referenced in ${id2} didn't resolve at build time, it will remain unchanged to be resolved at runtime`
+            );
+          }
+        }
+        return url;
+      };
+      const {
+        code: css,
+        modules,
+        deps,
+        map: map2
+      } = await compileCSS(
+        id,
+        raw,
+        config,
+        preprocessorWorkerController,
+        urlReplacer
+      );
+      if (modules) {
+        moduleCache.set(id, modules);
+      }
+      if (deps) {
+        for (const file of deps) {
+          this.addWatchFile(file);
+        }
+      }
+      return {
+        code: css,
+        map: map2
+      };
+    }
+  };
+}
+function cssPostPlugin(config) {
+  const styles = /* @__PURE__ */ new Map();
+  let codeSplitEmitQueue = createSerialPromiseQueue();
+  const urlEmitQueue = createSerialPromiseQueue();
+  let pureCssChunks;
+  let hasEmitted = false;
+  let chunkCSSMap;
+  const rollupOptionsOutput = config.build.rollupOptions.output;
+  const assetFileNames = (Array.isArray(rollupOptionsOutput) ? rollupOptionsOutput[0] : rollupOptionsOutput)?.assetFileNames;
+  const getCssAssetDirname = (cssAssetName) => {
+    const cssAssetNameDir = path$n.dirname(cssAssetName);
+    if (!assetFileNames) {
+      return path$n.join(config.build.assetsDir, cssAssetNameDir);
+    } else if (typeof assetFileNames === "string") {
+      return path$n.join(path$n.dirname(assetFileNames), cssAssetNameDir);
+    } else {
+      return path$n.dirname(
+        assetFileNames({
+          type: "asset",
+          name: cssAssetName,
+          originalFileName: null,
+          source: "/* vite internal call, ignore */"
+        })
+      );
+    }
+  };
+  return {
+    name: "vite:css-post",
+    renderStart() {
+      pureCssChunks = /* @__PURE__ */ new Set();
+      hasEmitted = false;
+      chunkCSSMap = /* @__PURE__ */ new Map();
+      codeSplitEmitQueue = createSerialPromiseQueue();
+    },
+    async transform(css, id, options) {
+      if (!isCSSRequest(id) || commonjsProxyRE.test(id) || SPECIAL_QUERY_RE.test(id)) {
+        return;
+      }
+      css = stripBomTag(css);
+      const inlineCSS = inlineCSSRE.test(id);
+      const isHTMLProxy = htmlProxyRE.test(id);
+      if (inlineCSS && isHTMLProxy) {
+        if (styleAttrRE.test(id)) {
+          css = css.replace(/"/g, "&quot;");
+        }
+        const index = htmlProxyIndexRE.exec(id)?.[1];
+        if (index == null) {
+          throw new Error(`HTML proxy index in "${id}" not found`);
+        }
+        addToHTMLProxyTransformResult(
+          `${getHash(cleanUrl(id))}_${Number.parseInt(index)}`,
+          css
+        );
+        return `export default ''`;
+      }
+      const inlined = inlineRE$1.test(id);
+      const modules = cssModulesCache.get(config).get(id);
+      const modulesCode = modules && !inlined && dataToEsm(modules, { namedExports: true, preferConst: true });
+      if (config.command === "serve") {
+        const getContentWithSourcemap = async (content) => {
+          if (config.css?.devSourcemap) {
+            const sourcemap = this.getCombinedSourcemap();
+            if (sourcemap.mappings) {
+              await injectSourcesContent(sourcemap, cleanUrl(id), config.logger);
+            }
+            return getCodeWithSourcemap("css", content, sourcemap);
+          }
+          return content;
+        };
+        if (isDirectCSSRequest(id)) {
+          return null;
+        }
+        if (options?.ssr) {
+          return modulesCode || `export default ${JSON.stringify(css)}`;
+        }
+        if (inlined) {
+          return `export default ${JSON.stringify(css)}`;
+        }
+        const cssContent = await getContentWithSourcemap(css);
+        const code2 = [
+          `import { updateStyle as __vite__updateStyle, removeStyle as __vite__removeStyle } from ${JSON.stringify(
+            path$n.posix.join(config.base, CLIENT_PUBLIC_PATH)
+          )}`,
+          `const __vite__id = ${JSON.stringify(id)}`,
+          `const __vite__css = ${JSON.stringify(cssContent)}`,
+          `__vite__updateStyle(__vite__id, __vite__css)`,
+          // css modules exports change on edit so it can't self accept
+          `${modulesCode || "import.meta.hot.accept()"}`,
+          `import.meta.hot.prune(() => __vite__removeStyle(__vite__id))`
+        ].join("\n");
+        return { code: code2, map: { mappings: "" } };
+      }
+      if (!inlined) {
+        styles.set(id, css);
+      }
+      let code;
+      if (modulesCode) {
+        code = modulesCode;
+      } else if (inlined) {
+        let content = css;
+        if (config.build.cssMinify) {
+          content = await minifyCSS(content, config, true);
+        }
+        code = `export default ${JSON.stringify(content)}`;
+      } else {
+        code = "";
+      }
+      return {
+        code,
+        map: { mappings: "" },
+        // avoid the css module from being tree-shaken so that we can retrieve
+        // it in renderChunk()
+        moduleSideEffects: modulesCode || inlined ? false : "no-treeshake"
+      };
+    },
+    async renderChunk(code, chunk, opts) {
+      let chunkCSS = "";
+      const isJsChunkEmpty = code === "" && !chunk.isEntry;
+      let isPureCssChunk = true;
+      const ids = Object.keys(chunk.modules);
+      for (const id of ids) {
+        if (styles.has(id)) {
+          if (!transformOnlyRE.test(id)) {
+            chunkCSS += styles.get(id);
+            if (cssModuleRE.test(id)) {
+              isPureCssChunk = false;
+            }
+          }
+        } else if (!isJsChunkEmpty) {
+          isPureCssChunk = false;
+        }
+      }
+      const publicAssetUrlMap = publicAssetUrlCache.get(config);
+      const resolveAssetUrlsInCss = (chunkCSS2, cssAssetName) => {
+        const encodedPublicUrls = encodePublicUrlsInCSS(config);
+        const relative = config.base === "./" || config.base === "";
+        const cssAssetDirname = encodedPublicUrls || relative ? slash$1(getCssAssetDirname(cssAssetName)) : void 0;
+        const toRelative = (filename) => {
+          const relativePath = normalizePath$3(
+            path$n.relative(cssAssetDirname, filename)
+          );
+          return relativePath[0] === "." ? relativePath : "./" + relativePath;
+        };
+        chunkCSS2 = chunkCSS2.replace(assetUrlRE, (_, fileHash, postfix = "") => {
+          const filename = this.getFileName(fileHash) + postfix;
+          chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
+          return encodeURIPath(
+            toOutputFilePathInCss(
+              filename,
+              "asset",
+              cssAssetName,
+              "css",
+              config,
+              toRelative
+            )
+          );
+        });
+        if (encodedPublicUrls) {
+          const relativePathToPublicFromCSS = normalizePath$3(
+            path$n.relative(cssAssetDirname, "")
+          );
+          chunkCSS2 = chunkCSS2.replace(publicAssetUrlRE, (_, hash) => {
+            const publicUrl = publicAssetUrlMap.get(hash).slice(1);
+            return encodeURIPath(
+              toOutputFilePathInCss(
+                publicUrl,
+                "public",
+                cssAssetName,
+                "css",
+                config,
+                () => `${relativePathToPublicFromCSS}/${publicUrl}`
+              )
+            );
+          });
+        }
+        return chunkCSS2;
+      };
+      function ensureFileExt(name, ext) {
+        return normalizePath$3(
+          path$n.format({ ...path$n.parse(name), base: void 0, ext })
+        );
+      }
+      let s;
+      const urlEmitTasks = [];
+      if (code.includes("__VITE_CSS_URL__")) {
+        let match;
+        cssUrlAssetRE.lastIndex = 0;
+        while (match = cssUrlAssetRE.exec(code)) {
+          const [full, idHex] = match;
+          const id = Buffer.from(idHex, "hex").toString();
+          const originalFileName = cleanUrl(id);
+          const cssAssetName = ensureFileExt(
+            path$n.basename(originalFileName),
+            ".css"
+          );
+          if (!styles.has(id)) {
+            throw new Error(
+              `css content for ${JSON.stringify(id)} was not found`
+            );
+          }
+          let cssContent = styles.get(id);
+          cssContent = resolveAssetUrlsInCss(cssContent, cssAssetName);
+          urlEmitTasks.push({
+            cssAssetName,
+            originalFileName,
+            content: cssContent,
+            start: match.index,
+            end: match.index + full.length
+          });
+        }
+      }
+      await urlEmitQueue.run(
+        async () => Promise.all(
+          urlEmitTasks.map(async (info) => {
+            info.content = await finalizeCss(info.content, true, config);
+          })
+        )
+      );
+      if (urlEmitTasks.length > 0) {
+        const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(
+          opts.format,
+          config.isWorker
+        );
+        s ||= new MagicString(code);
+        for (const {
+          cssAssetName,
+          originalFileName,
+          content,
+          start,
+          end
+        } of urlEmitTasks) {
+          const referenceId = this.emitFile({
+            type: "asset",
+            name: cssAssetName,
+            originalFileName,
+            source: content
+          });
+          generatedAssets.get(config).set(referenceId, { originalFileName });
+          const filename = this.getFileName(referenceId);
+          chunk.viteMetadata.importedAssets.add(cleanUrl(filename));
+          const replacement = toOutputFilePathInJS(
+            filename,
+            "asset",
+            chunk.fileName,
+            "js",
+            config,
+            toRelativeRuntime
+          );
+          const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+          s.update(start, end, replacementString);
+        }
+      }
+      if (chunkCSS) {
+        if (isPureCssChunk && (opts.format === "es" || opts.format === "cjs")) {
+          pureCssChunks.add(chunk);
+        }
+        if (config.build.cssCodeSplit) {
+          if (opts.format === "es" || opts.format === "cjs") {
+            const isEntry = chunk.isEntry && isPureCssChunk;
+            const cssFullAssetName = ensureFileExt(chunk.name, ".css");
+            const cssAssetName = chunk.isEntry && (!chunk.facadeModuleId || !isCSSRequest(chunk.facadeModuleId)) ? path$n.basename(cssFullAssetName) : cssFullAssetName;
+            const originalFileName = getChunkOriginalFileName(
+              chunk,
+              config.root,
+              opts.format
+            );
+            chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssAssetName);
+            chunkCSS = await codeSplitEmitQueue.run(async () => {
+              return finalizeCss(chunkCSS, true, config);
+            });
+            const referenceId = this.emitFile({
+              type: "asset",
+              name: cssAssetName,
+              originalFileName,
+              source: chunkCSS
+            });
+            generatedAssets.get(config).set(referenceId, { originalFileName, isEntry });
+            chunk.viteMetadata.importedCss.add(this.getFileName(referenceId));
+          } else if (!config.build.ssr) {
+            chunkCSS = await finalizeCss(chunkCSS, true, config);
+            let cssString = JSON.stringify(chunkCSS);
+            cssString = renderAssetUrlInJS(
+              this,
+              config,
+              chunk,
+              opts,
+              cssString
+            )?.toString() || cssString;
+            const style = `__vite_style__`;
+            const injectCode = `var ${style} = document.createElement('style');${style}.textContent = ${cssString};document.head.appendChild(${style});`;
+            let injectionPoint;
+            const wrapIdx = code.indexOf("System.register");
+            if (wrapIdx >= 0) {
+              const executeFnStart = code.indexOf("execute:", wrapIdx);
+              injectionPoint = code.indexOf("{", executeFnStart) + 1;
+            } else {
+              const insertMark = "'use strict';";
+              injectionPoint = code.indexOf(insertMark) + insertMark.length;
+            }
+            s ||= new MagicString(code);
+            s.appendRight(injectionPoint, injectCode);
+          }
+        } else {
+          chunkCSS = resolveAssetUrlsInCss(chunkCSS, cssBundleName);
+          chunkCSSMap.set(chunk.fileName, chunkCSS);
+        }
+      }
+      if (s) {
+        if (config.build.sourcemap) {
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: "boundary" })
+          };
+        } else {
+          return { code: s.toString() };
+        }
+      }
+      return null;
+    },
+    augmentChunkHash(chunk) {
+      if (chunk.viteMetadata?.importedCss.size) {
+        let hash = "";
+        for (const id of chunk.viteMetadata.importedCss) {
+          hash += id;
+        }
+        return hash;
+      }
+    },
+    async generateBundle(opts, bundle) {
+      if (opts.__vite_skip_asset_emit__) {
+        return;
+      }
+      function extractCss() {
+        let css = "";
+        const collected = /* @__PURE__ */ new Set();
+        const dynamicImports = /* @__PURE__ */ new Set();
+        function collect(chunk) {
+          if (!chunk || chunk.type !== "chunk" || collected.has(chunk)) return;
+          collected.add(chunk);
+          chunk.imports.forEach((importName) => collect(bundle[importName]));
+          chunk.dynamicImports.forEach(
+            (importName) => dynamicImports.add(importName)
+          );
+          css += chunkCSSMap.get(chunk.preliminaryFileName) ?? "";
+        }
+        for (const chunk of Object.values(bundle)) {
+          if (chunk.type === "chunk" && chunk.isEntry) {
+            collect(chunk);
+          }
+        }
+        for (const chunkName of dynamicImports) {
+          collect(bundle[chunkName]);
+        }
+        return css;
+      }
+      let extractedCss = !hasEmitted && extractCss();
+      if (extractedCss) {
+        hasEmitted = true;
+        extractedCss = await finalizeCss(extractedCss, true, config);
+        this.emitFile({
+          name: cssBundleName,
+          type: "asset",
+          source: extractedCss
+        });
+      }
+      if (pureCssChunks.size) {
+        const prelimaryNameToChunkMap = Object.fromEntries(
+          Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.preliminaryFileName, chunk.fileName])
+        );
+        const pureCssChunkNames = [...pureCssChunks].map((pureCssChunk) => prelimaryNameToChunkMap[pureCssChunk.fileName]).filter(Boolean);
+        const replaceEmptyChunk = getEmptyChunkReplacer(
+          pureCssChunkNames,
+          opts.format
+        );
+        for (const file in bundle) {
+          const chunk = bundle[file];
+          if (chunk.type === "chunk") {
+            let chunkImportsPureCssChunk = false;
+            chunk.imports = chunk.imports.filter((file2) => {
+              if (pureCssChunkNames.includes(file2)) {
+                const { importedCss, importedAssets } = bundle[file2].viteMetadata;
+                importedCss.forEach(
+                  (file3) => chunk.viteMetadata.importedCss.add(file3)
+                );
+                importedAssets.forEach(
+                  (file3) => chunk.viteMetadata.importedAssets.add(file3)
+                );
+                chunkImportsPureCssChunk = true;
+                return false;
+              }
+              return true;
+            });
+            if (chunkImportsPureCssChunk) {
+              chunk.code = replaceEmptyChunk(chunk.code);
+            }
+          }
+        }
+        const removedPureCssFiles = removedPureCssFilesCache.get(config);
+        pureCssChunkNames.forEach((fileName) => {
+          removedPureCssFiles.set(fileName, bundle[fileName]);
+          delete bundle[fileName];
+          delete bundle[`${fileName}.map`];
+        });
+      }
+    }
+  };
+}
+function cssAnalysisPlugin(config) {
+  let server;
+  return {
+    name: "vite:css-analysis",
+    configureServer(_server) {
+      server = _server;
+    },
+    async transform(_, id, options) {
+      if (!isCSSRequest(id) || commonjsProxyRE.test(id) || SPECIAL_QUERY_RE.test(id)) {
+        return;
+      }
+      const ssr = options?.ssr === true;
+      const { moduleGraph } = server;
+      const thisModule = moduleGraph.getModuleById(id);
+      if (thisModule) {
+        const isSelfAccepting = !cssModulesCache.get(config)?.get(id) && !inlineRE$1.test(id) && !htmlProxyRE.test(id);
+        const pluginImports = this._addedImports;
+        if (pluginImports) {
+          const depModules = /* @__PURE__ */ new Set();
+          for (const file of pluginImports) {
+            depModules.add(
+              isCSSRequest(file) ? moduleGraph.createFileOnlyEntry(file) : await moduleGraph.ensureEntryFromUrl(
+                fileToDevUrl(
+                  file,
+                  config,
+                  /* skipBase */
+                  true
+                ),
+                ssr
+              )
+            );
+          }
+          moduleGraph.updateModuleInfo(
+            thisModule,
+            depModules,
+            null,
+            // The root CSS proxy module is self-accepting and should not
+            // have an explicit accept list
+            /* @__PURE__ */ new Set(),
+            null,
+            isSelfAccepting,
+            ssr
+          );
+        } else {
+          thisModule.isSelfAccepting = isSelfAccepting;
+        }
+      }
+    }
+  };
+}
+function getEmptyChunkReplacer(pureCssChunkNames, outputFormat) {
+  const emptyChunkFiles = pureCssChunkNames.map((file) => path$n.basename(file)).join("|").replace(/\./g, "\\.");
+  const emptyChunkRE = new RegExp(
+    outputFormat === "es" ? `\\bimport\\s*["'][^"']*(?:${emptyChunkFiles})["'];` : `(\\b|,\\s*)require\\(\\s*["'][^"']*(?:${emptyChunkFiles})["']\\)(;|,)`,
+    "g"
+  );
+  return (code) => code.replace(
+    emptyChunkRE,
+    // remove css import while preserving source map location
+    (m) => outputFormat === "es" ? `/* empty css ${"".padEnd(m.length - 15)}*/` : `${m.at(-1)}/* empty css ${"".padEnd(m.length - 16)}*/`
+  );
+}
+function createCSSResolvers(config) {
+  let cssResolve;
+  let sassResolve;
+  let lessResolve;
+  return {
+    get css() {
+      return cssResolve || (cssResolve = config.createResolver({
+        extensions: [".css"],
+        mainFields: ["style"],
+        conditions: ["style"],
+        tryIndex: false,
+        preferRelative: true
+      }));
+    },
+    get sass() {
+      if (!sassResolve) {
+        const resolver = config.createResolver({
+          extensions: [".scss", ".sass", ".css"],
+          mainFields: ["sass", "style"],
+          conditions: ["sass", "style"],
+          tryIndex: true,
+          tryPrefix: "_",
+          preferRelative: true
+        });
+        sassResolve = async (...args) => {
+          if (args[0].startsWith("file://")) {
+            args[0] = fileURLToPath(args[0]);
+          }
+          return resolver(...args);
+        };
+      }
+      return sassResolve;
+    },
+    get less() {
+      return lessResolve || (lessResolve = config.createResolver({
+        extensions: [".less", ".css"],
+        mainFields: ["less", "style"],
+        conditions: ["less", "style"],
+        tryIndex: false,
+        preferRelative: true
+      }));
+    }
+  };
+}
+function getCssResolversKeys(resolvers) {
+  return Object.keys(resolvers);
+}
+async function compileCSSPreprocessors(id, lang, code, config, workerController) {
+  const { preprocessorOptions, devSourcemap } = config.css ?? {};
+  const atImportResolvers = getAtImportResolvers(config);
+  const preProcessor = workerController[lang];
+  let opts = preprocessorOptions && preprocessorOptions[lang] || {};
+  switch (lang) {
+    case "scss" /* scss */:
+    case "sass" /* sass */:
+      opts = {
+        includePaths: ["node_modules"],
+        alias: config.resolve.alias,
+        ...opts
+      };
+      break;
+    case "less" /* less */:
+    case "styl" /* styl */:
+    case "stylus" /* stylus */:
+      opts = {
+        paths: ["node_modules"],
+        alias: config.resolve.alias,
+        ...opts
+      };
+  }
+  opts.filename = cleanUrl(id);
+  opts.enableSourcemap = devSourcemap ?? false;
+  const preprocessResult = await preProcessor(
+    code,
+    config.root,
+    opts,
+    atImportResolvers
+  );
+  if (preprocessResult.error) {
+    throw preprocessResult.error;
+  }
+  let deps;
+  if (preprocessResult.deps) {
+    const normalizedFilename = normalizePath$3(opts.filename);
+    deps = new Set(
+      [...preprocessResult.deps].filter(
+        (dep) => normalizePath$3(dep) !== normalizedFilename
+      )
+    );
+  }
+  return {
+    code: preprocessResult.code,
+    map: combineSourcemapsIfExists(
+      opts.filename,
+      preprocessResult.map,
+      preprocessResult.additionalMap
+    ),
+    deps
+  };
+}
+const configToAtImportResolvers = /* @__PURE__ */ new WeakMap();
+function getAtImportResolvers(config) {
+  let atImportResolvers = configToAtImportResolvers.get(config);
+  if (!atImportResolvers) {
+    atImportResolvers = createCSSResolvers(config);
+    configToAtImportResolvers.set(config, atImportResolvers);
+  }
+  return atImportResolvers;
+}
+async function compileCSS(id, code, config, workerController, urlReplacer) {
+  if (config.css?.transformer === "lightningcss") {
+    return compileLightningCSS(id, code, config, urlReplacer);
+  }
+  const { modules: modulesOptions, devSourcemap } = config.css || {};
+  const isModule = modulesOptions !== false && cssModuleRE.test(id);
+  const needInlineImport = code.includes("@import");
+  const hasUrl = cssUrlRE.test(code) || cssImageSetRE.test(code);
+  const lang = CSS_LANGS_RE.exec(id)?.[1];
+  const postcssConfig = await resolvePostcssConfig(config);
+  if (lang === "css" && !postcssConfig && !isModule && !needInlineImport && !hasUrl) {
+    return { code, map: null };
+  }
+  let modules;
+  const deps = /* @__PURE__ */ new Set();
+  let preprocessorMap;
+  if (isPreProcessor(lang)) {
+    const preprocessorResult = await compileCSSPreprocessors(
+      id,
+      lang,
+      code,
+      config,
+      workerController
+    );
+    code = preprocessorResult.code;
+    preprocessorMap = preprocessorResult.map;
+    preprocessorResult.deps?.forEach((dep) => deps.add(dep));
+  }
+  const atImportResolvers = getAtImportResolvers(config);
+  const postcssOptions = postcssConfig && postcssConfig.options || {};
+  const postcssPlugins = postcssConfig && postcssConfig.plugins ? postcssConfig.plugins.slice() : [];
+  if (needInlineImport) {
+    postcssPlugins.unshift(
+      (await importPostcssImport()).default({
+        async resolve(id2, basedir) {
+          const publicFile = checkPublicFile(id2, config);
+          if (publicFile) {
+            return publicFile;
+          }
+          const resolved = await atImportResolvers.css(
+            id2,
+            path$n.join(basedir, "*")
+          );
+          if (resolved) {
+            return path$n.resolve(resolved);
+          }
+          if (!path$n.isAbsolute(id2)) {
+            config.logger.error(
+              colors$1.red(
+                `Unable to resolve \`@import "${id2}"\` from ${basedir}`
+              )
+            );
+          }
+          return id2;
+        },
+        async load(id2) {
+          const code2 = await fs__default.promises.readFile(id2, "utf-8");
+          const lang2 = CSS_LANGS_RE.exec(id2)?.[1];
+          if (isPreProcessor(lang2)) {
+            const result = await compileCSSPreprocessors(
+              id2,
+              lang2,
+              code2,
+              config,
+              workerController
+            );
+            result.deps?.forEach((dep) => deps.add(dep));
+            return result.code;
+          }
+          return code2;
+        },
+        nameLayer(index) {
+          return `vite--anon-layer-${getHash(id)}-${index}`;
+        }
+      })
+    );
+  }
+  if (urlReplacer) {
+    postcssPlugins.push(
+      UrlRewritePostcssPlugin({
+        replacer: urlReplacer,
+        logger: config.logger
+      })
+    );
+  }
+  if (isModule) {
+    postcssPlugins.unshift(
+      (await importPostcssModules()).default({
+        ...modulesOptions,
+        localsConvention: modulesOptions?.localsConvention,
+        getJSON(cssFileName, _modules, outputFileName) {
+          modules = _modules;
+          if (modulesOptions && typeof modulesOptions.getJSON === "function") {
+            modulesOptions.getJSON(cssFileName, _modules, outputFileName);
+          }
+        },
+        async resolve(id2, importer) {
+          for (const key of getCssResolversKeys(atImportResolvers)) {
+            const resolved = await atImportResolvers[key](id2, importer);
+            if (resolved) {
+              return path$n.resolve(resolved);
+            }
+          }
+          return id2;
+        }
+      })
+    );
+  }
+  if (!postcssPlugins.length) {
+    return {
+      code,
+      map: preprocessorMap,
+      deps
+    };
+  }
+  let postcssResult;
+  try {
+    const source = removeDirectQuery(id);
+    const postcss = await importPostcss();
+    postcssResult = await postcss.default(postcssPlugins).process(code, {
+      ...postcssOptions,
+      parser: lang === "sss" ? loadSss(config.root) : postcssOptions.parser,
+      to: source,
+      from: source,
+      ...devSourcemap ? {
+        map: {
+          inline: false,
+          annotation: false,
+          // postcss may return virtual files
+          // we cannot obtain content of them, so this needs to be enabled
+          sourcesContent: true
+          // when "prev: preprocessorMap", the result map may include duplicate filename in `postcssResult.map.sources`
+          // prev: preprocessorMap,
+        }
+      } : {}
+    });
+    for (const message of postcssResult.messages) {
+      if (message.type === "dependency") {
+        deps.add(normalizePath$3(message.file));
+      } else if (message.type === "dir-dependency") {
+        const { dir, glob: globPattern = "**" } = message;
+        const pattern = glob.escapePath(normalizePath$3(path$n.resolve(path$n.dirname(id), dir))) + `/` + globPattern;
+        const files = glob.sync(pattern, {
+          ignore: ["**/node_modules/**"]
+        });
+        for (let i = 0; i < files.length; i++) {
+          deps.add(files[i]);
+        }
+      } else if (message.type === "warning") {
+        const warning = message;
+        let msg = `[vite:css] ${warning.text}`;
+        msg += `
+${generateCodeFrame(
+          code,
+          {
+            line: warning.line,
+            column: warning.column - 1
+            // 1-based
+          },
+          warning.endLine !== void 0 && warning.endColumn !== void 0 ? {
+            line: warning.endLine,
+            column: warning.endColumn - 1
+            // 1-based
+          } : void 0
+        )}`;
+        config.logger.warn(colors$1.yellow(msg));
+      }
+    }
+  } catch (e) {
+    e.message = `[postcss] ${e.message}`;
+    e.code = code;
+    e.loc = {
+      file: e.file,
+      line: e.line,
+      column: e.column - 1
+      // 1-based
+    };
+    throw e;
+  }
+  if (!devSourcemap) {
+    return {
+      ast: postcssResult,
+      code: postcssResult.css,
+      map: { mappings: "" },
+      modules,
+      deps
+    };
+  }
+  const rawPostcssMap = postcssResult.map.toJSON();
+  const postcssMap = await formatPostcssSourceMap(
+    // version property of rawPostcssMap is declared as string
+    // but actually it is a number
+    rawPostcssMap,
+    cleanUrl(id)
+  );
+  return {
+    ast: postcssResult,
+    code: postcssResult.css,
+    map: combineSourcemapsIfExists(cleanUrl(id), postcssMap, preprocessorMap),
+    modules,
+    deps
+  };
+}
+function createCachedImport(imp) {
+  let cached;
+  return () => {
+    if (!cached) {
+      cached = imp().then((module) => {
+        cached = module;
+        return module;
+      });
+    }
+    return cached;
+  };
+}
+const importPostcssImport = createCachedImport(() => import('./dep-B7_zXWZq.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-BaJt-LTH.js').then(function (n) { return n.i; }));
+const importPostcss = createCachedImport(() => import('postcss'));
+const preprocessorWorkerControllerCache = /* @__PURE__ */ new WeakMap();
+let alwaysFakeWorkerWorkerControllerCache;
+async function preprocessCSS(code, filename, config) {
+  let workerController = preprocessorWorkerControllerCache.get(config);
+  if (!workerController) {
+    alwaysFakeWorkerWorkerControllerCache ||= createPreprocessorWorkerController(0);
+    workerController = alwaysFakeWorkerWorkerControllerCache;
+  }
+  return await compileCSS(filename, code, config, workerController);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+  const inputFileDir = path$n.dirname(file);
+  const sources = rawMap.sources.map((source) => {
+    const cleanSource = cleanUrl(decodeURIComponent(source));
+    if (cleanSource[0] === "<" && cleanSource[cleanSource.length - 1] === ">") {
+      return `\0${cleanSource}`;
+    }
+    return normalizePath$3(path$n.resolve(inputFileDir, cleanSource));
+  });
+  return {
+    file,
+    mappings: rawMap.mappings,
+    names: rawMap.names,
+    sources,
+    sourcesContent: rawMap.sourcesContent,
+    version: rawMap.version
+  };
+}
+function combineSourcemapsIfExists(filename, map1, map2) {
+  return map1 && map2 ? combineSourcemaps(filename, [
+    // type of version property of ExistingRawSourceMap is number
+    // but it is always 3
+    map1,
+    map2
+  ]) : map1;
+}
+async function finalizeCss(css, minify, config) {
+  if (css.includes("@import") || css.includes("@charset")) {
+    css = await hoistAtRules(css);
+  }
+  if (config.build.cssMinify) {
+    css = await minifyCSS(css, config, false);
+  }
+  return css;
+}
+async function resolvePostcssConfig(config) {
+  let result = postcssConfigCache.get(config);
+  if (result !== void 0) {
+    return await result;
+  }
+  const inlineOptions = config.css?.postcss;
+  if (isObject$1(inlineOptions)) {
+    const options = { ...inlineOptions };
+    delete options.plugins;
+    result = {
+      options,
+      plugins: inlineOptions.plugins || []
+    };
+  } else {
+    const searchPath = typeof inlineOptions === "string" ? inlineOptions : config.root;
+    result = postcssrc({}, searchPath).catch((e) => {
+      if (!e.message.includes("No PostCSS Config found")) {
+        if (e instanceof Error) {
+          const { name, message, stack } = e;
+          e.name = "Failed to load PostCSS config";
+          e.message = `Failed to load PostCSS config (searchPath: ${searchPath}): [${name}] ${message}
+${stack}`;
+          e.stack = "";
+          throw e;
+        } else {
+          throw new Error(`Failed to load PostCSS config: ${e}`);
+        }
+      }
+      return null;
+    });
+    result.then((resolved) => {
+      postcssConfigCache.set(config, resolved);
+    });
+  }
+  postcssConfigCache.set(config, result);
+  return result;
+}
+const cssUrlRE = /(?<=^|[^\w\-\u0080-\uffff])url\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
+const cssDataUriRE = /(?<=^|[^\w\-\u0080-\uffff])data-uri\((\s*('[^']+'|"[^"]+")\s*|[^'")]+)\)/;
+const importCssRE = /@import ('[^']+\.css'|"[^"]+\.css"|[^'")]+\.css)/;
+const cssImageSetRE = /(?<=image-set\()((?:[\w\-]{1,256}\([^)]*\)|[^)])*)(?=\))/;
+const UrlRewritePostcssPlugin = (opts) => {
+  if (!opts) {
+    throw new Error("base or replace is required");
+  }
+  return {
+    postcssPlugin: "vite-url-rewrite",
+    Once(root) {
+      const promises = [];
+      root.walkDecls((declaration) => {
+        const importer = declaration.source?.input.file;
+        if (!importer) {
+          opts.logger.warnOnce(
+            "\nA PostCSS plugin did not pass the `from` option to `postcss.parse`. This may cause imported assets to be incorrectly transformed. If you've recently added a PostCSS plugin that raised this warning, please contact the package author to fix the issue."
+          );
+        }
+        const isCssUrl = cssUrlRE.test(declaration.value);
+        const isCssImageSet = cssImageSetRE.test(declaration.value);
+        if (isCssUrl || isCssImageSet) {
+          const replacerForDeclaration = (rawUrl) => {
+            return opts.replacer(rawUrl, importer);
+          };
+          const rewriterToUse = isCssImageSet ? rewriteCssImageSet : rewriteCssUrls;
+          promises.push(
+            rewriterToUse(declaration.value, replacerForDeclaration).then(
+              (url) => {
+                declaration.value = url;
+              }
+            )
+          );
+        }
+      });
+      if (promises.length) {
+        return Promise.all(promises);
+      }
+    }
+  };
+};
+UrlRewritePostcssPlugin.postcss = true;
+function rewriteCssUrls(css, replacer) {
+  return asyncReplace(css, cssUrlRE, async (match) => {
+    const [matched, rawUrl] = match;
+    return await doUrlReplace(rawUrl.trim(), matched, replacer);
+  });
+}
+function rewriteCssDataUris(css, replacer) {
+  return asyncReplace(css, cssDataUriRE, async (match) => {
+    const [matched, rawUrl] = match;
+    return await doUrlReplace(rawUrl.trim(), matched, replacer, "data-uri");
+  });
+}
+function rewriteImportCss(css, replacer) {
+  return asyncReplace(css, importCssRE, async (match) => {
+    const [matched, rawUrl] = match;
+    return await doImportCSSReplace(rawUrl, matched, replacer);
+  });
+}
+const cssNotProcessedRE = /(?:gradient|element|cross-fade|image)\(/;
+async function rewriteCssImageSet(css, replacer) {
+  return await asyncReplace(css, cssImageSetRE, async (match) => {
+    const [, rawUrl] = match;
+    const url = await processSrcSet(rawUrl, async ({ url: url2 }) => {
+      if (cssUrlRE.test(url2)) {
+        return await rewriteCssUrls(url2, replacer);
+      }
+      if (!cssNotProcessedRE.test(url2)) {
+        return await doUrlReplace(url2, url2, replacer);
+      }
+      return url2;
+    });
+    return url;
+  });
+}
+function skipUrlReplacer(rawUrl) {
+  return isExternalUrl(rawUrl) || isDataUrl(rawUrl) || rawUrl[0] === "#" || functionCallRE.test(rawUrl);
+}
+async function doUrlReplace(rawUrl, matched, replacer, funcName = "url") {
+  let wrap = "";
+  const first = rawUrl[0];
+  if (first === `"` || first === `'`) {
+    wrap = first;
+    rawUrl = rawUrl.slice(1, -1);
+  }
+  if (skipUrlReplacer(rawUrl)) {
+    return matched;
+  }
+  let newUrl = await replacer(rawUrl);
+  if (wrap === "" && newUrl !== encodeURI(newUrl)) {
+    wrap = '"';
+  }
+  if (wrap === "'" && newUrl.includes("'")) {
+    wrap = '"';
+  }
+  if (wrap === '"' && newUrl.includes('"')) {
+    newUrl = newUrl.replace(nonEscapedDoubleQuoteRe, '\\"');
+  }
+  return `${funcName}(${wrap}${newUrl}${wrap})`;
+}
+async function doImportCSSReplace(rawUrl, matched, replacer) {
+  let wrap = "";
+  const first = rawUrl[0];
+  if (first === `"` || first === `'`) {
+    wrap = first;
+    rawUrl = rawUrl.slice(1, -1);
+  }
+  if (isExternalUrl(rawUrl) || isDataUrl(rawUrl) || rawUrl[0] === "#") {
+    return matched;
+  }
+  return `@import ${wrap}${await replacer(rawUrl)}${wrap}`;
+}
+async function minifyCSS(css, config, inlined) {
+  if (config.build.cssMinify === "lightningcss") {
+    const { code, warnings } = (await importLightningCSS()).transform({
+      ...config.css?.lightningcss,
+      targets: convertTargets(config.build.cssTarget),
+      cssModules: void 0,
+      filename: cssBundleName,
+      code: Buffer.from(css),
+      minify: true
+    });
+    if (warnings.length) {
+      config.logger.warn(
+        colors$1.yellow(
+          `warnings when minifying css:
+${warnings.map((w) => w.message).join("\n")}`
+        )
+      );
+    }
+    return decoder.decode(code) + (inlined ? "" : "\n");
+  }
+  try {
+    const { code, warnings } = await transform$1(css, {
+      loader: "css",
+      target: config.build.cssTarget || void 0,
+      ...resolveMinifyCssEsbuildOptions(config.esbuild || {})
+    });
+    if (warnings.length) {
+      const msgs = await formatMessages(warnings, { kind: "warning" });
+      config.logger.warn(
+        colors$1.yellow(`warnings when minifying css:
+${msgs.join("\n")}`)
+      );
+    }
+    return inlined ? code.trimEnd() : code;
+  } catch (e) {
+    if (e.errors) {
+      e.message = "[esbuild css minify] " + e.message;
+      const msgs = await formatMessages(e.errors, { kind: "error" });
+      e.frame = "\n" + msgs.join("\n");
+      e.loc = e.errors[0].location;
+    }
+    throw e;
+  }
+}
+function resolveMinifyCssEsbuildOptions(options) {
+  const base = {
+    charset: options.charset ?? "utf8",
+    logLevel: options.logLevel,
+    logLimit: options.logLimit,
+    logOverride: options.logOverride,
+    legalComments: options.legalComments
+  };
+  if (options.minifyIdentifiers != null || options.minifySyntax != null || options.minifyWhitespace != null) {
+    return {
+      ...base,
+      minifyIdentifiers: options.minifyIdentifiers ?? true,
+      minifySyntax: options.minifySyntax ?? true,
+      minifyWhitespace: options.minifyWhitespace ?? true
+    };
+  } else {
+    return { ...base, minify: true };
+  }
+}
+const atImportRE = /@import(?:\s*(?:url\([^)]*\)|"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+const atCharsetRE = /@charset(?:\s*(?:"(?:[^"]|(?<=\\)")*"|'(?:[^']|(?<=\\)')*').*?|[^;]*);/g;
+async function hoistAtRules(css) {
+  const s = new MagicString(css);
+  const cleanCss = emptyCssComments(css);
+  let match;
+  atImportRE.lastIndex = 0;
+  while (match = atImportRE.exec(cleanCss)) {
+    s.remove(match.index, match.index + match[0].length);
+    s.appendLeft(0, match[0]);
+  }
+  atCharsetRE.lastIndex = 0;
+  let foundCharset = false;
+  while (match = atCharsetRE.exec(cleanCss)) {
+    s.remove(match.index, match.index + match[0].length);
+    if (!foundCharset) {
+      s.prepend(match[0]);
+      foundCharset = true;
+    }
+  }
+  return s.toString();
+}
+const loadedPreprocessorPath = {};
+function loadPreprocessorPath(lang, root) {
+  const cached = loadedPreprocessorPath[lang];
+  if (cached) {
+    return cached;
+  }
+  try {
+    const resolved = requireResolveFromRootWithFallback(root, lang);
+    return loadedPreprocessorPath[lang] = resolved;
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      const installCommand = getPackageManagerCommand("install");
+      throw new Error(
+        `Preprocessor dependency "${lang}" not found. Did you install it? Try \`${installCommand} -D ${lang}\`.`
+      );
+    } else {
+      const message = new Error(
+        `Preprocessor dependency "${lang}" failed to load:
+${e.message}`
+      );
+      message.stack = e.stack + "\n" + message.stack;
+      throw message;
+    }
+  }
+}
+function loadSassPackage(root) {
+  try {
+    const path2 = loadPreprocessorPath("sass-embedded", root);
+    return { name: "sass-embedded", path: path2 };
+  } catch (e1) {
+    try {
+      const path2 = loadPreprocessorPath("sass" /* sass */, root);
+      return { name: "sass", path: path2 };
+    } catch (e2) {
+      throw e1;
+    }
+  }
+}
+let cachedSss;
+function loadSss(root) {
+  if (cachedSss) return cachedSss;
+  const sssPath = loadPreprocessorPath("sugarss" /* sss */, root);
+  cachedSss = createRequire$1(import.meta.url)(sssPath);
+  return cachedSss;
+}
+function cleanScssBugUrl(url) {
+  if (
+    // check bug via `window` and `location` global
+    typeof window !== "undefined" && typeof location !== "undefined" && typeof location?.href === "string"
+  ) {
+    const prefix = location.href.replace(/\/$/, "");
+    return url.replace(prefix, "");
+  } else {
+    return url;
+  }
+}
+function fixScssBugImportValue(data) {
+  if (
+    // check bug via `window` and `location` global
+    typeof window !== "undefined" && typeof location !== "undefined" && data && "file" in data && (!("contents" in data) || data.contents == null)
+  ) {
+    data.contents = fs__default.readFileSync(data.file, "utf-8");
+  }
+  return data;
+}
+const makeScssWorker = (resolvers, alias, maxWorkers, packageName) => {
+  const internalImporter = async (url, importer, filename) => {
+    importer = cleanScssBugUrl(importer);
+    const resolved = await resolvers.sass(url, importer);
+    if (resolved) {
+      try {
+        const data = await rebaseUrls(
+          resolved,
+          filename,
+          alias,
+          "$",
+          resolvers.sass
+        );
+        if (packageName === "sass-embedded") {
+          return data;
+        }
+        return fixScssBugImportValue(data);
+      } catch (data) {
+        return data;
+      }
+    } else {
+      return null;
+    }
+  };
+  const worker = new WorkerWithFallback(
+    () => async (sassPath, data, options) => {
+      const sass = require(sassPath);
+      const path2 = require("node:path");
+      const _internalImporter = (url, importer2, done) => {
+        internalImporter(url, importer2, options.filename).then(
+          (data2) => done?.(data2)
+        );
+      };
+      const importer = [_internalImporter];
+      if (options.importer) {
+        Array.isArray(options.importer) ? importer.unshift(...options.importer) : importer.unshift(options.importer);
+      }
+      const finalOptions = {
+        ...options,
+        data,
+        file: options.filename,
+        outFile: options.filename,
+        importer,
+        ...options.enableSourcemap ? {
+          sourceMap: true,
+          omitSourceMapUrl: true,
+          sourceMapRoot: path2.dirname(options.filename)
+        } : {}
+      };
+      return new Promise((resolve, reject) => {
+        sass.render(finalOptions, (err, res) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({
+              css: res.css.toString(),
+              map: res.map?.toString(),
+              stats: res.stats
+            });
+          }
+        });
+      });
+    },
+    {
+      parentFunctions: { internalImporter },
+      shouldUseFake(_sassPath, _data, options) {
+        return !!(options.functions && Object.keys(options.functions).length > 0 || options.importer && (!Array.isArray(options.importer) || options.importer.length > 0));
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const makeModernScssWorker = (resolvers, alias, maxWorkers) => {
+  const internalCanonicalize = async (url, importer) => {
+    importer = cleanScssBugUrl(importer);
+    const resolved = await resolvers.sass(url, importer);
+    return resolved ?? null;
+  };
+  const internalLoad = async (file, rootFile) => {
+    const result = await rebaseUrls(file, rootFile, alias, "$", resolvers.sass);
+    if (result.contents) {
+      return result.contents;
+    }
+    return await fsp.readFile(result.file, "utf-8");
+  };
+  const worker = new WorkerWithFallback(
+    () => async (sassPath, data, options) => {
+      const sass = require(sassPath);
+      const path2 = require("node:path");
+      const { fileURLToPath: fileURLToPath2, pathToFileURL: pathToFileURL2 } = (
+        // eslint-disable-next-line no-restricted-globals
+        require("node:url")
+      );
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL2(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath2(context.containingUrl) : options.filename;
+          const resolved = await internalCanonicalize(url, importer);
+          return resolved ? pathToFileURL2(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path2.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const contents = await internalLoad(
+            fileURLToPath2(canonicalUrl),
+            options.filename
+          );
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await sass.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath2(url))
+        }
+      };
+    },
+    {
+      parentFunctions: {
+        internalCanonicalize,
+        internalLoad
+      },
+      shouldUseFake(_sassPath, _data, options) {
+        return !!(options.functions && Object.keys(options.functions).length > 0 || options.importers && (!Array.isArray(options.importers) || options.importers.length > 0));
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const makeModernCompilerScssWorker = (resolvers, alias, _maxWorkers) => {
+  let compilerPromise;
+  const worker = {
+    async run(sassPath, data, options) {
+      const sass = (await import(pathToFileURL(sassPath).href)).default;
+      compilerPromise ??= sass.initAsyncCompiler();
+      const compiler = await compilerPromise;
+      const sassOptions = { ...options };
+      sassOptions.url = pathToFileURL(options.filename);
+      sassOptions.sourceMap = options.enableSourcemap;
+      const internalImporter = {
+        async canonicalize(url, context) {
+          const importer = context.containingUrl ? fileURLToPath(context.containingUrl) : options.filename;
+          const resolved = await resolvers.sass(url, cleanScssBugUrl(importer));
+          return resolved ? pathToFileURL(resolved) : null;
+        },
+        async load(canonicalUrl) {
+          const ext = path$n.extname(canonicalUrl.pathname);
+          let syntax = "scss";
+          if (ext === ".sass") {
+            syntax = "indented";
+          } else if (ext === ".css") {
+            syntax = "css";
+          }
+          const result2 = await rebaseUrls(
+            fileURLToPath(canonicalUrl),
+            options.filename,
+            alias,
+            "$",
+            resolvers.sass
+          );
+          const contents = result2.contents ?? await fsp.readFile(result2.file, "utf-8");
+          return { contents, syntax, sourceMapUrl: canonicalUrl };
+        }
+      };
+      sassOptions.importers = [
+        ...sassOptions.importers ?? [],
+        internalImporter
+      ];
+      const result = await compiler.compileStringAsync(data, sassOptions);
+      return {
+        css: result.css,
+        map: result.sourceMap ? JSON.stringify(result.sourceMap) : void 0,
+        stats: {
+          includedFiles: result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url))
+        }
+      };
+    },
+    async stop() {
+      (await compilerPromise)?.dispose();
+      compilerPromise = void 0;
+    }
+  };
+  return worker;
+};
+const scssProcessor = (maxWorkers) => {
+  const workerMap = /* @__PURE__ */ new Map();
+  return {
+    close() {
+      for (const worker of workerMap.values()) {
+        worker.stop();
+      }
+    },
+    async process(source, root, options, resolvers) {
+      const sassPackage = loadSassPackage(root);
+      const api = options.api ?? "legacy";
+      if (!workerMap.has(options.alias)) {
+        workerMap.set(
+          options.alias,
+          api === "modern-compiler" ? makeModernCompilerScssWorker(resolvers, options.alias) : api === "modern" ? makeModernScssWorker(resolvers, options.alias, maxWorkers) : makeScssWorker(
+            resolvers,
+            options.alias,
+            maxWorkers,
+            sassPackage.name
+          )
+        );
+      }
+      const worker = workerMap.get(options.alias);
+      const { content: data, map: additionalMap } = await getSource(
+        source,
+        options.filename,
+        options.additionalData,
+        options.enableSourcemap
+      );
+      const optionsWithoutAdditionalData = {
+        ...options,
+        additionalData: void 0
+      };
+      try {
+        const result = await worker.run(
+          sassPackage.path,
+          data,
+          optionsWithoutAdditionalData
+        );
+        const deps = result.stats.includedFiles.map((f) => cleanScssBugUrl(f));
+        const map2 = result.map ? JSON.parse(result.map.toString()) : void 0;
+        if (map2) {
+          map2.sources = map2.sources.map(
+            (url) => url.startsWith("file://") ? normalizePath$3(fileURLToPath(url)) : url
+          );
+        }
+        return {
+          code: result.css.toString(),
+          map: map2,
+          additionalMap,
+          deps
+        };
+      } catch (e) {
+        e.message = `[sass] ${e.message}`;
+        e.id = e.file;
+        e.frame = e.formatted;
+        return { code: "", error: e, deps: [] };
+      }
+    }
+  };
+};
+async function rebaseUrls(file, rootFile, alias, variablePrefix, resolver) {
+  file = path$n.resolve(file);
+  const fileDir = path$n.dirname(file);
+  const rootDir = path$n.dirname(rootFile);
+  if (fileDir === rootDir) {
+    return { file };
+  }
+  const content = await fsp.readFile(file, "utf-8");
+  const hasUrls = cssUrlRE.test(content);
+  const hasDataUris = cssDataUriRE.test(content);
+  const hasImportCss = importCssRE.test(content);
+  if (!hasUrls && !hasDataUris && !hasImportCss) {
+    return { file };
+  }
+  let rebased;
+  const rebaseFn = async (url) => {
+    if (url[0] === "/") return url;
+    if (url.startsWith(variablePrefix)) return url;
+    for (const { find } of alias) {
+      const matches = typeof find === "string" ? url.startsWith(find) : find.test(url);
+      if (matches) {
+        return url;
+      }
+    }
+    const absolute = await resolver(url, file) || path$n.resolve(fileDir, url);
+    const relative = path$n.relative(rootDir, absolute);
+    return normalizePath$3(relative);
+  };
+  if (hasImportCss) {
+    rebased = await rewriteImportCss(content, rebaseFn);
+  }
+  if (hasUrls) {
+    rebased = await rewriteCssUrls(rebased || content, rebaseFn);
+  }
+  if (hasDataUris) {
+    rebased = await rewriteCssDataUris(rebased || content, rebaseFn);
+  }
+  return {
+    file,
+    contents: rebased
+  };
+}
+const makeLessWorker = (resolvers, alias, maxWorkers) => {
+  const viteLessResolve = async (filename, dir, rootFile) => {
+    const resolved = await resolvers.less(filename, path$n.join(dir, "*"));
+    if (!resolved) return void 0;
+    const result = await rebaseUrls(
+      resolved,
+      rootFile,
+      alias,
+      "@",
+      resolvers.less
+    );
+    if (result) {
+      return {
+        resolved,
+        contents: "contents" in result ? result.contents : void 0
+      };
+    }
+    return result;
+  };
+  const worker = new WorkerWithFallback(
+    () => {
+      const fsp2 = require("node:fs/promises");
+      const path2 = require("node:path");
+      let ViteLessManager;
+      const createViteLessPlugin = (less, rootFile) => {
+        const { FileManager } = less;
+        ViteLessManager ??= class ViteManager extends FileManager {
+          rootFile;
+          constructor(rootFile2) {
+            super();
+            this.rootFile = rootFile2;
+          }
+          supports(filename) {
+            return !/^(?:https?:)?\/\//.test(filename);
+          }
+          supportsSync() {
+            return false;
+          }
+          async loadFile(filename, dir, opts, env) {
+            const result = await viteLessResolve(filename, dir, this.rootFile);
+            if (result) {
+              return {
+                filename: path2.resolve(result.resolved),
+                contents: result.contents ?? await fsp2.readFile(result.resolved, "utf-8")
+              };
+            } else {
+              return super.loadFile(filename, dir, opts, env);
+            }
+          }
+        };
+        return {
+          install(_, pluginManager) {
+            pluginManager.addFileManager(new ViteLessManager(rootFile));
+          },
+          minVersion: [3, 0, 0]
+        };
+      };
+      return async (lessPath, content, options) => {
+        const nodeLess = require(lessPath);
+        const viteResolverPlugin = createViteLessPlugin(
+          nodeLess,
+          options.filename
+        );
+        const result = await nodeLess.render(content, {
+          ...options,
+          plugins: [viteResolverPlugin, ...options.plugins || []],
+          ...options.enableSourcemap ? {
+            sourceMap: {
+              outputSourceFiles: true,
+              sourceMapFileInline: false
+            }
+          } : {}
+        });
+        return result;
+      };
+    },
+    {
+      parentFunctions: { viteLessResolve },
+      shouldUseFake(_lessPath, _content, options) {
+        return options.plugins?.length > 0;
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const lessProcessor = (maxWorkers) => {
+  const workerMap = /* @__PURE__ */ new Map();
+  return {
+    close() {
+      for (const worker of workerMap.values()) {
+        worker.stop();
+      }
+    },
+    async process(source, root, options, resolvers) {
+      const lessPath = loadPreprocessorPath("less" /* less */, root);
+      if (!workerMap.has(options.alias)) {
+        workerMap.set(
+          options.alias,
+          makeLessWorker(resolvers, options.alias, maxWorkers)
+        );
+      }
+      const worker = workerMap.get(options.alias);
+      const { content, map: additionalMap } = await getSource(
+        source,
+        options.filename,
+        options.additionalData,
+        options.enableSourcemap
+      );
+      let result;
+      const optionsWithoutAdditionalData = {
+        ...options,
+        additionalData: void 0
+      };
+      try {
+        result = await worker.run(
+          lessPath,
+          content,
+          optionsWithoutAdditionalData
+        );
+      } catch (e) {
+        const error = e;
+        const normalizedError = new Error(
+          `[less] ${error.message || error.type}`
+        );
+        normalizedError.loc = {
+          file: error.filename || options.filename,
+          line: error.line,
+          column: error.column
+        };
+        return { code: "", error: normalizedError, deps: [] };
+      }
+      const map2 = result.map && JSON.parse(result.map);
+      if (map2) {
+        delete map2.sourcesContent;
+      }
+      return {
+        code: result.css.toString(),
+        map: map2,
+        additionalMap,
+        deps: result.imports
+      };
+    }
+  };
+};
+const makeStylWorker = (maxWorkers) => {
+  const worker = new WorkerWithFallback(
+    () => {
+      return async (stylusPath, content, root, options) => {
+        const nodeStylus = require(stylusPath);
+        const ref = nodeStylus(content, options);
+        if (options.define) {
+          for (const key in options.define) {
+            ref.define(key, options.define[key]);
+          }
+        }
+        if (options.enableSourcemap) {
+          ref.set("sourcemap", {
+            comment: false,
+            inline: false,
+            basePath: root
+          });
+        }
+        return {
+          code: ref.render(),
+          // @ts-expect-error sourcemap exists
+          map: ref.sourcemap,
+          deps: ref.deps()
+        };
+      };
+    },
+    {
+      shouldUseFake(_stylusPath, _content, _root, options) {
+        return !!(options.define && Object.values(options.define).some((d) => typeof d === "function"));
+      },
+      max: maxWorkers
+    }
+  );
+  return worker;
+};
+const stylProcessor = (maxWorkers) => {
+  const workerMap = /* @__PURE__ */ new Map();
+  return {
+    close() {
+      for (const worker of workerMap.values()) {
+        worker.stop();
+      }
+    },
+    async process(source, root, options, resolvers) {
+      const stylusPath = loadPreprocessorPath("stylus" /* stylus */, root);
+      if (!workerMap.has(options.alias)) {
+        workerMap.set(options.alias, makeStylWorker(maxWorkers));
+      }
+      const worker = workerMap.get(options.alias);
+      const { content, map: additionalMap } = await getSource(
+        source,
+        options.filename,
+        options.additionalData,
+        options.enableSourcemap,
+        "\n"
+      );
+      const importsDeps = (options.imports ?? []).map(
+        (dep) => path$n.resolve(dep)
+      );
+      const optionsWithoutAdditionalData = {
+        ...options,
+        additionalData: void 0
+      };
+      try {
+        const { code, map: map2, deps } = await worker.run(
+          stylusPath,
+          content,
+          root,
+          optionsWithoutAdditionalData
+        );
+        return {
+          code,
+          map: formatStylusSourceMap(map2, root),
+          additionalMap,
+          // Concat imports deps with computed deps
+          deps: [...deps, ...importsDeps]
+        };
+      } catch (e) {
+        const wrapped = new Error(`[stylus] ${e.message}`);
+        wrapped.name = e.name;
+        wrapped.stack = e.stack;
+        return { code: "", error: wrapped, deps: [] };
+      }
+    }
+  };
+};
+function formatStylusSourceMap(mapBefore, root) {
+  if (!mapBefore) return void 0;
+  const map2 = { ...mapBefore };
+  const resolveFromRoot = (p) => normalizePath$3(path$n.resolve(root, p));
+  if (map2.file) {
+    map2.file = resolveFromRoot(map2.file);
+  }
+  map2.sources = map2.sources.map(resolveFromRoot);
+  return map2;
+}
+async function getSource(source, filename, additionalData, enableSourcemap, sep = "") {
+  if (!additionalData) return { content: source };
+  if (typeof additionalData === "function") {
+    const newContent = await additionalData(source, filename);
+    if (typeof newContent === "string") {
+      return { content: newContent };
+    }
+    return newContent;
+  }
+  if (!enableSourcemap) {
+    return { content: additionalData + sep + source };
+  }
+  const ms = new MagicString(source);
+  ms.appendLeft(0, sep);
+  ms.appendLeft(0, additionalData);
+  const map2 = ms.generateMap({ hires: "boundary" });
+  map2.file = filename;
+  map2.sources = [filename];
+  return {
+    content: ms.toString(),
+    map: map2
+  };
+}
+const createPreprocessorWorkerController = (maxWorkers) => {
+  const scss = scssProcessor(maxWorkers);
+  const less = lessProcessor(maxWorkers);
+  const styl = stylProcessor(maxWorkers);
+  const sassProcess = (source, root, options, resolvers) => {
+    return scss.process(
+      source,
+      root,
+      { ...options, indentedSyntax: true, syntax: "indented" },
+      resolvers
+    );
+  };
+  const close = () => {
+    less.close();
+    scss.close();
+    styl.close();
+  };
+  return {
+    ["less" /* less */]: less.process,
+    ["scss" /* scss */]: scss.process,
+    ["sass" /* sass */]: sassProcess,
+    ["styl" /* styl */]: styl.process,
+    ["stylus" /* stylus */]: styl.process,
+    close
+  };
+};
+const normalizeMaxWorkers = (maxWorker) => {
+  if (maxWorker === void 0) return 0;
+  if (maxWorker === true) return void 0;
+  return maxWorker;
+};
+const preprocessorSet = /* @__PURE__ */ new Set([
+  "less" /* less */,
+  "sass" /* sass */,
+  "scss" /* scss */,
+  "styl" /* styl */,
+  "stylus" /* stylus */
+]);
+function isPreProcessor(lang) {
+  return lang && preprocessorSet.has(lang);
+}
+const importLightningCSS = createCachedImport(() => import('lightningcss'));
+async function compileLightningCSS(id, src, config, urlReplacer) {
+  const deps = /* @__PURE__ */ new Set();
+  const filename = cleanUrl(path$n.relative(config.root, id));
+  const toAbsolute = (filePath) => path$n.isAbsolute(filePath) ? filePath : path$n.join(config.root, filePath);
+  const res = styleAttrRE.test(id) ? (await importLightningCSS()).transformStyleAttribute({
+    filename,
+    code: Buffer.from(src),
+    targets: config.css?.lightningcss?.targets,
+    minify: config.isProduction && !!config.build.cssMinify,
+    analyzeDependencies: true
+  }) : await (await importLightningCSS()).bundleAsync({
+    ...config.css?.lightningcss,
+    filename,
+    resolver: {
+      read(filePath) {
+        if (filePath === filename) {
+          return src;
+        }
+        if (!filePath.endsWith(".css")) {
+          return src;
+        }
+        return fs__default.readFileSync(toAbsolute(filePath), "utf-8");
+      },
+      async resolve(id2, from) {
+        const publicFile = checkPublicFile(id2, config);
+        if (publicFile) {
+          return publicFile;
+        }
+        const resolved = await getAtImportResolvers(config).css(
+          id2,
+          toAbsolute(from)
+        );
+        if (resolved) {
+          deps.add(resolved);
+          return resolved;
+        }
+        return id2;
+      }
+    },
+    minify: config.isProduction && !!config.build.cssMinify,
+    sourceMap: config.command === "build" ? !!config.build.sourcemap : config.css?.devSourcemap,
+    analyzeDependencies: true,
+    cssModules: cssModuleRE.test(id) ? config.css?.lightningcss?.cssModules ?? true : void 0
+  });
+  let css = decoder.decode(res.code);
+  for (const dep of res.dependencies) {
+    switch (dep.type) {
+      case "url":
+        if (skipUrlReplacer(dep.url)) {
+          css = css.replace(dep.placeholder, () => dep.url);
+          break;
+        }
+        deps.add(dep.url);
+        if (urlReplacer) {
+          const replaceUrl = await urlReplacer(dep.url, dep.loc.filePath);
+          css = css.replace(dep.placeholder, () => replaceUrl);
+        } else {
+          css = css.replace(dep.placeholder, () => dep.url);
+        }
+        break;
+      default:
+        throw new Error(`Unsupported dependency type: ${dep.type}`);
+    }
+  }
+  let modules;
+  if ("exports" in res && res.exports) {
+    modules = {};
+    const sortedEntries = Object.entries(res.exports).sort(
+      (a, b) => a[0].localeCompare(b[0])
+    );
+    for (const [key, value] of sortedEntries) {
+      modules[key] = value.name;
+      for (const c of value.composes) {
+        modules[key] += " " + c.name;
+      }
+    }
+  }
+  return {
+    code: css,
+    map: "map" in res ? res.map?.toString() : void 0,
+    deps,
+    modules
+  };
+}
+const map = {
+  chrome: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  hermes: false,
+  ie: "ie",
+  ios: "ios_saf",
+  node: false,
+  opera: "opera",
+  rhino: false,
+  safari: "safari"
+};
+const esMap = {
+  // https://caniuse.com/?search=es2015
+  2015: ["chrome49", "edge13", "safari10", "firefox44", "opera36"],
+  // https://caniuse.com/?search=es2016
+  2016: ["chrome50", "edge13", "safari10", "firefox43", "opera37"],
+  // https://caniuse.com/?search=es2017
+  2017: ["chrome58", "edge15", "safari11", "firefox52", "opera45"],
+  // https://caniuse.com/?search=es2018
+  2018: ["chrome63", "edge79", "safari12", "firefox58", "opera50"],
+  // https://caniuse.com/?search=es2019
+  2019: ["chrome73", "edge79", "safari12.1", "firefox64", "opera60"],
+  // https://caniuse.com/?search=es2020
+  2020: ["chrome80", "edge80", "safari14.1", "firefox80", "opera67"],
+  // https://caniuse.com/?search=es2021
+  2021: ["chrome85", "edge85", "safari14.1", "firefox80", "opera71"],
+  // https://caniuse.com/?search=es2022
+  2022: ["chrome94", "edge94", "safari16.4", "firefox93", "opera80"]
+};
+const esRE = /es(\d{4})/;
+const versionRE = /\d/;
+const convertTargetsCache = /* @__PURE__ */ new Map();
+const convertTargets = (esbuildTarget) => {
+  if (!esbuildTarget) return {};
+  const cached = convertTargetsCache.get(esbuildTarget);
+  if (cached) return cached;
+  const targets = {};
+  const entriesWithoutES = arraify(esbuildTarget).flatMap((e) => {
+    const match = esRE.exec(e);
+    if (!match) return e;
+    const year = Number(match[1]);
+    if (!esMap[year]) throw new Error(`Unsupported target "${e}"`);
+    return esMap[year];
+  });
+  for (const entry of entriesWithoutES) {
+    if (entry === "esnext") continue;
+    const index = entry.search(versionRE);
+    if (index >= 0) {
+      const browser = map[entry.slice(0, index)];
+      if (browser === false) continue;
+      if (browser) {
+        const [major, minor = 0] = entry.slice(index).split(".").map((v) => parseInt(v, 10));
+        if (!isNaN(major) && !isNaN(minor)) {
+          const version = major << 16 | minor << 8;
+          if (!targets[browser] || version < targets[browser]) {
+            targets[browser] = version;
+          }
+          continue;
+        }
+      }
+    }
+    throw new Error(`Unsupported target "${entry}"`);
+  }
+  convertTargetsCache.set(esbuildTarget, targets);
+  return targets;
+};
+
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_SPACE_RE = /%20/gi;
+function encode(text) {
+  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeQueryValue(input) {
+  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
+}
+function encodeQueryKey(text) {
+  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function encodeQueryItem(key, value) {
+  if (typeof value === "number" || typeof value === "boolean") {
+    value = String(value);
+  }
+  if (!value) {
+    return encodeQueryKey(key);
+  }
+  if (Array.isArray(value)) {
+    return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+  }
+  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+
+new Set(builtinModules);
+function clearImports(imports) {
+  return (imports || "").replace(/(\/\/[^\n]*\n|\/\*.*\*\/)/g, "").replace(/\s+/g, " ");
+}
+function getImportNames(cleanedImports) {
+  const topLevelImports = cleanedImports.replace(/{([^}]*)}/, "");
+  const namespacedImport = topLevelImports.match(/\* as \s*(\S*)/)?.[1];
+  const defaultImport = topLevelImports.split(",").find((index) => !/[*{}]/.test(index))?.trim() || void 0;
+  return {
+    namespacedImport,
+    defaultImport
+  };
+}
+
+/**
+ * @typedef ErrnoExceptionFields
+ * @property {number | undefined} [errnode]
+ * @property {string | undefined} [code]
+ * @property {string | undefined} [path]
+ * @property {string | undefined} [syscall]
+ * @property {string | undefined} [url]
+ *
+ * @typedef {Error & ErrnoExceptionFields} ErrnoException
+ */
+
+
+const own$1 = {}.hasOwnProperty;
+
+const classRegExp = /^([A-Z][a-z\d]*)+$/;
+// Sorted by a rough estimate on most frequently used entries.
+const kTypes = new Set([
+  'string',
+  'function',
+  'number',
+  'object',
+  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+  'Function',
+  'Object',
+  'boolean',
+  'bigint',
+  'symbol'
+]);
+
+/**
+ * Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
+ * We cannot use Intl.ListFormat because it's not available in
+ * --without-intl builds.
+ *
+ * @param {Array<string>} array
+ *   An array of strings.
+ * @param {string} [type]
+ *   The list type to be inserted before the last element.
+ * @returns {string}
+ */
+function formatList(array, type = 'and') {
+  return array.length < 3
+    ? array.join(` ${type} `)
+    : `${array.slice(0, -1).join(', ')}, ${type} ${array[array.length - 1]}`
+}
+
+/** @type {Map<string, MessageFunction | string>} */
+const messages = new Map();
+const nodeInternalPrefix = '__node_internal_';
+/** @type {number} */
+let userStackTraceLimit;
+
+createError(
+  'ERR_INVALID_ARG_TYPE',
+  /**
+   * @param {string} name
+   * @param {Array<string> | string} expected
+   * @param {unknown} actual
+   */
+  (name, expected, actual) => {
+    assert$1(typeof name === 'string', "'name' must be a string");
+    if (!Array.isArray(expected)) {
+      expected = [expected];
+    }
+
+    let message = 'The ';
+    if (name.endsWith(' argument')) {
+      // For cases like 'first argument'
+      message += `${name} `;
+    } else {
+      const type = name.includes('.') ? 'property' : 'argument';
+      message += `"${name}" ${type} `;
+    }
+
+    message += 'must be ';
+
+    /** @type {Array<string>} */
+    const types = [];
+    /** @type {Array<string>} */
+    const instances = [];
+    /** @type {Array<string>} */
+    const other = [];
+
+    for (const value of expected) {
+      assert$1(
+        typeof value === 'string',
+        'All expected entries have to be of type string'
+      );
+
+      if (kTypes.has(value)) {
+        types.push(value.toLowerCase());
+      } else if (classRegExp.exec(value) === null) {
+        assert$1(
+          value !== 'object',
+          'The value "object" should be written as "Object"'
+        );
+        other.push(value);
+      } else {
+        instances.push(value);
+      }
+    }
+
+    // Special handle `object` in case other instances are allowed to outline
+    // the differences between each other.
+    if (instances.length > 0) {
+      const pos = types.indexOf('object');
+      if (pos !== -1) {
+        types.slice(pos, 1);
+        instances.push('Object');
+      }
+    }
+
+    if (types.length > 0) {
+      message += `${types.length > 1 ? 'one of type' : 'of type'} ${formatList(
+        types,
+        'or'
+      )}`;
+      if (instances.length > 0 || other.length > 0) message += ' or ';
+    }
+
+    if (instances.length > 0) {
+      message += `an instance of ${formatList(instances, 'or')}`;
+      if (other.length > 0) message += ' or ';
+    }
+
+    if (other.length > 0) {
+      if (other.length > 1) {
+        message += `one of ${formatList(other, 'or')}`;
+      } else {
+        if (other[0].toLowerCase() !== other[0]) message += 'an ';
+        message += `${other[0]}`;
+      }
+    }
+
+    message += `. Received ${determineSpecificType(actual)}`;
+
+    return message
+  },
+  TypeError
+);
+
+createError(
+  'ERR_INVALID_MODULE_SPECIFIER',
+  /**
+   * @param {string} request
+   * @param {string} reason
+   * @param {string} [base]
+   */
+  (request, reason, base = undefined) => {
+    return `Invalid module "${request}" ${reason}${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_INVALID_PACKAGE_CONFIG',
+  /**
+   * @param {string} path
+   * @param {string} [base]
+   * @param {string} [message]
+   */
+  (path, base, message) => {
+    return `Invalid package config ${path}${
+      base ? ` while importing ${base}` : ''
+    }${message ? `. ${message}` : ''}`
+  },
+  Error
+);
+
+createError(
+  'ERR_INVALID_PACKAGE_TARGET',
+  /**
+   * @param {string} packagePath
+   * @param {string} key
+   * @param {unknown} target
+   * @param {boolean} [isImport=false]
+   * @param {string} [base]
+   */
+  (packagePath, key, target, isImport = false, base = undefined) => {
+    const relatedError =
+      typeof target === 'string' &&
+      !isImport &&
+      target.length > 0 &&
+      !target.startsWith('./');
+    if (key === '.') {
+      assert$1(isImport === false);
+      return (
+        `Invalid "exports" main target ${JSON.stringify(target)} defined ` +
+        `in the package config ${packagePath}package.json${
+          base ? ` imported from ${base}` : ''
+        }${relatedError ? '; targets must start with "./"' : ''}`
+      )
+    }
+
+    return `Invalid "${
+      isImport ? 'imports' : 'exports'
+    }" target ${JSON.stringify(
+      target
+    )} defined for '${key}' in the package config ${packagePath}package.json${
+      base ? ` imported from ${base}` : ''
+    }${relatedError ? '; targets must start with "./"' : ''}`
+  },
+  Error
+);
+
+createError(
+  'ERR_MODULE_NOT_FOUND',
+  /**
+   * @param {string} path
+   * @param {string} base
+   * @param {boolean} [exactUrl]
+   */
+  (path, base, exactUrl = false) => {
+    return `Cannot find ${
+      exactUrl ? 'module' : 'package'
+    } '${path}' imported from ${base}`
+  },
+  Error
+);
+
+createError(
+  'ERR_NETWORK_IMPORT_DISALLOWED',
+  "import of '%s' by %s is not supported: %s",
+  Error
+);
+
+createError(
+  'ERR_PACKAGE_IMPORT_NOT_DEFINED',
+  /**
+   * @param {string} specifier
+   * @param {string} packagePath
+   * @param {string} base
+   */
+  (specifier, packagePath, base) => {
+    return `Package import specifier "${specifier}" is not defined${
+      packagePath ? ` in package ${packagePath}package.json` : ''
+    } imported from ${base}`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_PACKAGE_PATH_NOT_EXPORTED',
+  /**
+   * @param {string} packagePath
+   * @param {string} subpath
+   * @param {string} [base]
+   */
+  (packagePath, subpath, base = undefined) => {
+    if (subpath === '.')
+      return `No "exports" main defined in ${packagePath}package.json${
+        base ? ` imported from ${base}` : ''
+      }`
+    return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${
+      base ? ` imported from ${base}` : ''
+    }`
+  },
+  Error
+);
+
+createError(
+  'ERR_UNSUPPORTED_DIR_IMPORT',
+  "Directory import '%s' is not supported " +
+    'resolving ES modules imported from %s',
+  Error
+);
+
+createError(
+  'ERR_UNSUPPORTED_RESOLVE_REQUEST',
+  'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
+  TypeError
+);
+
+createError(
+  'ERR_UNKNOWN_FILE_EXTENSION',
+  /**
+   * @param {string} extension
+   * @param {string} path
+   */
+  (extension, path) => {
+    return `Unknown file extension "${extension}" for ${path}`
+  },
+  TypeError
+);
+
+createError(
+  'ERR_INVALID_ARG_VALUE',
+  /**
+   * @param {string} name
+   * @param {unknown} value
+   * @param {string} [reason='is invalid']
+   */
+  (name, value, reason = 'is invalid') => {
+    let inspected = inspect(value);
+
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+
+    const type = name.includes('.') ? 'property' : 'argument';
+
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`
+  },
+  TypeError
+  // Note: extra classes have been shaken out.
+  // , RangeError
+);
+
+/**
+ * Utility function for registering the error codes. Only used here. Exported
+ * *only* to allow for testing.
+ * @param {string} sym
+ * @param {MessageFunction | string} value
+ * @param {ErrorConstructor} constructor
+ * @returns {new (...parameters: Array<any>) => Error}
+ */
+function createError(sym, value, constructor) {
+  // Special case for SystemError that formats the error message differently
+  // The SystemErrors only have SystemError as their base classes.
+  messages.set(sym, value);
+
+  return makeNodeErrorWithCode(constructor, sym)
+}
+
+/**
+ * @param {ErrorConstructor} Base
+ * @param {string} key
+ * @returns {ErrorConstructor}
+ */
+function makeNodeErrorWithCode(Base, key) {
+  // @ts-expect-error It’s a Node error.
+  return NodeError
+  /**
+   * @param {Array<unknown>} parameters
+   */
+  function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    // Reset the limit and setting the name property.
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+
+    captureLargerStackTrace(error);
+    // @ts-expect-error It’s a Node error.
+    error.code = key;
+    return error
+  }
+}
+
+/**
+ * @returns {boolean}
+ */
+function isErrorStackTraceLimitWritable() {
+  // Do no touch Error.stackTraceLimit as V8 would attempt to install
+  // it again during deserialization.
+  try {
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false
+    }
+  } catch {}
+
+  const desc = Object.getOwnPropertyDescriptor(Error, 'stackTraceLimit');
+  if (desc === undefined) {
+    return Object.isExtensible(Error)
+  }
+
+  return own$1.call(desc, 'writable') && desc.writable !== undefined
+    ? desc.writable
+    : desc.set !== undefined
+}
+
+/**
+ * This function removes unnecessary frames from Node.js core errors.
+ * @template {(...parameters: unknown[]) => unknown} T
+ * @param {T} wrappedFunction
+ * @returns {T}
+ */
+function hideStackFrames(wrappedFunction) {
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, 'name', {value: hidden});
+  return wrappedFunction
+}
+
+const captureLargerStackTrace = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @returns {Error}
+   */
+  // @ts-expect-error: fine
+  function (error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+
+    Error.captureStackTrace(error);
+
+    // Reset the limit
+    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+
+    return error
+  }
+);
+
+/**
+ * @param {string} key
+ * @param {Array<unknown>} parameters
+ * @param {Error} self
+ * @returns {string}
+ */
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert$1(message !== undefined, 'expected `message` to be found');
+
+  if (typeof message === 'function') {
+    assert$1(
+      message.length <= parameters.length, // Default options do not count.
+      `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
+        `match the required ones (${message.length}).`
+    );
+    return Reflect.apply(message, self, parameters)
+  }
+
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert$1(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not ` +
+      `match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message
+
+  parameters.unshift(message);
+  return Reflect.apply(format$2, null, parameters)
+}
+
+/**
+ * Determine the specific type of a value for type-mismatch errors.
+ * @param {unknown} value
+ * @returns {string}
+ */
+function determineSpecificType(value) {
+  if (value === null || value === undefined) {
+    return String(value)
+  }
+
+  if (typeof value === 'function' && value.name) {
+    return `function ${value.name}`
+  }
+
+  if (typeof value === 'object') {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`
+    }
+
+    return `${inspect(value, {depth: -1})}`
+  }
+
+  let inspected = inspect(value, {colors: false});
+
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+
+  return `type ${typeof value} (${inspected})`
+}
+
+const ESM_STATIC_IMPORT_RE = /(?<=\s|^|;|\})import\s*([\s"']*(?<imports>[\p{L}\p{M}\w\t\n\r $*,/{}@.]+)from\s*)?["']\s*(?<specifier>(?<="\s*)[^"]*[^\s"](?=\s*")|(?<='\s*)[^']*[^\s'](?=\s*'))\s*["'][\s;]*/gmu;
+const TYPE_RE = /^\s*?type\s/;
+function parseStaticImport(matched) {
+  const cleanedImports = clearImports(matched.imports);
+  const namedImports = {};
+  const _matches = cleanedImports.match(/{([^}]*)}/)?.[1]?.split(",") || [];
+  for (const namedImport of _matches) {
+    const _match = namedImport.match(/^\s*(\S*) as (\S*)\s*$/);
+    const source = _match?.[1] || namedImport.trim();
+    const importName = _match?.[2] || source;
+    if (source && !TYPE_RE.test(source)) {
+      namedImports[source] = importName;
+    }
+  }
+  const { namespacedImport, defaultImport } = getImportNames(cleanedImports);
+  return {
+    ...matched,
+    defaultImport,
+    namespacedImport,
+    namedImports
+  };
+}
+
+const ESM_RE = /([\s;]|^)(import[\s\w*,{}]*from|import\s*["'*{]|export\b\s*(?:[*{]|default|class|type|function|const|var|let|async function)|import\.meta\b)/m;
+const COMMENT_RE = /\/\*.+?\*\/|\/\/.*(?=[nr])/g;
+function hasESMSyntax(code, opts = {}) {
+  if (opts.stripComments) {
+    code = code.replace(COMMENT_RE, "");
+  }
+  return ESM_RE.test(code);
+}
+
+const { isMatch: isMatch$1, scan } = micromatch$2;
+function getAffectedGlobModules(file, server) {
+  const modules = [];
+  for (const [id, allGlobs] of server._importGlobMap) {
+    if (allGlobs.some(
+      ({ affirmed, negated }) => (!affirmed.length || affirmed.some((glob) => isMatch$1(file, glob))) && (!negated.length || negated.every((glob) => isMatch$1(file, glob)))
+    )) {
+      const mod = server.moduleGraph.getModuleById(id);
+      if (mod) modules.push(mod);
+    }
+  }
+  modules.forEach((i) => {
+    if (i?.file) server.moduleGraph.onFileChange(i.file);
+  });
+  return modules;
+}
+function importGlobPlugin(config) {
+  let server;
+  return {
+    name: "vite:import-glob",
+    configureServer(_server) {
+      server = _server;
+      server._importGlobMap.clear();
+    },
+    async transform(code, id) {
+      if (!code.includes("import.meta.glob")) return;
+      const result = await transformGlobImport(
+        code,
+        id,
+        config.root,
+        (im, _, options) => this.resolve(im, id, options).then((i) => i?.id || im),
+        config.experimental.importGlobRestoreExtension,
+        config.logger
+      );
+      if (result) {
+        if (server) {
+          const allGlobs = result.matches.map((i) => i.globsResolved);
+          server._importGlobMap.set(
+            id,
+            allGlobs.map((globs) => {
+              const affirmed = [];
+              const negated = [];
+              for (const glob of globs) {
+                (glob[0] === "!" ? negated : affirmed).push(glob);
+              }
+              return { affirmed, negated };
+            })
+          );
+        }
+        return transformStableResult(result.s, id, config);
+      }
+    }
+  };
+}
+const importGlobRE = /\bimport\.meta\.glob(?:<\w+>)?\s*\(/g;
+const knownOptions = {
+  as: ["string"],
+  eager: ["boolean"],
+  import: ["string"],
+  exhaustive: ["boolean"],
+  query: ["object", "string"]
+};
+const forceDefaultAs = ["raw", "url"];
+function err$1(e, pos) {
+  const error = new Error(e);
+  error.pos = pos;
+  return error;
+}
+function parseGlobOptions(rawOpts, optsStartIndex, logger) {
+  let opts = {};
+  try {
+    opts = evalValue(rawOpts);
+  } catch {
+    throw err$1(
+      "Vite is unable to parse the glob options as the value is not static",
+      optsStartIndex
+    );
+  }
+  if (opts == null) {
+    return {};
+  }
+  for (const key in opts) {
+    if (!(key in knownOptions)) {
+      throw err$1(`Unknown glob option "${key}"`, optsStartIndex);
+    }
+    const allowedTypes = knownOptions[key];
+    const valueType = typeof opts[key];
+    if (!allowedTypes.includes(valueType)) {
+      throw err$1(
+        `Expected glob option "${key}" to be of type ${allowedTypes.join(
+          " or "
+        )}, but got ${valueType}`,
+        optsStartIndex
+      );
+    }
+  }
+  if (typeof opts.query === "object") {
+    for (const key in opts.query) {
+      const value = opts.query[key];
+      if (!["string", "number", "boolean"].includes(typeof value)) {
+        throw err$1(
+          `Expected glob option "query.${key}" to be of type string, number, or boolean, but got ${typeof value}`,
+          optsStartIndex
+        );
+      }
+    }
+    opts.query = stringifyQuery(opts.query);
+  }
+  if (opts.as && logger) {
+    const importSuggestion = forceDefaultAs.includes(opts.as) ? `, import: 'default'` : "";
+    logger.warn(
+      colors$1.yellow(
+        `The glob option "as" has been deprecated in favour of "query". Please update \`as: '${opts.as}'\` to \`query: '?${opts.as}'${importSuggestion}\`.`
+      )
+    );
+  }
+  if (opts.as && forceDefaultAs.includes(opts.as)) {
+    if (opts.import && opts.import !== "default" && opts.import !== "*")
+      throw err$1(
+        `Option "import" can only be "default" or "*" when "as" is "${opts.as}", but got "${opts.import}"`,
+        optsStartIndex
+      );
+    opts.import = opts.import || "default";
+  }
+  if (opts.as && opts.query)
+    throw err$1(
+      'Options "as" and "query" cannot be used together',
+      optsStartIndex
+    );
+  if (opts.as) opts.query = opts.as;
+  if (opts.query && opts.query[0] !== "?") opts.query = `?${opts.query}`;
+  return opts;
+}
+async function parseImportGlob(code, importer, root, resolveId, logger) {
+  let cleanCode;
+  try {
+    cleanCode = stripLiteral(code);
+  } catch (e) {
+    return [];
+  }
+  const matches = Array.from(cleanCode.matchAll(importGlobRE));
+  const tasks = matches.map(async (match, index) => {
+    const start = match.index;
+    const err2 = (msg) => {
+      const e = new Error(`Invalid glob import syntax: ${msg}`);
+      e.pos = start;
+      return e;
+    };
+    const end = findCorrespondingCloseParenthesisPosition(
+      cleanCode,
+      start + match[0].length
+    ) + 1;
+    if (end <= 0) {
+      throw err2("Close parenthesis not found");
+    }
+    const statementCode = code.slice(start, end);
+    const rootAst = (await parseAstAsync(statementCode)).body[0];
+    if (rootAst.type !== "ExpressionStatement") {
+      throw err2(`Expect CallExpression, got ${rootAst.type}`);
+    }
+    const ast = rootAst.expression;
+    if (ast.type !== "CallExpression") {
+      throw err2(`Expect CallExpression, got ${ast.type}`);
+    }
+    if (ast.arguments.length < 1 || ast.arguments.length > 2)
+      throw err2(`Expected 1-2 arguments, but got ${ast.arguments.length}`);
+    const arg1 = ast.arguments[0];
+    const arg2 = ast.arguments[1];
+    const globs = [];
+    const validateLiteral = (element) => {
+      if (!element) return;
+      if (element.type === "Literal") {
+        if (typeof element.value !== "string")
+          throw err2(
+            `Expected glob to be a string, but got "${typeof element.value}"`
+          );
+        globs.push(element.value);
+      } else if (element.type === "TemplateLiteral") {
+        if (element.expressions.length !== 0) {
+          throw err2(
+            `Expected glob to be a string, but got dynamic template literal`
+          );
+        }
+        globs.push(element.quasis[0].value.raw);
+      } else {
+        throw err2("Could only use literals");
+      }
+    };
+    if (arg1.type === "ArrayExpression") {
+      for (const element of arg1.elements) {
+        validateLiteral(element);
+      }
+    } else {
+      validateLiteral(arg1);
+    }
+    let options = {};
+    if (arg2) {
+      if (arg2.type !== "ObjectExpression")
+        throw err2(
+          `Expected the second argument to be an object literal, but got "${arg2.type}"`
+        );
+      options = parseGlobOptions(
+        code.slice(start + arg2.start, start + arg2.end),
+        start + arg2.start,
+        logger
+      );
+    }
+    const globsResolved = await Promise.all(
+      globs.map((glob) => toAbsoluteGlob(glob, root, importer, resolveId))
+    );
+    const isRelative = globs.every((i) => ".!".includes(i[0]));
+    return {
+      index,
+      globs,
+      globsResolved,
+      isRelative,
+      options,
+      start,
+      end
+    };
+  });
+  return (await Promise.all(tasks)).filter(Boolean);
+}
+function findCorrespondingCloseParenthesisPosition(cleanCode, openPos) {
+  const closePos = cleanCode.indexOf(")", openPos);
+  if (closePos < 0) return -1;
+  if (!cleanCode.slice(openPos, closePos).includes("(")) return closePos;
+  let remainingParenthesisCount = 0;
+  const cleanCodeLen = cleanCode.length;
+  for (let pos = openPos; pos < cleanCodeLen; pos++) {
+    switch (cleanCode[pos]) {
+      case "(": {
+        remainingParenthesisCount++;
+        break;
+      }
+      case ")": {
+        remainingParenthesisCount--;
+        if (remainingParenthesisCount <= 0) {
+          return pos;
+        }
+      }
+    }
+  }
+  return -1;
+}
+const importPrefix = "__vite_glob_";
+const { basename, dirname, relative, join } = posix$1;
+async function transformGlobImport(code, id, root, resolveId, restoreQueryExtension = false, logger) {
+  id = slash$1(id);
+  root = slash$1(root);
+  const isVirtual = isVirtualModule(id);
+  const dir = isVirtual ? void 0 : dirname(id);
+  const matches = await parseImportGlob(
+    code,
+    isVirtual ? void 0 : id,
+    root,
+    resolveId,
+    logger
+  );
+  const matchedFiles = /* @__PURE__ */ new Set();
+  if (!matches.length) return null;
+  const s = new MagicString(code);
+  const staticImports = (await Promise.all(
+    matches.map(
+      async ({ globsResolved, isRelative, options, index, start, end }) => {
+        const cwd = getCommonBase(globsResolved) ?? root;
+        const files = (await glob(globsResolved, {
+          cwd,
+          absolute: true,
+          dot: !!options.exhaustive,
+          ignore: options.exhaustive ? [] : [join(cwd, "**/node_modules/**")]
+        })).filter((file) => file !== id).sort();
+        const objectProps = [];
+        const staticImports2 = [];
+        const resolvePaths = (file) => {
+          if (!dir) {
+            if (isRelative)
+              throw new Error(
+                "In virtual modules, all globs must start with '/'"
+              );
+            const filePath2 = `/${relative(root, file)}`;
+            return { filePath: filePath2, importPath: filePath2 };
+          }
+          let importPath = relative(dir, file);
+          if (importPath[0] !== ".") importPath = `./${importPath}`;
+          let filePath;
+          if (isRelative) {
+            filePath = importPath;
+          } else {
+            filePath = relative(root, file);
+            if (filePath[0] !== ".") filePath = `/${filePath}`;
+          }
+          return { filePath, importPath };
+        };
+        files.forEach((file, i) => {
+          const paths = resolvePaths(file);
+          const filePath = paths.filePath;
+          let importPath = paths.importPath;
+          let importQuery = options.query ?? "";
+          if (importQuery && importQuery !== "?raw") {
+            const fileExtension = basename(file).split(".").slice(-1)[0];
+            if (fileExtension && restoreQueryExtension)
+              importQuery = `${importQuery}&lang.${fileExtension}`;
+          }
+          importPath = `${importPath}${importQuery}`;
+          const importKey = options.import && options.import !== "*" ? options.import : void 0;
+          if (options.eager) {
+            const variableName = `${importPrefix}${index}_${i}`;
+            const expression = importKey ? `{ ${importKey} as ${variableName} }` : `* as ${variableName}`;
+            staticImports2.push(
+              `import ${expression} from ${JSON.stringify(importPath)}`
+            );
+            objectProps.push(`${JSON.stringify(filePath)}: ${variableName}`);
+          } else {
+            let importStatement = `import(${JSON.stringify(importPath)})`;
+            if (importKey)
+              importStatement += `.then(m => m[${JSON.stringify(importKey)}])`;
+            objectProps.push(
+              `${JSON.stringify(filePath)}: () => ${importStatement}`
+            );
+          }
+        });
+        files.forEach((i) => matchedFiles.add(i));
+        const originalLineBreakCount = code.slice(start, end).match(/\n/g)?.length ?? 0;
+        const lineBreaks = originalLineBreakCount > 0 ? "\n".repeat(originalLineBreakCount) : "";
+        const replacement = `/* #__PURE__ */ Object.assign({${objectProps.join(
+          ","
+        )}${lineBreaks}})`;
+        s.overwrite(start, end, replacement);
+        return staticImports2;
+      }
+    )
+  )).flat();
+  if (staticImports.length) s.prepend(`${staticImports.join(";")};`);
+  return {
+    s,
+    matches,
+    files: matchedFiles
+  };
+}
+function globSafePath(path) {
+  return glob.escapePath(normalizePath$3(path));
+}
+function lastNthChar(str, n) {
+  return str.charAt(str.length - 1 - n);
+}
+function globSafeResolvedPath(resolved, glob) {
+  let numEqual = 0;
+  const maxEqual = Math.min(resolved.length, glob.length);
+  while (numEqual < maxEqual && lastNthChar(resolved, numEqual) === lastNthChar(glob, numEqual)) {
+    numEqual += 1;
+  }
+  const staticPartEnd = resolved.length - numEqual;
+  const staticPart = resolved.slice(0, staticPartEnd);
+  const dynamicPart = resolved.slice(staticPartEnd);
+  return globSafePath(staticPart) + dynamicPart;
+}
+async function toAbsoluteGlob(glob, root, importer, resolveId) {
+  let pre = "";
+  if (glob[0] === "!") {
+    pre = "!";
+    glob = glob.slice(1);
+  }
+  root = globSafePath(root);
+  const dir = importer ? globSafePath(dirname(importer)) : root;
+  if (glob[0] === "/") return pre + posix$1.join(root, glob.slice(1));
+  if (glob.startsWith("./")) return pre + posix$1.join(dir, glob.slice(2));
+  if (glob.startsWith("../")) return pre + posix$1.join(dir, glob);
+  if (glob.startsWith("**")) return pre + glob;
+  const isSubImportsPattern = glob[0] === "#" && glob.includes("*");
+  const resolved = normalizePath$3(
+    await resolveId(glob, importer, {
+      custom: { "vite:import-glob": { isSubImportsPattern } }
+    }) || glob
+  );
+  if (isAbsolute$1(resolved)) {
+    return pre + globSafeResolvedPath(resolved, glob);
+  }
+  throw new Error(
+    `Invalid glob: "${glob}" (resolved: "${resolved}"). It must start with '/' or './'`
+  );
+}
+function getCommonBase(globsResolved) {
+  const bases = globsResolved.filter((g) => g[0] !== "!").map((glob) => {
+    let { base } = scan(glob);
+    if (posix$1.basename(base).includes(".")) base = posix$1.dirname(base);
+    return base;
+  });
+  if (!bases.length) return null;
+  let commonAncestor = "";
+  const dirS = bases[0].split("/");
+  for (let i = 0; i < dirS.length; i++) {
+    const candidate = dirS.slice(0, i + 1).join("/");
+    if (bases.every((base) => base.startsWith(candidate)))
+      commonAncestor = candidate;
+    else break;
+  }
+  if (!commonAncestor) commonAncestor = "/";
+  return commonAncestor;
+}
+function isVirtualModule(id) {
+  return id.startsWith("virtual:") || id[0] === "\0" || !id.includes("/");
+}
+
+var src = {exports: {}};
+
+var browser = {exports: {}};
+
+var debug$f = {exports: {}};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isNaN(val) === false) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  if (ms >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (ms >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (ms >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (ms >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  return plural(ms, d, 'day') ||
+	    plural(ms, h, 'hour') ||
+	    plural(ms, m, 'minute') ||
+	    plural(ms, s, 'second') ||
+	    ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, n, name) {
+	  if (ms < n) {
+	    return;
+	  }
+	  if (ms < n * 1.5) {
+	    return Math.floor(ms / n) + ' ' + name;
+	  }
+	  return Math.ceil(ms / n) + ' ' + name + 's';
+	}
+	return ms;
+}
+
+var hasRequiredDebug;
+
+function requireDebug () {
+	if (hasRequiredDebug) return debug$f.exports;
+	hasRequiredDebug = 1;
+	(function (module, exports) {
+		/**
+		 * This is the common logic for both the Node.js and web browser
+		 * implementations of `debug()`.
+		 *
+		 * Expose `debug()` as the module.
+		 */
+
+		exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+		exports.coerce = coerce;
+		exports.disable = disable;
+		exports.enable = enable;
+		exports.enabled = enabled;
+		exports.humanize = requireMs();
+
+		/**
+		 * The currently active debug mode names, and names to skip.
+		 */
+
+		exports.names = [];
+		exports.skips = [];
+
+		/**
+		 * Map of special "%n" handling functions, for the debug "format" argument.
+		 *
+		 * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		 */
+
+		exports.formatters = {};
+
+		/**
+		 * Previous log timestamp.
+		 */
+
+		var prevTime;
+
+		/**
+		 * Select a color.
+		 * @param {String} namespace
+		 * @return {Number}
+		 * @api private
+		 */
+
+		function selectColor(namespace) {
+		  var hash = 0, i;
+
+		  for (i in namespace) {
+		    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
+		    hash |= 0; // Convert to 32bit integer
+		  }
+
+		  return exports.colors[Math.abs(hash) % exports.colors.length];
+		}
+
+		/**
+		 * Create a debugger with the given `namespace`.
+		 *
+		 * @param {String} namespace
+		 * @return {Function}
+		 * @api public
+		 */
+
+		function createDebug(namespace) {
+
+		  function debug() {
+		    // disabled?
+		    if (!debug.enabled) return;
+
+		    var self = debug;
+
+		    // set `diff` timestamp
+		    var curr = +new Date();
+		    var ms = curr - (prevTime || curr);
+		    self.diff = ms;
+		    self.prev = prevTime;
+		    self.curr = curr;
+		    prevTime = curr;
+
+		    // turn the `arguments` into a proper Array
+		    var args = new Array(arguments.length);
+		    for (var i = 0; i < args.length; i++) {
+		      args[i] = arguments[i];
+		    }
+
+		    args[0] = exports.coerce(args[0]);
+
+		    if ('string' !== typeof args[0]) {
+		      // anything else let's inspect with %O
+		      args.unshift('%O');
+		    }
+
+		    // apply any `formatters` transformations
+		    var index = 0;
+		    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+		      // if we encounter an escaped % then don't increase the array index
+		      if (match === '%%') return match;
+		      index++;
+		      var formatter = exports.formatters[format];
+		      if ('function' === typeof formatter) {
+		        var val = args[index];
+		        match = formatter.call(self, val);
+
+		        // now we need to remove `args[index]` since it's inlined in the `format`
+		        args.splice(index, 1);
+		        index--;
+		      }
+		      return match;
+		    });
+
+		    // apply env-specific formatting (colors, etc.)
+		    exports.formatArgs.call(self, args);
+
+		    var logFn = debug.log || exports.log || console.log.bind(console);
+		    logFn.apply(self, args);
+		  }
+
+		  debug.namespace = namespace;
+		  debug.enabled = exports.enabled(namespace);
+		  debug.useColors = exports.useColors();
+		  debug.color = selectColor(namespace);
+
+		  // env-specific initialization logic for debug instances
+		  if ('function' === typeof exports.init) {
+		    exports.init(debug);
+		  }
+
+		  return debug;
+		}
+
+		/**
+		 * Enables a debug mode by namespaces. This can include modes
+		 * separated by a colon and wildcards.
+		 *
+		 * @param {String} namespaces
+		 * @api public
+		 */
+
+		function enable(namespaces) {
+		  exports.save(namespaces);
+
+		  exports.names = [];
+		  exports.skips = [];
+
+		  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+		  var len = split.length;
+
+		  for (var i = 0; i < len; i++) {
+		    if (!split[i]) continue; // ignore empty strings
+		    namespaces = split[i].replace(/\*/g, '.*?');
+		    if (namespaces[0] === '-') {
+		      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+		    } else {
+		      exports.names.push(new RegExp('^' + namespaces + '$'));
+		    }
+		  }
+		}
+
+		/**
+		 * Disable debug output.
+		 *
+		 * @api public
+		 */
+
+		function disable() {
+		  exports.enable('');
+		}
+
+		/**
+		 * Returns true if the given mode name is enabled, false otherwise.
+		 *
+		 * @param {String} name
+		 * @return {Boolean}
+		 * @api public
+		 */
+
+		function enabled(name) {
+		  var i, len;
+		  for (i = 0, len = exports.skips.length; i < len; i++) {
+		    if (exports.skips[i].test(name)) {
+		      return false;
+		    }
+		  }
+		  for (i = 0, len = exports.names.length; i < len; i++) {
+		    if (exports.names[i].test(name)) {
+		      return true;
+		    }
+		  }
+		  return false;
+		}
+
+		/**
+		 * Coerce `val`.
+		 *
+		 * @param {Mixed} val
+		 * @return {Mixed}
+		 * @api private
+		 */
+
+		function coerce(val) {
+		  if (val instanceof Error) return val.stack || val.message;
+		  return val;
+		} 
+	} (debug$f, debug$f.exports));
+	return debug$f.exports;
+}
+
+/**
+ * This is the web browser implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser.exports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		exports = module.exports = requireDebug();
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = 'undefined' != typeof chrome
+		               && 'undefined' != typeof chrome.storage
+		                  ? chrome.storage.local
+		                  : localstorage();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+		  'lightseagreen',
+		  'forestgreen',
+		  'goldenrod',
+		  'dodgerblue',
+		  'darkorchid',
+		  'crimson'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		function useColors() {
+		  // NB: In an Electron preload script, document will be defined but not fully
+		  // initialized. Since we know we're in Chrome, we'll just detect this case
+		  // explicitly
+		  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
+		    return true;
+		  }
+
+		  // is webkit? http://stackoverflow.com/a/16459606/376773
+		  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+		  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+		    // is firebug? http://stackoverflow.com/a/398120/376773
+		    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+		    // is firefox >= v31?
+		    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+		    // double check webkit in userAgent just in case we are in a worker
+		    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+		}
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		exports.formatters.j = function(v) {
+		  try {
+		    return JSON.stringify(v);
+		  } catch (err) {
+		    return '[UnexpectedJSONParseError]: ' + err.message;
+		  }
+		};
+
+
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+		  var useColors = this.useColors;
+
+		  args[0] = (useColors ? '%c' : '')
+		    + this.namespace
+		    + (useColors ? ' %c' : ' ')
+		    + args[0]
+		    + (useColors ? '%c ' : ' ')
+		    + '+' + exports.humanize(this.diff);
+
+		  if (!useColors) return;
+
+		  var c = 'color: ' + this.color;
+		  args.splice(1, 0, c, 'color: inherit');
+
+		  // the final "%c" is somewhat tricky, because there could be other
+		  // arguments passed either before or after the %c, so we need to
+		  // figure out the correct index to insert the CSS into
+		  var index = 0;
+		  var lastC = 0;
+		  args[0].replace(/%[a-zA-Z%]/g, function(match) {
+		    if ('%%' === match) return;
+		    index++;
+		    if ('%c' === match) {
+		      // we only are interested in the *last* %c
+		      // (the user may have provided their own)
+		      lastC = index;
+		    }
+		  });
+
+		  args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.log()` when available.
+		 * No-op when `console.log` is not a "function".
+		 *
+		 * @api public
+		 */
+
+		function log() {
+		  // this hackery is required for IE8/9, where
+		  // the `console.log` function doesn't have 'apply'
+		  return 'object' === typeof console
+		    && console.log
+		    && Function.prototype.apply.call(console.log, console, arguments);
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+
+		function save(namespaces) {
+		  try {
+		    if (null == namespaces) {
+		      exports.storage.removeItem('debug');
+		    } else {
+		      exports.storage.debug = namespaces;
+		    }
+		  } catch(e) {}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+		  var r;
+		  try {
+		    r = exports.storage.debug;
+		  } catch(e) {}
+
+		  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+		  if (!r && typeof process !== 'undefined' && 'env' in process) {
+		    r = process.env.DEBUG;
+		  }
+
+		  return r;
+		}
+
+		/**
+		 * Enable namespaces listed in `localStorage.debug` initially.
+		 */
+
+		exports.enable(load());
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+		  try {
+		    return window.localStorage;
+		  } catch (e) {}
+		} 
+	} (browser, browser.exports));
+	return browser.exports;
+}
+
+var node = {exports: {}};
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		var tty = require$$0$3;
+		var util = require$$0$5;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 *
+		 * Expose `debug()` as the module.
+		 */
+
+		exports = module.exports = requireDebug();
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(function (key) {
+		  return /^debug_/i.test(key);
+		}).reduce(function (obj, key) {
+		  // camel-case
+		  var prop = key
+		    .substring(6)
+		    .toLowerCase()
+		    .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() });
+
+		  // coerce string value into JS value
+		  var val = process.env[key];
+		  if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
+		  else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
+		  else if (val === 'null') val = null;
+		  else val = Number(val);
+
+		  obj[prop] = val;
+		  return obj;
+		}, {});
+
+		/**
+		 * The file descriptor to write the `debug()` calls to.
+		 * Set the `DEBUG_FD` env variable to override with another value. i.e.:
+		 *
+		 *   $ DEBUG_FD=3 node script.js 3>debug.log
+		 */
+
+		var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+
+		if (1 !== fd && 2 !== fd) {
+		  util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')();
+		}
+
+		var stream = 1 === fd ? process.stdout :
+		             2 === fd ? process.stderr :
+		             createWritableStdioStream(fd);
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+		  return 'colors' in exports.inspectOpts
+		    ? Boolean(exports.inspectOpts.colors)
+		    : tty.isatty(fd);
+		}
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		exports.formatters.o = function(v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts)
+		    .split('\n').map(function(str) {
+		      return str.trim()
+		    }).join(' ');
+		};
+
+		/**
+		 * Map %o to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		exports.formatters.O = function(v) {
+		  this.inspectOpts.colors = this.useColors;
+		  return util.inspect(v, this.inspectOpts);
+		};
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+		  var name = this.namespace;
+		  var useColors = this.useColors;
+
+		  if (useColors) {
+		    var c = this.color;
+		    var prefix = '  \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m';
+
+		    args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		    args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
+		  } else {
+		    args[0] = new Date().toUTCString()
+		      + ' ' + name + ' ' + args[0];
+		  }
+		}
+
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to `stream`.
+		 */
+
+		function log() {
+		  return stream.write(util.format.apply(util, arguments) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+
+		function save(namespaces) {
+		  if (null == namespaces) {
+		    // If you set a process.env field to null or undefined, it gets cast to the
+		    // string 'null' or 'undefined'. Just delete instead.
+		    delete process.env.DEBUG;
+		  } else {
+		    process.env.DEBUG = namespaces;
+		  }
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+		  return process.env.DEBUG;
+		}
+
+		/**
+		 * Copied from `node/src/node.js`.
+		 *
+		 * XXX: It's lame that node doesn't expose this API out-of-the-box. It also
+		 * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame.
+		 */
+
+		function createWritableStdioStream (fd) {
+		  var stream;
+		  var tty_wrap = process.binding('tty_wrap');
+
+		  // Note stream._type is used for test-module-load-list.js
+
+		  switch (tty_wrap.guessHandleType(fd)) {
+		    case 'TTY':
+		      stream = new tty.WriteStream(fd);
+		      stream._type = 'tty';
+
+		      // Hack to have stream not keep the event loop alive.
+		      // See https://github.com/joyent/node/issues/1726
+		      if (stream._handle && stream._handle.unref) {
+		        stream._handle.unref();
+		      }
+		      break;
+
+		    case 'FILE':
+		      var fs = require$$0__default;
+		      stream = new fs.SyncWriteStream(fd, { autoClose: false });
+		      stream._type = 'fs';
+		      break;
+
+		    case 'PIPE':
+		    case 'TCP':
+		      var net = require$$4$1;
+		      stream = new net.Socket({
+		        fd: fd,
+		        readable: false,
+		        writable: true
+		      });
+
+		      // FIXME Should probably have an option in net.Socket to create a
+		      // stream from an existing fd which is writable only. But for now
+		      // we'll just add this hack and set the `readable` member to false.
+		      // Test: ./node test/fixtures/echo.js < /etc/passwd
+		      stream.readable = false;
+		      stream.read = null;
+		      stream._type = 'pipe';
+
+		      // FIXME Hack to have stream not keep the event loop alive.
+		      // See https://github.com/joyent/node/issues/1726
+		      if (stream._handle && stream._handle.unref) {
+		        stream._handle.unref();
+		      }
+		      break;
+
+		    default:
+		      // Probably an error on in uv_guess_handle()
+		      throw new Error('Implement me. Unknown stream file type!');
+		  }
+
+		  // For supporting legacy API we put the FD here.
+		  stream.fd = fd;
+
+		  stream._isStdio = true;
+
+		  return stream;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init (debug) {
+		  debug.inspectOpts = {};
+
+		  var keys = Object.keys(exports.inspectOpts);
+		  for (var i = 0; i < keys.length; i++) {
+		    debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		  }
+		}
+
+		/**
+		 * Enable namespaces listed in `process.env.DEBUG` initially.
+		 */
+
+		exports.enable(load()); 
+	} (node, node.exports));
+	return node.exports;
+}
+
+/**
+ * Detect Electron renderer process, which is node, but we should
+ * treat as a browser.
+ */
+
+if (typeof process !== 'undefined' && process.type === 'renderer') {
+  src.exports = requireBrowser();
+} else {
+  src.exports = requireNode();
+}
+
+var srcExports = src.exports;
+
+/*!
+ * encodeurl
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var encodeurl = encodeUrl$1;
+
+/**
+ * RegExp to match non-URL code points, *after* encoding (i.e. not including "%")
+ * and including invalid escape sequences.
+ * @private
+ */
+
+var ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x61-\x7A\x7E]|%(?:[^0-9A-Fa-f]|[0-9A-Fa-f][^0-9A-Fa-f]|$))+/g;
+
+/**
+ * RegExp to match unmatched surrogate pair.
+ * @private
+ */
+
+var UNMATCHED_SURROGATE_PAIR_REGEXP = /(^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]|[\uD800-\uDBFF]([^\uDC00-\uDFFF]|$)/g;
+
+/**
+ * String to replace unmatched surrogate pair with.
+ * @private
+ */
+
+var UNMATCHED_SURROGATE_PAIR_REPLACE = '$1\uFFFD$2';
+
+/**
+ * Encode a URL to a percent-encoded form, excluding already-encoded sequences.
+ *
+ * This function will take an already-encoded URL and encode all the non-URL
+ * code points. This function will not encode the "%" character unless it is
+ * not part of a valid sequence (`%20` will be left as-is, but `%foo` will
+ * be encoded as `%25foo`).
+ *
+ * This encode is meant to be "safe" and does not throw errors. It will try as
+ * hard as it can to properly encode the given URL, including replacing any raw,
+ * unpaired surrogate pairs with the Unicode replacement character prior to
+ * encoding.
+ *
+ * @param {string} url
+ * @return {string}
+ * @public
+ */
+
+function encodeUrl$1 (url) {
+  return String(url)
+    .replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE)
+    .replace(ENCODE_CHARS_REGEXP, encodeURI)
+}
+
+/*!
+ * escape-html
+ * Copyright(c) 2012-2013 TJ Holowaychuk
+ * Copyright(c) 2015 Andreas Lubbe
+ * Copyright(c) 2015 Tiancheng "Timothy" Gu
+ * MIT Licensed
+ */
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var matchHtmlRegExp = /["'&<>]/;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var escapeHtml_1 = escapeHtml$1;
+
+/**
+ * Escape special characters in the given string of html.
+ *
+ * @param  {string} string The string to escape for inserting into HTML
+ * @return {string}
+ * @public
+ */
+
+function escapeHtml$1(string) {
+  var str = '' + string;
+  var match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  var escape;
+  var html = '';
+  var index = 0;
+  var lastIndex = 0;
+
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34: // "
+        escape = '&quot;';
+        break;
+      case 38: // &
+        escape = '&amp;';
+        break;
+      case 39: // '
+        escape = '&#39;';
+        break;
+      case 60: // <
+        escape = '&lt;';
+        break;
+      case 62: // >
+        escape = '&gt;';
+        break;
+      default:
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index
+    ? html + str.substring(lastIndex, index)
+    : html;
+}
+
+var escapeHtml$2 = /*@__PURE__*/getDefaultExportFromCjs(escapeHtml_1);
+
+var onFinished$2 = {exports: {}};
+
+/*!
+ * ee-first
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var eeFirst = first$1;
+
+/**
+ * Get the first event in a set of event emitters and event pairs.
+ *
+ * @param {array} stuff
+ * @param {function} done
+ * @public
+ */
+
+function first$1(stuff, done) {
+  if (!Array.isArray(stuff))
+    throw new TypeError('arg must be an array of [ee, events...] arrays')
+
+  var cleanups = [];
+
+  for (var i = 0; i < stuff.length; i++) {
+    var arr = stuff[i];
+
+    if (!Array.isArray(arr) || arr.length < 2)
+      throw new TypeError('each array member must be [ee, events...]')
+
+    var ee = arr[0];
+
+    for (var j = 1; j < arr.length; j++) {
+      var event = arr[j];
+      var fn = listener(event, callback);
+
+      // listen to the event
+      ee.on(event, fn);
+      // push this listener to the list of cleanups
+      cleanups.push({
+        ee: ee,
+        event: event,
+        fn: fn,
+      });
+    }
+  }
+
+  function callback() {
+    cleanup();
+    done.apply(null, arguments);
+  }
+
+  function cleanup() {
+    var x;
+    for (var i = 0; i < cleanups.length; i++) {
+      x = cleanups[i];
+      x.ee.removeListener(x.event, x.fn);
+    }
+  }
+
+  function thunk(fn) {
+    done = fn;
+  }
+
+  thunk.cancel = cleanup;
+
+  return thunk
+}
+
+/**
+ * Create the event listener.
+ * @private
+ */
+
+function listener(event, done) {
+  return function onevent(arg1) {
+    var args = new Array(arguments.length);
+    var ee = this;
+    var err = event === 'error'
+      ? arg1
+      : null;
+
+    // copy args to prevent arguments escaping scope
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+
+    done(err, ee, event, args);
+  }
+}
+
+/*!
+ * on-finished
+ * Copyright(c) 2013 Jonathan Ong
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+onFinished$2.exports = onFinished$1;
+onFinished$2.exports.isFinished = isFinished$1;
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var first = eeFirst;
+
+/**
+ * Variables.
+ * @private
+ */
+
+/* istanbul ignore next */
+var defer$2 = typeof setImmediate === 'function'
+  ? setImmediate
+  : function(fn){ process.nextTick(fn.bind.apply(fn, arguments)); };
+
+/**
+ * Invoke callback when the response has finished, useful for
+ * cleaning up resources afterwards.
+ *
+ * @param {object} msg
+ * @param {function} listener
+ * @return {object}
+ * @public
+ */
+
+function onFinished$1(msg, listener) {
+  if (isFinished$1(msg) !== false) {
+    defer$2(listener, null, msg);
+    return msg
+  }
+
+  // attach the listener to the message
+  attachListener(msg, listener);
+
+  return msg
+}
+
+/**
+ * Determine if message is already finished.
+ *
+ * @param {object} msg
+ * @return {boolean}
+ * @public
+ */
+
+function isFinished$1(msg) {
+  var socket = msg.socket;
+
+  if (typeof msg.finished === 'boolean') {
+    // OutgoingMessage
+    return Boolean(msg.finished || (socket && !socket.writable))
+  }
+
+  if (typeof msg.complete === 'boolean') {
+    // IncomingMessage
+    return Boolean(msg.upgrade || !socket || !socket.readable || (msg.complete && !msg.readable))
+  }
+
+  // don't know
+  return undefined
+}
+
+/**
+ * Attach a finished listener to the message.
+ *
+ * @param {object} msg
+ * @param {function} callback
+ * @private
+ */
+
+function attachFinishedListener(msg, callback) {
+  var eeMsg;
+  var eeSocket;
+  var finished = false;
+
+  function onFinish(error) {
+    eeMsg.cancel();
+    eeSocket.cancel();
+
+    finished = true;
+    callback(error);
+  }
+
+  // finished on first message event
+  eeMsg = eeSocket = first([[msg, 'end', 'finish']], onFinish);
+
+  function onSocket(socket) {
+    // remove listener
+    msg.removeListener('socket', onSocket);
+
+    if (finished) return
+    if (eeMsg !== eeSocket) return
+
+    // finished on first socket event
+    eeSocket = first([[socket, 'error', 'close']], onFinish);
+  }
+
+  if (msg.socket) {
+    // socket already assigned
+    onSocket(msg.socket);
+    return
+  }
+
+  // wait for socket to be assigned
+  msg.on('socket', onSocket);
+
+  if (msg.socket === undefined) {
+    // node.js 0.8 patch
+    patchAssignSocket(msg, onSocket);
+  }
+}
+
+/**
+ * Attach the listener to the message.
+ *
+ * @param {object} msg
+ * @return {function}
+ * @private
+ */
+
+function attachListener(msg, listener) {
+  var attached = msg.__onFinished;
+
+  // create a private single listener with queue
+  if (!attached || !attached.queue) {
+    attached = msg.__onFinished = createListener(msg);
+    attachFinishedListener(msg, attached);
+  }
+
+  attached.queue.push(listener);
+}
+
+/**
+ * Create listener on message.
+ *
+ * @param {object} msg
+ * @return {function}
+ * @private
+ */
+
+function createListener(msg) {
+  function listener(err) {
+    if (msg.__onFinished === listener) msg.__onFinished = null;
+    if (!listener.queue) return
+
+    var queue = listener.queue;
+    listener.queue = null;
+
+    for (var i = 0; i < queue.length; i++) {
+      queue[i](err, msg);
+    }
+  }
+
+  listener.queue = [];
+
+  return listener
+}
+
+/**
+ * Patch ServerResponse.prototype.assignSocket for node.js 0.8.
+ *
+ * @param {ServerResponse} res
+ * @param {function} callback
+ * @private
+ */
+
+function patchAssignSocket(res, callback) {
+  var assignSocket = res.assignSocket;
+
+  if (typeof assignSocket !== 'function') return
+
+  // res.on('socket', callback) is broken in 0.8
+  res.assignSocket = function _assignSocket(socket) {
+    assignSocket.call(this, socket);
+    callback(socket);
+  };
+}
+
+var onFinishedExports = onFinished$2.exports;
+
+var parseurl$1 = {exports: {}};
+
+/*!
+ * parseurl
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var url$3 = require$$0$9;
+var parse$8 = url$3.parse;
+var Url = url$3.Url;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+parseurl$1.exports = parseurl;
+parseurl$1.exports.original = originalurl;
+
+/**
+ * Parse the `req` url with memoization.
+ *
+ * @param {ServerRequest} req
+ * @return {Object}
+ * @public
+ */
+
+function parseurl (req) {
+  var url = req.url;
+
+  if (url === undefined) {
+    // URL is undefined
+    return undefined
+  }
+
+  var parsed = req._parsedUrl;
+
+  if (fresh(url, parsed)) {
+    // Return cached URL parse
+    return parsed
+  }
+
+  // Parse the URL
+  parsed = fastparse(url);
+  parsed._raw = url;
+
+  return (req._parsedUrl = parsed)
+}
+/**
+ * Parse the `req` original url with fallback and memoization.
+ *
+ * @param {ServerRequest} req
+ * @return {Object}
+ * @public
+ */
+
+function originalurl (req) {
+  var url = req.originalUrl;
+
+  if (typeof url !== 'string') {
+    // Fallback
+    return parseurl(req)
+  }
+
+  var parsed = req._parsedOriginalUrl;
+
+  if (fresh(url, parsed)) {
+    // Return cached URL parse
+    return parsed
+  }
+
+  // Parse the URL
+  parsed = fastparse(url);
+  parsed._raw = url;
+
+  return (req._parsedOriginalUrl = parsed)
+}
+/**
+ * Parse the `str` url with fast-path short-cut.
+ *
+ * @param {string} str
+ * @return {Object}
+ * @private
+ */
+
+function fastparse (str) {
+  if (typeof str !== 'string' || str.charCodeAt(0) !== 0x2f /* / */) {
+    return parse$8(str)
+  }
+
+  var pathname = str;
+  var query = null;
+  var search = null;
+
+  // This takes the regexp from https://github.com/joyent/node/pull/7878
+  // Which is /^(\/[^?#\s]*)(\?[^#\s]*)?$/
+  // And unrolls it into a for loop
+  for (var i = 1; i < str.length; i++) {
+    switch (str.charCodeAt(i)) {
+      case 0x3f: /* ?  */
+        if (search === null) {
+          pathname = str.substring(0, i);
+          query = str.substring(i + 1);
+          search = str.substring(i);
+        }
+        break
+      case 0x09: /* \t */
+      case 0x0a: /* \n */
+      case 0x0c: /* \f */
+      case 0x0d: /* \r */
+      case 0x20: /*    */
+      case 0x23: /* #  */
+      case 0xa0:
+      case 0xfeff:
+        return parse$8(str)
+    }
+  }
+
+  var url = Url !== undefined
+    ? new Url()
+    : {};
+
+  url.path = str;
+  url.href = str;
+  url.pathname = pathname;
+
+  if (search !== null) {
+    url.query = query;
+    url.search = search;
+  }
+
+  return url
+}
+
+/**
+ * Determine if parsed is still fresh for url.
+ *
+ * @param {string} url
+ * @param {object} parsedUrl
+ * @return {boolean}
+ * @private
+ */
+
+function fresh (url, parsedUrl) {
+  return typeof parsedUrl === 'object' &&
+    parsedUrl !== null &&
+    (Url === undefined || parsedUrl instanceof Url) &&
+    parsedUrl._raw === url
+}
+
+var parseurlExports = parseurl$1.exports;
+
+var require$$0$1 = {
+	"100": "Continue",
+	"101": "Switching Protocols",
+	"102": "Processing",
+	"103": "Early Hints",
+	"200": "OK",
+	"201": "Created",
+	"202": "Accepted",
+	"203": "Non-Authoritative Information",
+	"204": "No Content",
+	"205": "Reset Content",
+	"206": "Partial Content",
+	"207": "Multi-Status",
+	"208": "Already Reported",
+	"226": "IM Used",
+	"300": "Multiple Choices",
+	"301": "Moved Permanently",
+	"302": "Found",
+	"303": "See Other",
+	"304": "Not Modified",
+	"305": "Use Proxy",
+	"306": "(Unused)",
+	"307": "Temporary Redirect",
+	"308": "Permanent Redirect",
+	"400": "Bad Request",
+	"401": "Unauthorized",
+	"402": "Payment Required",
+	"403": "Forbidden",
+	"404": "Not Found",
+	"405": "Method Not Allowed",
+	"406": "Not Acceptable",
+	"407": "Proxy Authentication Required",
+	"408": "Request Timeout",
+	"409": "Conflict",
+	"410": "Gone",
+	"411": "Length Required",
+	"412": "Precondition Failed",
+	"413": "Payload Too Large",
+	"414": "URI Too Long",
+	"415": "Unsupported Media Type",
+	"416": "Range Not Satisfiable",
+	"417": "Expectation Failed",
+	"418": "I'm a teapot",
+	"421": "Misdirected Request",
+	"422": "Unprocessable Entity",
+	"423": "Locked",
+	"424": "Failed Dependency",
+	"425": "Unordered Collection",
+	"426": "Upgrade Required",
+	"428": "Precondition Required",
+	"429": "Too Many Requests",
+	"431": "Request Header Fields Too Large",
+	"451": "Unavailable For Legal Reasons",
+	"500": "Internal Server Error",
+	"501": "Not Implemented",
+	"502": "Bad Gateway",
+	"503": "Service Unavailable",
+	"504": "Gateway Timeout",
+	"505": "HTTP Version Not Supported",
+	"506": "Variant Also Negotiates",
+	"507": "Insufficient Storage",
+	"508": "Loop Detected",
+	"509": "Bandwidth Limit Exceeded",
+	"510": "Not Extended",
+	"511": "Network Authentication Required"
+};
+
+/*!
+ * statuses
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var codes = require$$0$1;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var statuses$1 = status;
+
+// status code to message map
+status.STATUS_CODES = codes;
+
+// array of status codes
+status.codes = populateStatusesMap(status, codes);
+
+// status codes for redirects
+status.redirect = {
+  300: true,
+  301: true,
+  302: true,
+  303: true,
+  305: true,
+  307: true,
+  308: true
+};
+
+// status codes for empty bodies
+status.empty = {
+  204: true,
+  205: true,
+  304: true
+};
+
+// status codes for when you should retry the request
+status.retry = {
+  502: true,
+  503: true,
+  504: true
+};
+
+/**
+ * Populate the statuses map for given codes.
+ * @private
+ */
+
+function populateStatusesMap (statuses, codes) {
+  var arr = [];
+
+  Object.keys(codes).forEach(function forEachCode (code) {
+    var message = codes[code];
+    var status = Number(code);
+
+    // Populate properties
+    statuses[status] = message;
+    statuses[message] = status;
+    statuses[message.toLowerCase()] = status;
+
+    // Add to array
+    arr.push(status);
+  });
+
+  return arr
+}
+
+/**
+ * Get the status code.
+ *
+ * Given a number, this will throw if it is not a known status
+ * code, otherwise the code will be returned. Given a string,
+ * the string will be parsed for a number and return the code
+ * if valid, otherwise will lookup the code assuming this is
+ * the status message.
+ *
+ * @param {string|number} code
+ * @returns {number}
+ * @public
+ */
+
+function status (code) {
+  if (typeof code === 'number') {
+    if (!status[code]) throw new Error('invalid status code: ' + code)
+    return code
+  }
+
+  if (typeof code !== 'string') {
+    throw new TypeError('code must be a number or string')
+  }
+
+  // '403'
+  var n = parseInt(code, 10);
+  if (!isNaN(n)) {
+    if (!status[n]) throw new Error('invalid status code: ' + n)
+    return n
+  }
+
+  n = status[code.toLowerCase()];
+  if (!n) throw new Error('invalid status message: "' + code + '"')
+  return n
+}
+
+/*!
+ * unpipe
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var unpipe_1 = unpipe$1;
+
+/**
+ * Determine if there are Node.js pipe-like data listeners.
+ * @private
+ */
+
+function hasPipeDataListeners(stream) {
+  var listeners = stream.listeners('data');
+
+  for (var i = 0; i < listeners.length; i++) {
+    if (listeners[i].name === 'ondata') {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Unpipe a stream from all destinations.
+ *
+ * @param {object} stream
+ * @public
+ */
+
+function unpipe$1(stream) {
+  if (!stream) {
+    throw new TypeError('argument stream is required')
+  }
+
+  if (typeof stream.unpipe === 'function') {
+    // new-style
+    stream.unpipe();
+    return
+  }
+
+  // Node.js 0.8 hack
+  if (!hasPipeDataListeners(stream)) {
+    return
+  }
+
+  var listener;
+  var listeners = stream.listeners('close');
+
+  for (var i = 0; i < listeners.length; i++) {
+    listener = listeners[i];
+
+    if (listener.name !== 'cleanup' && listener.name !== 'onclose') {
+      continue
+    }
+
+    // invoke the listener
+    listener.call(stream);
+  }
+}
+
+/*!
+ * finalhandler
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var debug$e = srcExports('finalhandler');
+var encodeUrl = encodeurl;
+var escapeHtml = escapeHtml_1;
+var onFinished = onFinishedExports;
+var parseUrl$2 = parseurlExports;
+var statuses = statuses$1;
+var unpipe = unpipe_1;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var DOUBLE_SPACE_REGEXP = /\x20{2}/g;
+var NEWLINE_REGEXP = /\n/g;
+
+/* istanbul ignore next */
+var defer$1 = typeof setImmediate === 'function'
+  ? setImmediate
+  : function (fn) { process.nextTick(fn.bind.apply(fn, arguments)); };
+var isFinished = onFinished.isFinished;
+
+/**
+ * Create a minimal HTML document.
+ *
+ * @param {string} message
+ * @private
+ */
+
+function createHtmlDocument (message) {
+  var body = escapeHtml(message)
+    .replace(NEWLINE_REGEXP, '<br>')
+    .replace(DOUBLE_SPACE_REGEXP, ' &nbsp;');
+
+  return '<!DOCTYPE html>\n' +
+    '<html lang="en">\n' +
+    '<head>\n' +
+    '<meta charset="utf-8">\n' +
+    '<title>Error</title>\n' +
+    '</head>\n' +
+    '<body>\n' +
+    '<pre>' + body + '</pre>\n' +
+    '</body>\n' +
+    '</html>\n'
+}
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var finalhandler_1 = finalhandler$1;
+
+/**
+ * Create a function to handle the final response.
+ *
+ * @param {Request} req
+ * @param {Response} res
+ * @param {Object} [options]
+ * @return {Function}
+ * @public
+ */
+
+function finalhandler$1 (req, res, options) {
+  var opts = options || {};
+
+  // get environment
+  var env = opts.env || process.env.NODE_ENV || 'development';
+
+  // get error callback
+  var onerror = opts.onerror;
+
+  return function (err) {
+    var headers;
+    var msg;
+    var status;
+
+    // ignore 404 on in-flight response
+    if (!err && headersSent(res)) {
+      debug$e('cannot 404 after headers sent');
+      return
+    }
+
+    // unhandled error
+    if (err) {
+      // respect status code from error
+      status = getErrorStatusCode(err);
+
+      if (status === undefined) {
+        // fallback to status code on response
+        status = getResponseStatusCode(res);
+      } else {
+        // respect headers from error
+        headers = getErrorHeaders(err);
+      }
+
+      // get error message
+      msg = getErrorMessage(err, status, env);
+    } else {
+      // not found
+      status = 404;
+      msg = 'Cannot ' + req.method + ' ' + encodeUrl(getResourceName(req));
+    }
+
+    debug$e('default %s', status);
+
+    // schedule onerror callback
+    if (err && onerror) {
+      defer$1(onerror, err, req, res);
+    }
+
+    // cannot actually respond
+    if (headersSent(res)) {
+      debug$e('cannot %d after headers sent', status);
+      req.socket.destroy();
+      return
+    }
+
+    // send response
+    send$2(req, res, status, headers, msg);
+  }
+}
+
+/**
+ * Get headers from Error object.
+ *
+ * @param {Error} err
+ * @return {object}
+ * @private
+ */
+
+function getErrorHeaders (err) {
+  if (!err.headers || typeof err.headers !== 'object') {
+    return undefined
+  }
+
+  var headers = Object.create(null);
+  var keys = Object.keys(err.headers);
+
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    headers[key] = err.headers[key];
+  }
+
+  return headers
+}
+
+/**
+ * Get message from Error object, fallback to status message.
+ *
+ * @param {Error} err
+ * @param {number} status
+ * @param {string} env
+ * @return {string}
+ * @private
+ */
+
+function getErrorMessage (err, status, env) {
+  var msg;
+
+  if (env !== 'production') {
+    // use err.stack, which typically includes err.message
+    msg = err.stack;
+
+    // fallback to err.toString() when possible
+    if (!msg && typeof err.toString === 'function') {
+      msg = err.toString();
+    }
+  }
+
+  return msg || statuses[status]
+}
+
+/**
+ * Get status code from Error object.
+ *
+ * @param {Error} err
+ * @return {number}
+ * @private
+ */
+
+function getErrorStatusCode (err) {
+  // check err.status
+  if (typeof err.status === 'number' && err.status >= 400 && err.status < 600) {
+    return err.status
+  }
+
+  // check err.statusCode
+  if (typeof err.statusCode === 'number' && err.statusCode >= 400 && err.statusCode < 600) {
+    return err.statusCode
+  }
+
+  return undefined
+}
+
+/**
+ * Get resource name for the request.
+ *
+ * This is typically just the original pathname of the request
+ * but will fallback to "resource" is that cannot be determined.
+ *
+ * @param {IncomingMessage} req
+ * @return {string}
+ * @private
+ */
+
+function getResourceName (req) {
+  try {
+    return parseUrl$2.original(req).pathname
+  } catch (e) {
+    return 'resource'
+  }
+}
+
+/**
+ * Get status code from response.
+ *
+ * @param {OutgoingMessage} res
+ * @return {number}
+ * @private
+ */
+
+function getResponseStatusCode (res) {
+  var status = res.statusCode;
+
+  // default status code to 500 if outside valid range
+  if (typeof status !== 'number' || status < 400 || status > 599) {
+    status = 500;
+  }
+
+  return status
+}
+
+/**
+ * Determine if the response headers have been sent.
+ *
+ * @param {object} res
+ * @returns {boolean}
+ * @private
+ */
+
+function headersSent (res) {
+  return typeof res.headersSent !== 'boolean'
+    ? Boolean(res._header)
+    : res.headersSent
+}
+
+/**
+ * Send response.
+ *
+ * @param {IncomingMessage} req
+ * @param {OutgoingMessage} res
+ * @param {number} status
+ * @param {object} headers
+ * @param {string} message
+ * @private
+ */
+
+function send$2 (req, res, status, headers, message) {
+  function write () {
+    // response body
+    var body = createHtmlDocument(message);
+
+    // response status
+    res.statusCode = status;
+    res.statusMessage = statuses[status];
+
+    // response headers
+    setHeaders(res, headers);
+
+    // security headers
+    res.setHeader('Content-Security-Policy', "default-src 'none'");
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+
+    // standard headers
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.setHeader('Content-Length', Buffer.byteLength(body, 'utf8'));
+
+    if (req.method === 'HEAD') {
+      res.end();
+      return
+    }
+
+    res.end(body, 'utf8');
+  }
+
+  if (isFinished(req)) {
+    write();
+    return
+  }
+
+  // unpipe everything from the request
+  unpipe(req);
+
+  // flush the request
+  onFinished(req, write);
+  req.resume();
+}
+
+/**
+ * Set response headers from an object.
+ *
+ * @param {OutgoingMessage} res
+ * @param {object} headers
+ * @private
+ */
+
+function setHeaders (res, headers) {
+  if (!headers) {
+    return
+  }
+
+  var keys = Object.keys(headers);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    res.setHeader(key, headers[key]);
+  }
+}
+
+var utilsMerge = {exports: {}};
+
+/**
+ * Merge object b with object a.
+ *
+ *     var a = { foo: 'bar' }
+ *       , b = { bar: 'baz' };
+ *
+ *     merge(a, b);
+ *     // => { foo: 'bar', bar: 'baz' }
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object}
+ * @api public
+ */
+
+(function (module, exports) {
+	module.exports = function(a, b){
+	  if (a && b) {
+	    for (var key in b) {
+	      a[key] = b[key];
+	    }
+	  }
+	  return a;
+	}; 
+} (utilsMerge));
+
+var utilsMergeExports = utilsMerge.exports;
+
+/*!
+ * connect
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var debug$d = srcExports('connect:dispatcher');
+var EventEmitter$3 = require$$0$7.EventEmitter;
+var finalhandler = finalhandler_1;
+var http$4 = require$$1;
+var merge = utilsMergeExports;
+var parseUrl$1 = parseurlExports;
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var connect = createServer$1;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var env = process.env.NODE_ENV || 'development';
+var proto = {};
+
+/* istanbul ignore next */
+var defer = typeof setImmediate === 'function'
+  ? setImmediate
+  : function(fn){ process.nextTick(fn.bind.apply(fn, arguments)); };
+
+/**
+ * Create a new connect server.
+ *
+ * @return {function}
+ * @public
+ */
+
+function createServer$1() {
+  function app(req, res, next){ app.handle(req, res, next); }
+  merge(app, proto);
+  merge(app, EventEmitter$3.prototype);
+  app.route = '/';
+  app.stack = [];
+  return app;
+}
+
+/**
+ * Utilize the given middleware `handle` to the given `route`,
+ * defaulting to _/_. This "route" is the mount-point for the
+ * middleware, when given a value other than _/_ the middleware
+ * is only effective when that segment is present in the request's
+ * pathname.
+ *
+ * For example if we were to mount a function at _/admin_, it would
+ * be invoked on _/admin_, and _/admin/settings_, however it would
+ * not be invoked for _/_, or _/posts_.
+ *
+ * @param {String|Function|Server} route, callback or server
+ * @param {Function|Server} callback or server
+ * @return {Server} for chaining
+ * @public
+ */
+
+proto.use = function use(route, fn) {
+  var handle = fn;
+  var path = route;
+
+  // default route to '/'
+  if (typeof route !== 'string') {
+    handle = route;
+    path = '/';
+  }
+
+  // wrap sub-apps
+  if (typeof handle.handle === 'function') {
+    var server = handle;
+    server.route = path;
+    handle = function (req, res, next) {
+      server.handle(req, res, next);
+    };
+  }
+
+  // wrap vanilla http.Servers
+  if (handle instanceof http$4.Server) {
+    handle = handle.listeners('request')[0];
+  }
+
+  // strip trailing slash
+  if (path[path.length - 1] === '/') {
+    path = path.slice(0, -1);
+  }
+
+  // add the middleware
+  debug$d('use %s %s', path || '/', handle.name || 'anonymous');
+  this.stack.push({ route: path, handle: handle });
+
+  return this;
+};
+
+/**
+ * Handle server requests, punting them down
+ * the middleware stack.
+ *
+ * @private
+ */
+
+proto.handle = function handle(req, res, out) {
+  var index = 0;
+  var protohost = getProtohost(req.url) || '';
+  var removed = '';
+  var slashAdded = false;
+  var stack = this.stack;
+
+  // final function handler
+  var done = out || finalhandler(req, res, {
+    env: env,
+    onerror: logerror
+  });
+
+  // store the original URL
+  req.originalUrl = req.originalUrl || req.url;
+
+  function next(err) {
+    if (slashAdded) {
+      req.url = req.url.substr(1);
+      slashAdded = false;
+    }
+
+    if (removed.length !== 0) {
+      req.url = protohost + removed + req.url.substr(protohost.length);
+      removed = '';
+    }
+
+    // next callback
+    var layer = stack[index++];
+
+    // all done
+    if (!layer) {
+      defer(done, err);
+      return;
+    }
+
+    // route data
+    var path = parseUrl$1(req).pathname || '/';
+    var route = layer.route;
+
+    // skip this layer if the route doesn't match
+    if (path.toLowerCase().substr(0, route.length) !== route.toLowerCase()) {
+      return next(err);
+    }
+
+    // skip if route match does not border "/", ".", or end
+    var c = path.length > route.length && path[route.length];
+    if (c && c !== '/' && c !== '.') {
+      return next(err);
+    }
+
+    // trim off the part of the url that matches the route
+    if (route.length !== 0 && route !== '/') {
+      removed = route;
+      req.url = protohost + req.url.substr(protohost.length + removed.length);
+
+      // ensure leading slash
+      if (!protohost && req.url[0] !== '/') {
+        req.url = '/' + req.url;
+        slashAdded = true;
+      }
+    }
+
+    // call the layer handle
+    call(layer.handle, route, err, req, res, next);
+  }
+
+  next();
+};
+
+/**
+ * Listen for connections.
+ *
+ * This method takes the same arguments
+ * as node's `http.Server#listen()`.
+ *
+ * HTTP and HTTPS:
+ *
+ * If you run your application both as HTTP
+ * and HTTPS you may wrap them individually,
+ * since your Connect "server" is really just
+ * a JavaScript `Function`.
+ *
+ *      var connect = require('connect')
+ *        , http = require('http')
+ *        , https = require('https');
+ *
+ *      var app = connect();
+ *
+ *      http.createServer(app).listen(80);
+ *      https.createServer(options, app).listen(443);
+ *
+ * @return {http.Server}
+ * @api public
+ */
+
+proto.listen = function listen() {
+  var server = http$4.createServer(this);
+  return server.listen.apply(server, arguments);
+};
+
+/**
+ * Invoke a route handle.
+ * @private
+ */
+
+function call(handle, route, err, req, res, next) {
+  var arity = handle.length;
+  var error = err;
+  var hasError = Boolean(err);
+
+  debug$d('%s %s : %s', handle.name || '<anonymous>', route, req.originalUrl);
+
+  try {
+    if (hasError && arity === 4) {
+      // error-handling middleware
+      handle(err, req, res, next);
+      return;
+    } else if (!hasError && arity < 4) {
+      // request-handling middleware
+      handle(req, res, next);
+      return;
+    }
+  } catch (e) {
+    // replace the error
+    error = e;
+  }
+
+  // continue
+  next(error);
+}
+
+/**
+ * Log error using console.error.
+ *
+ * @param {Error} err
+ * @private
+ */
+
+function logerror(err) {
+  if (env !== 'test') console.error(err.stack || err.toString());
+}
+
+/**
+ * Get get protocol + host for a URL.
+ *
+ * @param {string} url
+ * @private
+ */
+
+function getProtohost(url) {
+  if (url.length === 0 || url[0] === '/') {
+    return undefined;
+  }
+
+  var fqdnIndex = url.indexOf('://');
+
+  return fqdnIndex !== -1 && url.lastIndexOf('?', fqdnIndex) === -1
+    ? url.substr(0, url.indexOf('/', 3 + fqdnIndex))
+    : undefined;
+}
+
+var connect$1 = /*@__PURE__*/getDefaultExportFromCjs(connect);
+
+var lib = {exports: {}};
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+	if (val === null || val === undefined) {
+		throw new TypeError('Object.assign cannot be called with null or undefined');
+	}
+
+	return Object(val);
+}
+
+function shouldUseNative() {
+	try {
+		if (!Object.assign) {
+			return false;
+		}
+
+		// Detect buggy property enumeration order in older V8 versions.
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+		test1[5] = 'de';
+		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test2 = {};
+		for (var i = 0; i < 10; i++) {
+			test2['_' + String.fromCharCode(i)] = i;
+		}
+		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+			return test2[n];
+		});
+		if (order2.join('') !== '0123456789') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test3 = {};
+		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+			test3[letter] = letter;
+		});
+		if (Object.keys(Object.assign({}, test3)).join('') !==
+				'abcdefghijklmnopqrst') {
+			return false;
+		}
+
+		return true;
+	} catch (err) {
+		// We don't expect any of the above to throw, but better to be safe.
+		return false;
+	}
+}
+
+var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+	var from;
+	var to = toObject(target);
+	var symbols;
+
+	for (var s = 1; s < arguments.length; s++) {
+		from = Object(arguments[s]);
+
+		for (var key in from) {
+			if (hasOwnProperty.call(from, key)) {
+				to[key] = from[key];
+			}
+		}
+
+		if (getOwnPropertySymbols) {
+			symbols = getOwnPropertySymbols(from);
+			for (var i = 0; i < symbols.length; i++) {
+				if (propIsEnumerable.call(from, symbols[i])) {
+					to[symbols[i]] = from[symbols[i]];
+				}
+			}
+		}
+	}
+
+	return to;
+};
+
+var vary$1 = {exports: {}};
+
+/*!
+ * vary
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ */
+
+vary$1.exports = vary;
+vary$1.exports.append = append;
+
+/**
+ * RegExp to match field-name in RFC 7230 sec 3.2
+ *
+ * field-name    = token
+ * token         = 1*tchar
+ * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+ *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+ *               / DIGIT / ALPHA
+ *               ; any VCHAR, except delimiters
+ */
+
+var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+
+/**
+ * Append a field to a vary header.
+ *
+ * @param {String} header
+ * @param {String|Array} field
+ * @return {String}
+ * @public
+ */
+
+function append (header, field) {
+  if (typeof header !== 'string') {
+    throw new TypeError('header argument is required')
+  }
+
+  if (!field) {
+    throw new TypeError('field argument is required')
+  }
+
+  // get fields array
+  var fields = !Array.isArray(field)
+    ? parse$7(String(field))
+    : field;
+
+  // assert on invalid field names
+  for (var j = 0; j < fields.length; j++) {
+    if (!FIELD_NAME_REGEXP.test(fields[j])) {
+      throw new TypeError('field argument contains an invalid header name')
+    }
+  }
+
+  // existing, unspecified vary
+  if (header === '*') {
+    return header
+  }
+
+  // enumerate current values
+  var val = header;
+  var vals = parse$7(header.toLowerCase());
+
+  // unspecified vary
+  if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
+    return '*'
+  }
+
+  for (var i = 0; i < fields.length; i++) {
+    var fld = fields[i].toLowerCase();
+
+    // append value (case-preserving)
+    if (vals.indexOf(fld) === -1) {
+      vals.push(fld);
+      val = val
+        ? val + ', ' + fields[i]
+        : fields[i];
+    }
+  }
+
+  return val
+}
+
+/**
+ * Parse a vary header into an array.
+ *
+ * @param {String} header
+ * @return {Array}
+ * @private
+ */
+
+function parse$7 (header) {
+  var end = 0;
+  var list = [];
+  var start = 0;
+
+  // gather tokens
+  for (var i = 0, len = header.length; i < len; i++) {
+    switch (header.charCodeAt(i)) {
+      case 0x20: /*   */
+        if (start === end) {
+          start = end = i + 1;
+        }
+        break
+      case 0x2c: /* , */
+        list.push(header.substring(start, end));
+        start = end = i + 1;
+        break
+      default:
+        end = i + 1;
+        break
+    }
+  }
+
+  // final token
+  list.push(header.substring(start, end));
+
+  return list
+}
+
+/**
+ * Mark that a request is varied on a header field.
+ *
+ * @param {Object} res
+ * @param {String|Array} field
+ * @public
+ */
+
+function vary (res, field) {
+  if (!res || !res.getHeader || !res.setHeader) {
+    // quack quack
+    throw new TypeError('res argument is required')
+  }
+
+  // get existing header
+  var val = res.getHeader('Vary') || '';
+  var header = Array.isArray(val)
+    ? val.join(', ')
+    : String(val);
+
+  // set new header
+  if ((val = append(header, field))) {
+    res.setHeader('Vary', val);
+  }
+}
+
+var varyExports = vary$1.exports;
+
+(function () {
+
+  var assign = objectAssign;
+  var vary = varyExports;
+
+  var defaults = {
+    origin: '*',
+    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+    preflightContinue: false,
+    optionsSuccessStatus: 204
+  };
+
+  function isString(s) {
+    return typeof s === 'string' || s instanceof String;
+  }
+
+  function isOriginAllowed(origin, allowedOrigin) {
+    if (Array.isArray(allowedOrigin)) {
+      for (var i = 0; i < allowedOrigin.length; ++i) {
+        if (isOriginAllowed(origin, allowedOrigin[i])) {
+          return true;
+        }
+      }
+      return false;
+    } else if (isString(allowedOrigin)) {
+      return origin === allowedOrigin;
+    } else if (allowedOrigin instanceof RegExp) {
+      return allowedOrigin.test(origin);
+    } else {
+      return !!allowedOrigin;
+    }
+  }
+
+  function configureOrigin(options, req) {
+    var requestOrigin = req.headers.origin,
+      headers = [],
+      isAllowed;
+
+    if (!options.origin || options.origin === '*') {
+      // allow any origin
+      headers.push([{
+        key: 'Access-Control-Allow-Origin',
+        value: '*'
+      }]);
+    } else if (isString(options.origin)) {
+      // fixed origin
+      headers.push([{
+        key: 'Access-Control-Allow-Origin',
+        value: options.origin
+      }]);
+      headers.push([{
+        key: 'Vary',
+        value: 'Origin'
+      }]);
+    } else {
+      isAllowed = isOriginAllowed(requestOrigin, options.origin);
+      // reflect origin
+      headers.push([{
+        key: 'Access-Control-Allow-Origin',
+        value: isAllowed ? requestOrigin : false
+      }]);
+      headers.push([{
+        key: 'Vary',
+        value: 'Origin'
+      }]);
+    }
+
+    return headers;
+  }
+
+  function configureMethods(options) {
+    var methods = options.methods;
+    if (methods.join) {
+      methods = options.methods.join(','); // .methods is an array, so turn it into a string
+    }
+    return {
+      key: 'Access-Control-Allow-Methods',
+      value: methods
+    };
+  }
+
+  function configureCredentials(options) {
+    if (options.credentials === true) {
+      return {
+        key: 'Access-Control-Allow-Credentials',
+        value: 'true'
+      };
+    }
+    return null;
+  }
+
+  function configureAllowedHeaders(options, req) {
+    var allowedHeaders = options.allowedHeaders || options.headers;
+    var headers = [];
+
+    if (!allowedHeaders) {
+      allowedHeaders = req.headers['access-control-request-headers']; // .headers wasn't specified, so reflect the request headers
+      headers.push([{
+        key: 'Vary',
+        value: 'Access-Control-Request-Headers'
+      }]);
+    } else if (allowedHeaders.join) {
+      allowedHeaders = allowedHeaders.join(','); // .headers is an array, so turn it into a string
+    }
+    if (allowedHeaders && allowedHeaders.length) {
+      headers.push([{
+        key: 'Access-Control-Allow-Headers',
+        value: allowedHeaders
+      }]);
+    }
+
+    return headers;
+  }
+
+  function configureExposedHeaders(options) {
+    var headers = options.exposedHeaders;
+    if (!headers) {
+      return null;
+    } else if (headers.join) {
+      headers = headers.join(','); // .headers is an array, so turn it into a string
+    }
+    if (headers && headers.length) {
+      return {
+        key: 'Access-Control-Expose-Headers',
+        value: headers
+      };
+    }
+    return null;
+  }
+
+  function configureMaxAge(options) {
+    var maxAge = (typeof options.maxAge === 'number' || options.maxAge) && options.maxAge.toString();
+    if (maxAge && maxAge.length) {
+      return {
+        key: 'Access-Control-Max-Age',
+        value: maxAge
+      };
+    }
+    return null;
+  }
+
+  function applyHeaders(headers, res) {
+    for (var i = 0, n = headers.length; i < n; i++) {
+      var header = headers[i];
+      if (header) {
+        if (Array.isArray(header)) {
+          applyHeaders(header, res);
+        } else if (header.key === 'Vary' && header.value) {
+          vary(res, header.value);
+        } else if (header.value) {
+          res.setHeader(header.key, header.value);
+        }
+      }
+    }
+  }
+
+  function cors(options, req, res, next) {
+    var headers = [],
+      method = req.method && req.method.toUpperCase && req.method.toUpperCase();
+
+    if (method === 'OPTIONS') {
+      // preflight
+      headers.push(configureOrigin(options, req));
+      headers.push(configureCredentials(options));
+      headers.push(configureMethods(options));
+      headers.push(configureAllowedHeaders(options, req));
+      headers.push(configureMaxAge(options));
+      headers.push(configureExposedHeaders(options));
+      applyHeaders(headers, res);
+
+      if (options.preflightContinue) {
+        next();
+      } else {
+        // Safari (and potentially other browsers) need content-length 0,
+        //   for 204 or they just hang waiting for a body
+        res.statusCode = options.optionsSuccessStatus;
+        res.setHeader('Content-Length', '0');
+        res.end();
+      }
+    } else {
+      // actual response
+      headers.push(configureOrigin(options, req));
+      headers.push(configureCredentials(options));
+      headers.push(configureExposedHeaders(options));
+      applyHeaders(headers, res);
+      next();
+    }
+  }
+
+  function middlewareWrapper(o) {
+    // if options are static (either via defaults or custom options passed in), wrap in a function
+    var optionsCallback = null;
+    if (typeof o === 'function') {
+      optionsCallback = o;
+    } else {
+      optionsCallback = function (req, cb) {
+        cb(null, o);
+      };
+    }
+
+    return function corsMiddleware(req, res, next) {
+      optionsCallback(req, function (err, options) {
+        if (err) {
+          next(err);
+        } else {
+          var corsOptions = assign({}, defaults, options);
+          var originCallback = null;
+          if (corsOptions.origin && typeof corsOptions.origin === 'function') {
+            originCallback = corsOptions.origin;
+          } else if (corsOptions.origin) {
+            originCallback = function (origin, cb) {
+              cb(null, corsOptions.origin);
+            };
+          }
+
+          if (originCallback) {
+            originCallback(req.headers.origin, function (err2, origin) {
+              if (err2 || !origin) {
+                next(err2);
+              } else {
+                corsOptions.origin = origin;
+                cors(corsOptions, req, res, next);
+              }
+            });
+          } else {
+            next();
+          }
+        }
+      });
+    };
+  }
+
+  // can pass either an options hash, an options delegate, or nothing
+  lib.exports = middlewareWrapper;
+
+}());
+
+var libExports = lib.exports;
+var corsMiddleware = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+var chokidar = {};
+
+const fs$8 = require$$0__default;
+const { Readable } = require$$0$6;
+const sysPath$3 = require$$0$4;
+const { promisify: promisify$3 } = require$$0$5;
+const picomatch$1 = picomatch$3;
+
+const readdir$1 = promisify$3(fs$8.readdir);
+const stat$3 = promisify$3(fs$8.stat);
+const lstat$2 = promisify$3(fs$8.lstat);
+const realpath$1 = promisify$3(fs$8.realpath);
+
+/**
+ * @typedef {Object} EntryInfo
+ * @property {String} path
+ * @property {String} fullPath
+ * @property {fs.Stats=} stats
+ * @property {fs.Dirent=} dirent
+ * @property {String} basename
+ */
+
+const BANG$2 = '!';
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const FILE_TYPE = 'files';
+const DIR_TYPE = 'directories';
+const FILE_DIR_TYPE = 'files_directories';
+const EVERYTHING_TYPE = 'all';
+const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
+
+const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
+
+const normalizeFilter = filter => {
+  if (filter === undefined) return;
+  if (typeof filter === 'function') return filter;
+
+  if (typeof filter === 'string') {
+    const glob = picomatch$1(filter.trim());
+    return entry => glob(entry.basename);
+  }
+
+  if (Array.isArray(filter)) {
+    const positive = [];
+    const negative = [];
+    for (const item of filter) {
+      const trimmed = item.trim();
+      if (trimmed.charAt(0) === BANG$2) {
+        negative.push(picomatch$1(trimmed.slice(1)));
+      } else {
+        positive.push(picomatch$1(trimmed));
+      }
+    }
+
+    if (negative.length > 0) {
+      if (positive.length > 0) {
+        return entry =>
+          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
+      }
+      return entry => !negative.some(f => f(entry.basename));
+    }
+    return entry => positive.some(f => f(entry.basename));
+  }
+};
+
+class ReaddirpStream extends Readable {
+  static get defaultOptions() {
+    return {
+      root: '.',
+      /* eslint-disable no-unused-vars */
+      fileFilter: (path) => true,
+      directoryFilter: (path) => true,
+      /* eslint-enable no-unused-vars */
+      type: FILE_TYPE,
+      lstat: false,
+      depth: 2147483648,
+      alwaysStat: false
+    };
+  }
+
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark || 4096
+    });
+    const opts = { ...ReaddirpStream.defaultOptions, ...options };
+    const { root, type } = opts;
+
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+
+    const statMethod = opts.lstat ? lstat$2 : stat$3;
+    // Use bigint stats if it's windows and stat() supports options (node 10+).
+    if (wantBigintFsStats) {
+      this._stat = path => statMethod(path, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+
+    this._maxDepth = opts.depth;
+    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
+    this._wantsEverything = type === EVERYTHING_TYPE;
+    this._root = sysPath$3.resolve(root);
+    this._isDirent = ('Dirent' in fs$8) && !opts.alwaysStat;
+    this._statsProp = this._isDirent ? 'dirent' : 'stats';
+    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+
+    // Launch stream with one parent, the root dir.
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = undefined;
+  }
+
+  async _read(batch) {
+    if (this.reading) return;
+    this.reading = true;
+
+    try {
+      while (!this.destroyed && batch > 0) {
+        const { path, depth, files = [] } = this.parent || {};
+
+        if (files.length > 0) {
+          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
+          for (const entry of await Promise.all(slice)) {
+            if (this.destroyed) return;
+
+            const entryType = await this._getEntryType(entry);
+            if (entryType === 'directory' && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed) return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+
+  async _exploreDir(path, depth) {
+    let files;
+    try {
+      files = await readdir$1(path, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path };
+  }
+
+  async _formatEntry(dirent, path) {
+    let entry;
+    try {
+      const basename = this._isDirent ? dirent.name : dirent;
+      const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
+      entry = { path: sysPath$3.relative(this._root, fullPath), fullPath, basename };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+    }
+    return entry;
+  }
+
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit('warn', err);
+    } else {
+      this.destroy(err);
+    }
+  }
+
+  async _getEntryType(entry) {
+    // entry may be undefined, because a warning or an error were emitted
+    // and the statsProp is undefined
+    const stats = entry && entry[this._statsProp];
+    if (!stats) {
+      return;
+    }
+    if (stats.isFile()) {
+      return 'file';
+    }
+    if (stats.isDirectory()) {
+      return 'directory';
+    }
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath$1(full);
+        const entryRealPathStats = await lstat$2(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return 'file';
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
+            const recursiveError = new Error(
+              `Circular symlink detected: "${full}" points to "${entryRealPath}"`
+            );
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return 'directory';
+        }
+      } catch (error) {
+        this._onError(error);
+      }
+    }
+  }
+
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+}
+
+/**
+ * @typedef {Object} ReaddirpArguments
+ * @property {Function=} fileFilter
+ * @property {Function=} directoryFilter
+ * @property {String=} type
+ * @property {Number=} depth
+ * @property {String=} root
+ * @property {Boolean=} lstat
+ * @property {Boolean=} bigint
+ */
+
+/**
+ * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
+ * @param {String} root Root directory
+ * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
+ */
+const readdirp$1 = (root, options = {}) => {
+  let type = options.entryType || options.type;
+  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
+  if (type) options.type = type;
+  if (!root) {
+    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+  } else if (typeof root !== 'string') {
+    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+  }
+
+  options.root = root;
+  return new ReaddirpStream(options);
+};
+
+const readdirpPromise = (root, options = {}) => {
+  return new Promise((resolve, reject) => {
+    const files = [];
+    readdirp$1(root, options)
+      .on('data', entry => files.push(entry))
+      .on('end', () => resolve(files))
+      .on('error', error => reject(error));
+  });
+};
+
+readdirp$1.promise = readdirpPromise;
+readdirp$1.ReaddirpStream = ReaddirpStream;
+readdirp$1.default = readdirp$1;
+
+var readdirp_1 = readdirp$1;
+
+var anymatch$2 = {exports: {}};
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var normalizePath$2 = function(path, stripTrailing) {
+  if (typeof path !== 'string') {
+    throw new TypeError('expected path to be a string');
+  }
+
+  if (path === '\\' || path === '/') return '/';
+
+  var len = path.length;
+  if (len <= 1) return path;
+
+  // ensure that win32 namespaces has two leading slashes, so that the path is
+  // handled properly by the win32 version of path.parse() after being normalized
+  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
+  var prefix = '';
+  if (len > 4 && path[3] === '\\') {
+    var ch = path[2];
+    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
+      path = path.slice(2);
+      prefix = '//';
+    }
+  }
+
+  var segs = path.split(/[/\\]+/);
+  if (stripTrailing !== false && segs[segs.length - 1] === '') {
+    segs.pop();
+  }
+  return prefix + segs.join('/');
+};
+
+var anymatch_1 = anymatch$2.exports;
+
+Object.defineProperty(anymatch_1, "__esModule", { value: true });
+
+const picomatch = picomatch$3;
+const normalizePath$1 = normalizePath$2;
+
+/**
+ * @typedef {(testString: string) => boolean} AnymatchFn
+ * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
+ * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
+ */
+const BANG$1 = '!';
+const DEFAULT_OPTIONS = {returnIndex: false};
+const arrify$1 = (item) => Array.isArray(item) ? item : [item];
+
+/**
+ * @param {AnymatchPattern} matcher
+ * @param {object} options
+ * @returns {AnymatchFn}
+ */
+const createPattern = (matcher, options) => {
+  if (typeof matcher === 'function') {
+    return matcher;
+  }
+  if (typeof matcher === 'string') {
+    const glob = picomatch(matcher, options);
+    return (string) => matcher === string || glob(string);
+  }
+  if (matcher instanceof RegExp) {
+    return (string) => matcher.test(string);
+  }
+  return (string) => false;
+};
+
+/**
+ * @param {Array<Function>} patterns
+ * @param {Array<Function>} negPatterns
+ * @param {String|Array} args
+ * @param {Boolean} returnIndex
+ * @returns {boolean|number}
+ */
+const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
+  const isList = Array.isArray(args);
+  const _path = isList ? args[0] : args;
+  if (!isList && typeof _path !== 'string') {
+    throw new TypeError('anymatch: second argument must be a string: got ' +
+      Object.prototype.toString.call(_path))
+  }
+  const path = normalizePath$1(_path);
+
+  for (let index = 0; index < negPatterns.length; index++) {
+    const nglob = negPatterns[index];
+    if (nglob(path)) {
+      return returnIndex ? -1 : false;
+    }
+  }
+
+  const applied = isList && [path].concat(args.slice(1));
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (isList ? pattern(...applied) : pattern(path)) {
+      return returnIndex ? index : true;
+    }
+  }
+
+  return returnIndex ? -1 : false;
+};
+
+/**
+ * @param {AnymatchMatcher} matchers
+ * @param {Array|string} testString
+ * @param {object} options
+ * @returns {boolean|number|Function}
+ */
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
+  if (matchers == null) {
+    throw new TypeError('anymatch: specify first argument');
+  }
+  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
+  const returnIndex = opts.returnIndex || false;
+
+  // Early cache for matchers.
+  const mtchers = arrify$1(matchers);
+  const negatedGlobs = mtchers
+    .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
+    .map(item => item.slice(1))
+    .map(item => picomatch(item, opts));
+  const patterns = mtchers
+    .filter(item => typeof item !== 'string' || (typeof item === 'string' && item.charAt(0) !== BANG$1))
+    .map(matcher => createPattern(matcher, opts));
+
+  if (testString == null) {
+    return (testString, ri = false) => {
+      const returnIndex = typeof ri === 'boolean' ? ri : false;
+      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+    }
+  }
+
+  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
+};
+
+anymatch$1.default = anymatch$1;
+anymatch$2.exports = anymatch$1;
+
+var anymatchExports = anymatch$2.exports;
+
+var require$$0 = [
+	"3dm",
+	"3ds",
+	"3g2",
+	"3gp",
+	"7z",
+	"a",
+	"aac",
+	"adp",
+	"ai",
+	"aif",
+	"aiff",
+	"alz",
+	"ape",
+	"apk",
+	"appimage",
+	"ar",
+	"arj",
+	"asf",
+	"au",
+	"avi",
+	"bak",
+	"baml",
+	"bh",
+	"bin",
+	"bk",
+	"bmp",
+	"btif",
+	"bz2",
+	"bzip2",
+	"cab",
+	"caf",
+	"cgm",
+	"class",
+	"cmx",
+	"cpio",
+	"cr2",
+	"cur",
+	"dat",
+	"dcm",
+	"deb",
+	"dex",
+	"djvu",
+	"dll",
+	"dmg",
+	"dng",
+	"doc",
+	"docm",
+	"docx",
+	"dot",
+	"dotm",
+	"dra",
+	"DS_Store",
+	"dsk",
+	"dts",
+	"dtshd",
+	"dvb",
+	"dwg",
+	"dxf",
+	"ecelp4800",
+	"ecelp7470",
+	"ecelp9600",
+	"egg",
+	"eol",
+	"eot",
+	"epub",
+	"exe",
+	"f4v",
+	"fbs",
+	"fh",
+	"fla",
+	"flac",
+	"flatpak",
+	"fli",
+	"flv",
+	"fpx",
+	"fst",
+	"fvt",
+	"g3",
+	"gh",
+	"gif",
+	"graffle",
+	"gz",
+	"gzip",
+	"h261",
+	"h263",
+	"h264",
+	"icns",
+	"ico",
+	"ief",
+	"img",
+	"ipa",
+	"iso",
+	"jar",
+	"jpeg",
+	"jpg",
+	"jpgv",
+	"jpm",
+	"jxr",
+	"key",
+	"ktx",
+	"lha",
+	"lib",
+	"lvp",
+	"lz",
+	"lzh",
+	"lzma",
+	"lzo",
+	"m3u",
+	"m4a",
+	"m4v",
+	"mar",
+	"mdi",
+	"mht",
+	"mid",
+	"midi",
+	"mj2",
+	"mka",
+	"mkv",
+	"mmr",
+	"mng",
+	"mobi",
+	"mov",
+	"movie",
+	"mp3",
+	"mp4",
+	"mp4a",
+	"mpeg",
+	"mpg",
+	"mpga",
+	"mxu",
+	"nef",
+	"npx",
+	"numbers",
+	"nupkg",
+	"o",
+	"odp",
+	"ods",
+	"odt",
+	"oga",
+	"ogg",
+	"ogv",
+	"otf",
+	"ott",
+	"pages",
+	"pbm",
+	"pcx",
+	"pdb",
+	"pdf",
+	"pea",
+	"pgm",
+	"pic",
+	"png",
+	"pnm",
+	"pot",
+	"potm",
+	"potx",
+	"ppa",
+	"ppam",
+	"ppm",
+	"pps",
+	"ppsm",
+	"ppsx",
+	"ppt",
+	"pptm",
+	"pptx",
+	"psd",
+	"pya",
+	"pyc",
+	"pyo",
+	"pyv",
+	"qt",
+	"rar",
+	"ras",
+	"raw",
+	"resources",
+	"rgb",
+	"rip",
+	"rlc",
+	"rmf",
+	"rmvb",
+	"rpm",
+	"rtf",
+	"rz",
+	"s3m",
+	"s7z",
+	"scpt",
+	"sgi",
+	"shar",
+	"snap",
+	"sil",
+	"sketch",
+	"slk",
+	"smv",
+	"snk",
+	"so",
+	"stl",
+	"suo",
+	"sub",
+	"swf",
+	"tar",
+	"tbz",
+	"tbz2",
+	"tga",
+	"tgz",
+	"thmx",
+	"tif",
+	"tiff",
+	"tlz",
+	"ttc",
+	"ttf",
+	"txz",
+	"udf",
+	"uvh",
+	"uvi",
+	"uvm",
+	"uvp",
+	"uvs",
+	"uvu",
+	"viv",
+	"vob",
+	"war",
+	"wav",
+	"wax",
+	"wbmp",
+	"wdp",
+	"weba",
+	"webm",
+	"webp",
+	"whl",
+	"wim",
+	"wm",
+	"wma",
+	"wmv",
+	"wmx",
+	"woff",
+	"woff2",
+	"wrm",
+	"wvx",
+	"xbm",
+	"xif",
+	"xla",
+	"xlam",
+	"xls",
+	"xlsb",
+	"xlsm",
+	"xlsx",
+	"xlt",
+	"xltm",
+	"xltx",
+	"xm",
+	"xmind",
+	"xpi",
+	"xpm",
+	"xwd",
+	"xz",
+	"z",
+	"zip",
+	"zipx"
+];
+
+var binaryExtensions$1 = require$$0;
+
+const path$8 = require$$0$4;
+const binaryExtensions = binaryExtensions$1;
+
+const extensions = new Set(binaryExtensions);
+
+var isBinaryPath$1 = filePath => extensions.has(path$8.extname(filePath).slice(1).toLowerCase());
+
+var constants$1 = {};
+
+(function (exports) {
+
+	const {sep} = require$$0$4;
+	const {platform} = process;
+	const os = require$$2;
+
+	exports.EV_ALL = 'all';
+	exports.EV_READY = 'ready';
+	exports.EV_ADD = 'add';
+	exports.EV_CHANGE = 'change';
+	exports.EV_ADD_DIR = 'addDir';
+	exports.EV_UNLINK = 'unlink';
+	exports.EV_UNLINK_DIR = 'unlinkDir';
+	exports.EV_RAW = 'raw';
+	exports.EV_ERROR = 'error';
+
+	exports.STR_DATA = 'data';
+	exports.STR_END = 'end';
+	exports.STR_CLOSE = 'close';
+
+	exports.FSEVENT_CREATED = 'created';
+	exports.FSEVENT_MODIFIED = 'modified';
+	exports.FSEVENT_DELETED = 'deleted';
+	exports.FSEVENT_MOVED = 'moved';
+	exports.FSEVENT_CLONED = 'cloned';
+	exports.FSEVENT_UNKNOWN = 'unknown';
+	exports.FSEVENT_FLAG_MUST_SCAN_SUBDIRS = 1;
+	exports.FSEVENT_TYPE_FILE = 'file';
+	exports.FSEVENT_TYPE_DIRECTORY = 'directory';
+	exports.FSEVENT_TYPE_SYMLINK = 'symlink';
+
+	exports.KEY_LISTENERS = 'listeners';
+	exports.KEY_ERR = 'errHandlers';
+	exports.KEY_RAW = 'rawEmitters';
+	exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];
+
+	exports.DOT_SLASH = `.${sep}`;
+
+	exports.BACK_SLASH_RE = /\\/g;
+	exports.DOUBLE_SLASH_RE = /\/\//;
+	exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
+	exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+	exports.REPLACER_RE = /^\.[/\\]/;
+
+	exports.SLASH = '/';
+	exports.SLASH_SLASH = '//';
+	exports.BRACE_START = '{';
+	exports.BANG = '!';
+	exports.ONE_DOT = '.';
+	exports.TWO_DOTS = '..';
+	exports.STAR = '*';
+	exports.GLOBSTAR = '**';
+	exports.ROOT_GLOBSTAR = '/**/*';
+	exports.SLASH_GLOBSTAR = '/**';
+	exports.DIR_SUFFIX = 'Dir';
+	exports.ANYMATCH_OPTS = {dot: true};
+	exports.STRING_TYPE = 'string';
+	exports.FUNCTION_TYPE = 'function';
+	exports.EMPTY_STR = '';
+	exports.EMPTY_FN = () => {};
+	exports.IDENTITY_FN = val => val;
+
+	exports.isWindows = platform === 'win32';
+	exports.isMacos = platform === 'darwin';
+	exports.isLinux = platform === 'linux';
+	exports.isIBMi = os.type() === 'OS400'; 
+} (constants$1));
+
+const fs$7 = require$$0__default;
+const sysPath$2 = require$$0$4;
+const { promisify: promisify$2 } = require$$0$5;
+const isBinaryPath = isBinaryPath$1;
+const {
+  isWindows: isWindows$2,
+  isLinux,
+  EMPTY_FN: EMPTY_FN$2,
+  EMPTY_STR: EMPTY_STR$1,
+  KEY_LISTENERS,
+  KEY_ERR,
+  KEY_RAW,
+  HANDLER_KEYS,
+  EV_CHANGE: EV_CHANGE$2,
+  EV_ADD: EV_ADD$2,
+  EV_ADD_DIR: EV_ADD_DIR$2,
+  EV_ERROR: EV_ERROR$2,
+  STR_DATA: STR_DATA$1,
+  STR_END: STR_END$2,
+  BRACE_START: BRACE_START$1,
+  STAR
+} = constants$1;
+
+const THROTTLE_MODE_WATCH = 'watch';
+
+const open$2 = promisify$2(fs$7.open);
+const stat$2 = promisify$2(fs$7.stat);
+const lstat$1 = promisify$2(fs$7.lstat);
+const close = promisify$2(fs$7.close);
+const fsrealpath = promisify$2(fs$7.realpath);
+
+const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
+
+// TODO: emit errors properly. Example: EMFILE on Macos.
+const foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+
+const addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+};
+
+const clearItem = cont => key => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+
+const delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+
+const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+
+/**
+ * @typedef {String} Path
+ */
+
+// fs_watch helpers
+
+// object to hold per-process fs_watch instances
+// (may be shared across chokidar FSWatcher instances)
+
+/**
+ * @typedef {Object} FsWatchContainer
+ * @property {Set} listeners
+ * @property {Set} errHandlers
+ * @property {Set} rawEmitters
+ * @property {fs.FSWatcher=} watcher
+ * @property {Boolean=} watcherUnusable
+ */
+
+/**
+ * @type {Map<String,FsWatchContainer>}
+ */
+const FsWatchInstances = new Map();
+
+/**
+ * Instantiates the fs_watch interface
+ * @param {String} path to be watched
+ * @param {Object} options to be passed to fs_watch
+ * @param {Function} listener main event handler
+ * @param {Function} errHandler emits info about errors
+ * @param {Function} emitRaw emits raw event data
+ * @returns {fs.FSWatcher} new fsevents instance
+ */
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path);
+    emitRaw(rawEvent, evPath, {watchedPath: path});
+
+    // emit based on events occurring for files from a directory's watcher in
+    // case the file's watcher misses it (and rely on throttling to de-dupe)
+    if (evPath && path !== evPath) {
+      fsWatchBroadcast(
+        sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
+      );
+    }
+  };
+  try {
+    return fs$7.watch(path, options, handleEvent);
+  } catch (error) {
+    errHandler(error);
+  }
+}
+
+/**
+ * Helper for passing fs_watch event data to a collection of listeners
+ * @param {Path} fullPath absolute path bound to fs_watch instance
+ * @param {String} type listener type
+ * @param {*=} val1 arguments to be passed to listeners
+ * @param {*=} val2
+ * @param {*=} val3
+ */
+const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont) return;
+  foreach(cont[type], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+
+/**
+ * Instantiates the fs_watch interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path
+ * @param {String} fullPath absolute path
+ * @param {Object} options to be passed to fs_watch
+ * @param {Object} handlers container for event listener functions
+ */
+const setFsWatchListener = (path, fullPath, options, handlers) => {
+  const {listener, errHandler, rawEmitter} = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+
+  /** @type {fs.FSWatcher=} */
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(
+      path, options, listener, errHandler, rawEmitter
+    );
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler, // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher) return;
+    watcher.on(EV_ERROR$2, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      cont.watcherUnusable = true; // documented since Node 10.4.1
+      // Workaround for https://github.com/joyent/node/issues/4337
+      if (isWindows$2 && error.code === 'EPERM') {
+        try {
+          const fd = await open$2(path, 'r');
+          await close(fd);
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  // const index = cont.listeners.indexOf(listener);
+
+  // removes this instance's listeners and closes the underlying fs_watch
+  // instance if there are no more listeners left
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      // Check to protect against issue gh-730.
+      // if (cont.watcherUnusable) {
+      cont.watcher.close();
+      // }
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+// fs_watchFile helpers
+
+// object to hold per-process fs_watchFile instances
+// (may be shared across chokidar FSWatcher instances)
+const FsWatchFileInstances = new Map();
+
+/**
+ * Instantiates the fs_watchFile interface or binds listeners
+ * to an existing one covering the same file system entry
+ * @param {String} path to be watched
+ * @param {String} fullPath absolute path
+ * @param {Object} options options to be passed to fs_watchFile
+ * @param {Object} handlers container for event listener functions
+ * @returns {Function} closer
+ */
+const setFsWatchFileListener = (path, fullPath, options, handlers) => {
+  const {listener, rawEmitter} = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    fs$7.unwatchFile(fullPath);
+    cont = undefined;
+  }
+
+  /* eslint-enable no-unused-vars, prefer-destructuring */
+
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    // TODO
+    // listeners.add(listener);
+    // rawEmitters.add(rawEmitter);
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: fs$7.watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter) => {
+          rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener) => listener(path, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  // const index = cont.listeners.indexOf(listener);
+
+  // Removes this instance's listeners and closes the underlying fs_watchFile
+  // instance if there are no more listeners left.
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      fs$7.unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+
+/**
+ * @mixin
+ */
+let NodeFsHandler$1 = class NodeFsHandler {
+
+/**
+ * @param {import("../index").FSWatcher} fsW
+ */
+constructor(fsW) {
+  this.fsw = fsW;
+  this._boundHandleError = (error) => fsW._handleError(error);
+}
+
+/**
+ * Watch file for changes with fs_watchFile or fs_watch.
+ * @param {String} path to file or dir
+ * @param {Function} listener on fs change
+ * @returns {Function} closer for the watcher instance
+ */
+_watchWithNodeFs(path, listener) {
+  const opts = this.fsw.options;
+  const directory = sysPath$2.dirname(path);
+  const basename = sysPath$2.basename(path);
+  const parent = this.fsw._getWatchedDir(directory);
+  parent.add(basename);
+  const absolutePath = sysPath$2.resolve(path);
+  const options = {persistent: opts.persistent};
+  if (!listener) listener = EMPTY_FN$2;
+
+  let closer;
+  if (opts.usePolling) {
+    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+      opts.binaryInterval : opts.interval;
+    closer = setFsWatchFileListener(path, absolutePath, options, {
+      listener,
+      rawEmitter: this.fsw._emitRaw
+    });
+  } else {
+    closer = setFsWatchListener(path, absolutePath, options, {
+      listener,
+      errHandler: this._boundHandleError,
+      rawEmitter: this.fsw._emitRaw
+    });
+  }
+  return closer;
+}
+
+/**
+ * Watch a file and emit add event if warranted.
+ * @param {Path} file Path
+ * @param {fs.Stats} stats result of fs_stat
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @returns {Function} closer for the watcher instance
+ */
+_handleFile(file, stats, initialAdd) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const dirname = sysPath$2.dirname(file);
+  const basename = sysPath$2.basename(file);
+  const parent = this.fsw._getWatchedDir(dirname);
+  // stats is always present
+  let prevStats = stats;
+
+  // if the file is already being watched, do nothing
+  if (parent.has(basename)) return;
+
+  const listener = async (path, newStats) => {
+    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
+    if (!newStats || newStats.mtimeMs === 0) {
+      try {
+        const newStats = await stat$2(file);
+        if (this.fsw.closed) return;
+        // Check that change event was not fired because of changed only accessTime.
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV_CHANGE$2, file, newStats);
+        }
+        if (isLinux && prevStats.ino !== newStats.ino) {
+          this.fsw._closeFile(path);
+          prevStats = newStats;
+          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+        } else {
+          prevStats = newStats;
+        }
+      } catch (error) {
+        // Fix issues where mtime is null but file is still present
+        this.fsw._remove(dirname, basename);
+      }
+      // add is about to be emitted if file not already tracked in parent
+    } else if (parent.has(basename)) {
+      // Check that change event was not fired because of changed only accessTime.
+      const at = newStats.atimeMs;
+      const mt = newStats.mtimeMs;
+      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+        this.fsw._emit(EV_CHANGE$2, file, newStats);
+      }
+      prevStats = newStats;
+    }
+  };
+  // kick off the watcher
+  const closer = this._watchWithNodeFs(file, listener);
+
+  // emit an add event if we're supposed to
+  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+    if (!this.fsw._throttle(EV_ADD$2, file, 0)) return;
+    this.fsw._emit(EV_ADD$2, file, stats);
+  }
+
+  return closer;
+}
+
+/**
+ * Handle symlinks encountered while reading a dir.
+ * @param {Object} entry returned by readdirp
+ * @param {String} directory path of dir being read
+ * @param {String} path of this item
+ * @param {String} item basename of this item
+ * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
+ */
+async _handleSymlink(entry, directory, path, item) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const full = entry.fullPath;
+  const dir = this.fsw._getWatchedDir(directory);
+
+  if (!this.fsw.options.followSymlinks) {
+    // watch symlink directly (don't follow) and detect changes
+    this.fsw._incrReadyCount();
+
+    let linkPath;
+    try {
+      linkPath = await fsrealpath(path);
+    } catch (e) {
+      this.fsw._emitReady();
+      return true;
+    }
+
+    if (this.fsw.closed) return;
+    if (dir.has(item)) {
+      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV_CHANGE$2, path, entry.stats);
+      }
+    } else {
+      dir.add(item);
+      this.fsw._symlinkPaths.set(full, linkPath);
+      this.fsw._emit(EV_ADD$2, path, entry.stats);
+    }
+    this.fsw._emitReady();
+    return true;
+  }
+
+  // don't follow the same symlink more than once
+  if (this.fsw._symlinkPaths.has(full)) {
+    return true;
+  }
+
+  this.fsw._symlinkPaths.set(full, true);
+}
+
+_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+  // Normalize the directory name on Windows
+  directory = sysPath$2.join(directory, EMPTY_STR$1);
+
+  if (!wh.hasGlob) {
+    throttler = this.fsw._throttle('readdir', directory, 1000);
+    if (!throttler) return;
+  }
+
+  const previous = this.fsw._getWatchedDir(wh.path);
+  const current = new Set();
+
+  let stream = this.fsw._readdirp(directory, {
+    fileFilter: entry => wh.filterPath(entry),
+    directoryFilter: entry => wh.filterDir(entry),
+    depth: 0
+  }).on(STR_DATA$1, async (entry) => {
+    if (this.fsw.closed) {
+      stream = undefined;
+      return;
+    }
+    const item = entry.path;
+    let path = sysPath$2.join(directory, item);
+    current.add(item);
+
+    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
+      return;
+    }
+
+    if (this.fsw.closed) {
+      stream = undefined;
+      return;
+    }
+    // Files that present in current directory snapshot
+    // but absent in previous are added to watch list and
+    // emit `add` event.
+    if (item === target || !target && !previous.has(item)) {
+      this.fsw._incrReadyCount();
+
+      // ensure relativeness of path is preserved in case of watcher reuse
+      path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
+
+      this._addToNodeFs(path, initialAdd, wh, depth + 1);
+    }
+  }).on(EV_ERROR$2, this._boundHandleError);
+
+  return new Promise(resolve =>
+    stream.once(STR_END$2, () => {
+      if (this.fsw.closed) {
+        stream = undefined;
+        return;
+      }
+      const wasThrottled = throttler ? throttler.clear() : false;
+
+      resolve();
+
+      // Files that absent in current directory snapshot
+      // but present in previous emit `remove` event
+      // and are removed from @watched[directory].
+      previous.getChildren().filter((item) => {
+        return item !== directory &&
+          !current.has(item) &&
+          // in case of intersecting globs;
+          // a path may have been filtered out of this readdir, but
+          // shouldn't be removed because it matches a different glob
+          (!wh.hasGlob || wh.filterPath({
+            fullPath: sysPath$2.resolve(directory, item)
+          }));
+      }).forEach((item) => {
+        this.fsw._remove(directory, item);
+      });
+
+      stream = undefined;
+
+      // one more time for any missed in case changes came in extremely quickly
+      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
+    })
+  );
+}
+
+/**
+ * Read directory to add / remove files from `@watched` list and re-read it on change.
+ * @param {String} dir fs path
+ * @param {fs.Stats} stats
+ * @param {Boolean} initialAdd
+ * @param {Number} depth relative to user-supplied path
+ * @param {String} target child path targeted for watch
+ * @param {Object} wh Common watch helpers for this path
+ * @param {String} realpath
+ * @returns {Promise<Function>} closer for the watcher instance.
+ */
+async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+  const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+  const tracked = parentDir.has(sysPath$2.basename(dir));
+  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
+  }
+
+  // ensure dir is tracked (harmless if redundant)
+  parentDir.add(sysPath$2.basename(dir));
+  this.fsw._getWatchedDir(dir);
+  let throttler;
+  let closer;
+
+  const oDepth = this.fsw.options.depth;
+  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+    if (!target) {
+      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+      if (this.fsw.closed) return;
+    }
+
+    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
+      // if current directory is removed, do nothing
+      if (stats && stats.mtimeMs === 0) return;
+
+      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+    });
+  }
+  return closer;
+}
+
+/**
+ * Handle added file, directory, or glob pattern.
+ * Delegates call to _handleFile / _handleDir after checks.
+ * @param {String} path to file or ir
+ * @param {Boolean} initialAdd was the file added at watch instantiation?
+ * @param {Object} priorWh depth relative to user-supplied path
+ * @param {Number} depth Child path actually targeted for watch
+ * @param {String=} target Child path actually targeted for watch
+ * @returns {Promise}
+ */
+async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+  const ready = this.fsw._emitReady;
+  if (this.fsw._isIgnored(path) || this.fsw.closed) {
+    ready();
+    return false;
+  }
+
+  const wh = this.fsw._getWatchHelpers(path, depth);
+  if (!wh.hasGlob && priorWh) {
+    wh.hasGlob = priorWh.hasGlob;
+    wh.globFilter = priorWh.globFilter;
+    wh.filterPath = entry => priorWh.filterPath(entry);
+    wh.filterDir = entry => priorWh.filterDir(entry);
+  }
+
+  // evaluate what is at the path we're being asked to watch
+  try {
+    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+      ready();
+      return false;
+    }
+
+    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
+    let closer;
+    if (stats.isDirectory()) {
+      const absPath = sysPath$2.resolve(path);
+      const targetPath = follow ? await fsrealpath(path) : path;
+      if (this.fsw.closed) return;
+      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+      if (this.fsw.closed) return;
+      // preserve this symlink's target path
+      if (absPath !== targetPath && targetPath !== undefined) {
+        this.fsw._symlinkPaths.set(absPath, targetPath);
+      }
+    } else if (stats.isSymbolicLink()) {
+      const targetPath = follow ? await fsrealpath(path) : path;
+      if (this.fsw.closed) return;
+      const parent = sysPath$2.dirname(wh.watchPath);
+      this.fsw._getWatchedDir(parent).add(wh.watchPath);
+      this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
+      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
+      if (this.fsw.closed) return;
+
+      // preserve this symlink's target path
+      if (targetPath !== undefined) {
+        this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
+      }
+    } else {
+      closer = this._handleFile(wh.watchPath, stats, initialAdd);
+    }
+    ready();
+
+    this.fsw._addPathCloser(path, closer);
+    return false;
+
+  } catch (error) {
+    if (this.fsw._handleError(error)) {
+      ready();
+      return path;
+    }
+  }
+}
+
+};
+
+var nodefsHandler = NodeFsHandler$1;
+
+var fseventsHandler = {exports: {}};
+
+const fs$6 = require$$0__default;
+const sysPath$1 = require$$0$4;
+const { promisify: promisify$1 } = require$$0$5;
+
+let fsevents;
+try {
+  fsevents = __require('fsevents');
+} catch (error) {
+  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
+}
+
+if (fsevents) {
+  // TODO: real check
+  const mtch = process.version.match(/v(\d+)\.(\d+)/);
+  if (mtch && mtch[1] && mtch[2]) {
+    const maj = Number.parseInt(mtch[1], 10);
+    const min = Number.parseInt(mtch[2], 10);
+    if (maj === 8 && min < 16) {
+      fsevents = undefined;
+    }
+  }
+}
+
+const {
+  EV_ADD: EV_ADD$1,
+  EV_CHANGE: EV_CHANGE$1,
+  EV_ADD_DIR: EV_ADD_DIR$1,
+  EV_UNLINK: EV_UNLINK$1,
+  EV_ERROR: EV_ERROR$1,
+  STR_DATA,
+  STR_END: STR_END$1,
+  FSEVENT_CREATED,
+  FSEVENT_MODIFIED,
+  FSEVENT_DELETED,
+  FSEVENT_MOVED,
+  // FSEVENT_CLONED,
+  FSEVENT_UNKNOWN,
+  FSEVENT_FLAG_MUST_SCAN_SUBDIRS,
+  FSEVENT_TYPE_FILE,
+  FSEVENT_TYPE_DIRECTORY,
+  FSEVENT_TYPE_SYMLINK,
+
+  ROOT_GLOBSTAR,
+  DIR_SUFFIX,
+  DOT_SLASH,
+  FUNCTION_TYPE: FUNCTION_TYPE$1,
+  EMPTY_FN: EMPTY_FN$1,
+  IDENTITY_FN
+} = constants$1;
+
+const Depth = (value) => isNaN(value) ? {} : {depth: value};
+
+const stat$1 = promisify$1(fs$6.stat);
+const lstat = promisify$1(fs$6.lstat);
+const realpath = promisify$1(fs$6.realpath);
+
+const statMethods = { stat: stat$1, lstat };
+
+/**
+ * @typedef {String} Path
+ */
+
+/**
+ * @typedef {Object} FsEventsWatchContainer
+ * @property {Set<Function>} listeners
+ * @property {Function} rawEmitter
+ * @property {{stop: Function}} watcher
+ */
+
+// fsevents instance helper functions
+/**
+ * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
+ * @type {Map<Path,FsEventsWatchContainer>}
+ */
+const FSEventsWatchers = new Map();
+
+// Threshold of duplicate path prefixes at which to start
+// consolidating going forward
+const consolidateThreshhold = 10;
+
+const wrongEventFlags = new Set([
+  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
+]);
+
+/**
+ * Instantiates the fsevents interface
+ * @param {Path} path path to be watched
+ * @param {Function} callback called when fsevents is bound and ready
+ * @returns {{stop: Function}} new fsevents instance
+ */
+const createFSEventsInstance = (path, callback) => {
+  const stop = fsevents.watch(path, callback);
+  return {stop};
+};
+
+/**
+ * Instantiates the fsevents interface or binds listeners to an existing one covering
+ * the same file tree.
+ * @param {Path} path           - to be watched
+ * @param {Path} realPath       - real path for symlinks
+ * @param {Function} listener   - called when fsevents emits events
+ * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
+ * @returns {Function} closer
+ */
+function setFSEventsListener(path, realPath, listener, rawEmitter) {
+  let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
+
+  const parentPath = sysPath$1.dirname(watchPath);
+  let cont = FSEventsWatchers.get(watchPath);
+
+  // If we've accumulated a substantial number of paths that
+  // could have been consolidated by watching one directory
+  // above the current one, create a watcher on the parent
+  // path instead, so that we do consolidate going forward.
+  if (couldConsolidate(parentPath)) {
+    watchPath = parentPath;
+  }
+
+  const resolvedPath = sysPath$1.resolve(path);
+  const hasSymlink = resolvedPath !== realPath;
+
+  const filteredListener = (fullPath, flags, info) => {
+    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
+    if (
+      fullPath === resolvedPath ||
+      !fullPath.indexOf(resolvedPath + sysPath$1.sep)
+    ) listener(fullPath, flags, info);
+  };
+
+  // check if there is already a watcher on a parent path
+  // modifies `watchPath` to the parent path when it finds a match
+  let watchedParent = false;
+  for (const watchedPath of FSEventsWatchers.keys()) {
+    if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
+      watchPath = watchedPath;
+      cont = FSEventsWatchers.get(watchPath);
+      watchedParent = true;
+      break;
+    }
+  }
+
+  if (cont || watchedParent) {
+    cont.listeners.add(filteredListener);
+  } else {
+    cont = {
+      listeners: new Set([filteredListener]),
+      rawEmitter,
+      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
+        if (!cont.listeners.size) return;
+        if (flags & FSEVENT_FLAG_MUST_SCAN_SUBDIRS) return;
+        const info = fsevents.getInfo(fullPath, flags);
+        cont.listeners.forEach(list => {
+          list(fullPath, flags, info);
+        });
+
+        cont.rawEmitter(info.event, fullPath, info);
+      })
+    };
+    FSEventsWatchers.set(watchPath, cont);
+  }
+
+  // removes this instance's listeners and closes the underlying fsevents
+  // instance if there are no more listeners left
+  return () => {
+    const lst = cont.listeners;
+
+    lst.delete(filteredListener);
+    if (!lst.size) {
+      FSEventsWatchers.delete(watchPath);
+      if (cont.watcher) return cont.watcher.stop().then(() => {
+        cont.rawEmitter = cont.watcher = undefined;
+        Object.freeze(cont);
+      });
+    }
+  };
+}
+
+// Decide whether or not we should start a new higher-level
+// parent watcher
+const couldConsolidate = (path) => {
+  let count = 0;
+  for (const watchPath of FSEventsWatchers.keys()) {
+    if (watchPath.indexOf(path) === 0) {
+      count++;
+      if (count >= consolidateThreshhold) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+// returns boolean indicating whether fsevents can be used
+const canUse = () => fsevents && FSEventsWatchers.size < 128;
+
+// determines subdirectory traversal levels from root to path
+const calcDepth = (path, root) => {
+  let i = 0;
+  while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
+  return i;
+};
+
+// returns boolean indicating whether the fsevents' event info has the same type
+// as the one returned by fs.stat
+const sameTypes = (info, stats) => (
+  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
+  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
+  info.type === FSEVENT_TYPE_FILE && stats.isFile()
+);
+
+/**
+ * @mixin
+ */
+let FsEventsHandler$1 = class FsEventsHandler {
+
+/**
+ * @param {import('../index').FSWatcher} fsw
+ */
+constructor(fsw) {
+  this.fsw = fsw;
+}
+checkIgnored(path, stats) {
+  const ipaths = this.fsw._ignoredPaths;
+  if (this.fsw._isIgnored(path, stats)) {
+    ipaths.add(path);
+    if (stats && stats.isDirectory()) {
+      ipaths.add(path + ROOT_GLOBSTAR);
+    }
+    return true;
+  }
+
+  ipaths.delete(path);
+  ipaths.delete(path + ROOT_GLOBSTAR);
+}
+
+addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
+  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+}
+
+async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  try {
+    const stats = await stat$1(path);
+    if (this.fsw.closed) return;
+    if (sameTypes(info, stats)) {
+      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    } else {
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    }
+  } catch (error) {
+    if (error.code === 'EACCES') {
+      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    } else {
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+    }
+  }
+}
+
+handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
+  if (this.fsw.closed || this.checkIgnored(path)) return;
+
+  if (event === EV_UNLINK$1) {
+    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
+    // suppress unlink events on never before seen files
+    if (isDirectory || watchedDir.has(item)) {
+      this.fsw._remove(parent, item, isDirectory);
+    }
+  } else {
+    if (event === EV_ADD$1) {
+      // track new directories
+      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);
+
+      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
+        // push symlinks back to the top of the stack to get handled
+        const curDepth = opts.depth === undefined ?
+          undefined : calcDepth(fullPath, realPath) + 1;
+        return this._addToFsEvents(path, false, true, curDepth);
+      }
+
+      // track new paths
+      // (other than symlinks being followed, which will be tracked soon)
+      this.fsw._getWatchedDir(parent).add(item);
+    }
+    /**
+     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
+     */
+    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
+    this.fsw._emit(eventName, path);
+    if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
+  }
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} watchPath  - file/dir path to be watched with fsevents
+ * @param {String} realPath   - real path (in case of symlinks)
+ * @param {Function} transform  - path transformer
+ * @param {Function} globFilter - path filter in case a glob pattern was provided
+ * @returns {Function} closer for the watcher instance
+*/
+_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
+  if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
+  const opts = this.fsw.options;
+  const watchCallback = async (fullPath, flags, info) => {
+    // PATCH: bypass the callback for better perf when fullPath hit the ignored file list 
+    if (this.fsw.closed || this.fsw._isIgnored(fullPath)) return;
+    if (
+      opts.depth !== undefined &&
+      calcDepth(fullPath, realPath) > opts.depth
+    ) return;
+    const path = transform(sysPath$1.join(
+      watchPath, sysPath$1.relative(watchPath, fullPath)
+    ));
+    if (globFilter && !globFilter(path)) return;
+    // ensure directories are tracked
+    const parent = sysPath$1.dirname(path);
+    const item = sysPath$1.basename(path);
+    const watchedDir = this.fsw._getWatchedDir(
+      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
+    );
+
+    // correct for wrong events emitted
+    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
+      if (typeof opts.ignored === FUNCTION_TYPE$1) {
+        let stats;
+        try {
+          stats = await stat$1(path);
+        } catch (error) {}
+        if (this.fsw.closed) return;
+        if (this.checkIgnored(path, stats)) return;
+        if (sameTypes(info, stats)) {
+          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        } else {
+          this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+        }
+      } else {
+        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      }
+    } else {
+      switch (info.event) {
+      case FSEVENT_CREATED:
+      case FSEVENT_MODIFIED:
+        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      case FSEVENT_DELETED:
+      case FSEVENT_MOVED:
+        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      }
+    }
+  };
+
+  const closer = setFSEventsListener(
+    watchPath,
+    realPath,
+    watchCallback,
+    this.fsw._emitRaw
+  );
+
+  this.fsw._emitReady();
+  return closer;
+}
+
+/**
+ * Handle symlinks encountered during directory scan
+ * @param {String} linkPath path to symlink
+ * @param {String} fullPath absolute path to the symlink
+ * @param {Function} transform pre-existing path transformer
+ * @param {Number} curDepth level of subdirectories traversed to where symlink is
+ * @returns {Promise<void>}
+ */
+async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
+  // don't follow the same symlink more than once
+  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;
+
+  this.fsw._symlinkPaths.set(fullPath, true);
+  this.fsw._incrReadyCount();
+
+  try {
+    const linkTarget = await realpath(linkPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(linkTarget)) {
+      return this.fsw._emitReady();
+    }
+
+    this.fsw._incrReadyCount();
+
+    // add the linkTarget for watching with a wrapper for transform
+    // that causes emitted paths to incorporate the link's path
+    this._addToFsEvents(linkTarget || linkPath, (path) => {
+      let aliasedPath = linkPath;
+      if (linkTarget && linkTarget !== DOT_SLASH) {
+        aliasedPath = path.replace(linkTarget, linkPath);
+      } else if (path !== DOT_SLASH) {
+        aliasedPath = sysPath$1.join(linkPath, path);
+      }
+      return transform(aliasedPath);
+    }, false, curDepth);
+  } catch(error) {
+    if (this.fsw._handleError(error)) {
+      return this.fsw._emitReady();
+    }
+  }
+}
+
+/**
+ *
+ * @param {Path} newPath
+ * @param {fs.Stats} stats
+ */
+emitAdd(newPath, stats, processPath, opts, forceAdd) {
+  const pp = processPath(newPath);
+  const isDir = stats.isDirectory();
+  const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+  const base = sysPath$1.basename(pp);
+
+  // ensure empty dirs get tracked
+  if (isDir) this.fsw._getWatchedDir(pp);
+  if (dirObj.has(base)) return;
+  dirObj.add(base);
+
+  if (!opts.ignoreInitial || forceAdd === true) {
+    this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
+  }
+}
+
+initWatch(realPath, path, wh, processPath) {
+  if (this.fsw.closed) return;
+  const closer = this._watchWithFsEvents(
+    wh.watchPath,
+    sysPath$1.resolve(realPath || wh.watchPath),
+    processPath,
+    wh.globFilter
+  );
+  this.fsw._addPathCloser(path, closer);
+}
+
+/**
+ * Handle added path with fsevents
+ * @param {String} path file/dir path or glob pattern
+ * @param {Function|Boolean=} transform converts working path to what the user expects
+ * @param {Boolean=} forceAdd ensure add is emitted
+ * @param {Number=} priorDepth Level of subdirectories already traversed.
+ * @returns {Promise<void>}
+ */
+async _addToFsEvents(path, transform, forceAdd, priorDepth) {
+  if (this.fsw.closed) {
+    return;
+  }
+  const opts = this.fsw.options;
+  const processPath = typeof transform === FUNCTION_TYPE$1 ? transform : IDENTITY_FN;
+
+  const wh = this.fsw._getWatchHelpers(path);
+
+  // evaluate what is at the path we're being asked to watch
+  try {
+    const stats = await statMethods[wh.statMethod](wh.watchPath);
+    if (this.fsw.closed) return;
+    if (this.fsw._isIgnored(wh.watchPath, stats)) {
+      throw null;
+    }
+    if (stats.isDirectory()) {
+      // emit addDir unless this is a glob parent
+      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);
+
+      // don't recurse further if it would exceed depth setting
+      if (priorDepth && priorDepth > opts.depth) return;
+
+      // scan the contents of the dir
+      this.fsw._readdirp(wh.watchPath, {
+        fileFilter: entry => wh.filterPath(entry),
+        directoryFilter: entry => wh.filterDir(entry),
+        ...Depth(opts.depth - (priorDepth || 0))
+      }).on(STR_DATA, (entry) => {
+        // need to check filterPath on dirs b/c filterDir is less restrictive
+        if (this.fsw.closed) {
+          return;
+        }
+        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
+
+        const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
+        const {fullPath} = entry;
+
+        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
+          // preserve the current depth here since it can't be derived from
+          // real paths past the symlink
+          const curDepth = opts.depth === undefined ?
+            undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
+
+          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
+        } else {
+          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
+        }
+      }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
+        this.fsw._emitReady();
+      });
+    } else {
+      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
+      this.fsw._emitReady();
+    }
+  } catch (error) {
+    if (!error || this.fsw._handleError(error)) {
+      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
+      this.fsw._emitReady();
+      this.fsw._emitReady();
+    }
+  }
+
+  if (opts.persistent && forceAdd !== true) {
+    if (typeof transform === FUNCTION_TYPE$1) {
+      // realpath has already been resolved
+      this.initWatch(undefined, path, wh, processPath);
+    } else {
+      let realPath;
+      try {
+        realPath = await realpath(wh.watchPath);
+      } catch (e) {}
+      this.initWatch(realPath, path, wh, processPath);
+    }
+  }
+}
+
+};
+
+fseventsHandler.exports = FsEventsHandler$1;
+fseventsHandler.exports.canUse = canUse;
+
+var fseventsHandlerExports = fseventsHandler.exports;
+
+const { EventEmitter: EventEmitter$2 } = require$$0$7;
+const fs$5 = require$$0__default;
+const sysPath = require$$0$4;
+const { promisify } = require$$0$5;
+const readdirp = readdirp_1;
+const anymatch = anymatchExports.default;
+const globParent = globParent$2;
+const isGlob = isGlob$2;
+const braces = braces_1;
+const normalizePath = normalizePath$2;
+
+const NodeFsHandler = nodefsHandler;
+const FsEventsHandler = fseventsHandlerExports;
+const {
+  EV_ALL,
+  EV_READY,
+  EV_ADD,
+  EV_CHANGE,
+  EV_UNLINK,
+  EV_ADD_DIR,
+  EV_UNLINK_DIR,
+  EV_RAW,
+  EV_ERROR,
+
+  STR_CLOSE,
+  STR_END,
+
+  BACK_SLASH_RE,
+  DOUBLE_SLASH_RE,
+  SLASH_OR_BACK_SLASH_RE,
+  DOT_RE,
+  REPLACER_RE,
+
+  SLASH,
+  SLASH_SLASH,
+  BRACE_START,
+  BANG,
+  ONE_DOT,
+  TWO_DOTS,
+  GLOBSTAR,
+  SLASH_GLOBSTAR,
+  ANYMATCH_OPTS,
+  STRING_TYPE,
+  FUNCTION_TYPE,
+  EMPTY_STR,
+  EMPTY_FN,
+
+  isWindows: isWindows$1,
+  isMacos,
+  isIBMi
+} = constants$1;
+
+const stat = promisify(fs$5.stat);
+const readdir = promisify(fs$5.readdir);
+
+/**
+ * @typedef {String} Path
+ * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
+ * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
+ */
+
+/**
+ *
+ * @typedef {Object} WatchHelpers
+ * @property {Boolean} followSymlinks
+ * @property {'stat'|'lstat'} statMethod
+ * @property {Path} path
+ * @property {Path} watchPath
+ * @property {Function} entryPath
+ * @property {Boolean} hasGlob
+ * @property {Object} globFilter
+ * @property {Function} filterPath
+ * @property {Function} filterDir
+ */
+
+const arrify = (value = []) => Array.isArray(value) ? value : [value];
+const flatten = (list, result = []) => {
+  list.forEach(item => {
+    if (Array.isArray(item)) {
+      flatten(item, result);
+    } else {
+      result.push(item);
+    }
+  });
+  return result;
+};
+
+const unifyPaths = (paths_) => {
+  /**
+   * @type {Array<String>}
+   */
+  const paths = flatten(arrify(paths_));
+  if (!paths.every(p => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+
+// If SLASH_SLASH occurs at the beginning of path, it is not replaced
+//     because "//StoragePC/DrivePool/Movies" is a valid network path
+const toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+
+// Our version of upath.normalize
+// TODO: this is not equal to path-normalize module - investigate why
+const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+
+const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
+  if (typeof path !== STRING_TYPE) return path;
+  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+};
+
+const getAbsolutePath = (path, cwd) => {
+  if (sysPath.isAbsolute(path)) {
+    return path;
+  }
+  if (path.startsWith(BANG)) {
+    return BANG + sysPath.join(cwd, path.slice(1));
+  }
+  return sysPath.join(cwd, path);
+};
+
+const undef = (opts, key) => opts[key] === undefined;
+
+/**
+ * Directory entry.
+ * @property {Path} path
+ * @property {Set<Path>} items
+ */
+class DirEntry {
+  /**
+   * @param {Path} dir
+   * @param {Function} removeWatcher
+   */
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    /** @type {Set<Path>} */
+    this.items = new Set();
+  }
+
+  add(item) {
+    const {items} = this;
+    if (!items) return;
+    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
+  }
+
+  async remove(item) {
+    const {items} = this;
+    if (!items) return;
+    items.delete(item);
+    if (items.size > 0) return;
+
+    const dir = this.path;
+    try {
+      await readdir(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+      }
+    }
+  }
+
+  has(item) {
+    const {items} = this;
+    if (!items) return;
+    return items.has(item);
+  }
+
+  /**
+   * @returns {Array<String>}
+   */
+  getChildren() {
+    const {items} = this;
+    if (!items) return;
+    return [...items.values()];
+  }
+
+  dispose() {
+    this.items.clear();
+    delete this.path;
+    delete this._removeWatcher;
+    delete this.items;
+    Object.freeze(this);
+  }
+}
+
+const STAT_METHOD_F = 'stat';
+const STAT_METHOD_L = 'lstat';
+class WatchHelper {
+  constructor(path, watchPath, follow, fsw) {
+    this.fsw = fsw;
+    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath.resolve(watchPath);
+    this.hasGlob = watchPath !== path;
+    /** @type {object|boolean} */
+    if (path === EMPTY_STR) this.hasGlob = false;
+    this.globSymlink = this.hasGlob && follow ? undefined : false;
+    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
+    this.dirParts = this.getDirParts(path);
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1) parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+
+  checkGlobSymlink(entry) {
+    // only need to resolve once
+    // first entry should always have entry.parentDir === EMPTY_STR
+    if (this.globSymlink === undefined) {
+      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
+        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
+    }
+
+    if (this.globSymlink) {
+      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
+    }
+
+    return entry.fullPath;
+  }
+
+  entryPath(entry) {
+    return sysPath.join(this.watchPath,
+      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+    );
+  }
+
+  filterPath(entry) {
+    const {stats} = entry;
+    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
+      this.globFilter(resolvedPath) : true;
+    return matchesGlob &&
+      this.fsw._isntIgnored(resolvedPath, stats) &&
+      this.fsw._hasReadPermissions(stats);
+  }
+
+  getDirParts(path) {
+    if (!this.hasGlob) return [];
+    const parts = [];
+    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
+    expandedPath.forEach((path) => {
+      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+    });
+    return parts;
+  }
+
+  filterDir(entry) {
+    if (this.hasGlob) {
+      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
+      let globstar = false;
+      this.unmatchedGlob = !this.dirParts.some((parts) => {
+        return parts.every((part, i) => {
+          if (part === GLOBSTAR) globstar = true;
+          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
+        });
+      });
+    }
+    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+}
+
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+class FSWatcher extends EventEmitter$2 {
+// Not indenting methods for history sake; for now.
+constructor(_opts) {
+  super();
+
+  const opts = {};
+  if (_opts) Object.assign(opts, _opts); // for frozen objects
+
+  /** @type {Map<String, DirEntry>} */
+  this._watched = new Map();
+  /** @type {Map<String, Array>} */
+  this._closers = new Map();
+  /** @type {Set<String>} */
+  this._ignoredPaths = new Set();
+
+  /** @type {Map<ThrottleType, Map>} */
+  this._throttled = new Map();
+
+  /** @type {Map<Path, String|Boolean>} */
+  this._symlinkPaths = new Map();
+
+  this._streams = new Set();
+  this.closed = false;
+
+  // Set up default options.
+  if (undef(opts, 'persistent')) opts.persistent = true;
+  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
+  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
+  if (undef(opts, 'interval')) opts.interval = 100;
+  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
+  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
+  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;
+
+  // Enable fsevents on OS X when polling isn't explicitly enabled.
+  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
+
+  // If we can't use fsevents, ensure the options reflect it's disabled.
+  const canUseFsEvents = FsEventsHandler.canUse();
+  if (!canUseFsEvents) opts.useFsEvents = false;
+
+  // Use polling on Mac if not using fsevents.
+  // Other platforms use non-polling fs_watch.
+  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
+    opts.usePolling = isMacos;
+  }
+
+  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+  if(isIBMi) {
+    opts.usePolling = true;
+  }
+
+  // Global override (useful for end-developers that need to force polling for all
+  // instances of chokidar, regardless of usage/dependency depth)
+  const envPoll = process.env.CHOKIDAR_USEPOLLING;
+  if (envPoll !== undefined) {
+    const envLower = envPoll.toLowerCase();
+
+    if (envLower === 'false' || envLower === '0') {
+      opts.usePolling = false;
+    } else if (envLower === 'true' || envLower === '1') {
+      opts.usePolling = true;
+    } else {
+      opts.usePolling = !!envLower;
+    }
+  }
+  const envInterval = process.env.CHOKIDAR_INTERVAL;
+  if (envInterval) {
+    opts.interval = Number.parseInt(envInterval, 10);
+  }
+
+  // Editor atomic write normalization enabled by default with fs.watch
+  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
+  if (opts.atomic) this._pendingUnlinks = new Map();
+
+  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;
+
+  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
+  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
+  const awf = opts.awaitWriteFinish;
+  if (awf) {
+    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
+    if (!awf.pollInterval) awf.pollInterval = 100;
+    this._pendingWrites = new Map();
+  }
+  if (opts.ignored) opts.ignored = arrify(opts.ignored);
+
+  let readyCalls = 0;
+  this._emitReady = () => {
+    readyCalls++;
+    if (readyCalls >= this._readyCount) {
+      this._emitReady = EMPTY_FN;
+      this._readyEmitted = true;
+      // use process.nextTick to allow time for listener to be bound
+      process.nextTick(() => this.emit(EV_READY));
+    }
+  };
+  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
+  this._readyEmitted = false;
+  this.options = opts;
+
+  // Initialize with proper watcher.
+  if (opts.useFsEvents) {
+    this._fsEventsHandler = new FsEventsHandler(this);
+  } else {
+    this._nodeFsHandler = new NodeFsHandler(this);
+  }
+
+  // You’re frozen when your heart’s not open.
+  Object.freeze(opts);
+}
+
+// Public methods
+
+/**
+ * Adds paths to be watched on an existing FSWatcher instance
+ * @param {Path|Array<Path>} paths_
+ * @param {String=} _origAdd private; for handling non-existent paths to be watched
+ * @param {Boolean=} _internal private; indicates a non-user add
+ * @returns {FSWatcher} for chaining
+ */
+add(paths_, _origAdd, _internal) {
+  const {cwd, disableGlobbing} = this.options;
+  this.closed = false;
+  let paths = unifyPaths(paths_);
+  if (cwd) {
+    paths = paths.map((path) => {
+      const absPath = getAbsolutePath(path, cwd);
+
+      // Check `path` instead of `absPath` because the cwd portion can't be a glob
+      if (disableGlobbing || !isGlob(path)) {
+        return absPath;
+      }
+      return normalizePath(absPath);
+    });
+  }
+
+  // set aside negated glob strings
+  paths = paths.filter((path) => {
+    if (path.startsWith(BANG)) {
+      this._ignoredPaths.add(path.slice(1));
+      return false;
+    }
+
+    // if a path is being added that was previously ignored, stop ignoring it
+    this._ignoredPaths.delete(path);
+    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);
+
+    // reset the cached userIgnored anymatch fn
+    // to make ignoredPaths changes effective
+    this._userIgnored = undefined;
+
+    return true;
+  });
+
+  if (this.options.useFsEvents && this._fsEventsHandler) {
+    if (!this._readyCount) this._readyCount = paths.length;
+    if (this.options.persistent) this._readyCount += paths.length;
+    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
+  } else {
+    if (!this._readyCount) this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(
+      paths.map(async path => {
+        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
+        if (res) this._emitReady();
+        return res;
+      })
+    ).then(results => {
+      if (this.closed) return;
+      results.filter(item => item).forEach(item => {
+        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+      });
+    });
+  }
+
+  return this;
+}
+
+/**
+ * Close watchers or start ignoring events from specified paths.
+ * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
+ * @returns {FSWatcher} for chaining
+*/
+unwatch(paths_) {
+  if (this.closed) return this;
+  const paths = unifyPaths(paths_);
+  const {cwd} = this.options;
+
+  paths.forEach((path) => {
+    // convert to absolute path unless relative path already matches
+    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+      if (cwd) path = sysPath.join(cwd, path);
+      path = sysPath.resolve(path);
+    }
+
+    this._closePath(path);
+
+    this._ignoredPaths.add(path);
+    if (this._watched.has(path)) {
+      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
+    }
+
+    // reset the cached userIgnored anymatch fn
+    // to make ignoredPaths changes effective
+    this._userIgnored = undefined;
+  });
+
+  return this;
+}
+
+/**
+ * Close watchers and remove all listeners from watched paths.
+ * @returns {Promise<void>}.
+*/
+close() {
+  if (this.closed) return this._closePromise;
+  this.closed = true;
+
+  // Memory management.
+  this.removeAllListeners();
+  const closers = [];
+  this._closers.forEach(closerList => closerList.forEach(closer => {
+    const promise = closer();
+    if (promise instanceof Promise) closers.push(promise);
+  }));
+  this._streams.forEach(stream => stream.destroy());
+  this._userIgnored = undefined;
+  this._readyCount = 0;
+  this._readyEmitted = false;
+  this._watched.forEach(dirent => dirent.dispose());
+  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
+    this[`_${key}`].clear();
+  });
+
+  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
+  return this._closePromise;
+}
+
+/**
+ * Expose list of watched paths
+ * @returns {Object} for chaining
+*/
+getWatched() {
+  const watchList = {};
+  this._watched.forEach((entry, dir) => {
+    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+    watchList[key || ONE_DOT] = entry.getChildren().sort();
+  });
+  return watchList;
+}
+
+emitWithAll(event, args) {
+  this.emit(...args);
+  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
+}
+
+// Common helpers
+// --------------
+
+/**
+ * Normalize and emit events.
+ * Calling _emit DOES NOT MEAN emit() would be called!
+ * @param {EventName} event Type of event
+ * @param {Path} path File or directory path
+ * @param {*=} val1 arguments to be passed with event
+ * @param {*=} val2
+ * @param {*=} val3
+ * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+async _emit(event, path, val1, val2, val3) {
+  if (this.closed) return;
+
+  const opts = this.options;
+  if (isWindows$1) path = sysPath.normalize(path);
+  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+  /** @type Array<any> */
+  const args = [event, path];
+  if (val3 !== undefined) args.push(val1, val2, val3);
+  else if (val2 !== undefined) args.push(val1, val2);
+  else if (val1 !== undefined) args.push(val1);
+
+  const awf = opts.awaitWriteFinish;
+  let pw;
+  if (awf && (pw = this._pendingWrites.get(path))) {
+    pw.lastChange = new Date();
+    return this;
+  }
+
+  if (opts.atomic) {
+    if (event === EV_UNLINK) {
+      this._pendingUnlinks.set(path, args);
+      setTimeout(() => {
+        this._pendingUnlinks.forEach((entry, path) => {
+          this.emit(...entry);
+          this.emit(EV_ALL, ...entry);
+          this._pendingUnlinks.delete(path);
+        });
+      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
+      return this;
+    }
+    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+      event = args[0] = EV_CHANGE;
+      this._pendingUnlinks.delete(path);
+    }
+  }
+
+  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
+    const awfEmit = (err, stats) => {
+      if (err) {
+        event = args[0] = EV_ERROR;
+        args[1] = err;
+        this.emitWithAll(event, args);
+      } else if (stats) {
+        // if stats doesn't exist the file must have been deleted
+        if (args.length > 2) {
+          args[2] = stats;
+        } else {
+          args.push(stats);
+        }
+        this.emitWithAll(event, args);
+      }
+    };
+
+    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
+    return this;
+  }
+
+  if (event === EV_CHANGE) {
+    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
+    if (isThrottled) return this;
+  }
+
+  if (opts.alwaysStat && val1 === undefined &&
+    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
+  ) {
+    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+    let stats;
+    try {
+      stats = await stat(fullPath);
+    } catch (err) {}
+    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
+    if (!stats || this.closed) return;
+    args.push(stats);
+  }
+  this.emitWithAll(event, args);
+
+  return this;
+}
+
+/**
+ * Common handler for errors
+ * @param {Error} error
+ * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+ */
+_handleError(error) {
+  const code = error && error.code;
+  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
+    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
+  ) {
+    this.emit(EV_ERROR, error);
+  }
+  return error || this.closed;
+}
+
+/**
+ * Helper utility for throttling
+ * @param {ThrottleType} actionType type being throttled
+ * @param {Path} path being acted upon
+ * @param {Number} timeout duration of time to suppress duplicate actions
+ * @returns {Object|false} tracking object or false if action should be suppressed
+ */
+_throttle(actionType, path, timeout) {
+  if (!this._throttled.has(actionType)) {
+    this._throttled.set(actionType, new Map());
+  }
+
+  /** @type {Map<Path, Object>} */
+  const action = this._throttled.get(actionType);
+  /** @type {Object} */
+  const actionPath = action.get(path);
+
+  if (actionPath) {
+    actionPath.count++;
+    return false;
+  }
+
+  let timeoutObject;
+  const clear = () => {
+    const item = action.get(path);
+    const count = item ? item.count : 0;
+    action.delete(path);
+    clearTimeout(timeoutObject);
+    if (item) clearTimeout(item.timeoutObject);
+    return count;
+  };
+  timeoutObject = setTimeout(clear, timeout);
+  const thr = {timeoutObject, clear, count: 0};
+  action.set(path, thr);
+  return thr;
+}
+
+_incrReadyCount() {
+  return this._readyCount++;
+}
+
+/**
+ * Awaits write operation to finish.
+ * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+ * @param {Path} path being acted upon
+ * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+ * @param {EventName} event
+ * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
+ */
+_awaitWriteFinish(path, threshold, event, awfEmit) {
+  let timeoutHandler;
+
+  let fullPath = path;
+  if (this.options.cwd && !sysPath.isAbsolute(path)) {
+    fullPath = sysPath.join(this.options.cwd, path);
+  }
+
+  const now = new Date();
+
+  const awaitWriteFinish = (prevStat) => {
+    fs$5.stat(fullPath, (err, curStat) => {
+      if (err || !this._pendingWrites.has(path)) {
+        if (err && err.code !== 'ENOENT') awfEmit(err);
+        return;
+      }
+
+      const now = Number(new Date());
+
+      if (prevStat && curStat.size !== prevStat.size) {
+        this._pendingWrites.get(path).lastChange = now;
+      }
+      const pw = this._pendingWrites.get(path);
+      const df = now - pw.lastChange;
+
+      if (df >= threshold) {
+        this._pendingWrites.delete(path);
+        awfEmit(undefined, curStat);
+      } else {
+        timeoutHandler = setTimeout(
+          awaitWriteFinish,
+          this.options.awaitWriteFinish.pollInterval,
+          curStat
+        );
+      }
+    });
+  };
+
+  if (!this._pendingWrites.has(path)) {
+    this._pendingWrites.set(path, {
+      lastChange: now,
+      cancelWait: () => {
+        this._pendingWrites.delete(path);
+        clearTimeout(timeoutHandler);
+        return event;
+      }
+    });
+    timeoutHandler = setTimeout(
+      awaitWriteFinish,
+      this.options.awaitWriteFinish.pollInterval
+    );
+  }
+}
+
+_getGlobIgnored() {
+  return [...this._ignoredPaths.values()];
+}
+
+/**
+ * Determines whether user has asked to ignore this path.
+ * @param {Path} path filepath or dir
+ * @param {fs.Stats=} stats result of fs.stat
+ * @returns {Boolean}
+ */
+_isIgnored(path, stats) {
+  if (this.options.atomic && DOT_RE.test(path)) return true;
+  if (!this._userIgnored) {
+    const {cwd} = this.options;
+    const ign = this.options.ignored;
+
+    const ignored = ign && ign.map(normalizeIgnored(cwd));
+    const paths = arrify(ignored)
+      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+      .map((path) => path + SLASH_GLOBSTAR);
+    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
+    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
+  }
+
+  return this._userIgnored([path, stats]);
+}
+
+_isntIgnored(path, stat) {
+  return !this._isIgnored(path, stat);
+}
+
+/**
+ * Provides a set of common helpers and properties relating to symlink and glob handling.
+ * @param {Path} path file, directory, or glob pattern being watched
+ * @param {Number=} depth at any depth > 0, this isn't a glob
+ * @returns {WatchHelper} object containing helpers for this path
+ */
+_getWatchHelpers(path, depth) {
+  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+  const follow = this.options.followSymlinks;
+
+  return new WatchHelper(path, watchPath, follow, this);
+}
+
+// Directory helpers
+// -----------------
+
+/**
+ * Provides directory tracking objects
+ * @param {String} directory path of the directory
+ * @returns {DirEntry} the directory's tracking object
+ */
+_getWatchedDir(directory) {
+  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
+  const dir = sysPath.resolve(directory);
+  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+  return this._watched.get(dir);
+}
+
+// File helpers
+// ------------
+
+/**
+ * Check for read permissions.
+ * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
+ * @param {fs.Stats} stats - object, result of fs_stat
+ * @returns {Boolean} indicates whether the file can be read
+*/
+_hasReadPermissions(stats) {
+  if (this.options.ignorePermissionErrors) return true;
+
+  // stats.mode may be bigint
+  const md = stats && Number.parseInt(stats.mode, 10);
+  const st = md & 0o777;
+  const it = Number.parseInt(st.toString(8)[0], 10);
+  return Boolean(4 & it);
+}
+
+/**
+ * Handles emitting unlink events for
+ * files and directories, and via recursion, for
+ * files and directories within directories that are unlinked
+ * @param {String} directory within which the following item is located
+ * @param {String} item      base path of item/directory
+ * @returns {void}
+*/
+_remove(directory, item, isDirectory) {
+  // if what is being deleted is a directory, get that directory's paths
+  // for recursive deleting and cleaning of watched object
+  // if it is not a directory, nestedDirectoryChildren will be empty array
+  const path = sysPath.join(directory, item);
+  const fullPath = sysPath.resolve(path);
+  isDirectory = isDirectory != null
+    ? isDirectory
+    : this._watched.has(path) || this._watched.has(fullPath);
+
+  // prevent duplicate handling in case of arriving here nearly simultaneously
+  // via multiple paths (such as _handleFile and _handleDir)
+  if (!this._throttle('remove', path, 100)) return;
+
+  // if the only watched file is removed, watch for its return
+  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
+    this.add(directory, item, true);
+  }
+
+  // This will create a new entry in the watched object in either case
+  // so we got to do the directory check beforehand
+  const wp = this._getWatchedDir(path);
+  const nestedDirectoryChildren = wp.getChildren();
+
+  // Recursively remove children directories / files.
+  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));
+
+  // Check if item was on the watched list and remove it
+  const parent = this._getWatchedDir(directory);
+  const wasTracked = parent.has(item);
+  parent.remove(item);
+
+  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
+  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
+  // but never removed from the map in case the path was deleted.
+  // This leads to an incorrect state if the path was recreated:
+  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
+  if (this._symlinkPaths.has(fullPath)) {
+    this._symlinkPaths.delete(fullPath);
+  }
+
+  // If we wait for this file to be fully written, cancel the wait.
+  let relPath = path;
+  if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
+  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+    const event = this._pendingWrites.get(relPath).cancelWait();
+    if (event === EV_ADD) return;
+  }
+
+  // The Entry will either be a directory that just got removed
+  // or a bogus entry to a file, in either case we have to remove it
+  this._watched.delete(path);
+  this._watched.delete(fullPath);
+  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
+  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
+
+  // Avoid conflicts if we later create another file with the same name
+  if (!this.options.useFsEvents) {
+    this._closePath(path);
+  }
+}
+
+/**
+ * Closes all watchers for a path
+ * @param {Path} path
+ */
+_closePath(path) {
+  this._closeFile(path);
+  const dir = sysPath.dirname(path);
+  this._getWatchedDir(dir).remove(sysPath.basename(path));
+}
+
+/**
+ * Closes only file-specific watchers
+ * @param {Path} path
+ */
+_closeFile(path) {
+  const closers = this._closers.get(path);
+  if (!closers) return;
+  closers.forEach(closer => closer());
+  this._closers.delete(path);
+}
+
+/**
+ *
+ * @param {Path} path
+ * @param {Function} closer
+ */
+_addPathCloser(path, closer) {
+  if (!closer) return;
+  let list = this._closers.get(path);
+  if (!list) {
+    list = [];
+    this._closers.set(path, list);
+  }
+  list.push(closer);
+}
+
+_readdirp(root, opts) {
+  if (this.closed) return;
+  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
+  let stream = readdirp(root, options);
+  this._streams.add(stream);
+  stream.once(STR_CLOSE, () => {
+    stream = undefined;
+  });
+  stream.once(STR_END, () => {
+    if (stream) {
+      this._streams.delete(stream);
+      stream = undefined;
+    }
+  });
+  return stream;
+}
+
+}
+
+// Export FSWatcher class
+chokidar.FSWatcher = FSWatcher;
+
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param {String|Array<String>} paths file/directory paths and/or globs
+ * @param {Object=} options chokidar opts
+ * @returns an instance of FSWatcher for chaining.
+ */
+const watch = (paths, options) => {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+};
+
+chokidar.watch = watch;
+
+var shellQuote$1 = {};
+
+var quote = function quote(xs) {
+	return xs.map(function (s) {
+		if (s && typeof s === 'object') {
+			return s.op.replace(/(.)/g, '\\$1');
+		}
+		if ((/["\s]/).test(s) && !(/'/).test(s)) {
+			return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
+		}
+		if ((/["'\s]/).test(s)) {
+			return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
+		}
+		return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
+	}).join(' ');
+};
+
+// '<(' is process substitution operator and
+// can be parsed the same as control operator
+var CONTROL = '(?:' + [
+	'\\|\\|',
+	'\\&\\&',
+	';;',
+	'\\|\\&',
+	'\\<\\(',
+	'\\<\\<\\<',
+	'>>',
+	'>\\&',
+	'<\\&',
+	'[&;()|<>]'
+].join('|') + ')';
+var controlRE = new RegExp('^' + CONTROL + '$');
+var META = '|&;()<> \\t';
+var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
+var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
+var hash = /^#$/;
+
+var SQ = "'";
+var DQ = '"';
+var DS = '$';
+
+var TOKEN = '';
+var mult = 0x100000000; // Math.pow(16, 8);
+for (var i = 0; i < 4; i++) {
+	TOKEN += (mult * Math.random()).toString(16);
+}
+var startsWithToken = new RegExp('^' + TOKEN);
+
+function matchAll(s, r) {
+	var origIndex = r.lastIndex;
+
+	var matches = [];
+	var matchObj;
+
+	while ((matchObj = r.exec(s))) {
+		matches.push(matchObj);
+		if (r.lastIndex === matchObj.index) {
+			r.lastIndex += 1;
+		}
+	}
+
+	r.lastIndex = origIndex;
+
+	return matches;
+}
+
+function getVar(env, pre, key) {
+	var r = typeof env === 'function' ? env(key) : env[key];
+	if (typeof r === 'undefined' && key != '') {
+		r = '';
+	} else if (typeof r === 'undefined') {
+		r = '$';
+	}
+
+	if (typeof r === 'object') {
+		return pre + TOKEN + JSON.stringify(r) + TOKEN;
+	}
+	return pre + r;
+}
+
+function parseInternal(string, env, opts) {
+	if (!opts) {
+		opts = {};
+	}
+	var BS = opts.escape || '\\';
+	var BAREWORD = '(\\' + BS + '[\'"' + META + ']|[^\\s\'"' + META + '])+';
+
+	var chunker = new RegExp([
+		'(' + CONTROL + ')', // control chars
+		'(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')+'
+	].join('|'), 'g');
+
+	var matches = matchAll(string, chunker);
+
+	if (matches.length === 0) {
+		return [];
+	}
+	if (!env) {
+		env = {};
+	}
+
+	var commented = false;
+
+	return matches.map(function (match) {
+		var s = match[0];
+		if (!s || commented) {
+			return void undefined;
+		}
+		if (controlRE.test(s)) {
+			return { op: s };
+		}
+
+		// Hand-written scanner/parser for Bash quoting rules:
+		//
+		// 1. inside single quotes, all characters are printed literally.
+		// 2. inside double quotes, all characters are printed literally
+		//    except variables prefixed by '$' and backslashes followed by
+		//    either a double quote or another backslash.
+		// 3. outside of any quotes, backslashes are treated as escape
+		//    characters and not printed (unless they are themselves escaped)
+		// 4. quote context can switch mid-token if there is no whitespace
+		//     between the two quote contexts (e.g. all'one'"token" parses as
+		//     "allonetoken")
+		var quote = false;
+		var esc = false;
+		var out = '';
+		var isGlob = false;
+		var i;
+
+		function parseEnvVar() {
+			i += 1;
+			var varend;
+			var varname;
+			var char = s.charAt(i);
+
+			if (char === '{') {
+				i += 1;
+				if (s.charAt(i) === '}') {
+					throw new Error('Bad substitution: ' + s.slice(i - 2, i + 1));
+				}
+				varend = s.indexOf('}', i);
+				if (varend < 0) {
+					throw new Error('Bad substitution: ' + s.slice(i));
+				}
+				varname = s.slice(i, varend);
+				i = varend;
+			} else if ((/[*@#?$!_-]/).test(char)) {
+				varname = char;
+				i += 1;
+			} else {
+				var slicedFromI = s.slice(i);
+				varend = slicedFromI.match(/[^\w\d_]/);
+				if (!varend) {
+					varname = slicedFromI;
+					i = s.length;
+				} else {
+					varname = slicedFromI.slice(0, varend.index);
+					i += varend.index - 1;
+				}
+			}
+			return getVar(env, '', varname);
+		}
+
+		for (i = 0; i < s.length; i++) {
+			var c = s.charAt(i);
+			isGlob = isGlob || (!quote && (c === '*' || c === '?'));
+			if (esc) {
+				out += c;
+				esc = false;
+			} else if (quote) {
+				if (c === quote) {
+					quote = false;
+				} else if (quote == SQ) {
+					out += c;
+				} else { // Double quote
+					if (c === BS) {
+						i += 1;
+						c = s.charAt(i);
+						if (c === DQ || c === BS || c === DS) {
+							out += c;
+						} else {
+							out += BS + c;
+						}
+					} else if (c === DS) {
+						out += parseEnvVar();
+					} else {
+						out += c;
+					}
+				}
+			} else if (c === DQ || c === SQ) {
+				quote = c;
+			} else if (controlRE.test(c)) {
+				return { op: s };
+			} else if (hash.test(c)) {
+				commented = true;
+				var commentObj = { comment: string.slice(match.index + i + 1) };
+				if (out.length) {
+					return [out, commentObj];
+				}
+				return [commentObj];
+			} else if (c === BS) {
+				esc = true;
+			} else if (c === DS) {
+				out += parseEnvVar();
+			} else {
+				out += c;
+			}
+		}
+
+		if (isGlob) {
+			return { op: 'glob', pattern: out };
+		}
+
+		return out;
+	}).reduce(function (prev, arg) { // finalize parsed arguments
+		// TODO: replace this whole reduce with a concat
+		return typeof arg === 'undefined' ? prev : prev.concat(arg);
+	}, []);
+}
+
+var parse$6 = function parse(s, env, opts) {
+	var mapped = parseInternal(s, env, opts);
+	if (typeof env !== 'function') {
+		return mapped;
+	}
+	return mapped.reduce(function (acc, s) {
+		if (typeof s === 'object') {
+			return acc.concat(s);
+		}
+		var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
+		if (xs.length === 1) {
+			return acc.concat(xs[0]);
+		}
+		return acc.concat(xs.filter(Boolean).map(function (x) {
+			if (startsWithToken.test(x)) {
+				return JSON.parse(x.split(TOKEN)[1]);
+			}
+			return x;
+		}));
+	}, []);
+};
+
+shellQuote$1.quote = quote;
+shellQuote$1.parse = parse$6;
+
+var macos = {
+  '/Applications/Atom.app/Contents/MacOS/Atom': 'atom',
+  '/Applications/Atom Beta.app/Contents/MacOS/Atom Beta':
+    '/Applications/Atom Beta.app/Contents/MacOS/Atom Beta',
+  '/Applications/Brackets.app/Contents/MacOS/Brackets': 'brackets',
+  '/Applications/Sublime Text.app/Contents/MacOS/Sublime Text':
+    '/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl',
+  '/Applications/Sublime Text.app/Contents/MacOS/sublime_text':
+    '/Applications/Sublime Text.app/Contents/SharedSupport/bin/subl',
+  '/Applications/Sublime Text 2.app/Contents/MacOS/Sublime Text 2':
+    '/Applications/Sublime Text 2.app/Contents/SharedSupport/bin/subl',
+  '/Applications/Sublime Text Dev.app/Contents/MacOS/Sublime Text':
+    '/Applications/Sublime Text Dev.app/Contents/SharedSupport/bin/subl',
+  '/Applications/Visual Studio Code.app/Contents/MacOS/Electron': 'code',
+  '/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron':
+    'code-insiders',
+  '/Applications/VSCodium.app/Contents/MacOS/Electron': 'codium',
+  '/Applications/Cursor.app/Contents/MacOS/Cursor': 'cursor',
+  '/Applications/AppCode.app/Contents/MacOS/appcode':
+    '/Applications/AppCode.app/Contents/MacOS/appcode',
+  '/Applications/CLion.app/Contents/MacOS/clion':
+    '/Applications/CLion.app/Contents/MacOS/clion',
+  '/Applications/IntelliJ IDEA.app/Contents/MacOS/idea':
+    '/Applications/IntelliJ IDEA.app/Contents/MacOS/idea',
+  '/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea':
+    '/Applications/IntelliJ IDEA Ultimate.app/Contents/MacOS/idea',
+  '/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea':
+    '/Applications/IntelliJ IDEA Community Edition.app/Contents/MacOS/idea',
+  '/Applications/PhpStorm.app/Contents/MacOS/phpstorm':
+    '/Applications/PhpStorm.app/Contents/MacOS/phpstorm',
+  '/Applications/PyCharm.app/Contents/MacOS/pycharm':
+    '/Applications/PyCharm.app/Contents/MacOS/pycharm',
+  '/Applications/PyCharm CE.app/Contents/MacOS/pycharm':
+    '/Applications/PyCharm CE.app/Contents/MacOS/pycharm',
+  '/Applications/RubyMine.app/Contents/MacOS/rubymine':
+    '/Applications/RubyMine.app/Contents/MacOS/rubymine',
+  '/Applications/WebStorm.app/Contents/MacOS/webstorm':
+    '/Applications/WebStorm.app/Contents/MacOS/webstorm',
+  '/Applications/MacVim.app/Contents/MacOS/MacVim': 'mvim',
+  '/Applications/GoLand.app/Contents/MacOS/goland':
+    '/Applications/GoLand.app/Contents/MacOS/goland',
+  '/Applications/Rider.app/Contents/MacOS/rider':
+    '/Applications/Rider.app/Contents/MacOS/rider',
+  '/Applications/Zed.app/Contents/MacOS/zed': 'zed'
+};
+
+var linux = {
+  atom: 'atom',
+  Brackets: 'brackets',
+  'code-insiders': 'code-insiders',
+  code: 'code',
+  vscodium: 'vscodium',
+  codium: 'codium',
+  emacs: 'emacs',
+  gvim: 'gvim',
+  'idea.sh': 'idea',
+  'phpstorm.sh': 'phpstorm',
+  'pycharm.sh': 'pycharm',
+  'rubymine.sh': 'rubymine',
+  sublime_text: 'subl',
+  vim: 'vim',
+  'webstorm.sh': 'webstorm',
+  'goland.sh': 'goland',
+  'rider.sh': 'rider'
+};
+
+var windows$1 = [
+  'Brackets.exe',
+  'Code.exe',
+  'Code - Insiders.exe',
+  'VSCodium.exe',
+  'atom.exe',
+  'sublime_text.exe',
+  'notepad++.exe',
+  'clion.exe',
+  'clion64.exe',
+  'idea.exe',
+  'idea64.exe',
+  'phpstorm.exe',
+  'phpstorm64.exe',
+  'pycharm.exe',
+  'pycharm64.exe',
+  'rubymine.exe',
+  'rubymine64.exe',
+  'webstorm.exe',
+  'webstorm64.exe',
+  'goland.exe',
+  'goland64.exe',
+  'rider.exe',
+  'rider64.exe'
+];
+
+const path$7 = require$$0$4;
+const shellQuote = shellQuote$1;
+const childProcess$2 = require$$2$1;
+
+// Map from full process name to binary that starts the process
+// We can't just re-use full process name, because it will spawn a new instance
+// of the app every time
+const COMMON_EDITORS_MACOS = macos;
+const COMMON_EDITORS_LINUX = linux;
+const COMMON_EDITORS_WIN = windows$1;
+
+var guess = function guessEditor (specifiedEditor) {
+  if (specifiedEditor) {
+    return shellQuote.parse(specifiedEditor)
+  }
+
+  if (process.env.LAUNCH_EDITOR) {
+    return [process.env.LAUNCH_EDITOR]
+  }
+
+  if (process.versions.webcontainer) {
+    return [process.env.EDITOR || 'code']
+  }
+
+  // We can find out which editor is currently running by:
+  // `ps x` on macOS and Linux
+  // `Get-Process` on Windows
+  try {
+    if (process.platform === 'darwin') {
+      const output = childProcess$2
+        .execSync('ps x -o comm=', {
+          stdio: ['pipe', 'pipe', 'ignore']
+        })
+        .toString();
+      const processNames = Object.keys(COMMON_EDITORS_MACOS);
+      const processList = output.split('\n');
+      for (let i = 0; i < processNames.length; i++) {
+        const processName = processNames[i];
+        // Find editor by exact match.
+        if (processList.includes(processName)) {
+          return [COMMON_EDITORS_MACOS[processName]]
+        }
+        const processNameWithoutApplications = processName.replace('/Applications', '');
+        // Find editor installation not in /Applications.
+        if (output.indexOf(processNameWithoutApplications) !== -1) {
+          // Use the CLI command if one is specified
+          if (processName !== COMMON_EDITORS_MACOS[processName]) {
+            return [COMMON_EDITORS_MACOS[processName]]
+          }
+          // Use a partial match to find the running process path.  If one is found, use the
+          // existing path since it can be running from anywhere.
+          const runningProcess = processList.find((procName) => procName.endsWith(processNameWithoutApplications));
+          if (runningProcess !== undefined) {
+            return [runningProcess]
+          }
+        }
+      }
+    } else if (process.platform === 'win32') {
+      const output = childProcess$2
+        .execSync(
+          'powershell -NoProfile -Command "Get-CimInstance -Query \\"select executablepath from win32_process where executablepath is not null\\" | % { $_.ExecutablePath }"',
+          {
+            stdio: ['pipe', 'pipe', 'ignore']
+          }
+        )
+        .toString();
+      const runningProcesses = output.split('\r\n');
+      for (let i = 0; i < runningProcesses.length; i++) {
+        const fullProcessPath = runningProcesses[i].trim();
+        const shortProcessName = path$7.basename(fullProcessPath);
+
+        if (COMMON_EDITORS_WIN.indexOf(shortProcessName) !== -1) {
+          return [fullProcessPath]
+        }
+      }
+    } else if (process.platform === 'linux') {
+      // --no-heading No header line
+      // x List all processes owned by you
+      // -o comm Need only names column
+      const output = childProcess$2
+        .execSync('ps x --no-heading -o comm --sort=comm', {
+          stdio: ['pipe', 'pipe', 'ignore']
+        })
+        .toString();
+      const processNames = Object.keys(COMMON_EDITORS_LINUX);
+      for (let i = 0; i < processNames.length; i++) {
+        const processName = processNames[i];
+        if (output.indexOf(processName) !== -1) {
+          return [COMMON_EDITORS_LINUX[processName]]
+        }
+      }
+    }
+  } catch (ignoreError) {
+    // Ignore...
+  }
+
+  // Last resort, use old skool env vars
+  if (process.env.VISUAL) {
+    return [process.env.VISUAL]
+  } else if (process.env.EDITOR) {
+    return [process.env.EDITOR]
+  }
+
+  return [null]
+};
+
+const path$6 = require$$0$4;
+
+// normalize file/line numbers into command line args for specific editors
+var getArgs = function getArgumentsForPosition (
+  editor,
+  fileName,
+  lineNumber,
+  columnNumber = 1
+) {
+  const editorBasename = path$6.basename(editor).replace(/\.(exe|cmd|bat)$/i, '');
+  switch (editorBasename) {
+    case 'atom':
+    case 'Atom':
+    case 'Atom Beta':
+    case 'subl':
+    case 'sublime':
+    case 'sublime_text':
+    case 'wstorm':
+    case 'charm':
+    case 'zed':
+      return [`${fileName}:${lineNumber}:${columnNumber}`]
+    case 'notepad++':
+      return ['-n' + lineNumber, '-c' + columnNumber, fileName]
+    case 'vim':
+    case 'mvim':
+      return [`+call cursor(${lineNumber}, ${columnNumber})`, fileName]
+    case 'joe':
+    case 'gvim':
+      return ['+' + `${lineNumber}`, fileName]
+    case 'emacs':
+    case 'emacsclient':
+      return [`+${lineNumber}:${columnNumber}`, fileName]
+    case 'rmate':
+    case 'mate':
+    case 'mine':
+      return ['--line', lineNumber, fileName]
+    case 'code':
+    case 'Code':
+    case 'code-insiders':
+    case 'Code - Insiders':
+    case 'codium':
+    case 'cursor':
+    case 'vscodium':
+    case 'VSCodium':
+      return ['-r', '-g', `${fileName}:${lineNumber}:${columnNumber}`]
+    case 'appcode':
+    case 'clion':
+    case 'clion64':
+    case 'idea':
+    case 'idea64':
+    case 'phpstorm':
+    case 'phpstorm64':
+    case 'pycharm':
+    case 'pycharm64':
+    case 'rubymine':
+    case 'rubymine64':
+    case 'webstorm':
+    case 'webstorm64':
+    case 'goland':
+    case 'goland64':
+    case 'rider':
+    case 'rider64':
+      return ['--line', lineNumber, '--column', columnNumber, fileName]
+  }
+
+  if (process.env.LAUNCH_EDITOR) {
+    return [fileName, lineNumber, columnNumber]
+  }
+
+  // For all others, drop the lineNumber until we have
+  // a mapping above, since providing the lineNumber incorrectly
+  // can result in errors or confusing behavior.
+  return [fileName]
+};
+
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebookincubator/create-react-app/blob/master/LICENSE
+ *
+ * Modified by Yuxi Evan You
+ */
+
+const fs$4 = require$$0__default;
+const os$1 = require$$2;
+const path$5 = require$$0$4;
+const colors = picocolorsExports;
+const childProcess$1 = require$$2$1;
+
+const guessEditor = guess;
+const getArgumentsForPosition = getArgs;
+
+function wrapErrorCallback (cb) {
+  return (fileName, errorMessage) => {
+    console.log();
+    console.log(
+      colors.red('Could not open ' + path$5.basename(fileName) + ' in the editor.')
+    );
+    if (errorMessage) {
+      if (errorMessage[errorMessage.length - 1] !== '.') {
+        errorMessage += '.';
+      }
+      console.log(
+        colors.red('The editor process exited with an error: ' + errorMessage)
+      );
+    }
+    console.log();
+    if (cb) cb(fileName, errorMessage);
+  }
+}
+
+function isTerminalEditor (editor) {
+  switch (editor) {
+    case 'vim':
+    case 'emacs':
+    case 'nano':
+      return true
+  }
+  return false
+}
+
+const positionRE = /:(\d+)(:(\d+))?$/;
+function parseFile (file) {
+  const fileName = file.replace(positionRE, '');
+  const match = file.match(positionRE);
+  const lineNumber = match && match[1];
+  const columnNumber = match && match[3];
+  return {
+    fileName,
+    lineNumber,
+    columnNumber
+  }
+}
+
+let _childProcess = null;
+
+function launchEditor (file, specifiedEditor, onErrorCallback) {
+  const parsed = parseFile(file);
+  let { fileName } = parsed;
+  const { lineNumber, columnNumber } = parsed;
+
+  if (!fs$4.existsSync(fileName)) {
+    return
+  }
+
+  if (typeof specifiedEditor === 'function') {
+    onErrorCallback = specifiedEditor;
+    specifiedEditor = undefined;
+  }
+
+  onErrorCallback = wrapErrorCallback(onErrorCallback);
+
+  const [editor, ...args] = guessEditor(specifiedEditor);
+  if (!editor) {
+    onErrorCallback(fileName, null);
+    return
+  }
+
+  if (
+    process.platform === 'linux' &&
+    fileName.startsWith('/mnt/') &&
+    /Microsoft/i.test(os$1.release())
+  ) {
+    // Assume WSL / "Bash on Ubuntu on Windows" is being used, and
+    // that the file exists on the Windows file system.
+    // `os.release()` is "4.4.0-43-Microsoft" in the current release
+    // build of WSL, see: https://github.com/Microsoft/BashOnWindows/issues/423#issuecomment-221627364
+    // When a Windows editor is specified, interop functionality can
+    // handle the path translation, but only if a relative path is used.
+    fileName = path$5.relative('', fileName);
+  }
+
+  // cmd.exe on Windows is vulnerable to RCE attacks given a file name of the
+  // form "C:\Users\myusername\Downloads\& curl 172.21.93.52". Use a safe file
+  // name pattern to validate user-provided file names. This doesn't cover the
+  // entire range of valid file names but should cover almost all of them in practice.
+  // (Backport of
+  // https://github.com/facebook/create-react-app/pull/4866
+  // and
+  // https://github.com/facebook/create-react-app/pull/5431)
+
+  // Allows alphanumeric characters, periods, dashes, slashes, underscores, plus and space.
+  const WINDOWS_CMD_SAFE_FILE_NAME_PATTERN = /^([A-Za-z]:[/\\])?[\p{L}0-9/.\-\\_+ ]+$/u;
+  if (
+    process.platform === 'win32' &&
+    !WINDOWS_CMD_SAFE_FILE_NAME_PATTERN.test(fileName.trim())
+  ) {
+    console.log();
+    console.log(
+      colors.red('Could not open ' + path$5.basename(fileName) + ' in the editor.')
+    );
+    console.log();
+    console.log(
+      'When running on Windows, file names are checked against a safe file name ' +
+        'pattern to protect against remote code execution attacks. File names ' +
+        'may consist only of alphanumeric characters (all languages), periods, ' +
+        'dashes, slashes, and underscores.'
+    );
+    console.log();
+    return
+  }
+
+  if (lineNumber) {
+    const extraArgs = getArgumentsForPosition(editor, fileName, lineNumber, columnNumber);
+    args.push.apply(args, extraArgs);
+  } else {
+    args.push(fileName);
+  }
+
+  if (_childProcess && isTerminalEditor(editor)) {
+    // There's an existing editor process already and it's attached
+    // to the terminal, so go kill it. Otherwise two separate editor
+    // instances attach to the stdin/stdout which gets confusing.
+    _childProcess.kill('SIGKILL');
+  }
+
+  if (process.platform === 'win32') {
+    // On Windows, launch the editor in a shell because spawn can only
+    // launch .exe files.
+    _childProcess = childProcess$1.spawn(
+      'cmd.exe',
+      ['/C', editor].concat(args),
+      { stdio: 'inherit' }
+    );
+  } else {
+    _childProcess = childProcess$1.spawn(editor, args, { stdio: 'inherit' });
+  }
+  _childProcess.on('exit', function (errorCode) {
+    _childProcess = null;
+
+    if (errorCode) {
+      onErrorCallback(fileName, '(code ' + errorCode + ')');
+    }
+  });
+
+  _childProcess.on('error', function (error) {
+    let { code, message } = error;
+    if ('ENOENT' === code) {
+      message = `${message} ('${editor}' command does not exist in 'PATH')`;
+    }
+    onErrorCallback(fileName, message);
+  });
+}
+
+var launchEditor_1 = launchEditor;
+
+const url$2 = require$$0$9;
+const path$4 = require$$0$4;
+const launch = launchEditor_1;
+
+var launchEditorMiddleware = (specifiedEditor, srcRoot, onErrorCallback) => {
+  if (typeof specifiedEditor === 'function') {
+    onErrorCallback = specifiedEditor;
+    specifiedEditor = undefined;
+  }
+
+  if (typeof srcRoot === 'function') {
+    onErrorCallback = srcRoot;
+    srcRoot = undefined;
+  }
+
+  srcRoot = srcRoot || process.cwd();
+
+  return function launchEditorMiddleware (req, res) {
+    const { file } = url$2.parse(req.url, true).query || {};
+    if (!file) {
+      res.statusCode = 500;
+      res.end(`launch-editor-middleware: required query param "file" is missing.`);
+    } else {
+      launch(path$4.resolve(srcRoot, file), specifiedEditor, onErrorCallback);
+      res.end();
+    }
+  }
+};
+
+var launchEditorMiddleware$1 = /*@__PURE__*/getDefaultExportFromCjs(launchEditorMiddleware);
+
+async function resolveHttpServer({ proxy }, app, httpsOptions) {
+  if (!httpsOptions) {
+    const { createServer } = await import('node:http');
+    return createServer(app);
+  }
+  if (proxy) {
+    const { createServer } = await import('node:https');
+    return createServer(httpsOptions, app);
+  } else {
+    const { createSecureServer } = await import('node:http2');
+    return createSecureServer(
+      {
+        // Manually increase the session memory to prevent 502 ENHANCE_YOUR_CALM
+        // errors on large numbers of requests
+        maxSessionMemory: 1e3,
+        ...httpsOptions,
+        allowHTTP1: true
+      },
+      // @ts-expect-error TODO: is this correct?
+      app
+    );
+  }
+}
+async function resolveHttpsConfig(https) {
+  if (!https) return void 0;
+  const [ca, cert, key, pfx] = await Promise.all([
+    readFileIfExists(https.ca),
+    readFileIfExists(https.cert),
+    readFileIfExists(https.key),
+    readFileIfExists(https.pfx)
+  ]);
+  return { ...https, ca, cert, key, pfx };
+}
+async function readFileIfExists(value) {
+  if (typeof value === "string") {
+    return fsp.readFile(path$n.resolve(value)).catch(() => value);
+  }
+  return value;
+}
+async function httpServerStart(httpServer, serverOptions) {
+  let { port, strictPort, host, logger } = serverOptions;
+  return new Promise((resolve, reject) => {
+    const onError = (e) => {
+      if (e.code === "EADDRINUSE") {
+        if (strictPort) {
+          httpServer.removeListener("error", onError);
+          reject(new Error(`Port ${port} is already in use`));
+        } else {
+          logger.info(`Port ${port} is in use, trying another one...`);
+          httpServer.listen(++port, host);
+        }
+      } else {
+        httpServer.removeListener("error", onError);
+        reject(e);
+      }
+    };
+    httpServer.on("error", onError);
+    httpServer.listen(port, host, () => {
+      httpServer.removeListener("error", onError);
+      resolve(port);
+    });
+  });
+}
+function setClientErrorHandler(server, logger) {
+  server.on("clientError", (err, socket) => {
+    let msg = "400 Bad Request";
+    if (err.code === "HPE_HEADER_OVERFLOW") {
+      msg = "431 Request Header Fields Too Large";
+      logger.warn(
+        colors$1.yellow(
+          "Server responded with status code 431. See https://vitejs.dev/guide/troubleshooting.html#_431-request-header-fields-too-large."
+        )
+      );
+    }
+    if (err.code === "ECONNRESET" || !socket.writable) {
+      return;
+    }
+    socket.end(`HTTP/1.1 ${msg}\r
+\r
+`);
+  });
+}
+
+const commonFsUtils = {
+  existsSync: fs__default.existsSync,
+  isDirectory,
+  tryResolveRealFile,
+  tryResolveRealFileWithExtensions,
+  tryResolveRealFileOrType
+};
+const cachedFsUtilsMap = /* @__PURE__ */ new WeakMap();
+function getFsUtils(config) {
+  let fsUtils = cachedFsUtilsMap.get(config);
+  if (!fsUtils) {
+    if (config.command !== "serve" || config.server.fs.cachedChecks !== true || config.server.watch?.ignored || process.versions.pnp) {
+      fsUtils = commonFsUtils;
+    } else if (!config.resolve.preserveSymlinks && config.root !== getRealPath(config.root)) {
+      fsUtils = commonFsUtils;
+    } else {
+      fsUtils = createCachedFsUtils(config);
+    }
+    cachedFsUtilsMap.set(config, fsUtils);
+  }
+  return fsUtils;
+}
+function readDirCacheSync(file) {
+  let dirents;
+  try {
+    dirents = fs__default.readdirSync(file, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  return direntsToDirentMap(dirents);
+}
+function direntsToDirentMap(fsDirents) {
+  const dirents = /* @__PURE__ */ new Map();
+  for (const dirent of fsDirents) {
+    const type = dirent.isDirectory() ? "directory" : dirent.isSymbolicLink() ? "symlink" : dirent.isFile() ? "file" : void 0;
+    if (type) {
+      dirents.set(dirent.name, { type });
+    }
+  }
+  return dirents;
+}
+function ensureFileMaybeSymlinkIsResolved(direntCache, filePath) {
+  if (direntCache.type !== "file_maybe_symlink") return;
+  const isSymlink = fs__default.lstatSync(filePath, { throwIfNoEntry: false })?.isSymbolicLink();
+  direntCache.type = isSymlink === void 0 ? "error" : isSymlink ? "symlink" : "file";
+}
+function pathUntilPart(root, parts, i) {
+  let p = root;
+  for (let k = 0; k < i; k++) p += "/" + parts[k];
+  return p;
+}
+function createCachedFsUtils(config) {
+  const root = config.root;
+  const rootDirPath = `${root}/`;
+  const rootCache = { type: "directory" };
+  const getDirentCacheSync = (parts) => {
+    let direntCache = rootCache;
+    for (let i = 0; i < parts.length; i++) {
+      if (direntCache.type === "directory") {
+        let dirPath;
+        if (!direntCache.dirents) {
+          dirPath = pathUntilPart(root, parts, i);
+          const dirents = readDirCacheSync(dirPath);
+          if (!dirents) {
+            direntCache.type = "error";
+            return;
+          }
+          direntCache.dirents = dirents;
+        }
+        const nextDirentCache = direntCache.dirents.get(parts[i]);
+        if (!nextDirentCache) {
+          return;
+        }
+        if (nextDirentCache.type === "directory_maybe_symlink") {
+          dirPath ??= pathUntilPart(root, parts, i + 1);
+          const isSymlink = fs__default.lstatSync(dirPath, { throwIfNoEntry: false })?.isSymbolicLink();
+          nextDirentCache.type = isSymlink ? "symlink" : "directory";
+        }
+        direntCache = nextDirentCache;
+      } else if (direntCache.type === "symlink") {
+        return direntCache;
+      } else if (direntCache.type === "error") {
+        return direntCache;
+      } else {
+        if (i !== parts.length - 1) {
+          return;
+        }
+        if (direntCache.type === "file_maybe_symlink") {
+          ensureFileMaybeSymlinkIsResolved(
+            direntCache,
+            pathUntilPart(root, parts, i)
+          );
+          return direntCache;
+        } else if (direntCache.type === "file") {
+          return direntCache;
+        } else {
+          return;
+        }
+      }
+    }
+    return direntCache;
+  };
+  function getDirentCacheFromPath(normalizedFile) {
+    if (normalizedFile[normalizedFile.length - 1] === "/") {
+      normalizedFile = normalizedFile.slice(0, -1);
+    }
+    if (normalizedFile === root) {
+      return rootCache;
+    }
+    if (!normalizedFile.startsWith(rootDirPath)) {
+      return void 0;
+    }
+    const pathFromRoot = normalizedFile.slice(rootDirPath.length);
+    const parts = pathFromRoot.split("/");
+    const direntCache = getDirentCacheSync(parts);
+    if (!direntCache || direntCache.type === "error") {
+      return false;
+    }
+    return direntCache;
+  }
+  function onPathAdd(file, type) {
+    const direntCache = getDirentCacheFromPath(
+      normalizePath$3(path$n.dirname(file))
+    );
+    if (direntCache && direntCache.type === "directory" && direntCache.dirents) {
+      direntCache.dirents.set(path$n.basename(file), { type });
+    }
+  }
+  function onPathUnlink(file) {
+    const direntCache = getDirentCacheFromPath(
+      normalizePath$3(path$n.dirname(file))
+    );
+    if (direntCache && direntCache.type === "directory" && direntCache.dirents) {
+      direntCache.dirents.delete(path$n.basename(file));
+    }
+  }
+  return {
+    existsSync(file) {
+      if (isInNodeModules$1(file)) {
+        return fs__default.existsSync(file);
+      }
+      const normalizedFile = normalizePath$3(file);
+      const direntCache = getDirentCacheFromPath(normalizedFile);
+      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
+        return fs__default.existsSync(file);
+      }
+      return !!direntCache;
+    },
+    tryResolveRealFile(file, preserveSymlinks) {
+      if (isInNodeModules$1(file)) {
+        return tryResolveRealFile(file, preserveSymlinks);
+      }
+      const normalizedFile = normalizePath$3(file);
+      const direntCache = getDirentCacheFromPath(normalizedFile);
+      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
+        return tryResolveRealFile(file, preserveSymlinks);
+      }
+      if (!direntCache || direntCache.type === "directory") {
+        return;
+      }
+      return normalizedFile;
+    },
+    tryResolveRealFileWithExtensions(file, extensions, preserveSymlinks) {
+      if (isInNodeModules$1(file)) {
+        return tryResolveRealFileWithExtensions(
+          file,
+          extensions,
+          preserveSymlinks
+        );
+      }
+      const normalizedFile = normalizePath$3(file);
+      const dirPath = path$n.posix.dirname(normalizedFile);
+      const direntCache = getDirentCacheFromPath(dirPath);
+      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
+        return tryResolveRealFileWithExtensions(
+          file,
+          extensions,
+          preserveSymlinks
+        );
+      }
+      if (!direntCache || direntCache.type !== "directory") {
+        return;
+      }
+      if (!direntCache.dirents) {
+        const dirents = readDirCacheSync(dirPath);
+        if (!dirents) {
+          direntCache.type = "error";
+          return;
+        }
+        direntCache.dirents = dirents;
+      }
+      const base = path$n.posix.basename(normalizedFile);
+      for (const ext of extensions) {
+        const fileName = base + ext;
+        const fileDirentCache = direntCache.dirents.get(fileName);
+        if (fileDirentCache) {
+          const filePath = dirPath + "/" + fileName;
+          ensureFileMaybeSymlinkIsResolved(fileDirentCache, filePath);
+          if (fileDirentCache.type === "symlink") {
+            return tryResolveRealFile(filePath, preserveSymlinks);
+          }
+          if (fileDirentCache.type === "file") {
+            return filePath;
+          }
+        }
+      }
+    },
+    tryResolveRealFileOrType(file, preserveSymlinks) {
+      if (isInNodeModules$1(file)) {
+        return tryResolveRealFileOrType(file, preserveSymlinks);
+      }
+      const normalizedFile = normalizePath$3(file);
+      const direntCache = getDirentCacheFromPath(normalizedFile);
+      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
+        return tryResolveRealFileOrType(file, preserveSymlinks);
+      }
+      if (!direntCache) {
+        return;
+      }
+      if (direntCache.type === "directory") {
+        return { type: "directory" };
+      }
+      return { path: normalizedFile, type: "file" };
+    },
+    isDirectory(dirPath) {
+      if (isInNodeModules$1(dirPath)) {
+        return isDirectory(dirPath);
+      }
+      const direntCache = getDirentCacheFromPath(normalizePath$3(dirPath));
+      if (direntCache === void 0 || direntCache && direntCache.type === "symlink") {
+        return isDirectory(dirPath);
+      }
+      return direntCache && direntCache.type === "directory";
+    },
+    initWatcher(watcher) {
+      watcher.on("add", (file) => {
+        onPathAdd(file, "file_maybe_symlink");
+      });
+      watcher.on("addDir", (dir) => {
+        onPathAdd(dir, "directory_maybe_symlink");
+      });
+      watcher.on("unlink", onPathUnlink);
+      watcher.on("unlinkDir", onPathUnlink);
+    }
+  };
+}
+function tryResolveRealFile(file, preserveSymlinks) {
+  const stat = tryStatSync(file);
+  if (stat?.isFile()) return getRealPath(file, preserveSymlinks);
+}
+function tryResolveRealFileWithExtensions(filePath, extensions, preserveSymlinks) {
+  for (const ext of extensions) {
+    const res = tryResolveRealFile(filePath + ext, preserveSymlinks);
+    if (res) return res;
+  }
+}
+function tryResolveRealFileOrType(file, preserveSymlinks) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile()) {
+    return { path: getRealPath(file, preserveSymlinks), type: "file" };
+  }
+  if (fileStat?.isDirectory()) {
+    return { type: "directory" };
+  }
+  return;
+}
+function getRealPath(resolved, preserveSymlinks) {
+  if (!preserveSymlinks) {
+    resolved = safeRealpathSync(resolved);
+  }
+  return normalizePath$3(resolved);
+}
+function isDirectory(path2) {
+  const stat = tryStatSync(path2);
+  return stat?.isDirectory() ?? false;
+}
+
+/*!
+ * etag
+ * Copyright(c) 2014-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ * @public
+ */
+
+var etag_1 = etag;
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var crypto = require$$3$1;
+var Stats = require$$0__default.Stats;
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Generate an entity tag.
+ *
+ * @param {Buffer|string} entity
+ * @return {string}
+ * @private
+ */
+
+function entitytag (entity) {
+  if (entity.length === 0) {
+    // fast-path empty
+    return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
+  }
+
+  // compute hash of entity
+  var hash = crypto
+    .createHash('sha1')
+    .update(entity, 'utf8')
+    .digest('base64')
+    .substring(0, 27);
+
+  // compute length of entity
+  var len = typeof entity === 'string'
+    ? Buffer.byteLength(entity, 'utf8')
+    : entity.length;
+
+  return '"' + len.toString(16) + '-' + hash + '"'
+}
+
+/**
+ * Create a simple ETag.
+ *
+ * @param {string|Buffer|Stats} entity
+ * @param {object} [options]
+ * @param {boolean} [options.weak]
+ * @return {String}
+ * @public
+ */
+
+function etag (entity, options) {
+  if (entity == null) {
+    throw new TypeError('argument entity is required')
+  }
+
+  // support fs.Stats object
+  var isStats = isstats(entity);
+  var weak = options && typeof options.weak === 'boolean'
+    ? options.weak
+    : isStats;
+
+  // validate argument
+  if (!isStats && typeof entity !== 'string' && !Buffer.isBuffer(entity)) {
+    throw new TypeError('argument entity must be string, Buffer, or fs.Stats')
+  }
+
+  // generate entity tag
+  var tag = isStats
+    ? stattag(entity)
+    : entitytag(entity);
+
+  return weak
+    ? 'W/' + tag
+    : tag
+}
+
+/**
+ * Determine if object is a Stats object.
+ *
+ * @param {object} obj
+ * @return {boolean}
+ * @api private
+ */
+
+function isstats (obj) {
+  // genuine fs.Stats
+  if (typeof Stats === 'function' && obj instanceof Stats) {
+    return true
+  }
+
+  // quack quack
+  return obj && typeof obj === 'object' &&
+    'ctime' in obj && toString.call(obj.ctime) === '[object Date]' &&
+    'mtime' in obj && toString.call(obj.mtime) === '[object Date]' &&
+    'ino' in obj && typeof obj.ino === 'number' &&
+    'size' in obj && typeof obj.size === 'number'
+}
+
+/**
+ * Generate a tag for a stat.
+ *
+ * @param {object} stat
+ * @return {string}
+ * @private
+ */
+
+function stattag (stat) {
+  var mtime = stat.mtime.getTime().toString(16);
+  var size = stat.size.toString(16);
+
+  return '"' + size + '-' + mtime + '"'
+}
+
+var getEtag = /*@__PURE__*/getDefaultExportFromCjs(etag_1);
+
+function e(e,n,r){throw new Error(r?`No known conditions for "${n}" specifier in "${e}" package`:`Missing "${n}" specifier in "${e}" package`)}function n(n,i,o,f){let s,u,l=r(n,o),c=function(e){let n=new Set(["default",...e.conditions||[]]);return e.unsafe||n.add(e.require?"require":"import"),e.unsafe||n.add(e.browser?"browser":"node"),n}(f||{}),a=i[l];if(void 0===a){let e,n,r,t;for(t in i)n&&t.length<n.length||("/"===t[t.length-1]&&l.startsWith(t)?(u=l.substring(t.length),n=t):t.length>1&&(r=t.indexOf("*",1),~r&&(e=RegExp("^"+t.substring(0,r)+"(.*)"+t.substring(1+r)).exec(l),e&&e[1]&&(u=e[1],n=t))));a=i[n];}return a||e(n,l),s=t(a,c),s||e(n,l,1),u&&function(e,n){let r,t=0,i=e.length,o=/[*]/g,f=/[/]$/;for(;t<i;t++)e[t]=o.test(r=e[t])?r.replace(o,n):f.test(r)?r+n:r;}(s,u),s}function r(e,n,r){if(e===n||"."===n)return ".";let t=e+"/",i=t.length,o=n.slice(0,i)===t,f=o?n.slice(i):n;return "#"===f[0]?f:o||!r?"./"===f.slice(0,2)?f:"./"+f:f}function t(e,n,r){if(e){if("string"==typeof e)return r&&r.add(e),[e];let i,o;if(Array.isArray(e)){for(o=r||new Set,i=0;i<e.length;i++)t(e[i],n,o);if(!r&&o.size)return [...o]}else for(i in e)if(n.has(i))return t(e[i],n,r)}}function o(e,r,t){let i,o=e.exports;if(o){if("string"==typeof o)o={".":o};else for(i in o){"."!==i[0]&&(o={".":o});break}return n(e.name,o,r||".",t)}}function f(e,r,t){if(e.imports)return n(e.name,e.imports,r,t)}
+
+const normalizedClientEntry$1 = normalizePath$3(CLIENT_ENTRY);
+const normalizedEnvEntry$1 = normalizePath$3(ENV_ENTRY);
+const ERR_RESOLVE_PACKAGE_ENTRY_FAIL = "ERR_RESOLVE_PACKAGE_ENTRY_FAIL";
+const browserExternalId = "__vite-browser-external";
+const optionalPeerDepId = "__vite-optional-peer-dep";
+const subpathImportsPrefix = "#";
+const startsWithWordCharRE = /^\w/;
+const debug$c = createDebugger("vite:resolve-details", {
+  onlyWhenFocused: true
+});
+function resolvePlugin(resolveOptions) {
+  const {
+    root,
+    isProduction,
+    asSrc,
+    ssrConfig,
+    preferRelative = false
+  } = resolveOptions;
+  const {
+    target: ssrTarget,
+    noExternal: ssrNoExternal,
+    external: ssrExternal
+  } = ssrConfig ?? {};
+  const rootInRoot = tryStatSync(path$n.join(root, root))?.isDirectory() ?? false;
+  return {
+    name: "vite:resolve",
+    async resolveId(id, importer, resolveOpts) {
+      if (id[0] === "\0" || id.startsWith("virtual:") || // When injected directly in html/client code
+      id.startsWith("/virtual:")) {
+        return;
+      }
+      const ssr = resolveOpts?.ssr === true;
+      const depsOptimizer = resolveOptions.getDepsOptimizer?.(ssr);
+      if (id.startsWith(browserExternalId)) {
+        return id;
+      }
+      const targetWeb = !ssr || ssrTarget === "webworker";
+      const isRequire = resolveOpts?.custom?.["node-resolve"]?.isRequire ?? false;
+      const ssrConditions = resolveOptions.ssrConfig?.resolve?.conditions || resolveOptions.conditions;
+      const options = {
+        isRequire,
+        ...resolveOptions,
+        scan: resolveOpts?.scan ?? resolveOptions.scan,
+        conditions: ssr ? ssrConditions : resolveOptions.conditions
+      };
+      const resolvedImports = resolveSubpathImports(
+        id,
+        importer,
+        options,
+        targetWeb
+      );
+      if (resolvedImports) {
+        id = resolvedImports;
+        if (resolveOpts.custom?.["vite:import-glob"]?.isSubImportsPattern) {
+          return normalizePath$3(path$n.join(root, id));
+        }
+      }
+      if (importer) {
+        if (isTsRequest(importer) || resolveOpts.custom?.depScan?.loader?.startsWith("ts")) {
+          options.isFromTsImporter = true;
+        } else {
+          const moduleLang = this.getModuleInfo(importer)?.meta?.vite?.lang;
+          options.isFromTsImporter = moduleLang && isTsRequest(`.${moduleLang}`);
+        }
+      }
+      let res;
+      if (asSrc && depsOptimizer?.isOptimizedDepUrl(id)) {
+        const optimizedPath = id.startsWith(FS_PREFIX) ? fsPathFromId(id) : normalizePath$3(path$n.resolve(root, id.slice(1)));
+        return optimizedPath;
+      }
+      if (asSrc && id.startsWith(FS_PREFIX)) {
+        res = fsPathFromId(id);
+        debug$c?.(`[@fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+        return ensureVersionQuery(res, id, options, depsOptimizer);
+      }
+      if (asSrc && id[0] === "/" && (rootInRoot || !id.startsWith(withTrailingSlash(root)))) {
+        const fsPath = path$n.resolve(root, id.slice(1));
+        if (res = tryFsResolve(fsPath, options)) {
+          debug$c?.(`[url] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+          return ensureVersionQuery(res, id, options, depsOptimizer);
+        }
+      }
+      if (id[0] === "." || (preferRelative || importer?.endsWith(".html")) && startsWithWordCharRE.test(id)) {
+        const basedir = importer ? path$n.dirname(importer) : process.cwd();
+        const fsPath = path$n.resolve(basedir, id);
+        const normalizedFsPath = normalizePath$3(fsPath);
+        if (depsOptimizer?.isOptimizedDepFile(normalizedFsPath)) {
+          if (!resolveOptions.isBuild && !DEP_VERSION_RE.test(normalizedFsPath)) {
+            const browserHash = optimizedDepInfoFromFile(
+              depsOptimizer.metadata,
+              normalizedFsPath
+            )?.browserHash;
+            if (browserHash) {
+              return injectQuery(normalizedFsPath, `v=${browserHash}`);
+            }
+          }
+          return normalizedFsPath;
+        }
+        if (targetWeb && options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(fsPath, importer, options, true))) {
+          return res;
+        }
+        if (res = tryFsResolve(fsPath, options)) {
+          res = ensureVersionQuery(res, id, options, depsOptimizer);
+          debug$c?.(`[relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+          if (!options.idOnly && !options.scan && options.isBuild && !importer?.endsWith(".html")) {
+            const resPkg = findNearestPackageData(
+              path$n.dirname(res),
+              options.packageCache
+            );
+            if (resPkg) {
+              return {
+                id: res,
+                moduleSideEffects: resPkg.hasSideEffects(res)
+              };
+            }
+          }
+          return res;
+        }
+      }
+      if (isWindows$3 && id[0] === "/") {
+        const basedir = importer ? path$n.dirname(importer) : process.cwd();
+        const fsPath = path$n.resolve(basedir, id);
+        if (res = tryFsResolve(fsPath, options)) {
+          debug$c?.(`[drive-relative] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+          return ensureVersionQuery(res, id, options, depsOptimizer);
+        }
+      }
+      if (isNonDriveRelativeAbsolutePath(id) && (res = tryFsResolve(id, options))) {
+        debug$c?.(`[fs] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+        return ensureVersionQuery(res, id, options, depsOptimizer);
+      }
+      if (isExternalUrl(id)) {
+        return options.idOnly ? id : { id, external: true };
+      }
+      if (isDataUrl(id)) {
+        return null;
+      }
+      if (bareImportRE.test(id)) {
+        const external = options.shouldExternalize?.(id, importer);
+        if (!external && asSrc && depsOptimizer && !options.scan && (res = await tryOptimizedResolve(
+          depsOptimizer,
+          id,
+          importer,
+          options.preserveSymlinks,
+          options.packageCache
+        ))) {
+          return res;
+        }
+        if (targetWeb && options.mainFields.includes("browser") && (res = tryResolveBrowserMapping(
+          id,
+          importer,
+          options,
+          false,
+          external
+        ))) {
+          return res;
+        }
+        if (res = tryNodeResolve(
+          id,
+          importer,
+          options,
+          targetWeb,
+          depsOptimizer,
+          ssr,
+          external
+        )) {
+          return res;
+        }
+        if (isBuiltin(id)) {
+          if (ssr) {
+            if (targetWeb && ssrNoExternal === true && // if both noExternal and external are true, noExternal will take the higher priority and bundle it.
+            // only if the id is explicitly listed in external, we will externalize it and skip this error.
+            (ssrExternal === true || !ssrExternal?.includes(id))) {
+              let message = `Cannot bundle Node.js built-in "${id}"`;
+              if (importer) {
+                message += ` imported from "${path$n.relative(
+                  process.cwd(),
+                  importer
+                )}"`;
+              }
+              message += `. Consider disabling ssr.noExternal or remove the built-in dependency.`;
+              this.error(message);
+            }
+            return options.idOnly ? id : { id, external: true, moduleSideEffects: false };
+          } else {
+            if (!asSrc) {
+              debug$c?.(
+                `externalized node built-in "${id}" to empty module. (imported by: ${colors$1.white(colors$1.dim(importer))})`
+              );
+            } else if (isProduction) {
+              this.warn(
+                `Module "${id}" has been externalized for browser compatibility, imported by "${importer}". See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`
+              );
+            }
+            return isProduction ? browserExternalId : `${browserExternalId}:${id}`;
+          }
+        }
+      }
+      debug$c?.(`[fallthrough] ${colors$1.dim(id)}`);
+    },
+    load(id) {
+      if (id.startsWith(browserExternalId)) {
+        if (isProduction) {
+          return `export default {}`;
+        } else {
+          id = id.slice(browserExternalId.length + 1);
+          return `export default new Proxy({}, {
+  get(_, key) {
+    throw new Error(\`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.\${key}" in client code.  See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+  }
+})`;
+        }
+      }
+      if (id.startsWith(optionalPeerDepId)) {
+        if (isProduction) {
+          return `export default {}`;
+        } else {
+          const [, peerDep, parentDep] = id.split(":");
+          return `throw new Error(\`Could not resolve "${peerDep}" imported by "${parentDep}". Is it installed?\`)`;
+        }
+      }
+    }
+  };
+}
+function resolveSubpathImports(id, importer, options, targetWeb) {
+  if (!importer || !id.startsWith(subpathImportsPrefix)) return;
+  const basedir = path$n.dirname(importer);
+  const pkgData = findNearestPackageData(basedir, options.packageCache);
+  if (!pkgData) return;
+  let { file: idWithoutPostfix, postfix } = splitFileAndPostfix(id.slice(1));
+  idWithoutPostfix = "#" + idWithoutPostfix;
+  let importsPath = resolveExportsOrImports(
+    pkgData.data,
+    idWithoutPostfix,
+    options,
+    targetWeb,
+    "imports"
+  );
+  if (importsPath?.[0] === ".") {
+    importsPath = path$n.relative(basedir, path$n.join(pkgData.dir, importsPath));
+    if (importsPath[0] !== ".") {
+      importsPath = `./${importsPath}`;
+    }
+  }
+  return importsPath + postfix;
+}
+function ensureVersionQuery(resolved, id, options, depsOptimizer) {
+  if (!options.isBuild && !options.scan && depsOptimizer && !(resolved === normalizedClientEntry$1 || resolved === normalizedEnvEntry$1)) {
+    const isNodeModule = isInNodeModules$1(id) || isInNodeModules$1(resolved);
+    if (isNodeModule && !DEP_VERSION_RE.test(resolved)) {
+      const versionHash = depsOptimizer.metadata.browserHash;
+      if (versionHash && isOptimizable(resolved, depsOptimizer.options)) {
+        resolved = injectQuery(resolved, `v=${versionHash}`);
+      }
+    }
+  }
+  return resolved;
+}
+function splitFileAndPostfix(path2) {
+  const file = cleanUrl(path2);
+  return { file, postfix: path2.slice(file.length) };
+}
+function tryFsResolve(fsPath, options, tryIndex = true, targetWeb = true, skipPackageJson = false) {
+  const hashIndex = fsPath.indexOf("#");
+  if (hashIndex >= 0 && isInNodeModules$1(fsPath)) {
+    const queryIndex = fsPath.indexOf("?");
+    if (queryIndex < 0 || queryIndex > hashIndex) {
+      const file2 = queryIndex > hashIndex ? fsPath.slice(0, queryIndex) : fsPath;
+      const res2 = tryCleanFsResolve(
+        file2,
+        options,
+        tryIndex,
+        targetWeb,
+        skipPackageJson
+      );
+      if (res2) return res2 + fsPath.slice(file2.length);
+    }
+  }
+  const { file, postfix } = splitFileAndPostfix(fsPath);
+  const res = tryCleanFsResolve(
+    file,
+    options,
+    tryIndex,
+    targetWeb,
+    skipPackageJson
+  );
+  if (res) return res + postfix;
+}
+const knownTsOutputRE = /\.(?:js|mjs|cjs|jsx)$/;
+const isPossibleTsOutput = (url) => knownTsOutputRE.test(url);
+function tryCleanFsResolve(file, options, tryIndex = true, targetWeb = true, skipPackageJson = false) {
+  const { tryPrefix, extensions, preserveSymlinks } = options;
+  const fsUtils = options.fsUtils ?? commonFsUtils;
+  const fileResult = fsUtils.tryResolveRealFileOrType(
+    file,
+    options.preserveSymlinks
+  );
+  if (fileResult?.path) return fileResult.path;
+  let res;
+  const possibleJsToTs = options.isFromTsImporter && isPossibleTsOutput(file);
+  if (possibleJsToTs || options.extensions.length || tryPrefix) {
+    const dirPath = path$n.dirname(file);
+    if (fsUtils.isDirectory(dirPath)) {
+      if (possibleJsToTs) {
+        const fileExt = path$n.extname(file);
+        const fileName = file.slice(0, -fileExt.length);
+        if (res = fsUtils.tryResolveRealFile(
+          fileName + fileExt.replace("js", "ts"),
+          preserveSymlinks
+        ))
+          return res;
+        if (fileExt === ".js" && (res = fsUtils.tryResolveRealFile(
+          fileName + ".tsx",
+          preserveSymlinks
+        )))
+          return res;
+      }
+      if (res = fsUtils.tryResolveRealFileWithExtensions(
+        file,
+        extensions,
+        preserveSymlinks
+      ))
+        return res;
+      if (tryPrefix) {
+        const prefixed = `${dirPath}/${options.tryPrefix}${path$n.basename(file)}`;
+        if (res = fsUtils.tryResolveRealFile(prefixed, preserveSymlinks))
+          return res;
+        if (res = fsUtils.tryResolveRealFileWithExtensions(
+          prefixed,
+          extensions,
+          preserveSymlinks
+        ))
+          return res;
+      }
+    }
+  }
+  if (tryIndex && fileResult?.type === "directory") {
+    const dirPath = file;
+    if (!skipPackageJson) {
+      let pkgPath = `${dirPath}/package.json`;
+      try {
+        if (fsUtils.existsSync(pkgPath)) {
+          if (!options.preserveSymlinks) {
+            pkgPath = safeRealpathSync(pkgPath);
+          }
+          const pkg = loadPackageData(pkgPath);
+          return resolvePackageEntry(dirPath, pkg, targetWeb, options);
+        }
+      } catch (e) {
+        if (e.code !== ERR_RESOLVE_PACKAGE_ENTRY_FAIL && e.code !== "ENOENT")
+          throw e;
+      }
+    }
+    if (res = fsUtils.tryResolveRealFileWithExtensions(
+      `${dirPath}/index`,
+      extensions,
+      preserveSymlinks
+    ))
+      return res;
+    if (tryPrefix) {
+      if (res = fsUtils.tryResolveRealFileWithExtensions(
+        `${dirPath}/${options.tryPrefix}index`,
+        extensions,
+        preserveSymlinks
+      ))
+        return res;
+    }
+  }
+}
+function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = false, externalize, allowLinkedExternal = true) {
+  const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
+  const deepMatch = deepImportRE.exec(id);
+  const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
+  let basedir;
+  if (dedupe?.includes(pkgId)) {
+    basedir = root;
+  } else if (importer && path$n.isAbsolute(importer) && // css processing appends `*` for importer
+  (importer[importer.length - 1] === "*" || fs__default.existsSync(cleanUrl(importer)))) {
+    basedir = path$n.dirname(importer);
+  } else {
+    basedir = root;
+  }
+  let selfPkg = null;
+  if (!isBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+    const selfPackageData = findNearestPackageData(basedir, packageCache);
+    selfPkg = selfPackageData?.data.exports && selfPackageData?.data.name === pkgId ? selfPackageData : null;
+  }
+  const pkg = selfPkg || resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
+  if (!pkg) {
+    if (basedir !== root && // root has no peer dep
+    !isBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+      const mainPkg = findNearestMainPackageData(basedir, packageCache)?.data;
+      if (mainPkg) {
+        const pkgName = getNpmPackageName(id);
+        if (pkgName != null && mainPkg.peerDependencies?.[pkgName] && mainPkg.peerDependenciesMeta?.[pkgName]?.optional) {
+          return {
+            id: `${optionalPeerDepId}:${id}:${mainPkg.name}`
+          };
+        }
+      }
+    }
+    return;
+  }
+  const resolveId = deepMatch ? resolveDeepImport : resolvePackageEntry;
+  const unresolvedId = deepMatch ? "." + id.slice(pkgId.length) : id;
+  let resolved;
+  try {
+    resolved = resolveId(unresolvedId, pkg, targetWeb, options);
+  } catch (err) {
+    if (!options.tryEsmOnly) {
+      throw err;
+    }
+  }
+  if (!resolved && options.tryEsmOnly) {
+    resolved = resolveId(unresolvedId, pkg, targetWeb, {
+      ...options,
+      isRequire: false,
+      mainFields: DEFAULT_MAIN_FIELDS,
+      extensions: DEFAULT_EXTENSIONS
+    });
+  }
+  if (!resolved) {
+    return;
+  }
+  const processResult = (resolved2) => {
+    if (!externalize) {
+      return resolved2;
+    }
+    if (!allowLinkedExternal && !isInNodeModules$1(resolved2.id)) {
+      return resolved2;
+    }
+    const resolvedExt = path$n.extname(resolved2.id);
+    if (resolvedExt && resolvedExt !== ".js" && resolvedExt !== ".mjs" && resolvedExt !== ".cjs") {
+      return resolved2;
+    }
+    let resolvedId = id;
+    if (deepMatch && !pkg?.data.exports && path$n.extname(id) !== resolvedExt) {
+      const index = resolved2.id.indexOf(id);
+      if (index > -1) {
+        resolvedId = resolved2.id.slice(index);
+        debug$c?.(
+          `[processResult] ${colors$1.cyan(id)} -> ${colors$1.dim(resolvedId)}`
+        );
+      }
+    }
+    return { ...resolved2, id: resolvedId, external: true };
+  };
+  if (!options.idOnly && (!options.scan && isBuild && !depsOptimizer || externalize)) {
+    return processResult({
+      id: resolved,
+      moduleSideEffects: pkg.hasSideEffects(resolved)
+    });
+  }
+  if (!options.ssrOptimizeCheck && (!isInNodeModules$1(resolved) || // linked
+  !depsOptimizer || // resolving before listening to the server
+  options.scan)) {
+    return { id: resolved };
+  }
+  const isJsType = depsOptimizer ? isOptimizable(resolved, depsOptimizer.options) : OPTIMIZABLE_ENTRY_RE.test(resolved);
+  let exclude = depsOptimizer?.options.exclude;
+  let include = depsOptimizer?.options.include;
+  if (options.ssrOptimizeCheck) {
+    exclude = options.ssrConfig?.optimizeDeps?.exclude;
+    include = options.ssrConfig?.optimizeDeps?.include;
+  }
+  const skipOptimization = !options.ssrOptimizeCheck && depsOptimizer?.options.noDiscovery || !isJsType || importer && isInNodeModules$1(importer) || exclude?.includes(pkgId) || exclude?.includes(id) || SPECIAL_QUERY_RE.test(resolved) || // During dev SSR, we don't have a way to reload the module graph if
+  // a non-optimized dep is found. So we need to skip optimization here.
+  // The only optimized deps are the ones explicitly listed in the config.
+  !options.ssrOptimizeCheck && !isBuild && ssr || // Only optimize non-external CJS deps during SSR by default
+  ssr && isFilePathESM(resolved, options.packageCache) && !(include?.includes(pkgId) || include?.includes(id));
+  if (options.ssrOptimizeCheck) {
+    return {
+      id: skipOptimization ? injectQuery(resolved, `__vite_skip_optimization`) : resolved
+    };
+  }
+  if (skipOptimization) {
+    if (!isBuild) {
+      const versionHash = depsOptimizer.metadata.browserHash;
+      if (versionHash && isJsType) {
+        resolved = injectQuery(resolved, `v=${versionHash}`);
+      }
+    }
+  } else {
+    const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
+    resolved = depsOptimizer.getOptimizedDepId(optimizedInfo);
+  }
+  if (!options.idOnly && !options.scan && isBuild) {
+    return {
+      id: resolved,
+      moduleSideEffects: pkg.hasSideEffects(resolved)
+    };
+  } else {
+    return { id: resolved };
+  }
+}
+async function tryOptimizedResolve(depsOptimizer, id, importer, preserveSymlinks, packageCache) {
+  await depsOptimizer.scanProcessing;
+  const metadata = depsOptimizer.metadata;
+  const depInfo = optimizedDepInfoFromId(metadata, id);
+  if (depInfo) {
+    return depsOptimizer.getOptimizedDepId(depInfo);
+  }
+  if (!importer) return;
+  let idPkgDir;
+  const nestedIdMatch = `> ${id}`;
+  for (const optimizedData of metadata.depInfoList) {
+    if (!optimizedData.src) continue;
+    if (!optimizedData.id.endsWith(nestedIdMatch)) continue;
+    if (idPkgDir == null) {
+      const pkgName = getNpmPackageName(id);
+      if (!pkgName) break;
+      idPkgDir = resolvePackageData(
+        pkgName,
+        importer,
+        preserveSymlinks,
+        packageCache
+      )?.dir;
+      if (idPkgDir == null) break;
+      idPkgDir = normalizePath$3(idPkgDir);
+    }
+    if (optimizedData.src.startsWith(withTrailingSlash(idPkgDir))) {
+      return depsOptimizer.getOptimizedDepId(optimizedData);
+    }
+  }
+}
+function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, targetWeb, options) {
+  const { file: idWithoutPostfix, postfix } = splitFileAndPostfix(id);
+  const cached = getResolvedCache(".", targetWeb);
+  if (cached) {
+    return cached + postfix;
+  }
+  try {
+    let entryPoint;
+    if (data.exports) {
+      entryPoint = resolveExportsOrImports(
+        data,
+        ".",
+        options,
+        targetWeb,
+        "exports"
+      );
+    }
+    if (!entryPoint) {
+      for (const field of options.mainFields) {
+        if (field === "browser") {
+          if (targetWeb) {
+            entryPoint = tryResolveBrowserEntry(dir, data, options);
+            if (entryPoint) {
+              break;
+            }
+          }
+        } else if (typeof data[field] === "string") {
+          entryPoint = data[field];
+          break;
+        }
+      }
+    }
+    entryPoint ||= data.main;
+    const entryPoints = entryPoint ? [entryPoint] : ["index.js", "index.json", "index.node"];
+    for (let entry of entryPoints) {
+      let skipPackageJson = false;
+      if (options.mainFields[0] === "sass" && !options.extensions.includes(path$n.extname(entry))) {
+        entry = "";
+        skipPackageJson = true;
+      } else {
+        const { browser: browserField } = data;
+        if (targetWeb && options.mainFields.includes("browser") && isObject$1(browserField)) {
+          entry = mapWithBrowserField(entry, browserField) || entry;
+        }
+      }
+      const entryPointPath = path$n.join(dir, entry);
+      const resolvedEntryPoint = tryFsResolve(
+        entryPointPath,
+        options,
+        true,
+        true,
+        skipPackageJson
+      );
+      if (resolvedEntryPoint) {
+        debug$c?.(
+          `[package entry] ${colors$1.cyan(idWithoutPostfix)} -> ${colors$1.dim(
+            resolvedEntryPoint
+          )}${postfix !== "" ? ` (postfix: ${postfix})` : ""}`
+        );
+        setResolvedCache(".", resolvedEntryPoint, targetWeb);
+        return resolvedEntryPoint + postfix;
+      }
+    }
+  } catch (e) {
+    packageEntryFailure(id, e.message);
+  }
+  packageEntryFailure(id);
+}
+function packageEntryFailure(id, details) {
+  const err = new Error(
+    `Failed to resolve entry for package "${id}". The package may have incorrect main/module/exports specified in its package.json` + (details ? ": " + details : ".")
+  );
+  err.code = ERR_RESOLVE_PACKAGE_ENTRY_FAIL;
+  throw err;
+}
+function resolveExportsOrImports(pkg, key, options, targetWeb, type) {
+  const additionalConditions = new Set(
+    options.overrideConditions || [
+      "production",
+      "development",
+      "module",
+      ...options.conditions
+    ]
+  );
+  const conditions = [...additionalConditions].filter((condition) => {
+    switch (condition) {
+      case "production":
+        return options.isProduction;
+      case "development":
+        return !options.isProduction;
+    }
+    return true;
+  });
+  const fn = type === "imports" ? f : o;
+  const result = fn(pkg, key, {
+    browser: targetWeb && !additionalConditions.has("node"),
+    require: options.isRequire && !additionalConditions.has("import"),
+    conditions
+  });
+  return result ? result[0] : void 0;
+}
+function resolveDeepImport(id, {
+  webResolvedImports,
+  setResolvedCache,
+  getResolvedCache,
+  dir,
+  data
+}, targetWeb, options) {
+  const cache = getResolvedCache(id, targetWeb);
+  if (cache) {
+    return cache;
+  }
+  let relativeId = id;
+  const { exports: exportsField, browser: browserField } = data;
+  if (exportsField) {
+    if (isObject$1(exportsField) && !Array.isArray(exportsField)) {
+      const { file, postfix } = splitFileAndPostfix(relativeId);
+      const exportsId = resolveExportsOrImports(
+        data,
+        file,
+        options,
+        targetWeb,
+        "exports"
+      );
+      if (exportsId !== void 0) {
+        relativeId = exportsId + postfix;
+      } else {
+        relativeId = void 0;
+      }
+    } else {
+      relativeId = void 0;
+    }
+    if (!relativeId) {
+      throw new Error(
+        `Package subpath '${relativeId}' is not defined by "exports" in ${path$n.join(dir, "package.json")}.`
+      );
+    }
+  } else if (targetWeb && options.mainFields.includes("browser") && isObject$1(browserField)) {
+    const { file, postfix } = splitFileAndPostfix(relativeId);
+    const mapped = mapWithBrowserField(file, browserField);
+    if (mapped) {
+      relativeId = mapped + postfix;
+    } else if (mapped === false) {
+      return webResolvedImports[id] = browserExternalId;
+    }
+  }
+  if (relativeId) {
+    const resolved = tryFsResolve(
+      path$n.join(dir, relativeId),
+      options,
+      !exportsField,
+      // try index only if no exports field
+      targetWeb
+    );
+    if (resolved) {
+      debug$c?.(
+        `[node/deep-import] ${colors$1.cyan(id)} -> ${colors$1.dim(resolved)}`
+      );
+      setResolvedCache(id, resolved, targetWeb);
+      return resolved;
+    }
+  }
+}
+function tryResolveBrowserMapping(id, importer, options, isFilePath, externalize) {
+  let res;
+  const pkg = importer && findNearestPackageData(path$n.dirname(importer), options.packageCache);
+  if (pkg && isObject$1(pkg.data.browser)) {
+    const mapId = isFilePath ? "./" + slash$1(path$n.relative(pkg.dir, id)) : id;
+    const browserMappedPath = mapWithBrowserField(mapId, pkg.data.browser);
+    if (browserMappedPath) {
+      if (res = bareImportRE.test(browserMappedPath) ? tryNodeResolve(browserMappedPath, importer, options, true)?.id : tryFsResolve(path$n.join(pkg.dir, browserMappedPath), options)) {
+        debug$c?.(`[browser mapped] ${colors$1.cyan(id)} -> ${colors$1.dim(res)}`);
+        let result = { id: res };
+        if (options.idOnly) {
+          return result;
+        }
+        if (!options.scan && options.isBuild) {
+          const resPkg = findNearestPackageData(
+            path$n.dirname(res),
+            options.packageCache
+          );
+          if (resPkg) {
+            result = {
+              id: res,
+              moduleSideEffects: resPkg.hasSideEffects(res)
+            };
+          }
+        }
+        return externalize ? { ...result, external: true } : result;
+      }
+    } else if (browserMappedPath === false) {
+      return browserExternalId;
+    }
+  }
+}
+function tryResolveBrowserEntry(dir, data, options) {
+  const browserEntry = typeof data.browser === "string" ? data.browser : isObject$1(data.browser) && data.browser["."];
+  if (browserEntry) {
+    if (!options.isRequire && options.mainFields.includes("module") && typeof data.module === "string" && data.module !== browserEntry) {
+      const resolvedBrowserEntry = tryFsResolve(
+        path$n.join(dir, browserEntry),
+        options
+      );
+      if (resolvedBrowserEntry) {
+        const content = fs__default.readFileSync(resolvedBrowserEntry, "utf-8");
+        if (hasESMSyntax(content)) {
+          return browserEntry;
+        } else {
+          return data.module;
+        }
+      }
+    } else {
+      return browserEntry;
+    }
+  }
+}
+function mapWithBrowserField(relativePathInPkgDir, map) {
+  const normalizedPath = path$n.posix.normalize(relativePathInPkgDir);
+  for (const key in map) {
+    const normalizedKey = path$n.posix.normalize(key);
+    if (normalizedPath === normalizedKey || equalWithoutSuffix(normalizedPath, normalizedKey, ".js") || equalWithoutSuffix(normalizedPath, normalizedKey, "/index.js")) {
+      return map[key];
+    }
+  }
+}
+function equalWithoutSuffix(path2, key, suffix) {
+  return key.endsWith(suffix) && key.slice(0, -suffix.length) === path2;
+}
+
+const externalWithConversionNamespace = "vite:dep-pre-bundle:external-conversion";
+const convertedExternalPrefix = "vite-dep-pre-bundle-external:";
+const cjsExternalFacadeNamespace = "vite:cjs-external-facade";
+const nonFacadePrefix = "vite-cjs-external-facade:";
+const externalTypes = [
+  "css",
+  // supported pre-processor types
+  "less",
+  "sass",
+  "scss",
+  "styl",
+  "stylus",
+  "pcss",
+  "postcss",
+  // wasm
+  "wasm",
+  // known SFC types
+  "vue",
+  "svelte",
+  "marko",
+  "astro",
+  "imba",
+  // JSX/TSX may be configured to be compiled differently from how esbuild
+  // handles it by default, so exclude them as well
+  "jsx",
+  "tsx",
+  ...KNOWN_ASSET_TYPES
+];
+function esbuildDepPlugin(qualified, external, config, ssr) {
+  const { extensions } = getDepOptimizationConfig(config, ssr);
+  const allExternalTypes = extensions ? externalTypes.filter((type) => !extensions?.includes("." + type)) : externalTypes;
+  const esmPackageCache = /* @__PURE__ */ new Map();
+  const cjsPackageCache = /* @__PURE__ */ new Map();
+  const _resolve = config.createResolver({
+    asSrc: false,
+    scan: true,
+    packageCache: esmPackageCache
+  });
+  const _resolveRequire = config.createResolver({
+    asSrc: false,
+    isRequire: true,
+    scan: true,
+    packageCache: cjsPackageCache
+  });
+  const resolve = (id, importer, kind, resolveDir) => {
+    let _importer;
+    {
+      _importer = importer in qualified ? qualified[importer] : importer;
+    }
+    const resolver = kind.startsWith("require") ? _resolveRequire : _resolve;
+    return resolver(id, _importer, void 0, ssr);
+  };
+  const resolveResult = (id, resolved) => {
+    if (resolved.startsWith(browserExternalId)) {
+      return {
+        path: id,
+        namespace: "browser-external"
+      };
+    }
+    if (resolved.startsWith(optionalPeerDepId)) {
+      return {
+        path: resolved,
+        namespace: "optional-peer-dep"
+      };
+    }
+    if (ssr && isBuiltin(resolved)) {
+      return;
+    }
+    if (isExternalUrl(resolved)) {
+      return {
+        path: resolved,
+        external: true
+      };
+    }
+    return {
+      path: path$n.resolve(resolved)
+    };
+  };
+  return {
+    name: "vite:dep-pre-bundle",
+    setup(build) {
+      build.onEnd(() => {
+        esmPackageCache.clear();
+        cjsPackageCache.clear();
+      });
+      build.onResolve(
+        {
+          filter: new RegExp(
+            `\\.(` + allExternalTypes.join("|") + `)(\\?.*)?$`
+          )
+        },
+        async ({ path: id, importer, kind }) => {
+          if (id.startsWith(convertedExternalPrefix)) {
+            return {
+              path: id.slice(convertedExternalPrefix.length),
+              external: true
+            };
+          }
+          const resolved = await resolve(id, importer, kind);
+          if (resolved) {
+            if (kind === "require-call") {
+              if (resolved.endsWith(".js")) {
+                return {
+                  path: resolved,
+                  external: false
+                };
+              }
+              return {
+                path: resolved,
+                namespace: externalWithConversionNamespace
+              };
+            }
+            return {
+              path: resolved,
+              external: true
+            };
+          }
+        }
+      );
+      build.onLoad(
+        { filter: /./, namespace: externalWithConversionNamespace },
+        (args) => {
+          const modulePath = `"${convertedExternalPrefix}${args.path}"`;
+          return {
+            contents: isCSSRequest(args.path) && !isModuleCSSRequest(args.path) ? `import ${modulePath};` : `export { default } from ${modulePath};export * from ${modulePath};`,
+            loader: "js"
+          };
+        }
+      );
+      function resolveEntry(id) {
+        const flatId = flattenId(id);
+        if (flatId in qualified) {
+          return {
+            path: qualified[flatId]
+          };
+        }
+      }
+      build.onResolve(
+        { filter: /^[\w@][^:]/ },
+        async ({ path: id, importer, kind }) => {
+          if (moduleListContains(external, id)) {
+            return {
+              path: id,
+              external: true
+            };
+          }
+          let entry;
+          if (!importer) {
+            if (entry = resolveEntry(id)) return entry;
+            const aliased = await _resolve(id, void 0, true);
+            if (aliased && (entry = resolveEntry(aliased))) {
+              return entry;
+            }
+          }
+          const resolved = await resolve(id, importer, kind);
+          if (resolved) {
+            return resolveResult(id, resolved);
+          }
+        }
+      );
+      build.onLoad(
+        { filter: /.*/, namespace: "browser-external" },
+        ({ path: path2 }) => {
+          if (config.isProduction) {
+            return {
+              contents: "module.exports = {}"
+            };
+          } else {
+            return {
+              // Return in CJS to intercept named imports. Use `Object.create` to
+              // create the Proxy in the prototype to workaround esbuild issue. Why?
+              //
+              // In short, esbuild cjs->esm flow:
+              // 1. Create empty object using `Object.create(Object.getPrototypeOf(module.exports))`.
+              // 2. Assign props of `module.exports` to the object.
+              // 3. Return object for ESM use.
+              //
+              // If we do `module.exports = new Proxy({}, {})`, step 1 returns empty object,
+              // step 2 does nothing as there's no props for `module.exports`. The final object
+              // is just an empty object.
+              //
+              // Creating the Proxy in the prototype satisfies step 1 immediately, which means
+              // the returned object is a Proxy that we can intercept.
+              //
+              // Note: Skip keys that are accessed by esbuild and browser devtools.
+              contents: `module.exports = Object.create(new Proxy({}, {
+  get(_, key) {
+    if (
+      key !== '__esModule' &&
+      key !== '__proto__' &&
+      key !== 'constructor' &&
+      key !== 'splice'
+    ) {
+      console.warn(\`Module "${path2}" has been externalized for browser compatibility. Cannot access "${path2}.\${key}" in client code. See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.\`)
+    }
+  }
+}))`
+            };
+          }
+        }
+      );
+      build.onLoad(
+        { filter: /.*/, namespace: "optional-peer-dep" },
+        ({ path: path2 }) => {
+          if (config.isProduction) {
+            return {
+              contents: "module.exports = {}"
+            };
+          } else {
+            const [, peerDep, parentDep] = path2.split(":");
+            return {
+              contents: `throw new Error(\`Could not resolve "${peerDep}" imported by "${parentDep}". Is it installed?\`)`
+            };
+          }
+        }
+      );
+    }
+  };
+}
+const matchesEntireLine = (text) => `^${escapeRegex(text)}$`;
+function esbuildCjsExternalPlugin(externals, platform) {
+  return {
+    name: "cjs-external",
+    setup(build) {
+      const filter = new RegExp(externals.map(matchesEntireLine).join("|"));
+      build.onResolve({ filter: new RegExp(`^${nonFacadePrefix}`) }, (args) => {
+        return {
+          path: args.path.slice(nonFacadePrefix.length),
+          external: true
+        };
+      });
+      build.onResolve({ filter }, (args) => {
+        if (args.kind === "require-call" && platform !== "node") {
+          return {
+            path: args.path,
+            namespace: cjsExternalFacadeNamespace
+          };
+        }
+        return {
+          path: args.path,
+          external: true
+        };
+      });
+      build.onLoad(
+        { filter: /.*/, namespace: cjsExternalFacadeNamespace },
+        (args) => ({
+          contents: `import * as m from ${JSON.stringify(
+            nonFacadePrefix + args.path
+          )};module.exports = m;`
+        })
+      );
+    }
+  };
+}
+
+const debug$b = createDebugger("vite:ssr-external");
+const isSsrExternalCache = /* @__PURE__ */ new WeakMap();
+function shouldExternalizeForSSR(id, importer, config) {
+  let isSsrExternal = isSsrExternalCache.get(config);
+  if (!isSsrExternal) {
+    isSsrExternal = createIsSsrExternal(config);
+    isSsrExternalCache.set(config, isSsrExternal);
+  }
+  return isSsrExternal(id, importer);
+}
+function createIsConfiguredAsSsrExternal(config) {
+  const { ssr, root } = config;
+  const noExternal = ssr?.noExternal;
+  const noExternalFilter = noExternal !== "undefined" && typeof noExternal !== "boolean" && createFilter(void 0, noExternal, { resolve: false });
+  const targetConditions = config.ssr.resolve?.externalConditions || [];
+  const resolveOptions = {
+    ...config.resolve,
+    root,
+    isProduction: false,
+    isBuild: true,
+    conditions: targetConditions
+  };
+  const isExternalizable = (id, importer, configuredAsExternal) => {
+    if (!bareImportRE.test(id) || id.includes("\0")) {
+      return false;
+    }
+    try {
+      return !!tryNodeResolve(
+        id,
+        // Skip passing importer in build to avoid externalizing non-hoisted dependencies
+        // unresolvable from root (which would be unresolvable from output bundles also)
+        config.command === "build" ? void 0 : importer,
+        resolveOptions,
+        ssr?.target === "webworker",
+        void 0,
+        true,
+        // try to externalize, will return undefined or an object without
+        // a external flag if it isn't externalizable
+        true,
+        // Allow linked packages to be externalized if they are explicitly
+        // configured as external
+        !!configuredAsExternal
+      )?.external;
+    } catch (e) {
+      debug$b?.(
+        `Failed to node resolve "${id}". Skipping externalizing it by default.`
+      );
+      return false;
+    }
+  };
+  return (id, importer) => {
+    if (
+      // If this id is defined as external, force it as external
+      // Note that individual package entries are allowed in ssr.external
+      ssr.external !== true && ssr.external?.includes(id)
+    ) {
+      return true;
+    }
+    const pkgName = getNpmPackageName(id);
+    if (!pkgName) {
+      return isExternalizable(id, importer);
+    }
+    if (
+      // A package name in ssr.external externalizes every
+      // externalizable package entry
+      ssr.external !== true && ssr.external?.includes(pkgName)
+    ) {
+      return isExternalizable(id, importer, true);
+    }
+    if (typeof noExternal === "boolean") {
+      return !noExternal;
+    }
+    if (noExternalFilter && !noExternalFilter(pkgName)) {
+      return false;
+    }
+    return isExternalizable(id, importer, ssr.external === true);
+  };
+}
+function createIsSsrExternal(config) {
+  const processedIds = /* @__PURE__ */ new Map();
+  const isConfiguredAsExternal = createIsConfiguredAsSsrExternal(config);
+  return (id, importer) => {
+    if (processedIds.has(id)) {
+      return processedIds.get(id);
+    }
+    let external = false;
+    if (id[0] !== "." && !path$n.isAbsolute(id)) {
+      external = isBuiltin(id) || isConfiguredAsExternal(id, importer);
+    }
+    processedIds.set(id, external);
+    return external;
+  };
+}
+
+const jsonExtRE = /\.json(?:$|\?)(?!commonjs-(?:proxy|external))/;
+const jsonLangs = `\\.(?:json|json5)(?:$|\\?)`;
+const jsonLangRE = new RegExp(jsonLangs);
+const isJSONRequest = (request) => jsonLangRE.test(request);
+function jsonPlugin(options = {}, isBuild) {
+  return {
+    name: "vite:json",
+    transform(json, id) {
+      if (!jsonExtRE.test(id)) return null;
+      if (SPECIAL_QUERY_RE.test(id)) return null;
+      json = stripBomTag(json);
+      try {
+        if (options.stringify) {
+          if (isBuild) {
+            return {
+              // during build, parse then double-stringify to remove all
+              // unnecessary whitespaces to reduce bundle size.
+              code: `export default JSON.parse(${JSON.stringify(
+                JSON.stringify(JSON.parse(json))
+              )})`,
+              map: { mappings: "" }
+            };
+          } else {
+            return `export default JSON.parse(${JSON.stringify(json)})`;
+          }
+        }
+        const parsed = JSON.parse(json);
+        return {
+          code: dataToEsm(parsed, {
+            preferConst: true,
+            namedExports: options.namedExports
+          }),
+          map: { mappings: "" }
+        };
+      } catch (e) {
+        const position = extractJsonErrorPosition(e.message, json.length);
+        const msg = position ? `, invalid JSON syntax found at position ${position}` : `.`;
+        this.error(`Failed to parse JSON file` + msg, position);
+      }
+    }
+  };
+}
+function extractJsonErrorPosition(errorMessage, inputLength) {
+  if (errorMessage.startsWith("Unexpected end of JSON input")) {
+    return inputLength - 1;
+  }
+  const errorMessageList = /at position (\d+)/.exec(errorMessage);
+  return errorMessageList ? Math.max(parseInt(errorMessageList[1], 10) - 1, 0) : void 0;
+}
+
+const ERR_OPTIMIZE_DEPS_PROCESSING_ERROR = "ERR_OPTIMIZE_DEPS_PROCESSING_ERROR";
+const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP";
+const ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR = "ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR";
+const debug$a = createDebugger("vite:optimize-deps");
+function optimizedDepsPlugin(config) {
+  return {
+    name: "vite:optimized-deps",
+    resolveId(id, source, { ssr }) {
+      if (getDepsOptimizer(config, ssr)?.isOptimizedDepFile(id)) {
+        return id;
+      }
+    },
+    // this.load({ id }) isn't implemented in PluginContainer
+    // The logic to register an id to wait until it is processed
+    // is in importAnalysis, see call to delayDepsOptimizerUntil
+    async load(id, options) {
+      const ssr = options?.ssr === true;
+      const depsOptimizer = getDepsOptimizer(config, ssr);
+      if (depsOptimizer?.isOptimizedDepFile(id)) {
+        const metadata = depsOptimizer.metadata;
+        const file = cleanUrl(id);
+        const versionMatch = DEP_VERSION_RE.exec(file);
+        const browserHash = versionMatch ? versionMatch[1].split("=")[1] : void 0;
+        const info = optimizedDepInfoFromFile(metadata, file);
+        if (info) {
+          if (browserHash && info.browserHash !== browserHash) {
+            throwOutdatedRequest(id);
+          }
+          try {
+            await info.processing;
+          } catch {
+            throwProcessingError(id);
+          }
+          const newMetadata = depsOptimizer.metadata;
+          if (metadata !== newMetadata) {
+            const currentInfo = optimizedDepInfoFromFile(newMetadata, file);
+            if (info.browserHash !== currentInfo?.browserHash) {
+              throwOutdatedRequest(id);
+            }
+          }
+        }
+        debug$a?.(`load ${colors$1.cyan(file)}`);
+        try {
+          return await fsp.readFile(file, "utf-8");
+        } catch (e) {
+          const newMetadata = depsOptimizer.metadata;
+          if (optimizedDepInfoFromFile(newMetadata, file)) {
+            throwOutdatedRequest(id);
+          }
+          throwFileNotFoundInOptimizedDep(id);
+        }
+      }
+    }
+  };
+}
+function throwProcessingError(id) {
+  const err = new Error(
+    `Something unexpected happened while optimizing "${id}". The current page should have reloaded by now`
+  );
+  err.code = ERR_OPTIMIZE_DEPS_PROCESSING_ERROR;
+  throw err;
+}
+function throwOutdatedRequest(id) {
+  const err = new Error(
+    `There is a new version of the pre-bundle for "${id}", a page reload is going to ask for it.`
+  );
+  err.code = ERR_OUTDATED_OPTIMIZED_DEP;
+  throw err;
+}
+function throwFileNotFoundInOptimizedDep(id) {
+  const err = new Error(
+    `The file does not exist at "${id}" which is in the optimize deps directory. The dependency might be incompatible with the dep optimizer. Try adding it to \`optimizeDeps.exclude\`.`
+  );
+  err.code = ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR;
+  throw err;
+}
+
+const nonJsRe = /\.json(?:$|\?)/;
+const isNonJsRequest = (request) => nonJsRe.test(request);
+const importMetaEnvMarker = "__vite_import_meta_env__";
+const importMetaEnvKeyReCache = /* @__PURE__ */ new Map();
+function definePlugin(config) {
+  const isBuild = config.command === "build";
+  const isBuildLib = isBuild && config.build.lib;
+  const processEnv = {};
+  if (!isBuildLib) {
+    const nodeEnv = process.env.NODE_ENV || config.mode;
+    Object.assign(processEnv, {
+      "process.env": `{}`,
+      "global.process.env": `{}`,
+      "globalThis.process.env": `{}`,
+      "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+      "globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
+    });
+  }
+  const importMetaKeys = {};
+  const importMetaEnvKeys = {};
+  const importMetaFallbackKeys = {};
+  if (isBuild) {
+    importMetaKeys["import.meta.hot"] = `undefined`;
+    for (const key in config.env) {
+      const val = JSON.stringify(config.env[key]);
+      importMetaKeys[`import.meta.env.${key}`] = val;
+      importMetaEnvKeys[key] = val;
+    }
+    importMetaKeys["import.meta.env.SSR"] = `undefined`;
+    importMetaFallbackKeys["import.meta.env"] = `undefined`;
+  }
+  const userDefine = {};
+  const userDefineEnv = {};
+  for (const key in config.define) {
+    userDefine[key] = handleDefineValue(config.define[key]);
+    if (isBuild && key.startsWith("import.meta.env.")) {
+      userDefineEnv[key.slice(16)] = config.define[key];
+    }
+  }
+  function generatePattern(ssr) {
+    const replaceProcessEnv = !ssr || config.ssr?.target === "webworker";
+    const define = {
+      ...replaceProcessEnv ? processEnv : {},
+      ...importMetaKeys,
+      ...userDefine,
+      ...importMetaFallbackKeys
+    };
+    if ("import.meta.env.SSR" in define) {
+      define["import.meta.env.SSR"] = ssr + "";
+    }
+    if ("import.meta.env" in define) {
+      define["import.meta.env"] = importMetaEnvMarker;
+    }
+    const importMetaEnvVal = serializeDefine({
+      ...importMetaEnvKeys,
+      SSR: ssr + "",
+      ...userDefineEnv
+    });
+    const patternKeys = Object.keys(userDefine);
+    if (replaceProcessEnv && Object.keys(processEnv).length) {
+      patternKeys.push("process.env");
+    }
+    if (Object.keys(importMetaKeys).length) {
+      patternKeys.push("import.meta.env", "import.meta.hot");
+    }
+    const pattern = patternKeys.length ? new RegExp(patternKeys.map(escapeRegex).join("|")) : null;
+    return [define, pattern, importMetaEnvVal];
+  }
+  const defaultPattern = generatePattern(false);
+  const ssrPattern = generatePattern(true);
+  return {
+    name: "vite:define",
+    async transform(code, id, options) {
+      const ssr = options?.ssr === true;
+      if (!ssr && !isBuild) {
+        return;
+      }
+      if (
+        // exclude html, css and static assets for performance
+        isHTMLRequest(id) || isCSSRequest(id) || isNonJsRequest(id) || config.assetsInclude(id)
+      ) {
+        return;
+      }
+      let [define, pattern, importMetaEnvVal] = ssr ? ssrPattern : defaultPattern;
+      if (!pattern) return;
+      pattern.lastIndex = 0;
+      if (!pattern.test(code)) return;
+      const hasDefineImportMetaEnv = "import.meta.env" in define;
+      let marker = importMetaEnvMarker;
+      if (hasDefineImportMetaEnv && code.includes(marker)) {
+        let i = 1;
+        do {
+          marker = importMetaEnvMarker + i++;
+        } while (code.includes(marker));
+        if (marker !== importMetaEnvMarker) {
+          define = { ...define, "import.meta.env": marker };
+        }
+      }
+      const result = await replaceDefine(code, id, define, config);
+      if (hasDefineImportMetaEnv) {
+        result.code = result.code.replaceAll(
+          getImportMetaEnvKeyRe(marker),
+          (m) => "undefined".padEnd(m.length)
+        );
+        if (result.code.includes(marker)) {
+          result.code = `const ${marker} = ${importMetaEnvVal};
+` + result.code;
+          if (result.map) {
+            const map = JSON.parse(result.map);
+            map.mappings = ";" + map.mappings;
+            result.map = map;
+          }
+        }
+      }
+      return result;
+    }
+  };
+}
+async function replaceDefine(code, id, define, config) {
+  const esbuildOptions = config.esbuild || {};
+  const result = await transform$1(code, {
+    loader: "js",
+    charset: esbuildOptions.charset ?? "utf8",
+    platform: "neutral",
+    define,
+    sourcefile: id,
+    sourcemap: config.command === "build" ? !!config.build.sourcemap : true
+  });
+  if (result.map.includes("<define:")) {
+    const originalMap = new TraceMap(result.map);
+    if (originalMap.sources.length >= 2) {
+      const sourceIndex = originalMap.sources.indexOf(id);
+      const decoded = decodedMap(originalMap);
+      decoded.sources = [id];
+      decoded.mappings = decoded.mappings.map(
+        (segments) => segments.filter((segment) => {
+          const index = segment[1];
+          segment[1] = 0;
+          return index === sourceIndex;
+        })
+      );
+      result.map = JSON.stringify(encodedMap(new TraceMap(decoded)));
+    }
+  }
+  return {
+    code: result.code,
+    map: result.map || null
+  };
+}
+function serializeDefine(define) {
+  let res = `{`;
+  const keys = Object.keys(define).sort();
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const val = define[key];
+    res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
+    if (i !== keys.length - 1) {
+      res += `, `;
+    }
+  }
+  return res + `}`;
+}
+function handleDefineValue(value) {
+  if (typeof value === "undefined") return "undefined";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function getImportMetaEnvKeyRe(marker) {
+  let re = importMetaEnvKeyReCache.get(marker);
+  if (!re) {
+    re = new RegExp(`${marker}\\..+?\\b`, "g");
+    importMetaEnvKeyReCache.set(marker, re);
+  }
+  return re;
+}
+
+const normalizedClientEntry = normalizePath$3(CLIENT_ENTRY);
+const normalizedEnvEntry = normalizePath$3(ENV_ENTRY);
+function clientInjectionsPlugin(config) {
+  let injectConfigValues;
+  return {
+    name: "vite:client-inject",
+    async buildStart() {
+      const resolvedServerHostname = (await resolveHostname(config.server.host)).name;
+      const resolvedServerPort = config.server.port;
+      const devBase = config.base;
+      const serverHost = `${resolvedServerHostname}:${resolvedServerPort}${devBase}`;
+      let hmrConfig = config.server.hmr;
+      hmrConfig = isObject$1(hmrConfig) ? hmrConfig : void 0;
+      const host = hmrConfig?.host || null;
+      const protocol = hmrConfig?.protocol || null;
+      const timeout = hmrConfig?.timeout || 3e4;
+      const overlay = hmrConfig?.overlay !== false;
+      const isHmrServerSpecified = !!hmrConfig?.server;
+      const hmrConfigName = path$n.basename(config.configFile || "vite.config.js");
+      let port = hmrConfig?.clientPort || hmrConfig?.port || null;
+      if (config.server.middlewareMode && !isHmrServerSpecified) {
+        port ||= 24678;
+      }
+      let directTarget = hmrConfig?.host || resolvedServerHostname;
+      directTarget += `:${hmrConfig?.port || resolvedServerPort}`;
+      directTarget += devBase;
+      let hmrBase = devBase;
+      if (hmrConfig?.path) {
+        hmrBase = path$n.posix.join(hmrBase, hmrConfig.path);
+      }
+      const userDefine = {};
+      for (const key in config.define) {
+        if (!key.startsWith("import.meta.env.")) {
+          userDefine[key] = config.define[key];
+        }
+      }
+      const serializedDefines = serializeDefine(userDefine);
+      const modeReplacement = escapeReplacement(config.mode);
+      const baseReplacement = escapeReplacement(devBase);
+      const definesReplacement = () => serializedDefines;
+      const serverHostReplacement = escapeReplacement(serverHost);
+      const hmrProtocolReplacement = escapeReplacement(protocol);
+      const hmrHostnameReplacement = escapeReplacement(host);
+      const hmrPortReplacement = escapeReplacement(port);
+      const hmrDirectTargetReplacement = escapeReplacement(directTarget);
+      const hmrBaseReplacement = escapeReplacement(hmrBase);
+      const hmrTimeoutReplacement = escapeReplacement(timeout);
+      const hmrEnableOverlayReplacement = escapeReplacement(overlay);
+      const hmrConfigNameReplacement = escapeReplacement(hmrConfigName);
+      injectConfigValues = (code) => {
+        return code.replace(`__MODE__`, modeReplacement).replace(/__BASE__/g, baseReplacement).replace(`__DEFINES__`, definesReplacement).replace(`__SERVER_HOST__`, serverHostReplacement).replace(`__HMR_PROTOCOL__`, hmrProtocolReplacement).replace(`__HMR_HOSTNAME__`, hmrHostnameReplacement).replace(`__HMR_PORT__`, hmrPortReplacement).replace(`__HMR_DIRECT_TARGET__`, hmrDirectTargetReplacement).replace(`__HMR_BASE__`, hmrBaseReplacement).replace(`__HMR_TIMEOUT__`, hmrTimeoutReplacement).replace(`__HMR_ENABLE_OVERLAY__`, hmrEnableOverlayReplacement).replace(`__HMR_CONFIG_NAME__`, hmrConfigNameReplacement);
+      };
+    },
+    async transform(code, id, options) {
+      if (id === normalizedClientEntry || id === normalizedEnvEntry) {
+        return injectConfigValues(code);
+      } else if (!options?.ssr && code.includes("process.env.NODE_ENV")) {
+        const nodeEnv = config.define?.["process.env.NODE_ENV"] || JSON.stringify(process.env.NODE_ENV || config.mode);
+        return await replaceDefine(
+          code,
+          id,
+          {
+            "process.env.NODE_ENV": nodeEnv,
+            "global.process.env.NODE_ENV": nodeEnv,
+            "globalThis.process.env.NODE_ENV": nodeEnv
+          },
+          config
+        );
+      }
+    }
+  };
+}
+function escapeReplacement(value) {
+  const jsonValue = JSON.stringify(value);
+  return () => jsonValue;
+}
+
+const wasmHelperId = "\0vite/wasm-helper.js";
+const wasmHelper = async (opts = {}, url) => {
+  let result;
+  if (url.startsWith("data:")) {
+    const urlContent = url.replace(/^data:.*?base64,/, "");
+    let bytes;
+    if (typeof Buffer === "function" && typeof Buffer.from === "function") {
+      bytes = Buffer.from(urlContent, "base64");
+    } else if (typeof atob === "function") {
+      const binaryString = atob(urlContent);
+      bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+    } else {
+      throw new Error(
+        "Failed to decode base64-encoded data URL, Buffer and atob are not supported"
+      );
+    }
+    result = await WebAssembly.instantiate(bytes, opts);
+  } else {
+    const response = await fetch(url);
+    const contentType = response.headers.get("Content-Type") || "";
+    if ("instantiateStreaming" in WebAssembly && contentType.startsWith("application/wasm")) {
+      result = await WebAssembly.instantiateStreaming(response, opts);
+    } else {
+      const buffer = await response.arrayBuffer();
+      result = await WebAssembly.instantiate(buffer, opts);
+    }
+  }
+  return result.instance;
+};
+const wasmHelperCode = wasmHelper.toString();
+const wasmHelperPlugin = (config) => {
+  return {
+    name: "vite:wasm-helper",
+    resolveId(id) {
+      if (id === wasmHelperId) {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === wasmHelperId) {
+        return `export default ${wasmHelperCode}`;
+      }
+      if (!id.endsWith(".wasm?init")) {
+        return;
+      }
+      const url = await fileToUrl$1(id, config, this);
+      return `
+import initWasm from "${wasmHelperId}"
+export default opts => initWasm(opts, ${JSON.stringify(url)})
+`;
+    }
+  };
+};
+const wasmFallbackPlugin = () => {
+  return {
+    name: "vite:wasm-fallback",
+    async load(id) {
+      if (!id.endsWith(".wasm")) {
+        return;
+      }
+      throw new Error(
+        '"ESM integration proposal for Wasm" is not supported currently. Use vite-plugin-wasm or other community plugins to handle this. Alternatively, you can use `.wasm?init` or `.wasm?url`. See https://vitejs.dev/guide/features.html#webassembly for more details.'
+      );
+    }
+  };
+};
+
+const workerOrSharedWorkerRE = /(?:\?|&)(worker|sharedworker)(?:&|$)/;
+const workerFileRE = /(?:\?|&)worker_file&type=(\w+)(?:&|$)/;
+const inlineRE = /[?&]inline\b/;
+const WORKER_FILE_ID = "worker_file";
+const workerCache = /* @__PURE__ */ new WeakMap();
+function saveEmitWorkerAsset(config, asset) {
+  const workerMap = workerCache.get(config.mainConfig || config);
+  workerMap.assets.set(asset.fileName, asset);
+}
+async function bundleWorkerEntry(config, id) {
+  const input = cleanUrl(id);
+  const newBundleChain = [...config.bundleChain, input];
+  if (config.bundleChain.includes(input)) {
+    throw new Error(
+      `Circular worker imports detected. Vite does not support it. Import chain: ${newBundleChain.map((id2) => prettifyUrl(id2, config.root)).join(" -> ")}`
+    );
+  }
+  const { rollup } = await import('rollup');
+  const { plugins, rollupOptions, format } = config.worker;
+  const bundle = await rollup({
+    ...rollupOptions,
+    input,
+    plugins: await plugins(newBundleChain),
+    onwarn(warning, warn) {
+      onRollupWarning(warning, warn, config);
+    },
+    preserveEntrySignatures: false
+  });
+  let chunk;
+  try {
+    const workerOutputConfig = config.worker.rollupOptions.output;
+    const workerConfig = workerOutputConfig ? Array.isArray(workerOutputConfig) ? workerOutputConfig[0] || {} : workerOutputConfig : {};
+    const {
+      output: [outputChunk, ...outputChunks]
+    } = await bundle.generate({
+      entryFileNames: path$n.posix.join(
+        config.build.assetsDir,
+        "[name]-[hash].js"
+      ),
+      chunkFileNames: path$n.posix.join(
+        config.build.assetsDir,
+        "[name]-[hash].js"
+      ),
+      assetFileNames: path$n.posix.join(
+        config.build.assetsDir,
+        "[name]-[hash].[ext]"
+      ),
+      ...workerConfig,
+      format,
+      sourcemap: config.build.sourcemap
+    });
+    chunk = outputChunk;
+    outputChunks.forEach((outputChunk2) => {
+      if (outputChunk2.type === "asset") {
+        saveEmitWorkerAsset(config, outputChunk2);
+      } else if (outputChunk2.type === "chunk") {
+        saveEmitWorkerAsset(config, {
+          fileName: outputChunk2.fileName,
+          originalFileName: null,
+          source: outputChunk2.code
+        });
+      }
+    });
+  } finally {
+    await bundle.close();
+  }
+  return emitSourcemapForWorkerEntry(config, chunk);
+}
+function emitSourcemapForWorkerEntry(config, chunk) {
+  const { map: sourcemap } = chunk;
+  if (sourcemap) {
+    if (config.build.sourcemap === "hidden" || config.build.sourcemap === true) {
+      const data = sourcemap.toString();
+      const mapFileName = chunk.fileName + ".map";
+      saveEmitWorkerAsset(config, {
+        fileName: mapFileName,
+        originalFileName: null,
+        source: data
+      });
+    }
+  }
+  return chunk;
+}
+const workerAssetUrlRE = /__VITE_WORKER_ASSET__([a-z\d]{8})__/g;
+function encodeWorkerAssetFileName(fileName, workerCache2) {
+  const { fileNameHash } = workerCache2;
+  const hash = getHash(fileName);
+  if (!fileNameHash.get(hash)) {
+    fileNameHash.set(hash, fileName);
+  }
+  return `__VITE_WORKER_ASSET__${hash}__`;
+}
+async function workerFileToUrl(config, id) {
+  const workerMap = workerCache.get(config.mainConfig || config);
+  let fileName = workerMap.bundle.get(id);
+  if (!fileName) {
+    const outputChunk = await bundleWorkerEntry(config, id);
+    fileName = outputChunk.fileName;
+    saveEmitWorkerAsset(config, {
+      fileName,
+      originalFileName: null,
+      source: outputChunk.code
+    });
+    workerMap.bundle.set(id, fileName);
+  }
+  return encodeWorkerAssetFileName(fileName, workerMap);
+}
+function webWorkerPostPlugin() {
+  return {
+    name: "vite:worker-post",
+    resolveImportMeta(property, { format }) {
+      if (format === "iife") {
+        if (!property) {
+          return `{
+            url: self.location.href
+          }`;
+        }
+        if (property === "url") {
+          return "self.location.href";
+        }
+      }
+      return null;
+    }
+  };
+}
+function webWorkerPlugin(config) {
+  const isBuild = config.command === "build";
+  let server;
+  const isWorker = config.isWorker;
+  return {
+    name: "vite:worker",
+    configureServer(_server) {
+      server = _server;
+    },
+    buildStart() {
+      if (isWorker) {
+        return;
+      }
+      workerCache.set(config, {
+        assets: /* @__PURE__ */ new Map(),
+        bundle: /* @__PURE__ */ new Map(),
+        fileNameHash: /* @__PURE__ */ new Map()
+      });
+    },
+    load(id) {
+      if (isBuild && workerOrSharedWorkerRE.test(id)) {
+        return "";
+      }
+    },
+    shouldTransformCachedModule({ id }) {
+      if (isBuild && config.build.watch && workerOrSharedWorkerRE.test(id)) {
+        return true;
+      }
+    },
+    async transform(raw, id) {
+      const workerFileMatch = workerFileRE.exec(id);
+      if (workerFileMatch) {
+        const workerType2 = workerFileMatch[1];
+        let injectEnv = "";
+        const scriptPath = JSON.stringify(
+          path$n.posix.join(config.base, ENV_PUBLIC_PATH)
+        );
+        if (workerType2 === "classic") {
+          injectEnv = `importScripts(${scriptPath})
+`;
+        } else if (workerType2 === "module") {
+          injectEnv = `import ${scriptPath}
+`;
+        } else if (workerType2 === "ignore") {
+          if (isBuild) {
+            injectEnv = "";
+          } else if (server) {
+            const { moduleGraph } = server;
+            const module = moduleGraph.getModuleById(ENV_ENTRY);
+            injectEnv = module?.transformResult?.code || "";
+          }
+        }
+        if (injectEnv) {
+          const s = new MagicString(raw);
+          s.prepend(injectEnv + ";\n");
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: "boundary" })
+          };
+        }
+        return;
+      }
+      const workerMatch = workerOrSharedWorkerRE.exec(id);
+      if (!workerMatch) return;
+      const { format } = config.worker;
+      const workerConstructor = workerMatch[1] === "sharedworker" ? "SharedWorker" : "Worker";
+      const workerType = isBuild ? format === "es" ? "module" : "classic" : "module";
+      const workerTypeOption = `{
+        ${workerType === "module" ? `type: "module",` : ""}
+        name: options?.name
+      }`;
+      let urlCode;
+      if (isBuild) {
+        if (isWorker && config.bundleChain.at(-1) === cleanUrl(id)) {
+          urlCode = "self.location.href";
+        } else if (inlineRE.test(id)) {
+          const chunk = await bundleWorkerEntry(config, id);
+          const encodedJs = `const encodedJs = "${Buffer.from(
+            chunk.code
+          ).toString("base64")}";`;
+          const code = (
+            // Using blob URL for SharedWorker results in multiple instances of a same worker
+            workerConstructor === "Worker" ? `${encodedJs}
+          const decodeBase64 = (base64) => Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+          const blob = typeof self !== "undefined" && self.Blob && new Blob([${workerType === "classic" ? "" : (
+              // `URL` is always available, in `Worker[type="module"]`
+              `'URL.revokeObjectURL(import.meta.url);',`
+            )}decodeBase64(encodedJs)], { type: "text/javascript;charset=utf-8" });
+          export default function WorkerWrapper(options) {
+            let objURL;
+            try {
+              objURL = blob && (self.URL || self.webkitURL).createObjectURL(blob);
+              if (!objURL) throw ''
+              const worker = new ${workerConstructor}(objURL, ${workerTypeOption});
+              worker.addEventListener("error", () => {
+                (self.URL || self.webkitURL).revokeObjectURL(objURL);
+              });
+              return worker;
+            } catch(e) {
+              return new ${workerConstructor}(
+                "data:text/javascript;base64," + encodedJs,
+                ${workerTypeOption}
+              );
+            }${// For module workers, we should not revoke the URL until the worker runs,
+            // otherwise the worker fails to run
+            workerType === "classic" ? ` finally {
+                    objURL && (self.URL || self.webkitURL).revokeObjectURL(objURL);
+                  }` : ""}
+          }` : `${encodedJs}
+          export default function WorkerWrapper(options) {
+            return new ${workerConstructor}(
+              "data:text/javascript;base64," + encodedJs,
+              ${workerTypeOption}
+            );
+          }
+          `
+          );
+          return {
+            code,
+            // Empty sourcemap to suppress Rollup warning
+            map: { mappings: "" }
+          };
+        } else {
+          urlCode = JSON.stringify(await workerFileToUrl(config, id));
+        }
+      } else {
+        let url = await fileToUrl$1(cleanUrl(id), config, this);
+        url = injectQuery(url, `${WORKER_FILE_ID}&type=${workerType}`);
+        urlCode = JSON.stringify(url);
+      }
+      if (urlRE.test(id)) {
+        return {
+          code: `export default ${urlCode}`,
+          map: { mappings: "" }
+          // Empty sourcemap to suppress Rollup warning
+        };
+      }
+      return {
+        code: `export default function WorkerWrapper(options) {
+          return new ${workerConstructor}(
+            ${urlCode},
+            ${workerTypeOption}
+          );
+        }`,
+        map: { mappings: "" }
+        // Empty sourcemap to suppress Rollup warning
+      };
+    },
+    renderChunk(code, chunk, outputOptions) {
+      let s;
+      const result = () => {
+        return s && {
+          code: s.toString(),
+          map: config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+        };
+      };
+      workerAssetUrlRE.lastIndex = 0;
+      if (workerAssetUrlRE.test(code)) {
+        const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(
+          outputOptions.format,
+          config.isWorker
+        );
+        let match;
+        s = new MagicString(code);
+        workerAssetUrlRE.lastIndex = 0;
+        const workerMap = workerCache.get(config.mainConfig || config);
+        const { fileNameHash } = workerMap;
+        while (match = workerAssetUrlRE.exec(code)) {
+          const [full, hash] = match;
+          const filename = fileNameHash.get(hash);
+          const replacement = toOutputFilePathInJS(
+            filename,
+            "asset",
+            chunk.fileName,
+            "js",
+            config,
+            toRelativeRuntime
+          );
+          const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`;
+          s.update(match.index, match.index + full.length, replacementString);
+        }
+      }
+      return result();
+    },
+    generateBundle(opts, bundle) {
+      if (opts.__vite_skip_asset_emit__ || isWorker) {
+        return;
+      }
+      const workerMap = workerCache.get(config);
+      workerMap.assets.forEach((asset) => {
+        const duplicateAsset = bundle[asset.fileName];
+        if (duplicateAsset) {
+          const content = duplicateAsset.type === "asset" ? duplicateAsset.source : duplicateAsset.code;
+          if (isSameContent(content, asset.source)) {
+            return;
+          }
+        }
+        this.emitFile({
+          type: "asset",
+          fileName: asset.fileName,
+          originalFileName: asset.originalFileName,
+          source: asset.source
+        });
+      });
+      workerMap.assets.clear();
+    }
+  };
+}
+function isSameContent(a, b) {
+  if (typeof a === "string") {
+    if (typeof b === "string") {
+      return a === b;
+    }
+    return Buffer.from(a).equals(b);
+  }
+  return Buffer.from(b).equals(a);
+}
+
+function preAliasPlugin(config) {
+  const findPatterns = getAliasPatterns(config.resolve.alias);
+  const isConfiguredAsExternal = createIsConfiguredAsSsrExternal(config);
+  const isBuild = config.command === "build";
+  const fsUtils = getFsUtils(config);
+  return {
+    name: "vite:pre-alias",
+    async resolveId(id, importer, options) {
+      const ssr = options?.ssr === true;
+      const depsOptimizer = !isBuild && getDepsOptimizer(config, ssr);
+      if (importer && depsOptimizer && bareImportRE.test(id) && !options?.scan && id !== "@vite/client" && id !== "@vite/env") {
+        if (findPatterns.find((pattern) => matches(pattern, id))) {
+          const optimizedId = await tryOptimizedResolve(
+            depsOptimizer,
+            id,
+            importer,
+            config.resolve.preserveSymlinks,
+            config.packageCache
+          );
+          if (optimizedId) {
+            return optimizedId;
+          }
+          if (depsOptimizer.options.noDiscovery) {
+            return;
+          }
+          const resolved = await this.resolve(id, importer, {
+            ...options,
+            custom: { ...options.custom, "vite:pre-alias": true }
+          });
+          if (resolved && !depsOptimizer.isOptimizedDepFile(resolved.id)) {
+            const optimizeDeps = depsOptimizer.options;
+            const resolvedId = cleanUrl(resolved.id);
+            const isVirtual = resolvedId === id || resolvedId.includes("\0");
+            if (!isVirtual && fsUtils.existsSync(resolvedId) && !moduleListContains(optimizeDeps.exclude, id) && path$n.isAbsolute(resolvedId) && (isInNodeModules$1(resolvedId) || optimizeDeps.include?.includes(id)) && isOptimizable(resolvedId, optimizeDeps) && !(isBuild && ssr && isConfiguredAsExternal(id, importer)) && (!ssr || optimizeAliasReplacementForSSR(resolvedId, optimizeDeps))) {
+              const optimizedInfo = depsOptimizer.registerMissingImport(
+                id,
+                resolvedId
+              );
+              return { id: depsOptimizer.getOptimizedDepId(optimizedInfo) };
+            }
+          }
+          return resolved;
+        }
+      }
+    }
+  };
+}
+function optimizeAliasReplacementForSSR(id, optimizeDeps) {
+  if (optimizeDeps.include?.includes(id)) {
+    return true;
+  }
+  return false;
+}
+function matches(pattern, importee) {
+  if (pattern instanceof RegExp) {
+    return pattern.test(importee);
+  }
+  if (importee.length < pattern.length) {
+    return false;
+  }
+  if (importee === pattern) {
+    return true;
+  }
+  return importee.startsWith(withTrailingSlash(pattern));
+}
+function getAliasPatterns(entries) {
+  if (!entries) {
+    return [];
+  }
+  if (Array.isArray(entries)) {
+    return entries.map((entry) => entry.find);
+  }
+  return Object.entries(entries).map(([find]) => find);
+}
+function getAliasPatternMatcher(entries) {
+  const patterns = getAliasPatterns(entries);
+  return (importee) => patterns.some((pattern) => matches(pattern, importee));
+}
+
+function err(e, pos) {
+  const error = new Error(e);
+  error.pos = pos;
+  return error;
+}
+function parseWorkerOptions(rawOpts, optsStartIndex) {
+  let opts = {};
+  try {
+    opts = evalValue(rawOpts);
+  } catch {
+    throw err(
+      "Vite is unable to parse the worker options as the value is not static.To ignore this error, please use /* @vite-ignore */ in the worker options.",
+      optsStartIndex
+    );
+  }
+  if (opts == null) {
+    return {};
+  }
+  if (typeof opts !== "object") {
+    throw err(
+      `Expected worker options to be an object, got ${typeof opts}`,
+      optsStartIndex
+    );
+  }
+  return opts;
+}
+function getWorkerType(raw, clean, i) {
+  const commaIndex = clean.indexOf(",", i);
+  if (commaIndex === -1) {
+    return "classic";
+  }
+  const endIndex = clean.indexOf(")", i);
+  if (commaIndex > endIndex) {
+    return "classic";
+  }
+  const workerOptString = raw.substring(commaIndex + 1, endIndex).replace(/\}[\s\S]*,/g, "}");
+  const hasViteIgnore = hasViteIgnoreRE.test(workerOptString);
+  if (hasViteIgnore) {
+    return "ignore";
+  }
+  const cleanWorkerOptString = clean.substring(commaIndex + 1, endIndex).trim();
+  if (!cleanWorkerOptString.length) {
+    return "classic";
+  }
+  const workerOpts = parseWorkerOptions(workerOptString, commaIndex + 1);
+  if (workerOpts.type && (workerOpts.type === "module" || workerOpts.type === "classic")) {
+    return workerOpts.type;
+  }
+  return "classic";
+}
+function isIncludeWorkerImportMetaUrl(code) {
+  if ((code.includes("new Worker") || code.includes("new SharedWorker")) && code.includes("new URL") && code.includes(`import.meta.url`)) {
+    return true;
+  }
+  return false;
+}
+function workerImportMetaUrlPlugin(config) {
+  const isBuild = config.command === "build";
+  let workerResolver;
+  const fsResolveOptions = {
+    ...config.resolve,
+    root: config.root,
+    isProduction: config.isProduction,
+    isBuild: config.command === "build",
+    packageCache: config.packageCache,
+    ssrConfig: config.ssr,
+    asSrc: true
+  };
+  return {
+    name: "vite:worker-import-meta-url",
+    shouldTransformCachedModule({ code }) {
+      if (isBuild && config.build.watch && isIncludeWorkerImportMetaUrl(code)) {
+        return true;
+      }
+    },
+    async transform(code, id, options) {
+      if (!options?.ssr && isIncludeWorkerImportMetaUrl(code)) {
+        let s;
+        const cleanString = stripLiteral(code);
+        const workerImportMetaUrlRE = /\bnew\s+(?:Worker|SharedWorker)\s*\(\s*(new\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*\))/dg;
+        let match;
+        while (match = workerImportMetaUrlRE.exec(cleanString)) {
+          const [[, endIndex], [expStart, expEnd], [urlStart, urlEnd]] = match.indices;
+          const rawUrl = code.slice(urlStart, urlEnd);
+          if (rawUrl[0] === "`" && rawUrl.includes("${")) {
+            this.error(
+              `\`new URL(url, import.meta.url)\` is not supported in dynamic template string.`,
+              expStart
+            );
+          }
+          s ||= new MagicString(code);
+          const workerType = getWorkerType(code, cleanString, endIndex);
+          const url = rawUrl.slice(1, -1);
+          let file;
+          if (url[0] === ".") {
+            file = path$n.resolve(path$n.dirname(id), url);
+            file = tryFsResolve(file, fsResolveOptions) ?? file;
+          } else {
+            workerResolver ??= config.createResolver({
+              extensions: [],
+              tryIndex: false,
+              preferRelative: true
+            });
+            file = await workerResolver(url, id);
+            file ??= url[0] === "/" ? slash$1(path$n.join(config.publicDir, url)) : slash$1(path$n.resolve(path$n.dirname(id), url));
+          }
+          if (isBuild && config.isWorker && config.bundleChain.at(-1) === cleanUrl(file)) {
+            s.update(expStart, expEnd, "self.location.href");
+          } else {
+            let builtUrl;
+            if (isBuild) {
+              builtUrl = await workerFileToUrl(config, file);
+            } else {
+              builtUrl = await fileToUrl$1(cleanUrl(file), config, this);
+              builtUrl = injectQuery(
+                builtUrl,
+                `${WORKER_FILE_ID}&type=${workerType}`
+              );
+            }
+            s.update(
+              expStart,
+              expEnd,
+              `new URL(/* @vite-ignore */ ${JSON.stringify(builtUrl)}, import.meta.url)`
+            );
+          }
+        }
+        if (s) {
+          return transformStableResult(s, id, config);
+        }
+        return null;
+      }
+    }
+  };
+}
+
+function assetImportMetaUrlPlugin(config) {
+  const { publicDir } = config;
+  let assetResolver;
+  const fsResolveOptions = {
+    ...config.resolve,
+    root: config.root,
+    isProduction: config.isProduction,
+    isBuild: config.command === "build",
+    packageCache: config.packageCache,
+    ssrConfig: config.ssr,
+    asSrc: true
+  };
+  return {
+    name: "vite:asset-import-meta-url",
+    async transform(code, id, options) {
+      if (!options?.ssr && id !== preloadHelperId && id !== CLIENT_ENTRY && code.includes("new URL") && code.includes(`import.meta.url`)) {
+        let s;
+        const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/dg;
+        const cleanString = stripLiteral(code);
+        let match;
+        while (match = assetImportMetaUrlRE.exec(cleanString)) {
+          const [[startIndex, endIndex], [urlStart, urlEnd]] = match.indices;
+          if (hasViteIgnoreRE.test(code.slice(startIndex, urlStart))) continue;
+          const rawUrl = code.slice(urlStart, urlEnd);
+          if (!s) s = new MagicString(code);
+          if (rawUrl[0] === "`" && rawUrl.includes("${")) {
+            const queryDelimiterIndex = getQueryDelimiterIndex(rawUrl);
+            const hasQueryDelimiter = queryDelimiterIndex !== -1;
+            const pureUrl = hasQueryDelimiter ? rawUrl.slice(0, queryDelimiterIndex) + "`" : rawUrl;
+            const queryString = hasQueryDelimiter ? rawUrl.slice(queryDelimiterIndex, -1) : "";
+            const ast = this.parse(pureUrl);
+            const templateLiteral = ast.body[0].expression;
+            if (templateLiteral.expressions.length) {
+              const pattern = buildGlobPattern(templateLiteral);
+              if (pattern.startsWith("**")) {
+                continue;
+              }
+              const globOptions = {
+                eager: true,
+                import: "default",
+                // A hack to allow 'as' & 'query' exist at the same time
+                query: injectQuery(queryString, "url")
+              };
+              s.update(
+                startIndex,
+                endIndex,
+                `new URL((import.meta.glob(${JSON.stringify(
+                  pattern
+                )}, ${JSON.stringify(
+                  globOptions
+                )}))[${pureUrl}], import.meta.url)`
+              );
+              continue;
+            }
+          }
+          const url = rawUrl.slice(1, -1);
+          let file;
+          if (url[0] === ".") {
+            file = slash$1(path$n.resolve(path$n.dirname(id), url));
+            file = tryFsResolve(file, fsResolveOptions) ?? file;
+          } else {
+            assetResolver ??= config.createResolver({
+              extensions: [],
+              mainFields: [],
+              tryIndex: false,
+              preferRelative: true
+            });
+            file = await assetResolver(url, id);
+            file ??= url[0] === "/" ? slash$1(path$n.join(publicDir, url)) : slash$1(path$n.resolve(path$n.dirname(id), url));
+          }
+          let builtUrl;
+          if (file) {
+            try {
+              if (publicDir && isParentDirectory(publicDir, file)) {
+                const publicPath = "/" + path$n.posix.relative(publicDir, file);
+                builtUrl = await fileToUrl$1(publicPath, config, this);
+              } else {
+                builtUrl = await fileToUrl$1(file, config, this);
+              }
+            } catch {
+            }
+          }
+          if (!builtUrl) {
+            const rawExp = code.slice(startIndex, endIndex);
+            config.logger.warnOnce(
+              `
+${rawExp} doesn't exist at build time, it will remain unchanged to be resolved at runtime. If this is intended, you can use the /* @vite-ignore */ comment to suppress this warning.`
+            );
+            builtUrl = url;
+          }
+          s.update(
+            startIndex,
+            endIndex,
+            `new URL(${JSON.stringify(builtUrl)}, import.meta.url)`
+          );
+        }
+        if (s) {
+          return transformStableResult(s, id, config);
+        }
+      }
+      return null;
+    }
+  };
+}
+function buildGlobPattern(ast) {
+  let pattern = "";
+  let lastElementIndex = -1;
+  for (const exp of ast.expressions) {
+    for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
+      const el = ast.quasis[i];
+      if (el.end < exp.start) {
+        pattern += el.value.raw;
+        lastElementIndex = i;
+      }
+    }
+    pattern += "**";
+  }
+  for (let i = lastElementIndex + 1; i < ast.quasis.length; i++) {
+    pattern += ast.quasis[i].value.raw;
+  }
+  return pattern;
+}
+function getQueryDelimiterIndex(rawUrl) {
+  let bracketsStack = 0;
+  for (let i = 0; i < rawUrl.length; i++) {
+    if (rawUrl[i] === "{") {
+      bracketsStack++;
+    } else if (rawUrl[i] === "}") {
+      bracketsStack--;
+    } else if (rawUrl[i] === "?" && bracketsStack === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function metadataPlugin() {
+  return {
+    name: "vite:build-metadata",
+    async renderChunk(_code, chunk) {
+      chunk.viteMetadata = {
+        importedAssets: /* @__PURE__ */ new Set(),
+        importedCss: /* @__PURE__ */ new Set()
+      };
+      return null;
+    }
+  };
+}
+
+// Astring is a tiny and fast JavaScript code generator from an ESTree-compliant AST.
+//
+// Astring was written by David Bonnet and released under an MIT license.
+//
+// The Git repository for Astring is available at:
+// https://github.com/davidbonnet/astring.git
+//
+// Please use the GitHub bug tracker to report issues:
+// https://github.com/davidbonnet/astring/issues
+
+
+/* c8 ignore if */
+if (!String.prototype.repeat) {
+  /* c8 ignore next */
+  throw new Error(
+    'String.prototype.repeat is undefined, see https://github.com/davidbonnet/astring#installation',
+  )
+}
+
+/* c8 ignore if */
+if (!String.prototype.endsWith) {
+  /* c8 ignore next */
+  throw new Error(
+    'String.prototype.endsWith is undefined, see https://github.com/davidbonnet/astring#installation',
+  )
+}
+
+class VariableDynamicImportError extends Error {}
+
+/* eslint-disable-next-line no-template-curly-in-string */
+const example = 'For example: import(`./foo/${bar}.js`).';
+
+function sanitizeString(str) {
+  if (str === '') return str;
+  if (str.includes('*')) {
+    throw new VariableDynamicImportError('A dynamic import cannot contain * characters.');
+  }
+  return glob.escapePath(str);
+}
+
+function templateLiteralToGlob(node) {
+  let glob = '';
+
+  for (let i = 0; i < node.quasis.length; i += 1) {
+    glob += sanitizeString(node.quasis[i].value.raw);
+    if (node.expressions[i]) {
+      glob += expressionToGlob(node.expressions[i]);
+    }
+  }
+
+  return glob;
+}
+
+function callExpressionToGlob(node) {
+  const { callee } = node;
+  if (
+    callee.type === 'MemberExpression' &&
+    callee.property.type === 'Identifier' &&
+    callee.property.name === 'concat'
+  ) {
+    return `${expressionToGlob(callee.object)}${node.arguments.map(expressionToGlob).join('')}`;
+  }
+  return '*';
+}
+
+function binaryExpressionToGlob(node) {
+  if (node.operator !== '+') {
+    throw new VariableDynamicImportError(`${node.operator} operator is not supported.`);
+  }
+
+  return `${expressionToGlob(node.left)}${expressionToGlob(node.right)}`;
+}
+
+function expressionToGlob(node) {
+  switch (node.type) {
+    case 'TemplateLiteral':
+      return templateLiteralToGlob(node);
+    case 'CallExpression':
+      return callExpressionToGlob(node);
+    case 'BinaryExpression':
+      return binaryExpressionToGlob(node);
+    case 'Literal': {
+      return sanitizeString(node.value);
+    }
+    default:
+      return '*';
+  }
+}
+
+const defaultProtocol = 'file:';
+const ignoredProtocols = ['data:', 'http:', 'https:'];
+
+function shouldIgnore(glob) {
+  const containsAsterisk = glob.includes('*');
+
+  const globURL = new URL(glob, defaultProtocol);
+
+  const containsIgnoredProtocol = ignoredProtocols.some(
+    (ignoredProtocol) => ignoredProtocol === globURL.protocol
+  );
+
+  return !containsAsterisk || containsIgnoredProtocol;
+}
+
+function dynamicImportToGlob(node, sourceString) {
+  let glob = expressionToGlob(node);
+
+  if (shouldIgnore(glob)) {
+    return null;
+  }
+
+  glob = glob.replace(/\*\*/g, '*');
+
+  if (glob.startsWith('*')) {
+    throw new VariableDynamicImportError(
+      `invalid import "${sourceString}". It cannot be statically analyzed. Variable dynamic imports must start with ./ and be limited to a specific directory. ${example}`
+    );
+  }
+
+  if (glob.startsWith('/')) {
+    throw new VariableDynamicImportError(
+      `invalid import "${sourceString}". Variable absolute imports are not supported, imports must start with ./ in the static part of the import. ${example}`
+    );
+  }
+
+  if (!glob.startsWith('./') && !glob.startsWith('../')) {
+    throw new VariableDynamicImportError(
+      `invalid import "${sourceString}". Variable bare imports are not supported, imports must start with ./ in the static part of the import. ${example}`
+    );
+  }
+
+  // Disallow ./*.ext
+  const ownDirectoryStarExtension = /^\.\/\*\.[\w]+$/;
+  if (ownDirectoryStarExtension.test(glob)) {
+    throw new VariableDynamicImportError(
+      `${
+        `invalid import "${sourceString}". Variable imports cannot import their own directory, ` +
+        'place imports in a separate directory or make the import filename more specific. '
+      }${example}`
+    );
+  }
+
+  if (require$$0$4.extname(glob) === '') {
+    throw new VariableDynamicImportError(
+      `invalid import "${sourceString}". A file extension must be included in the static part of the import. ${example}`
+    );
+  }
+
+  return glob;
+}
+
+const dynamicImportHelperId = "\0vite/dynamic-import-helper.js";
+const relativePathRE = /^\.{1,2}\//;
+const hasDynamicImportRE = /\bimport\s*[(/]/;
+const dynamicImportHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+function parseDynamicImportPattern(strings) {
+  const filename = strings.slice(1, -1);
+  const ast = parseAst(strings).body[0].expression;
+  const userPatternQuery = dynamicImportToGlob(ast, filename);
+  if (!userPatternQuery) {
+    return null;
+  }
+  const [userPattern] = userPatternQuery.split(
+    // ? is escaped on posix OS
+    requestQueryMaybeEscapedSplitRE,
+    2
+  );
+  let [rawPattern, search] = filename.split(requestQuerySplitRE, 2);
+  let globParams = null;
+  if (search) {
+    search = "?" + search;
+    if (workerOrSharedWorkerRE.test(search) || urlRE.test(search) || rawRE.test(search)) {
+      globParams = {
+        query: search,
+        import: "*"
+      };
+    } else {
+      globParams = {
+        query: search
+      };
+    }
+  }
+  return {
+    globParams,
+    userPattern,
+    rawPattern
+  };
+}
+async function transformDynamicImport(importSource, importer, resolve, root) {
+  if (importSource[1] !== "." && importSource[1] !== "/") {
+    const resolvedFileName = await resolve(importSource.slice(1, -1), importer);
+    if (!resolvedFileName) {
+      return null;
+    }
+    const relativeFileName = normalizePath$3(
+      posix$1.relative(
+        posix$1.dirname(normalizePath$3(importer)),
+        normalizePath$3(resolvedFileName)
+      )
+    );
+    importSource = "`" + (relativeFileName[0] === "." ? "" : "./") + relativeFileName + "`";
+  }
+  const dynamicImportPattern = parseDynamicImportPattern(importSource);
+  if (!dynamicImportPattern) {
+    return null;
+  }
+  const { globParams, rawPattern, userPattern } = dynamicImportPattern;
+  const params = globParams ? `, ${JSON.stringify(globParams)}` : "";
+  let newRawPattern = posix$1.relative(
+    posix$1.dirname(importer),
+    await toAbsoluteGlob(rawPattern, root, importer, resolve)
+  );
+  if (!relativePathRE.test(newRawPattern)) {
+    newRawPattern = `./${newRawPattern}`;
+  }
+  const exp = `(import.meta.glob(${JSON.stringify(userPattern)}${params}))`;
+  return {
+    rawPattern: newRawPattern,
+    pattern: userPattern,
+    glob: exp
+  };
+}
+function dynamicImportVarsPlugin(config) {
+  const resolve = config.createResolver({
+    preferRelative: true,
+    tryIndex: false,
+    extensions: []
+  });
+  const { include, exclude, warnOnError } = config.build.dynamicImportVarsOptions;
+  const filter = createFilter(include, exclude);
+  return {
+    name: "vite:dynamic-import-vars",
+    resolveId(id) {
+      if (id === dynamicImportHelperId) {
+        return id;
+      }
+    },
+    load(id) {
+      if (id === dynamicImportHelperId) {
+        return "export default " + dynamicImportHelper.toString();
+      }
+    },
+    async transform(source, importer) {
+      if (!filter(importer) || importer === CLIENT_ENTRY || !hasDynamicImportRE.test(source)) {
+        return;
+      }
+      await init;
+      let imports = [];
+      try {
+        imports = parse$d(source)[0];
+      } catch (e) {
+        return null;
+      }
+      if (!imports.length) {
+        return null;
+      }
+      let s;
+      let needDynamicImportHelper = false;
+      for (let index = 0; index < imports.length; index++) {
+        const {
+          s: start,
+          e: end,
+          ss: expStart,
+          se: expEnd,
+          d: dynamicIndex
+        } = imports[index];
+        if (dynamicIndex === -1 || source[start] !== "`") {
+          continue;
+        }
+        if (hasViteIgnoreRE.test(source.slice(expStart, expEnd))) {
+          continue;
+        }
+        s ||= new MagicString(source);
+        let result;
+        try {
+          result = await transformDynamicImport(
+            source.slice(start, end),
+            importer,
+            resolve,
+            config.root
+          );
+        } catch (error) {
+          if (warnOnError) {
+            this.warn(error);
+          } else {
+            this.error(error);
+          }
+        }
+        if (!result) {
+          continue;
+        }
+        const { rawPattern, glob } = result;
+        needDynamicImportHelper = true;
+        s.overwrite(
+          expStart,
+          expEnd,
+          `__variableDynamicImportRuntimeHelper(${glob}, \`${rawPattern}\`, ${rawPattern.split("/").length})`
+        );
+      }
+      if (s) {
+        if (needDynamicImportHelper) {
+          s.prepend(
+            `import __variableDynamicImportRuntimeHelper from "${dynamicImportHelperId}";`
+          );
+        }
+        return transformStableResult(s, importer, config);
+      }
+    }
+  };
+}
+
+async function resolvePlugins(config, prePlugins, normalPlugins, postPlugins) {
+  const isBuild = config.command === "build";
+  const isWorker = config.isWorker;
+  const buildPlugins = isBuild ? await (await Promise.resolve().then(function () { return build$1; })).resolveBuildPlugins(config) : { pre: [], post: [] };
+  const { modulePreload } = config.build;
+  const depsOptimizerEnabled = !isBuild && (isDepsOptimizerEnabled(config, false) || isDepsOptimizerEnabled(config, true));
+  return [
+    depsOptimizerEnabled ? optimizedDepsPlugin(config) : null,
+    isBuild ? metadataPlugin() : null,
+    !isWorker ? watchPackageDataPlugin(config.packageCache) : null,
+    preAliasPlugin(config),
+    alias$1({
+      entries: config.resolve.alias,
+      customResolver: viteAliasCustomResolver
+    }),
+    ...prePlugins,
+    modulePreload !== false && modulePreload.polyfill ? modulePreloadPolyfillPlugin(config) : null,
+    resolvePlugin({
+      ...config.resolve,
+      root: config.root,
+      isProduction: config.isProduction,
+      isBuild,
+      packageCache: config.packageCache,
+      ssrConfig: config.ssr,
+      asSrc: true,
+      fsUtils: getFsUtils(config),
+      getDepsOptimizer: isBuild ? void 0 : (ssr) => getDepsOptimizer(config, ssr),
+      shouldExternalize: isBuild && config.build.ssr ? (id, importer) => shouldExternalizeForSSR(id, importer, config) : void 0
+    }),
+    htmlInlineProxyPlugin(config),
+    cssPlugin(config),
+    config.esbuild !== false ? esbuildPlugin(config) : null,
+    jsonPlugin(
+      {
+        namedExports: true,
+        ...config.json
+      },
+      isBuild
+    ),
+    wasmHelperPlugin(config),
+    webWorkerPlugin(config),
+    assetPlugin(config),
+    ...normalPlugins,
+    wasmFallbackPlugin(),
+    definePlugin(config),
+    cssPostPlugin(config),
+    isBuild && buildHtmlPlugin(config),
+    workerImportMetaUrlPlugin(config),
+    assetImportMetaUrlPlugin(config),
+    ...buildPlugins.pre,
+    dynamicImportVarsPlugin(config),
+    importGlobPlugin(config),
+    ...postPlugins,
+    ...buildPlugins.post,
+    // internal server-only plugins are always applied after everything else
+    ...isBuild ? [] : [
+      clientInjectionsPlugin(config),
+      cssAnalysisPlugin(config),
+      importAnalysisPlugin(config)
+    ]
+  ].filter(Boolean);
+}
+function createPluginHookUtils(plugins) {
+  const sortedPluginsCache = /* @__PURE__ */ new Map();
+  function getSortedPlugins(hookName) {
+    if (sortedPluginsCache.has(hookName))
+      return sortedPluginsCache.get(hookName);
+    const sorted = getSortedPluginsByHook(hookName, plugins);
+    sortedPluginsCache.set(hookName, sorted);
+    return sorted;
+  }
+  function getSortedPluginHooks(hookName) {
+    const plugins2 = getSortedPlugins(hookName);
+    return plugins2.map((p) => getHookHandler(p[hookName])).filter(Boolean);
+  }
+  return {
+    getSortedPlugins,
+    getSortedPluginHooks
+  };
+}
+function getSortedPluginsByHook(hookName, plugins) {
+  const sortedPlugins = [];
+  let pre = 0, normal = 0, post = 0;
+  for (const plugin of plugins) {
+    const hook = plugin[hookName];
+    if (hook) {
+      if (typeof hook === "object") {
+        if (hook.order === "pre") {
+          sortedPlugins.splice(pre++, 0, plugin);
+          continue;
+        }
+        if (hook.order === "post") {
+          sortedPlugins.splice(pre + normal + post++, 0, plugin);
+          continue;
+        }
+      }
+      sortedPlugins.splice(pre + normal++, 0, plugin);
+    }
+  }
+  return sortedPlugins;
+}
+function getHookHandler(hook) {
+  return typeof hook === "object" ? hook.handler : hook;
+}
+const viteAliasCustomResolver = async function(id, importer, options) {
+  const resolved = await this.resolve(id, importer, options);
+  return resolved || { id, meta: { "vite:alias": { noResolved: true } } };
+};
+
+function ansiRegex({onlyFirst = false} = {}) {
+	const pattern = [
+	    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+}
+
+const regex = ansiRegex();
+
+function stripAnsi(string) {
+	if (typeof string !== 'string') {
+		throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+	}
+
+	// Even though the regex is global, we don't need to reset the `.lastIndex`
+	// because unlike `.exec()` and `.test()`, `.replace()` does it automatically
+	// and doing it manually has a performance penalty.
+	return string.replace(regex, '');
+}
+
+function prepareError(err) {
+  return {
+    message: stripAnsi(err.message),
+    stack: stripAnsi(cleanStack(err.stack || "")),
+    id: err.id,
+    frame: stripAnsi(err.frame || ""),
+    plugin: err.plugin,
+    pluginCode: err.pluginCode?.toString(),
+    loc: err.loc
+  };
+}
+function buildErrorMessage(err, args = [], includeStack = true) {
+  if (err.plugin) args.push(`  Plugin: ${colors$1.magenta(err.plugin)}`);
+  const loc = err.loc ? `:${err.loc.line}:${err.loc.column}` : "";
+  if (err.id) args.push(`  File: ${colors$1.cyan(err.id)}${loc}`);
+  if (err.frame) args.push(colors$1.yellow(pad$1(err.frame)));
+  if (includeStack && err.stack) args.push(pad$1(cleanStack(err.stack)));
+  return args.join("\n");
+}
+function cleanStack(stack) {
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function logError(server, err) {
+  const msg = buildErrorMessage(err, [
+    colors$1.red(`Internal server error: ${err.message}`)
+  ]);
+  server.config.logger.error(msg, {
+    clear: true,
+    timestamp: true,
+    error: err
+  });
+  server.hot.send({
+    type: "error",
+    err: prepareError(err)
+  });
+}
+function errorMiddleware(server, allowNext = false) {
+  return function viteErrorMiddleware(err, _req, res, next) {
+    logError(server, err);
+    if (allowNext) {
+      next();
+    } else {
+      res.statusCode = 500;
+      res.end(`
+        <!DOCTYPE html>
+        <html lang="en">
+          <head>
+            <meta charset="UTF-8" />
+            <title>Error</title>
+            <script type="module">
+              const error = ${JSON.stringify(prepareError(err)).replace(
+        /</g,
+        "\\u003c"
+      )}
+              try {
+                const { ErrorOverlay } = await import(${JSON.stringify(path$n.posix.join(server.config.base, CLIENT_PUBLIC_PATH))})
+                document.body.appendChild(new ErrorOverlay(error))
+              } catch {
+                const h = (tag, text) => {
+                  const el = document.createElement(tag)
+                  el.textContent = text
+                  return el
+                }
+                document.body.appendChild(h('h1', 'Internal Server Error'))
+                document.body.appendChild(h('h2', error.message))
+                document.body.appendChild(h('pre', error.stack))
+                document.body.appendChild(h('p', '(Error overlay failed to load)'))
+              }
+            <\/script>
+          </head>
+          <body>
+          </body>
+        </html>
+      `);
+    }
+  };
+}
+
+const noop$3 = () => {
+};
+const EMPTY_OBJECT = Object.freeze({});
+const debugSourcemapCombineFilter = process.env.DEBUG_VITE_SOURCEMAP_COMBINE_FILTER;
+const debugSourcemapCombine = createDebugger("vite:sourcemap-combine", {
+  onlyWhenFocused: true
+});
+const debugResolve = createDebugger("vite:resolve");
+const debugPluginResolve = createDebugger("vite:plugin-resolve", {
+  onlyWhenFocused: "vite:plugin"
+});
+const debugPluginTransform = createDebugger("vite:plugin-transform", {
+  onlyWhenFocused: "vite:plugin"
+});
+const ERR_CLOSED_SERVER = "ERR_CLOSED_SERVER";
+function throwClosedServerError() {
+  const err = new Error(
+    "The server is being restarted or closed. Request is outdated"
+  );
+  err.code = ERR_CLOSED_SERVER;
+  throw err;
+}
+async function createPluginContainer(config, moduleGraph, watcher) {
+  const container = new PluginContainer(config, moduleGraph, watcher);
+  await container.resolveRollupOptions();
+  return container;
+}
+class PluginContainer {
+  /**
+   * @internal use `createPluginContainer` instead
+   */
+  constructor(config, moduleGraph, watcher, plugins = config.plugins) {
+    this.config = config;
+    this.moduleGraph = moduleGraph;
+    this.watcher = watcher;
+    this.plugins = plugins;
+    this.minimalContext = {
+      meta: {
+        rollupVersion,
+        watchMode: true
+      },
+      debug: noop$3,
+      info: noop$3,
+      warn: noop$3,
+      // @ts-expect-error noop
+      error: noop$3
+    };
+    const utils = createPluginHookUtils(plugins);
+    this.getSortedPlugins = utils.getSortedPlugins;
+    this.getSortedPluginHooks = utils.getSortedPluginHooks;
+  }
+  _pluginContextMap = /* @__PURE__ */ new Map();
+  _pluginContextMapSsr = /* @__PURE__ */ new Map();
+  _resolvedRollupOptions;
+  _processesing = /* @__PURE__ */ new Set();
+  _seenResolves = {};
+  _closed = false;
+  // _addedFiles from the `load()` hook gets saved here so it can be reused in the `transform()` hook
+  _moduleNodeToLoadAddedImports = /* @__PURE__ */ new WeakMap();
+  getSortedPluginHooks;
+  getSortedPlugins;
+  watchFiles = /* @__PURE__ */ new Set();
+  minimalContext;
+  _updateModuleLoadAddedImports(id, addedImports) {
+    const module = this.moduleGraph?.getModuleById(id);
+    if (module) {
+      this._moduleNodeToLoadAddedImports.set(module, addedImports);
+    }
+  }
+  _getAddedImports(id) {
+    const module = this.moduleGraph?.getModuleById(id);
+    return module ? this._moduleNodeToLoadAddedImports.get(module) || null : null;
+  }
+  getModuleInfo(id) {
+    const module = this.moduleGraph?.getModuleById(id);
+    if (!module) {
+      return null;
+    }
+    if (!module.info) {
+      module.info = new Proxy(
+        { id, meta: module.meta || EMPTY_OBJECT },
+        // throw when an unsupported ModuleInfo property is accessed,
+        // so that incompatible plugins fail in a non-cryptic way.
+        {
+          get(info, key) {
+            if (key in info) {
+              return info[key];
+            }
+            if (key === "then") {
+              return void 0;
+            }
+            throw Error(
+              `[vite] The "${key}" property of ModuleInfo is not supported.`
+            );
+          }
+        }
+      );
+    }
+    return module.info ?? null;
+  }
+  // keeps track of hook promises so that we can wait for them all to finish upon closing the server
+  handleHookPromise(maybePromise) {
+    if (!maybePromise?.then) {
+      return maybePromise;
+    }
+    const promise = maybePromise;
+    this._processesing.add(promise);
+    return promise.finally(() => this._processesing.delete(promise));
+  }
+  get options() {
+    return this._resolvedRollupOptions;
+  }
+  async resolveRollupOptions() {
+    if (!this._resolvedRollupOptions) {
+      let options = this.config.build.rollupOptions;
+      for (const optionsHook of this.getSortedPluginHooks("options")) {
+        if (this._closed) {
+          throwClosedServerError();
+        }
+        options = await this.handleHookPromise(
+          optionsHook.call(this.minimalContext, options)
+        ) || options;
+      }
+      this._resolvedRollupOptions = options;
+    }
+    return this._resolvedRollupOptions;
+  }
+  _getPluginContext(plugin, ssr) {
+    const map = ssr ? this._pluginContextMapSsr : this._pluginContextMap;
+    if (!map.has(plugin)) {
+      const ctx = new PluginContext(plugin, this, ssr);
+      map.set(plugin, ctx);
+    }
+    return map.get(plugin);
+  }
+  // parallel, ignores returns
+  async hookParallel(hookName, context, args) {
+    const parallelPromises = [];
+    for (const plugin of this.getSortedPlugins(hookName)) {
+      const hook = plugin[hookName];
+      if (!hook) continue;
+      const handler = getHookHandler(hook);
+      if (hook.sequential) {
+        await Promise.all(parallelPromises);
+        parallelPromises.length = 0;
+        await handler.apply(context(plugin), args(plugin));
+      } else {
+        parallelPromises.push(handler.apply(context(plugin), args(plugin)));
+      }
+    }
+    await Promise.all(parallelPromises);
+  }
+  async buildStart(_options) {
+    await this.handleHookPromise(
+      this.hookParallel(
+        "buildStart",
+        (plugin) => this._getPluginContext(plugin, false),
+        () => [this.options]
+      )
+    );
+  }
+  async resolveId(rawId, importer = join$2(this.config.root, "index.html"), options) {
+    const skip = options?.skip;
+    const ssr = options?.ssr;
+    const scan = !!options?.scan;
+    const ctx = new ResolveIdContext(this, !!ssr, skip, scan);
+    const resolveStart = debugResolve ? performance$1.now() : 0;
+    let id = null;
+    const partial = {};
+    for (const plugin of this.getSortedPlugins("resolveId")) {
+      if (this._closed && !ssr) throwClosedServerError();
+      if (!plugin.resolveId) continue;
+      if (skip?.has(plugin)) continue;
+      ctx._plugin = plugin;
+      const pluginResolveStart = debugPluginResolve ? performance$1.now() : 0;
+      const handler = getHookHandler(plugin.resolveId);
+      const result = await this.handleHookPromise(
+        handler.call(ctx, rawId, importer, {
+          attributes: options?.attributes ?? {},
+          custom: options?.custom,
+          isEntry: !!options?.isEntry,
+          ssr,
+          scan
+        })
+      );
+      if (!result) continue;
+      if (typeof result === "string") {
+        id = result;
+      } else {
+        id = result.id;
+        Object.assign(partial, result);
+      }
+      debugPluginResolve?.(
+        timeFrom(pluginResolveStart),
+        plugin.name,
+        prettifyUrl(id, this.config.root)
+      );
+      break;
+    }
+    if (debugResolve && rawId !== id && !rawId.startsWith(FS_PREFIX)) {
+      const key = rawId + id;
+      if (!this._seenResolves[key]) {
+        this._seenResolves[key] = true;
+        debugResolve(
+          `${timeFrom(resolveStart)} ${colors$1.cyan(rawId)} -> ${colors$1.dim(
+            id
+          )}`
+        );
+      }
+    }
+    if (id) {
+      partial.id = isExternalUrl(id) ? id : normalizePath$3(id);
+      return partial;
+    } else {
+      return null;
+    }
+  }
+  async load(id, options) {
+    const ssr = options?.ssr;
+    const ctx = new LoadPluginContext(this, !!ssr);
+    for (const plugin of this.getSortedPlugins("load")) {
+      if (this._closed && !ssr) throwClosedServerError();
+      if (!plugin.load) continue;
+      ctx._plugin = plugin;
+      const handler = getHookHandler(plugin.load);
+      const result = await this.handleHookPromise(
+        handler.call(ctx, id, { ssr })
+      );
+      if (result != null) {
+        if (isObject$1(result)) {
+          ctx._updateModuleInfo(id, result);
+        }
+        this._updateModuleLoadAddedImports(id, ctx._addedImports);
+        return result;
+      }
+    }
+    this._updateModuleLoadAddedImports(id, ctx._addedImports);
+    return null;
+  }
+  async transform(code, id, options) {
+    const inMap = options?.inMap;
+    const ssr = options?.ssr;
+    const ctx = new TransformPluginContext(
+      this,
+      id,
+      code,
+      inMap,
+      !!ssr
+    );
+    ctx._addedImports = this._getAddedImports(id);
+    for (const plugin of this.getSortedPlugins("transform")) {
+      if (this._closed && !ssr) throwClosedServerError();
+      if (!plugin.transform) continue;
+      ctx._updateActiveInfo(plugin, id, code);
+      const start = debugPluginTransform ? performance$1.now() : 0;
+      let result;
+      const handler = getHookHandler(plugin.transform);
+      try {
+        result = await this.handleHookPromise(
+          handler.call(ctx, code, id, { ssr })
+        );
+      } catch (e) {
+        ctx.error(e);
+      }
+      if (!result) continue;
+      debugPluginTransform?.(
+        timeFrom(start),
+        plugin.name,
+        prettifyUrl(id, this.config.root)
+      );
+      if (isObject$1(result)) {
+        if (result.code !== void 0) {
+          code = result.code;
+          if (result.map) {
+            if (debugSourcemapCombine) {
+              result.map.name = plugin.name;
+            }
+            ctx.sourcemapChain.push(result.map);
+          }
+        }
+        ctx._updateModuleInfo(id, result);
+      } else {
+        code = result;
+      }
+    }
+    return {
+      code,
+      map: ctx._getCombinedSourcemap()
+    };
+  }
+  async watchChange(id, change) {
+    await this.hookParallel(
+      "watchChange",
+      (plugin) => this._getPluginContext(plugin, false),
+      () => [id, change]
+    );
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    await Promise.allSettled(Array.from(this._processesing));
+    await this.hookParallel(
+      "buildEnd",
+      (plugin) => this._getPluginContext(plugin, false),
+      () => []
+    );
+    await this.hookParallel(
+      "closeBundle",
+      (plugin) => this._getPluginContext(plugin, false),
+      () => []
+    );
+  }
+}
+class PluginContext {
+  constructor(_plugin, _container, ssr) {
+    this._plugin = _plugin;
+    this._container = _container;
+    this.ssr = ssr;
+    this.meta = this._container.minimalContext.meta;
+  }
+  _scan = false;
+  _resolveSkips;
+  _activeId = null;
+  _activeCode = null;
+  meta;
+  parse(code, opts) {
+    return parseAst(code, opts);
+  }
+  getModuleInfo(id) {
+    return this._container.getModuleInfo(id);
+  }
+  async resolve(id, importer, options) {
+    let skip;
+    if (options?.skipSelf !== false && this._plugin) {
+      skip = new Set(this._resolveSkips);
+      skip.add(this._plugin);
+    }
+    let out = await this._container.resolveId(id, importer, {
+      attributes: options?.attributes,
+      custom: options?.custom,
+      isEntry: !!options?.isEntry,
+      skip,
+      ssr: this.ssr,
+      scan: this._scan
+    });
+    if (typeof out === "string") out = { id: out };
+    return out;
+  }
+  async load(options) {
+    await this._container.moduleGraph?.ensureEntryFromUrl(
+      unwrapId$1(options.id),
+      this.ssr
+    );
+    this._updateModuleInfo(options.id, options);
+    const loadResult = await this._container.load(options.id, {
+      ssr: this.ssr
+    });
+    const code = typeof loadResult === "object" ? loadResult?.code : loadResult;
+    if (code != null) {
+      await this._container.transform(code, options.id, { ssr: this.ssr });
+    }
+    const moduleInfo = this.getModuleInfo(options.id);
+    if (!moduleInfo) throw Error(`Failed to load module with id ${options.id}`);
+    return moduleInfo;
+  }
+  _updateModuleInfo(id, { meta }) {
+    if (meta) {
+      const moduleInfo = this.getModuleInfo(id);
+      if (moduleInfo) {
+        moduleInfo.meta = { ...moduleInfo.meta, ...meta };
+      }
+    }
+  }
+  getModuleIds() {
+    return this._container.moduleGraph ? this._container.moduleGraph.idToModuleMap.keys() : Array.prototype[Symbol.iterator]();
+  }
+  addWatchFile(id) {
+    this._container.watchFiles.add(id);
+    if (this._container.watcher)
+      ensureWatchedFile(
+        this._container.watcher,
+        id,
+        this._container.config.root
+      );
+  }
+  getWatchFiles() {
+    return [...this._container.watchFiles];
+  }
+  emitFile(assetOrFile) {
+    this._warnIncompatibleMethod(`emitFile`);
+    return "";
+  }
+  setAssetSource() {
+    this._warnIncompatibleMethod(`setAssetSource`);
+  }
+  getFileName() {
+    this._warnIncompatibleMethod(`getFileName`);
+    return "";
+  }
+  warn(e, position) {
+    const err = this._formatError(typeof e === "function" ? e() : e, position);
+    const msg = buildErrorMessage(
+      err,
+      [colors$1.yellow(`warning: ${err.message}`)],
+      false
+    );
+    this._container.config.logger.warn(msg, {
+      clear: true,
+      timestamp: true
+    });
+  }
+  error(e, position) {
+    throw this._formatError(e, position);
+  }
+  debug = noop$3;
+  info = noop$3;
+  _formatError(e, position) {
+    const err = typeof e === "string" ? new Error(e) : e;
+    if (err.pluginCode) {
+      return err;
+    }
+    if (this._plugin) err.plugin = this._plugin.name;
+    if (this._activeId && !err.id) err.id = this._activeId;
+    if (this._activeCode) {
+      err.pluginCode = this._activeCode;
+      const pos = position ?? err.pos ?? err.position;
+      if (pos != null) {
+        let errLocation;
+        try {
+          errLocation = numberToPos(this._activeCode, pos);
+        } catch (err2) {
+          this._container.config.logger.error(
+            colors$1.red(
+              `Error in error handler:
+${err2.stack || err2.message}
+`
+            ),
+            // print extra newline to separate the two errors
+            { error: err2 }
+          );
+          throw err;
+        }
+        err.loc = err.loc || {
+          file: err.id,
+          ...errLocation
+        };
+        err.frame = err.frame || generateCodeFrame(this._activeCode, pos);
+      } else if (err.loc) {
+        if (!err.frame) {
+          let code = this._activeCode;
+          if (err.loc.file) {
+            err.id = normalizePath$3(err.loc.file);
+            try {
+              code = fs__default.readFileSync(err.loc.file, "utf-8");
+            } catch {
+            }
+          }
+          err.frame = generateCodeFrame(code, err.loc);
+        }
+      } else if (err.line && err.column) {
+        err.loc = {
+          file: err.id,
+          line: err.line,
+          column: err.column
+        };
+        err.frame = err.frame || generateCodeFrame(this._activeCode, err.loc);
+      }
+      if (this instanceof TransformPluginContext && typeof err.loc?.line === "number" && typeof err.loc?.column === "number") {
+        const rawSourceMap = this._getCombinedSourcemap();
+        if (rawSourceMap && "version" in rawSourceMap) {
+          const traced = new TraceMap(rawSourceMap);
+          const { source, line, column } = originalPositionFor$1(traced, {
+            line: Number(err.loc.line),
+            column: Number(err.loc.column)
+          });
+          if (source && line != null && column != null) {
+            err.loc = { file: source, line, column };
+          }
+        }
+      }
+    } else if (err.loc) {
+      if (!err.frame) {
+        let code = err.pluginCode;
+        if (err.loc.file) {
+          err.id = normalizePath$3(err.loc.file);
+          if (!code) {
+            try {
+              code = fs__default.readFileSync(err.loc.file, "utf-8");
+            } catch {
+            }
+          }
+        }
+        if (code) {
+          err.frame = generateCodeFrame(`${code}`, err.loc);
+        }
+      }
+    }
+    if (typeof err.loc?.column !== "number" && typeof err.loc?.line !== "number" && !err.loc?.file) {
+      delete err.loc;
+    }
+    return err;
+  }
+  _warnIncompatibleMethod(method) {
+    this._container.config.logger.warn(
+      colors$1.cyan(`[plugin:${this._plugin.name}] `) + colors$1.yellow(
+        `context method ${colors$1.bold(
+          `${method}()`
+        )} is not supported in serve mode. This plugin is likely not vite-compatible.`
+      )
+    );
+  }
+}
+class ResolveIdContext extends PluginContext {
+  constructor(container, ssr, skip, scan) {
+    super(null, container, ssr);
+    this._resolveSkips = skip;
+    this._scan = scan;
+  }
+}
+class LoadPluginContext extends PluginContext {
+  _addedImports = null;
+  constructor(container, ssr) {
+    super(null, container, ssr);
+  }
+  addWatchFile(id) {
+    if (!this._addedImports) {
+      this._addedImports = /* @__PURE__ */ new Set();
+    }
+    this._addedImports.add(id);
+    super.addWatchFile(id);
+  }
+}
+class TransformPluginContext extends LoadPluginContext {
+  filename;
+  originalCode;
+  originalSourcemap = null;
+  sourcemapChain = [];
+  combinedMap = null;
+  constructor(container, id, code, inMap, ssr) {
+    super(container, ssr);
+    this.filename = id;
+    this.originalCode = code;
+    if (inMap) {
+      if (debugSourcemapCombine) {
+        inMap.name = "$inMap";
+      }
+      this.sourcemapChain.push(inMap);
+    }
+  }
+  _getCombinedSourcemap() {
+    if (debugSourcemapCombine && debugSourcemapCombineFilter && this.filename.includes(debugSourcemapCombineFilter)) {
+      debugSourcemapCombine("----------", this.filename);
+      debugSourcemapCombine(this.combinedMap);
+      debugSourcemapCombine(this.sourcemapChain);
+      debugSourcemapCombine("----------");
+    }
+    let combinedMap = this.combinedMap;
+    if (combinedMap && !("version" in combinedMap) && combinedMap.mappings === "") {
+      this.sourcemapChain.length = 0;
+      return combinedMap;
+    }
+    for (let m of this.sourcemapChain) {
+      if (typeof m === "string") m = JSON.parse(m);
+      if (!("version" in m)) {
+        if (m.mappings === "") {
+          combinedMap = { mappings: "" };
+          break;
+        }
+        combinedMap = null;
+        break;
+      }
+      if (!combinedMap) {
+        const sm = m;
+        if (sm.sources.length === 1 && !sm.sources[0]) {
+          combinedMap = {
+            ...sm,
+            sources: [this.filename],
+            sourcesContent: [this.originalCode]
+          };
+        } else {
+          combinedMap = sm;
+        }
+      } else {
+        combinedMap = combineSourcemaps(cleanUrl(this.filename), [
+          m,
+          combinedMap
+        ]);
+      }
+    }
+    if (combinedMap !== this.combinedMap) {
+      this.combinedMap = combinedMap;
+      this.sourcemapChain.length = 0;
+    }
+    return this.combinedMap;
+  }
+  getCombinedSourcemap() {
+    const map = this._getCombinedSourcemap();
+    if (!map || !("version" in map) && map.mappings === "") {
+      return new MagicString(this.originalCode).generateMap({
+        includeContent: true,
+        hires: "boundary",
+        source: cleanUrl(this.filename)
+      });
+    }
+    return map;
+  }
+  _updateActiveInfo(plugin, id, code) {
+    this._plugin = plugin;
+    this._activeId = id;
+    this._activeCode = code;
+  }
+}
+
+const debug$9 = createDebugger("vite:deps");
+const htmlTypesRE = /\.(html|vue|svelte|astro|imba)$/;
+const importsRE = /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type)(?:[\w*{}\n\r\t, ]+from)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm;
+function scanImports(config) {
+  const start = performance$1.now();
+  const deps = {};
+  const missing = {};
+  let entries;
+  const scanContext = { cancelled: false };
+  const esbuildContext = computeEntries(
+    config
+  ).then((computedEntries) => {
+    entries = computedEntries;
+    if (!entries.length) {
+      if (!config.optimizeDeps.entries && !config.optimizeDeps.include) {
+        config.logger.warn(
+          colors$1.yellow(
+            "(!) Could not auto-determine entry point from rollupOptions or html files and there are no explicit optimizeDeps.include patterns. Skipping dependency pre-bundling."
+          )
+        );
+      }
+      return;
+    }
+    if (scanContext.cancelled) return;
+    debug$9?.(
+      `Crawling dependencies using entries: ${entries.map((entry) => `
+  ${colors$1.dim(entry)}`).join("")}`
+    );
+    return prepareEsbuildScanner(config, entries, deps, missing, scanContext);
+  });
+  const result = esbuildContext.then((context) => {
+    function disposeContext() {
+      return context?.dispose().catch((e) => {
+        config.logger.error("Failed to dispose esbuild context", { error: e });
+      });
+    }
+    if (!context || scanContext?.cancelled) {
+      disposeContext();
+      return { deps: {}, missing: {} };
+    }
+    return context.rebuild().then(() => {
+      return {
+        // Ensure a fixed order so hashes are stable and improve logs
+        deps: orderedDependencies(deps),
+        missing
+      };
+    }).finally(() => {
+      return disposeContext();
+    });
+  }).catch(async (e) => {
+    if (e.errors && e.message.includes("The build was canceled")) {
+      return { deps: {}, missing: {} };
+    }
+    const prependMessage = colors$1.red(`  Failed to scan for dependencies from entries:
+  ${entries.join("\n")}
+
+  `);
+    if (e.errors) {
+      const msgs = await formatMessages(e.errors, {
+        kind: "error",
+        color: true
+      });
+      e.message = prependMessage + msgs.join("\n");
+    } else {
+      e.message = prependMessage + e.message;
+    }
+    throw e;
+  }).finally(() => {
+    if (debug$9) {
+      const duration = (performance$1.now() - start).toFixed(2);
+      const depsStr = Object.keys(orderedDependencies(deps)).sort().map((id) => `
+  ${colors$1.cyan(id)} -> ${colors$1.dim(deps[id])}`).join("") || colors$1.dim("no dependencies found");
+      debug$9(`Scan completed in ${duration}ms: ${depsStr}`);
+    }
+  });
+  return {
+    cancel: async () => {
+      scanContext.cancelled = true;
+      return esbuildContext.then((context) => context?.cancel());
+    },
+    result
+  };
+}
+async function computeEntries(config) {
+  let entries = [];
+  const explicitEntryPatterns = config.optimizeDeps.entries;
+  const buildInput = config.build.rollupOptions?.input;
+  if (explicitEntryPatterns) {
+    entries = await globEntries(explicitEntryPatterns, config);
+  } else if (buildInput) {
+    const resolvePath = (p) => path$n.resolve(config.root, p);
+    if (typeof buildInput === "string") {
+      entries = [resolvePath(buildInput)];
+    } else if (Array.isArray(buildInput)) {
+      entries = buildInput.map(resolvePath);
+    } else if (isObject$1(buildInput)) {
+      entries = Object.values(buildInput).map(resolvePath);
+    } else {
+      throw new Error("invalid rollupOptions.input value.");
+    }
+  } else {
+    entries = await globEntries("**/*.html", config);
+  }
+  entries = entries.filter(
+    (entry) => isScannable(entry, config.optimizeDeps.extensions) && fs__default.existsSync(entry)
+  );
+  return entries;
+}
+async function prepareEsbuildScanner(config, entries, deps, missing, scanContext) {
+  const container = await createPluginContainer(config);
+  if (scanContext?.cancelled) return;
+  const plugin = esbuildScanPlugin(config, container, deps, missing, entries);
+  const { plugins = [], ...esbuildOptions } = config.optimizeDeps?.esbuildOptions ?? {};
+  let tsconfigRaw = esbuildOptions.tsconfigRaw;
+  if (!tsconfigRaw && !esbuildOptions.tsconfig) {
+    const tsconfigResult = await loadTsconfigJsonForFile(
+      path$n.join(config.root, "_dummy.js")
+    );
+    if (tsconfigResult.compilerOptions?.experimentalDecorators) {
+      tsconfigRaw = { compilerOptions: { experimentalDecorators: true } };
+    }
+  }
+  return await esbuild.context({
+    absWorkingDir: process.cwd(),
+    write: false,
+    stdin: {
+      contents: entries.map((e) => `import ${JSON.stringify(e)}`).join("\n"),
+      loader: "js"
+    },
+    bundle: true,
+    format: "esm",
+    logLevel: "silent",
+    plugins: [...plugins, plugin],
+    ...esbuildOptions,
+    tsconfigRaw
+  });
+}
+function orderedDependencies(deps) {
+  const depsList = Object.entries(deps);
+  depsList.sort((a, b) => a[0].localeCompare(b[0]));
+  return Object.fromEntries(depsList);
+}
+function globEntries(pattern, config) {
+  const resolvedPatterns = arraify(pattern);
+  if (resolvedPatterns.every((str) => !glob.isDynamicPattern(str))) {
+    return resolvedPatterns.map(
+      (p) => normalizePath$3(path$n.resolve(config.root, p))
+    );
+  }
+  return glob(pattern, {
+    cwd: config.root,
+    ignore: [
+      "**/node_modules/**",
+      `**/${config.build.outDir}/**`,
+      // if there aren't explicit entries, also ignore other common folders
+      ...config.optimizeDeps.entries ? [] : [`**/__tests__/**`, `**/coverage/**`]
+    ],
+    absolute: true,
+    suppressErrors: true
+    // suppress EACCES errors
+  });
+}
+const scriptRE = /(<script(?:\s+[a-z_:][-\w:]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^"'<>=\s]+))?)*\s*>)(.*?)<\/script>/gis;
+const commentRE = /<!--.*?-->/gs;
+const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteScriptModuleRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i;
+const svelteModuleRE = /\smodule\b/i;
+function esbuildScanPlugin(config, container, depImports, missing, entries) {
+  const seen = /* @__PURE__ */ new Map();
+  const resolve = async (id, importer, options) => {
+    const key = id + (importer && path$n.dirname(importer));
+    if (seen.has(key)) {
+      return seen.get(key);
+    }
+    const resolved = await container.resolveId(
+      id,
+      importer && normalizePath$3(importer),
+      {
+        ...options,
+        scan: true
+      }
+    );
+    const res = resolved?.id;
+    seen.set(key, res);
+    return res;
+  };
+  const include = config.optimizeDeps?.include;
+  const exclude = [
+    ...config.optimizeDeps?.exclude || [],
+    "@vite/client",
+    "@vite/env"
+  ];
+  const isUnlessEntry = (path2) => !entries.includes(path2);
+  const externalUnlessEntry = ({ path: path2 }) => ({
+    path: path2,
+    external: isUnlessEntry(path2)
+  });
+  const doTransformGlobImport = async (contents, id, loader) => {
+    let transpiledContents;
+    if (loader !== "js") {
+      transpiledContents = (await transform$1(contents, { loader })).code;
+    } else {
+      transpiledContents = contents;
+    }
+    const result = await transformGlobImport(
+      transpiledContents,
+      id,
+      config.root,
+      resolve
+    );
+    return result?.s.toString() || transpiledContents;
+  };
+  return {
+    name: "vite:dep-scan",
+    setup(build) {
+      const scripts = {};
+      build.onResolve({ filter: externalRE }, ({ path: path2 }) => ({
+        path: path2,
+        external: true
+      }));
+      build.onResolve({ filter: dataUrlRE }, ({ path: path2 }) => ({
+        path: path2,
+        external: true
+      }));
+      build.onResolve({ filter: virtualModuleRE }, ({ path: path2 }) => {
+        return {
+          // strip prefix to get valid filesystem path so esbuild can resolve imports in the file
+          path: path2.replace(virtualModulePrefix, ""),
+          namespace: "script"
+        };
+      });
+      build.onLoad({ filter: /.*/, namespace: "script" }, ({ path: path2 }) => {
+        return scripts[path2];
+      });
+      build.onResolve({ filter: htmlTypesRE }, async ({ path: path2, importer }) => {
+        const resolved = await resolve(path2, importer);
+        if (!resolved) return;
+        if (isInNodeModules$1(resolved) && isOptimizable(resolved, config.optimizeDeps))
+          return;
+        return {
+          path: resolved,
+          namespace: "html"
+        };
+      });
+      const htmlTypeOnLoadCallback = async ({ path: p }) => {
+        let raw = await fsp.readFile(p, "utf-8");
+        raw = raw.replace(commentRE, "<!---->");
+        const isHtml = p.endsWith(".html");
+        let js = "";
+        let scriptId = 0;
+        const matches = raw.matchAll(scriptRE);
+        for (const [, openTag, content] of matches) {
+          const typeMatch = typeRE.exec(openTag);
+          const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
+          const langMatch = langRE.exec(openTag);
+          const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3]);
+          if (isHtml && type !== "module") {
+            continue;
+          }
+          if (type && !(type.includes("javascript") || type.includes("ecmascript") || type === "module")) {
+            continue;
+          }
+          let loader = "js";
+          if (lang === "ts" || lang === "tsx" || lang === "jsx") {
+            loader = lang;
+          } else if (p.endsWith(".astro")) {
+            loader = "ts";
+          }
+          const srcMatch = srcRE.exec(openTag);
+          if (srcMatch) {
+            const src = srcMatch[1] || srcMatch[2] || srcMatch[3];
+            js += `import ${JSON.stringify(src)}
+`;
+          } else if (content.trim()) {
+            const contents = content + (loader.startsWith("ts") ? extractImportPaths(content) : "");
+            const key = `${p}?id=${scriptId++}`;
+            if (contents.includes("import.meta.glob")) {
+              scripts[key] = {
+                loader: "js",
+                // since it is transpiled
+                contents: await doTransformGlobImport(contents, p, loader),
+                resolveDir: normalizePath$3(path$n.dirname(p)),
+                pluginData: {
+                  htmlType: { loader }
+                }
+              };
+            } else {
+              scripts[key] = {
+                loader,
+                contents,
+                resolveDir: normalizePath$3(path$n.dirname(p)),
+                pluginData: {
+                  htmlType: { loader }
+                }
+              };
+            }
+            const virtualModulePath = JSON.stringify(virtualModulePrefix + key);
+            let addedImport = false;
+            if (p.endsWith(".svelte")) {
+              let isModule = svelteModuleRE.test(openTag);
+              if (!isModule) {
+                const contextMatch = svelteScriptModuleRE.exec(openTag);
+                const context = contextMatch && (contextMatch[1] || contextMatch[2] || contextMatch[3]);
+                isModule = context === "module";
+              }
+              if (!isModule) {
+                addedImport = true;
+                js += `import ${virtualModulePath}
+`;
+              }
+            }
+            if (!addedImport) {
+              js += `export * from ${virtualModulePath}
+`;
+            }
+          }
+        }
+        if (!p.endsWith(".vue") || !js.includes("export default")) {
+          js += "\nexport default {}";
+        }
+        return {
+          loader: "js",
+          contents: js
+        };
+      };
+      build.onLoad(
+        { filter: htmlTypesRE, namespace: "html" },
+        htmlTypeOnLoadCallback
+      );
+      build.onLoad(
+        { filter: htmlTypesRE, namespace: "file" },
+        htmlTypeOnLoadCallback
+      );
+      build.onResolve(
+        {
+          // avoid matching windows volume
+          filter: /^[\w@][^:]/
+        },
+        async ({ path: id, importer, pluginData }) => {
+          if (moduleListContains(exclude, id)) {
+            return externalUnlessEntry({ path: id });
+          }
+          if (depImports[id]) {
+            return externalUnlessEntry({ path: id });
+          }
+          const resolved = await resolve(id, importer, {
+            custom: {
+              depScan: { loader: pluginData?.htmlType?.loader }
+            }
+          });
+          if (resolved) {
+            if (shouldExternalizeDep(resolved, id)) {
+              return externalUnlessEntry({ path: id });
+            }
+            if (isInNodeModules$1(resolved) || include?.includes(id)) {
+              if (isOptimizable(resolved, config.optimizeDeps)) {
+                depImports[id] = resolved;
+              }
+              return externalUnlessEntry({ path: id });
+            } else if (isScannable(resolved, config.optimizeDeps.extensions)) {
+              const namespace = htmlTypesRE.test(resolved) ? "html" : void 0;
+              return {
+                path: path$n.resolve(resolved),
+                namespace
+              };
+            } else {
+              return externalUnlessEntry({ path: id });
+            }
+          } else {
+            missing[id] = normalizePath$3(importer);
+          }
+        }
+      );
+      const setupExternalize = (filter, doExternalize) => {
+        build.onResolve({ filter }, ({ path: path2 }) => {
+          return {
+            path: path2,
+            external: doExternalize(path2)
+          };
+        });
+      };
+      setupExternalize(CSS_LANGS_RE, isUnlessEntry);
+      setupExternalize(/\.(json|json5|wasm)$/, isUnlessEntry);
+      setupExternalize(
+        new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`),
+        isUnlessEntry
+      );
+      setupExternalize(SPECIAL_QUERY_RE, () => true);
+      build.onResolve(
+        {
+          filter: /.*/
+        },
+        async ({ path: id, importer, pluginData }) => {
+          const resolved = await resolve(id, importer, {
+            custom: {
+              depScan: { loader: pluginData?.htmlType?.loader }
+            }
+          });
+          if (resolved) {
+            if (shouldExternalizeDep(resolved, id) || !isScannable(resolved, config.optimizeDeps.extensions)) {
+              return externalUnlessEntry({ path: id });
+            }
+            const namespace = htmlTypesRE.test(resolved) ? "html" : void 0;
+            return {
+              path: path$n.resolve(cleanUrl(resolved)),
+              namespace
+            };
+          } else {
+            return externalUnlessEntry({ path: id });
+          }
+        }
+      );
+      build.onLoad({ filter: JS_TYPES_RE }, async ({ path: id }) => {
+        let ext = path$n.extname(id).slice(1);
+        if (ext === "mjs") ext = "js";
+        let contents = await fsp.readFile(id, "utf-8");
+        if (ext.endsWith("x") && config.esbuild && config.esbuild.jsxInject) {
+          contents = config.esbuild.jsxInject + `
+` + contents;
+        }
+        const loader = config.optimizeDeps?.esbuildOptions?.loader?.[`.${ext}`] || ext;
+        if (contents.includes("import.meta.glob")) {
+          return {
+            loader: "js",
+            // since it is transpiled,
+            contents: await doTransformGlobImport(contents, id, loader)
+          };
+        }
+        return {
+          loader,
+          contents
+        };
+      });
+      build.onLoad({ filter: /.*/, namespace: "file" }, () => {
+        return {
+          loader: "js",
+          contents: "export default {}"
+        };
+      });
+    }
+  };
+}
+function extractImportPaths(code) {
+  code = code.replace(multilineCommentsRE, "/* */").replace(singlelineCommentsRE, "");
+  let js = "";
+  let m;
+  importsRE.lastIndex = 0;
+  while ((m = importsRE.exec(code)) != null) {
+    js += `
+import ${m[1]}`;
+  }
+  return js;
+}
+function shouldExternalizeDep(resolvedId, rawId) {
+  if (!path$n.isAbsolute(resolvedId)) {
+    return true;
+  }
+  if (resolvedId === rawId || resolvedId.includes("\0")) {
+    return true;
+  }
+  return false;
+}
+function isScannable(id, extensions) {
+  return JS_TYPES_RE.test(id) || htmlTypesRE.test(id) || extensions?.includes(path$n.extname(id)) || false;
+}
+
+function createOptimizeDepsIncludeResolver(config, ssr) {
+  const resolve = config.createResolver({
+    asSrc: false,
+    scan: true,
+    ssrOptimizeCheck: ssr,
+    ssrConfig: config.ssr,
+    packageCache: /* @__PURE__ */ new Map()
+  });
+  return async (id) => {
+    const lastArrowIndex = id.lastIndexOf(">");
+    if (lastArrowIndex === -1) {
+      return await resolve(id, void 0, void 0, ssr);
+    }
+    const nestedRoot = id.substring(0, lastArrowIndex).trim();
+    const nestedPath = id.substring(lastArrowIndex + 1).trim();
+    const basedir = nestedResolveBasedir(
+      nestedRoot,
+      config.root,
+      config.resolve.preserveSymlinks
+    );
+    return await resolve(
+      nestedPath,
+      path$n.resolve(basedir, "package.json"),
+      void 0,
+      ssr
+    );
+  };
+}
+function expandGlobIds(id, config) {
+  const pkgName = getNpmPackageName(id);
+  if (!pkgName) return [];
+  const pkgData = resolvePackageData(
+    pkgName,
+    config.root,
+    config.resolve.preserveSymlinks,
+    config.packageCache
+  );
+  if (!pkgData) return [];
+  const pattern = "." + id.slice(pkgName.length);
+  const exports = pkgData.data.exports;
+  if (exports) {
+    if (typeof exports === "string" || Array.isArray(exports)) {
+      return [pkgName];
+    }
+    const possibleExportPaths = [];
+    for (const key in exports) {
+      if (key[0] === ".") {
+        if (key.includes("*")) {
+          const exportsValue = getFirstExportStringValue(exports[key]);
+          if (!exportsValue) continue;
+          const exportValuePattern = exportsValue.replace(/\*/g, "**/*");
+          const exportsValueGlobRe = new RegExp(
+            exportsValue.split("*").map(escapeRegex).join("(.*)")
+          );
+          possibleExportPaths.push(
+            ...glob.sync(exportValuePattern, {
+              cwd: pkgData.dir,
+              ignore: ["node_modules"]
+            }).map((filePath) => {
+              if (exportsValue.startsWith("./") && !filePath.startsWith("./")) {
+                filePath = "./" + filePath;
+              }
+              const matched2 = exportsValueGlobRe.exec(slash$1(filePath));
+              if (matched2) {
+                let allGlobSame = matched2.length === 2;
+                if (!allGlobSame) {
+                  allGlobSame = true;
+                  for (let i = 2; i < matched2.length; i++) {
+                    if (matched2[i] !== matched2[i - 1]) {
+                      allGlobSame = false;
+                      break;
+                    }
+                  }
+                }
+                if (allGlobSame) {
+                  return key.replace("*", matched2[1]).slice(2);
+                }
+              }
+              return "";
+            }).filter(Boolean)
+          );
+        } else {
+          possibleExportPaths.push(key.slice(2));
+        }
+      }
+    }
+    const matched = micromatch$2(possibleExportPaths, pattern).map(
+      (match) => path$n.posix.join(pkgName, match)
+    );
+    matched.unshift(pkgName);
+    return matched;
+  } else {
+    const matched = glob.sync(pattern, { cwd: pkgData.dir, ignore: ["node_modules"] }).map((match) => path$n.posix.join(pkgName, slash$1(match)));
+    matched.unshift(pkgName);
+    return matched;
+  }
+}
+function getFirstExportStringValue(obj) {
+  if (typeof obj === "string") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return obj[0];
+  } else {
+    for (const key in obj) {
+      return getFirstExportStringValue(obj[key]);
+    }
+  }
+}
+function nestedResolveBasedir(id, basedir, preserveSymlinks = false) {
+  const pkgs = id.split(">").map((pkg) => pkg.trim());
+  for (const pkg of pkgs) {
+    basedir = resolvePackageData(pkg, basedir, preserveSymlinks)?.dir || basedir;
+  }
+  return basedir;
+}
+
+const debug$8 = createDebugger("vite:deps");
+const debounceMs = 100;
+const depsOptimizerMap = /* @__PURE__ */ new WeakMap();
+const devSsrDepsOptimizerMap = /* @__PURE__ */ new WeakMap();
+function getDepsOptimizer(config, ssr) {
+  return (ssr ? devSsrDepsOptimizerMap : depsOptimizerMap).get(config);
+}
+async function initDepsOptimizer(config, server) {
+  if (!getDepsOptimizer(config, false)) {
+    await createDepsOptimizer(config, server);
+  }
+}
+let creatingDevSsrOptimizer;
+async function initDevSsrDepsOptimizer(config, server) {
+  if (getDepsOptimizer(config, true)) {
+    return;
+  }
+  if (creatingDevSsrOptimizer) {
+    return creatingDevSsrOptimizer;
+  }
+  creatingDevSsrOptimizer = async function() {
+    const ssr = false;
+    if (!getDepsOptimizer(config, ssr)) {
+      await initDepsOptimizer(config, server);
+    }
+    await getDepsOptimizer(config, ssr).scanProcessing;
+    await createDevSsrDepsOptimizer(config);
+    creatingDevSsrOptimizer = void 0;
+  }();
+  return await creatingDevSsrOptimizer;
+}
+async function createDepsOptimizer(config, server) {
+  const { logger } = config;
+  const ssr = false;
+  const sessionTimestamp = Date.now().toString();
+  const cachedMetadata = await loadCachedDepOptimizationMetadata(config, ssr);
+  let debounceProcessingHandle;
+  let closed = false;
+  let metadata = cachedMetadata || initDepsOptimizerMetadata(config, ssr, sessionTimestamp);
+  const options = getDepOptimizationConfig(config, ssr);
+  const { noDiscovery, holdUntilCrawlEnd } = options;
+  const depsOptimizer = {
+    metadata,
+    registerMissingImport,
+    run: () => debouncedProcessing(0),
+    isOptimizedDepFile: createIsOptimizedDepFile(config),
+    isOptimizedDepUrl: createIsOptimizedDepUrl(config),
+    getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
+    close,
+    options
+  };
+  depsOptimizerMap.set(config, depsOptimizer);
+  let newDepsDiscovered = false;
+  let newDepsToLog = [];
+  let newDepsToLogHandle;
+  const logNewlyDiscoveredDeps = () => {
+    if (newDepsToLog.length) {
+      logger.info(
+        colors$1.green(
+          `\u2728 new dependencies optimized: ${depsLogString(newDepsToLog)}`
+        ),
+        {
+          timestamp: true
+        }
+      );
+      newDepsToLog = [];
+    }
+  };
+  let discoveredDepsWhileScanning = [];
+  const logDiscoveredDepsWhileScanning = () => {
+    if (discoveredDepsWhileScanning.length) {
+      logger.info(
+        colors$1.green(
+          `\u2728 discovered while scanning: ${depsLogString(
+            discoveredDepsWhileScanning
+          )}`
+        ),
+        {
+          timestamp: true
+        }
+      );
+      discoveredDepsWhileScanning = [];
+    }
+  };
+  let depOptimizationProcessing = promiseWithResolvers();
+  let depOptimizationProcessingQueue = [];
+  const resolveEnqueuedProcessingPromises = () => {
+    for (const processing of depOptimizationProcessingQueue) {
+      processing.resolve();
+    }
+    depOptimizationProcessingQueue = [];
+  };
+  let enqueuedRerun;
+  let currentlyProcessing = false;
+  let firstRunCalled = !!cachedMetadata;
+  let warnAboutMissedDependencies = false;
+  let waitingForCrawlEnd = false;
+  if (!cachedMetadata) {
+    server._onCrawlEnd(onCrawlEnd);
+    waitingForCrawlEnd = true;
+  }
+  let optimizationResult;
+  let discover;
+  async function close() {
+    closed = true;
+    await Promise.allSettled([
+      discover?.cancel(),
+      depsOptimizer.scanProcessing,
+      optimizationResult?.cancel()
+    ]);
+  }
+  if (!cachedMetadata) {
+    currentlyProcessing = true;
+    const manuallyIncludedDeps = {};
+    await addManuallyIncludedOptimizeDeps(manuallyIncludedDeps, config, ssr);
+    const manuallyIncludedDepsInfo = toDiscoveredDependencies(
+      config,
+      manuallyIncludedDeps,
+      ssr,
+      sessionTimestamp
+    );
+    for (const depInfo of Object.values(manuallyIncludedDepsInfo)) {
+      addOptimizedDepInfo(metadata, "discovered", {
+        ...depInfo,
+        processing: depOptimizationProcessing.promise
+      });
+      newDepsDiscovered = true;
+    }
+    if (noDiscovery) {
+      runOptimizer();
+    } else {
+      depsOptimizer.scanProcessing = new Promise((resolve) => {
+        (async () => {
+          try {
+            debug$8?.(colors$1.green(`scanning for dependencies...`));
+            discover = discoverProjectDependencies(config);
+            const deps = await discover.result;
+            discover = void 0;
+            const manuallyIncluded = Object.keys(manuallyIncludedDepsInfo);
+            discoveredDepsWhileScanning.push(
+              ...Object.keys(metadata.discovered).filter(
+                (dep) => !deps[dep] && !manuallyIncluded.includes(dep)
+              )
+            );
+            for (const id of Object.keys(deps)) {
+              if (!metadata.discovered[id]) {
+                addMissingDep(id, deps[id]);
+              }
+            }
+            const knownDeps = prepareKnownDeps();
+            startNextDiscoveredBatch();
+            optimizationResult = runOptimizeDeps(config, knownDeps, ssr);
+            if (!holdUntilCrawlEnd) {
+              optimizationResult.result.then((result) => {
+                if (!waitingForCrawlEnd) return;
+                optimizationResult = void 0;
+                runOptimizer(result);
+              });
+            }
+          } catch (e) {
+            logger.error(e.stack || e.message);
+          } finally {
+            resolve();
+            depsOptimizer.scanProcessing = void 0;
+          }
+        })();
+      });
+    }
+  }
+  function startNextDiscoveredBatch() {
+    newDepsDiscovered = false;
+    depOptimizationProcessingQueue.push(depOptimizationProcessing);
+    depOptimizationProcessing = promiseWithResolvers();
+  }
+  function prepareKnownDeps() {
+    const knownDeps = {};
+    for (const dep of Object.keys(metadata.optimized)) {
+      knownDeps[dep] = { ...metadata.optimized[dep] };
+    }
+    for (const dep of Object.keys(metadata.discovered)) {
+      const { processing, ...info } = metadata.discovered[dep];
+      knownDeps[dep] = info;
+    }
+    return knownDeps;
+  }
+  async function runOptimizer(preRunResult) {
+    const isRerun = firstRunCalled;
+    firstRunCalled = true;
+    enqueuedRerun = void 0;
+    if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
+    if (closed) {
+      currentlyProcessing = false;
+      return;
+    }
+    currentlyProcessing = true;
+    try {
+      let processingResult;
+      if (preRunResult) {
+        processingResult = preRunResult;
+      } else {
+        const knownDeps = prepareKnownDeps();
+        startNextDiscoveredBatch();
+        optimizationResult = runOptimizeDeps(config, knownDeps, ssr);
+        processingResult = await optimizationResult.result;
+        optimizationResult = void 0;
+      }
+      if (closed) {
+        currentlyProcessing = false;
+        processingResult.cancel();
+        resolveEnqueuedProcessingPromises();
+        return;
+      }
+      const newData = processingResult.metadata;
+      const needsInteropMismatch = findInteropMismatches(
+        metadata.discovered,
+        newData.optimized
+      );
+      const needsReload = needsInteropMismatch.length > 0 || metadata.hash !== newData.hash || Object.keys(metadata.optimized).some((dep) => {
+        return metadata.optimized[dep].fileHash !== newData.optimized[dep].fileHash;
+      });
+      const commitProcessing = async () => {
+        await processingResult.commit();
+        for (const id in metadata.discovered) {
+          if (!newData.optimized[id]) {
+            addOptimizedDepInfo(newData, "discovered", metadata.discovered[id]);
+          }
+        }
+        if (!needsReload) {
+          newData.browserHash = metadata.browserHash;
+          for (const dep in newData.chunks) {
+            newData.chunks[dep].browserHash = metadata.browserHash;
+          }
+          for (const dep in newData.optimized) {
+            newData.optimized[dep].browserHash = (metadata.optimized[dep] || metadata.discovered[dep]).browserHash;
+          }
+        }
+        for (const o in newData.optimized) {
+          const discovered = metadata.discovered[o];
+          if (discovered) {
+            const optimized = newData.optimized[o];
+            discovered.browserHash = optimized.browserHash;
+            discovered.fileHash = optimized.fileHash;
+            discovered.needsInterop = optimized.needsInterop;
+            discovered.processing = void 0;
+          }
+        }
+        if (isRerun) {
+          newDepsToLog.push(
+            ...Object.keys(newData.optimized).filter(
+              (dep) => !metadata.optimized[dep]
+            )
+          );
+        }
+        metadata = depsOptimizer.metadata = newData;
+        resolveEnqueuedProcessingPromises();
+      };
+      if (!needsReload) {
+        await commitProcessing();
+        if (!debug$8) {
+          if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+          newDepsToLogHandle = setTimeout(() => {
+            newDepsToLogHandle = void 0;
+            logNewlyDiscoveredDeps();
+            if (warnAboutMissedDependencies) {
+              logDiscoveredDepsWhileScanning();
+              logger.info(
+                colors$1.magenta(
+                  `\u2757 add these dependencies to optimizeDeps.include to speed up cold start`
+                ),
+                { timestamp: true }
+              );
+              warnAboutMissedDependencies = false;
+            }
+          }, 2 * debounceMs);
+        } else {
+          debug$8(
+            colors$1.green(
+              `\u2728 ${!isRerun ? `dependencies optimized` : `optimized dependencies unchanged`}`
+            )
+          );
+        }
+      } else {
+        if (newDepsDiscovered) {
+          processingResult.cancel();
+          debug$8?.(
+            colors$1.green(
+              `\u2728 delaying reload as new dependencies have been found...`
+            )
+          );
+        } else {
+          await commitProcessing();
+          if (!debug$8) {
+            if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+            newDepsToLogHandle = void 0;
+            logNewlyDiscoveredDeps();
+            if (warnAboutMissedDependencies) {
+              logDiscoveredDepsWhileScanning();
+              logger.info(
+                colors$1.magenta(
+                  `\u2757 add these dependencies to optimizeDeps.include to avoid a full page reload during cold start`
+                ),
+                { timestamp: true }
+              );
+              warnAboutMissedDependencies = false;
+            }
+          }
+          logger.info(
+            colors$1.green(`\u2728 optimized dependencies changed. reloading`),
+            {
+              timestamp: true
+            }
+          );
+          if (needsInteropMismatch.length > 0) {
+            logger.warn(
+              `Mixed ESM and CJS detected in ${colors$1.yellow(
+                needsInteropMismatch.join(", ")
+              )}, add ${needsInteropMismatch.length === 1 ? "it" : "them"} to optimizeDeps.needsInterop to speed up cold start`,
+              {
+                timestamp: true
+              }
+            );
+          }
+          fullReload();
+        }
+      }
+    } catch (e) {
+      logger.error(
+        colors$1.red(`error while updating dependencies:
+${e.stack}`),
+        { timestamp: true, error: e }
+      );
+      resolveEnqueuedProcessingPromises();
+      metadata.discovered = {};
+    }
+    currentlyProcessing = false;
+    enqueuedRerun?.();
+  }
+  function fullReload() {
+    server.moduleGraph.invalidateAll();
+    server.hot.send({
+      type: "full-reload",
+      path: "*"
+    });
+  }
+  async function rerun() {
+    const deps = Object.keys(metadata.discovered);
+    const depsString = depsLogString(deps);
+    debug$8?.(colors$1.green(`new dependencies found: ${depsString}`));
+    runOptimizer();
+  }
+  function getDiscoveredBrowserHash(hash, deps, missing) {
+    return getHash(
+      hash + JSON.stringify(deps) + JSON.stringify(missing) + sessionTimestamp
+    );
+  }
+  function registerMissingImport(id, resolved) {
+    const optimized = metadata.optimized[id];
+    if (optimized) {
+      return optimized;
+    }
+    const chunk = metadata.chunks[id];
+    if (chunk) {
+      return chunk;
+    }
+    let missing = metadata.discovered[id];
+    if (missing) {
+      return missing;
+    }
+    missing = addMissingDep(id, resolved);
+    if (!waitingForCrawlEnd) {
+      debouncedProcessing();
+    }
+    return missing;
+  }
+  function addMissingDep(id, resolved) {
+    newDepsDiscovered = true;
+    return addOptimizedDepInfo(metadata, "discovered", {
+      id,
+      file: getOptimizedDepPath(id, config, ssr),
+      src: resolved,
+      // Adding a browserHash to this missing dependency that is unique to
+      // the current state of known + missing deps. If its optimizeDeps run
+      // doesn't alter the bundled files of previous known dependencies,
+      // we don't need a full reload and this browserHash will be kept
+      browserHash: getDiscoveredBrowserHash(
+        metadata.hash,
+        depsFromOptimizedDepInfo(metadata.optimized),
+        depsFromOptimizedDepInfo(metadata.discovered)
+      ),
+      // loading of this pre-bundled dep needs to await for its processing
+      // promise to be resolved
+      processing: depOptimizationProcessing.promise,
+      exportsData: extractExportsData(resolved, config, ssr)
+    });
+  }
+  function debouncedProcessing(timeout = debounceMs) {
+    enqueuedRerun = void 0;
+    if (debounceProcessingHandle) clearTimeout(debounceProcessingHandle);
+    if (newDepsToLogHandle) clearTimeout(newDepsToLogHandle);
+    newDepsToLogHandle = void 0;
+    debounceProcessingHandle = setTimeout(() => {
+      debounceProcessingHandle = void 0;
+      enqueuedRerun = rerun;
+      if (!currentlyProcessing) {
+        enqueuedRerun();
+      }
+    }, timeout);
+  }
+  async function onCrawlEnd() {
+    waitingForCrawlEnd = false;
+    debug$8?.(colors$1.green(`\u2728 static imports crawl ended`));
+    if (closed) {
+      return;
+    }
+    await depsOptimizer.scanProcessing;
+    if (optimizationResult && !config.optimizeDeps.noDiscovery) {
+      const afterScanResult = optimizationResult.result;
+      optimizationResult = void 0;
+      const result = await afterScanResult;
+      currentlyProcessing = false;
+      const crawlDeps = Object.keys(metadata.discovered);
+      const scanDeps = Object.keys(result.metadata.optimized);
+      if (scanDeps.length === 0 && crawlDeps.length === 0) {
+        debug$8?.(
+          colors$1.green(
+            `\u2728 no dependencies found by the scanner or crawling static imports`
+          )
+        );
+        startNextDiscoveredBatch();
+        runOptimizer(result);
+        return;
+      }
+      const needsInteropMismatch = findInteropMismatches(
+        metadata.discovered,
+        result.metadata.optimized
+      );
+      const scannerMissedDeps = crawlDeps.some((dep) => !scanDeps.includes(dep));
+      const outdatedResult = needsInteropMismatch.length > 0 || scannerMissedDeps;
+      if (outdatedResult) {
+        result.cancel();
+        for (const dep of scanDeps) {
+          if (!crawlDeps.includes(dep)) {
+            addMissingDep(dep, result.metadata.optimized[dep].src);
+          }
+        }
+        if (scannerMissedDeps) {
+          debug$8?.(
+            colors$1.yellow(
+              `\u2728 new dependencies were found while crawling that weren't detected by the scanner`
+            )
+          );
+        }
+        debug$8?.(colors$1.green(`\u2728 re-running optimizer`));
+        debouncedProcessing(0);
+      } else {
+        debug$8?.(
+          colors$1.green(
+            `\u2728 using post-scan optimizer result, the scanner found every used dependency`
+          )
+        );
+        startNextDiscoveredBatch();
+        runOptimizer(result);
+      }
+    } else if (!holdUntilCrawlEnd) {
+      if (newDepsDiscovered) {
+        debug$8?.(
+          colors$1.green(
+            `\u2728 new dependencies were found while crawling static imports, re-running optimizer`
+          )
+        );
+        warnAboutMissedDependencies = true;
+        debouncedProcessing(0);
+      }
+    } else {
+      const crawlDeps = Object.keys(metadata.discovered);
+      currentlyProcessing = false;
+      if (crawlDeps.length === 0) {
+        debug$8?.(
+          colors$1.green(
+            `\u2728 no dependencies found while crawling the static imports`
+          )
+        );
+        firstRunCalled = true;
+      }
+      debouncedProcessing(0);
+    }
+  }
+}
+async function createDevSsrDepsOptimizer(config) {
+  const metadata = await optimizeServerSsrDeps(config);
+  const depsOptimizer = {
+    metadata,
+    isOptimizedDepFile: createIsOptimizedDepFile(config),
+    isOptimizedDepUrl: createIsOptimizedDepUrl(config),
+    getOptimizedDepId: (depInfo) => `${depInfo.file}?v=${depInfo.browserHash}`,
+    registerMissingImport: () => {
+      throw new Error(
+        "Vite Internal Error: registerMissingImport is not supported in dev SSR"
+      );
+    },
+    // noop, there is no scanning during dev SSR
+    // the optimizer blocks the server start
+    run: () => {
+    },
+    close: async () => {
+    },
+    options: config.ssr.optimizeDeps
+  };
+  devSsrDepsOptimizerMap.set(config, depsOptimizer);
+}
+function findInteropMismatches(discovered, optimized) {
+  const needsInteropMismatch = [];
+  for (const dep in discovered) {
+    const discoveredDepInfo = discovered[dep];
+    if (discoveredDepInfo.needsInterop === void 0) continue;
+    const depInfo = optimized[dep];
+    if (!depInfo) continue;
+    if (depInfo.needsInterop !== discoveredDepInfo.needsInterop) {
+      needsInteropMismatch.push(dep);
+      debug$8?.(colors$1.cyan(`\u2728 needsInterop mismatch detected for ${dep}`));
+    }
+  }
+  return needsInteropMismatch;
+}
+
+const debug$7 = createDebugger("vite:deps");
+const jsExtensionRE = /\.js$/i;
+const jsMapExtensionRE = /\.js\.map$/i;
+async function optimizeDeps(config, force = config.optimizeDeps.force, asCommand = false) {
+  const log = asCommand ? config.logger.info : debug$7;
+  const ssr = false;
+  const cachedMetadata = await loadCachedDepOptimizationMetadata(
+    config,
+    ssr,
+    force,
+    asCommand
+  );
+  if (cachedMetadata) {
+    return cachedMetadata;
+  }
+  const deps = await discoverProjectDependencies(config).result;
+  await addManuallyIncludedOptimizeDeps(deps, config, ssr);
+  const depsString = depsLogString(Object.keys(deps));
+  log?.(colors$1.green(`Optimizing dependencies:
+  ${depsString}`));
+  const depsInfo = toDiscoveredDependencies(config, deps, ssr);
+  const result = await runOptimizeDeps(config, depsInfo, ssr).result;
+  await result.commit();
+  return result.metadata;
+}
+async function optimizeServerSsrDeps(config) {
+  const ssr = true;
+  const cachedMetadata = await loadCachedDepOptimizationMetadata(
+    config,
+    ssr,
+    config.optimizeDeps.force,
+    false
+  );
+  if (cachedMetadata) {
+    return cachedMetadata;
+  }
+  const deps = {};
+  await addManuallyIncludedOptimizeDeps(deps, config, ssr);
+  const depsInfo = toDiscoveredDependencies(config, deps, ssr);
+  const result = await runOptimizeDeps(config, depsInfo, ssr).result;
+  await result.commit();
+  return result.metadata;
+}
+function initDepsOptimizerMetadata(config, ssr, timestamp) {
+  const { lockfileHash, configHash, hash } = getDepHash(config, ssr);
+  return {
+    hash,
+    lockfileHash,
+    configHash,
+    browserHash: getOptimizedBrowserHash(hash, {}, timestamp),
+    optimized: {},
+    chunks: {},
+    discovered: {},
+    depInfoList: []
+  };
+}
+function addOptimizedDepInfo(metadata, type, depInfo) {
+  metadata[type][depInfo.id] = depInfo;
+  metadata.depInfoList.push(depInfo);
+  return depInfo;
+}
+let firstLoadCachedDepOptimizationMetadata = true;
+async function loadCachedDepOptimizationMetadata(config, ssr, force = config.optimizeDeps.force, asCommand = false) {
+  const log = asCommand ? config.logger.info : debug$7;
+  if (firstLoadCachedDepOptimizationMetadata) {
+    firstLoadCachedDepOptimizationMetadata = false;
+    setTimeout(() => cleanupDepsCacheStaleDirs(config), 0);
+  }
+  const depsCacheDir = getDepsCacheDir(config, ssr);
+  if (!force) {
+    let cachedMetadata;
+    try {
+      const cachedMetadataPath = path$n.join(depsCacheDir, METADATA_FILENAME);
+      cachedMetadata = parseDepsOptimizerMetadata(
+        await fsp.readFile(cachedMetadataPath, "utf-8"),
+        depsCacheDir
+      );
+    } catch (e) {
+    }
+    if (cachedMetadata) {
+      if (cachedMetadata.lockfileHash !== getLockfileHash(config)) {
+        config.logger.info(
+          "Re-optimizing dependencies because lockfile has changed"
+        );
+      } else if (cachedMetadata.configHash !== getConfigHash(config, ssr)) {
+        config.logger.info(
+          "Re-optimizing dependencies because vite config has changed"
+        );
+      } else {
+        log?.("Hash is consistent. Skipping. Use --force to override.");
+        return cachedMetadata;
+      }
+    }
+  } else {
+    config.logger.info("Forced re-optimization of dependencies");
+  }
+  debug$7?.(colors$1.green(`removing old cache dir ${depsCacheDir}`));
+  await fsp.rm(depsCacheDir, { recursive: true, force: true });
+}
+function discoverProjectDependencies(config) {
+  const { cancel, result } = scanImports(config);
+  return {
+    cancel,
+    result: result.then(({ deps, missing }) => {
+      const missingIds = Object.keys(missing);
+      if (missingIds.length) {
+        throw new Error(
+          `The following dependencies are imported but could not be resolved:
+
+  ${missingIds.map(
+            (id) => `${colors$1.cyan(id)} ${colors$1.white(
+              colors$1.dim(`(imported by ${missing[id]})`)
+            )}`
+          ).join(`
+  `)}
+
+Are they installed?`
+        );
+      }
+      return deps;
+    })
+  };
+}
+function toDiscoveredDependencies(config, deps, ssr, timestamp) {
+  const browserHash = getOptimizedBrowserHash(
+    getDepHash(config, ssr).hash,
+    deps,
+    timestamp
+  );
+  const discovered = {};
+  for (const id in deps) {
+    const src = deps[id];
+    discovered[id] = {
+      id,
+      file: getOptimizedDepPath(id, config, ssr),
+      src,
+      browserHash,
+      exportsData: extractExportsData(src, config, ssr)
+    };
+  }
+  return discovered;
+}
+function depsLogString(qualifiedIds) {
+  return colors$1.yellow(qualifiedIds.join(`, `));
+}
+function runOptimizeDeps(resolvedConfig, depsInfo, ssr) {
+  const optimizerContext = { cancelled: false };
+  const config = {
+    ...resolvedConfig,
+    command: "build"
+  };
+  const depsCacheDir = getDepsCacheDir(resolvedConfig, ssr);
+  const processingCacheDir = getProcessingDepsCacheDir(resolvedConfig, ssr);
+  fs__default.mkdirSync(processingCacheDir, { recursive: true });
+  debug$7?.(colors$1.green(`creating package.json in ${processingCacheDir}`));
+  fs__default.writeFileSync(
+    path$n.resolve(processingCacheDir, "package.json"),
+    `{
+  "type": "module"
+}
+`
+  );
+  const metadata = initDepsOptimizerMetadata(config, ssr);
+  metadata.browserHash = getOptimizedBrowserHash(
+    metadata.hash,
+    depsFromOptimizedDepInfo(depsInfo)
+  );
+  const qualifiedIds = Object.keys(depsInfo);
+  let cleaned = false;
+  let committed = false;
+  const cleanUp = () => {
+    if (!cleaned && !committed) {
+      cleaned = true;
+      debug$7?.(colors$1.green(`removing cache dir ${processingCacheDir}`));
+      try {
+        fs__default.rmSync(processingCacheDir, { recursive: true, force: true });
+      } catch (error) {
+      }
+    }
+  };
+  const successfulResult = {
+    metadata,
+    cancel: cleanUp,
+    commit: async () => {
+      if (cleaned) {
+        throw new Error(
+          "Can not commit a Deps Optimization run as it was cancelled"
+        );
+      }
+      committed = true;
+      const dataPath = path$n.join(processingCacheDir, METADATA_FILENAME);
+      debug$7?.(
+        colors$1.green(`creating ${METADATA_FILENAME} in ${processingCacheDir}`)
+      );
+      fs__default.writeFileSync(
+        dataPath,
+        stringifyDepsOptimizerMetadata(metadata, depsCacheDir)
+      );
+      const temporaryPath = depsCacheDir + getTempSuffix();
+      const depsCacheDirPresent = fs__default.existsSync(depsCacheDir);
+      if (isWindows$3) {
+        if (depsCacheDirPresent) {
+          debug$7?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+          await safeRename(depsCacheDir, temporaryPath);
+        }
+        debug$7?.(
+          colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`)
+        );
+        await safeRename(processingCacheDir, depsCacheDir);
+      } else {
+        if (depsCacheDirPresent) {
+          debug$7?.(colors$1.green(`renaming ${depsCacheDir} to ${temporaryPath}`));
+          fs__default.renameSync(depsCacheDir, temporaryPath);
+        }
+        debug$7?.(
+          colors$1.green(`renaming ${processingCacheDir} to ${depsCacheDir}`)
+        );
+        fs__default.renameSync(processingCacheDir, depsCacheDir);
+      }
+      if (depsCacheDirPresent) {
+        debug$7?.(colors$1.green(`removing cache temp dir ${temporaryPath}`));
+        fsp.rm(temporaryPath, { recursive: true, force: true });
+      }
+    }
+  };
+  if (!qualifiedIds.length) {
+    return {
+      cancel: async () => cleanUp(),
+      result: Promise.resolve(successfulResult)
+    };
+  }
+  const cancelledResult = {
+    metadata,
+    commit: async () => cleanUp(),
+    cancel: cleanUp
+  };
+  const start = performance$1.now();
+  const preparedRun = prepareEsbuildOptimizerRun(
+    resolvedConfig,
+    depsInfo,
+    ssr,
+    processingCacheDir,
+    optimizerContext
+  );
+  const runResult = preparedRun.then(({ context, idToExports }) => {
+    function disposeContext() {
+      return context?.dispose().catch((e) => {
+        config.logger.error("Failed to dispose esbuild context", { error: e });
+      });
+    }
+    if (!context || optimizerContext.cancelled) {
+      disposeContext();
+      return cancelledResult;
+    }
+    return context.rebuild().then((result) => {
+      const meta = result.metafile;
+      const processingCacheDirOutputPath = path$n.relative(
+        process.cwd(),
+        processingCacheDir
+      );
+      for (const id in depsInfo) {
+        const output = esbuildOutputFromId(
+          meta.outputs,
+          id,
+          processingCacheDir
+        );
+        const { exportsData, ...info } = depsInfo[id];
+        addOptimizedDepInfo(metadata, "optimized", {
+          ...info,
+          // We only need to hash the output.imports in to check for stability, but adding the hash
+          // and file path gives us a unique hash that may be useful for other things in the future
+          fileHash: getHash(
+            metadata.hash + depsInfo[id].file + JSON.stringify(output.imports)
+          ),
+          browserHash: metadata.browserHash,
+          // After bundling we have more information and can warn the user about legacy packages
+          // that require manual configuration
+          needsInterop: needsInterop(
+            config,
+            ssr,
+            id,
+            idToExports[id],
+            output
+          )
+        });
+      }
+      for (const o of Object.keys(meta.outputs)) {
+        if (!jsMapExtensionRE.test(o)) {
+          const id = path$n.relative(processingCacheDirOutputPath, o).replace(jsExtensionRE, "");
+          const file = getOptimizedDepPath(id, resolvedConfig, ssr);
+          if (!findOptimizedDepInfoInRecord(
+            metadata.optimized,
+            (depInfo) => depInfo.file === file
+          )) {
+            addOptimizedDepInfo(metadata, "chunks", {
+              id,
+              file,
+              needsInterop: false,
+              browserHash: metadata.browserHash
+            });
+          }
+        }
+      }
+      debug$7?.(
+        `Dependencies bundled in ${(performance$1.now() - start).toFixed(2)}ms`
+      );
+      return successfulResult;
+    }).catch((e) => {
+      if (e.errors && e.message.includes("The build was canceled")) {
+        return cancelledResult;
+      }
+      throw e;
+    }).finally(() => {
+      return disposeContext();
+    });
+  });
+  runResult.catch(() => {
+    cleanUp();
+  });
+  return {
+    async cancel() {
+      optimizerContext.cancelled = true;
+      const { context } = await preparedRun;
+      await context?.cancel();
+      cleanUp();
+    },
+    result: runResult
+  };
+}
+async function prepareEsbuildOptimizerRun(resolvedConfig, depsInfo, ssr, processingCacheDir, optimizerContext) {
+  const config = {
+    ...resolvedConfig,
+    command: "build"
+  };
+  const flatIdDeps = {};
+  const idToExports = {};
+  const optimizeDeps2 = getDepOptimizationConfig(config, ssr);
+  const { plugins: pluginsFromConfig = [], ...esbuildOptions } = optimizeDeps2?.esbuildOptions ?? {};
+  await Promise.all(
+    Object.keys(depsInfo).map(async (id) => {
+      const src = depsInfo[id].src;
+      const exportsData = await (depsInfo[id].exportsData ?? extractExportsData(src, config, ssr));
+      if (exportsData.jsxLoader && !esbuildOptions.loader?.[".js"]) {
+        esbuildOptions.loader = {
+          ".js": "jsx",
+          ...esbuildOptions.loader
+        };
+      }
+      const flatId = flattenId(id);
+      flatIdDeps[flatId] = src;
+      idToExports[id] = exportsData;
+    })
+  );
+  if (optimizerContext.cancelled) return { context: void 0, idToExports };
+  const define = {
+    "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || config.mode)
+  };
+  const platform = ssr && config.ssr?.target !== "webworker" ? "node" : "browser";
+  const external = [...optimizeDeps2?.exclude ?? []];
+  const plugins = [...pluginsFromConfig];
+  if (external.length) {
+    plugins.push(esbuildCjsExternalPlugin(external, platform));
+  }
+  plugins.push(esbuildDepPlugin(flatIdDeps, external, config, ssr));
+  const context = await esbuild.context({
+    absWorkingDir: process.cwd(),
+    entryPoints: Object.keys(flatIdDeps),
+    bundle: true,
+    // We can't use platform 'neutral', as esbuild has custom handling
+    // when the platform is 'node' or 'browser' that can't be emulated
+    // by using mainFields and conditions
+    platform,
+    define,
+    format: "esm",
+    // See https://github.com/evanw/esbuild/issues/1921#issuecomment-1152991694
+    banner: platform === "node" ? {
+      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+    } : void 0,
+    target: ESBUILD_MODULES_TARGET,
+    external,
+    logLevel: "error",
+    splitting: true,
+    sourcemap: true,
+    outdir: processingCacheDir,
+    ignoreAnnotations: true,
+    metafile: true,
+    plugins,
+    charset: "utf8",
+    ...esbuildOptions,
+    supported: {
+      ...defaultEsbuildSupported,
+      ...esbuildOptions.supported
+    }
+  });
+  return { context, idToExports };
+}
+async function addManuallyIncludedOptimizeDeps(deps, config, ssr) {
+  const { logger } = config;
+  const optimizeDeps2 = getDepOptimizationConfig(config, ssr);
+  const optimizeDepsInclude = optimizeDeps2?.include ?? [];
+  if (optimizeDepsInclude.length) {
+    const unableToOptimize = (id, msg) => {
+      if (optimizeDepsInclude.includes(id)) {
+        logger.warn(
+          `${msg}: ${colors$1.cyan(id)}, present in '${ssr ? "ssr." : ""}optimizeDeps.include'`
+        );
+      }
+    };
+    const includes = [...optimizeDepsInclude];
+    for (let i = 0; i < includes.length; i++) {
+      const id = includes[i];
+      if (glob.isDynamicPattern(id)) {
+        const globIds = expandGlobIds(id, config);
+        includes.splice(i, 1, ...globIds);
+        i += globIds.length - 1;
+      }
+    }
+    const resolve = createOptimizeDepsIncludeResolver(config, ssr);
+    for (const id of includes) {
+      const normalizedId = normalizeId(id);
+      if (!deps[normalizedId]) {
+        const entry = await resolve(id);
+        if (entry) {
+          if (isOptimizable(entry, optimizeDeps2)) {
+            if (!entry.endsWith("?__vite_skip_optimization")) {
+              deps[normalizedId] = entry;
+            }
+          } else {
+            unableToOptimize(id, "Cannot optimize dependency");
+          }
+        } else {
+          unableToOptimize(id, "Failed to resolve dependency");
+        }
+      }
+    }
+  }
+}
+function depsFromOptimizedDepInfo(depsInfo) {
+  const obj = {};
+  for (const key in depsInfo) {
+    obj[key] = depsInfo[key].src;
+  }
+  return obj;
+}
+function getOptimizedDepPath(id, config, ssr) {
+  return normalizePath$3(
+    path$n.resolve(getDepsCacheDir(config, ssr), flattenId(id) + ".js")
+  );
+}
+function getDepsCacheSuffix(ssr) {
+  return ssr ? "_ssr" : "";
+}
+function getDepsCacheDir(config, ssr) {
+  return getDepsCacheDirPrefix(config) + getDepsCacheSuffix(ssr);
+}
+function getProcessingDepsCacheDir(config, ssr) {
+  return getDepsCacheDirPrefix(config) + getDepsCacheSuffix(ssr) + getTempSuffix();
+}
+function getTempSuffix() {
+  return "_temp_" + getHash(
+    `${process.pid}:${Date.now().toString()}:${Math.random().toString(16).slice(2)}`
+  );
+}
+function getDepsCacheDirPrefix(config) {
+  return normalizePath$3(path$n.resolve(config.cacheDir, "deps"));
+}
+function createIsOptimizedDepFile(config) {
+  const depsCacheDirPrefix = getDepsCacheDirPrefix(config);
+  return (id) => id.startsWith(depsCacheDirPrefix);
+}
+function createIsOptimizedDepUrl(config) {
+  const { root } = config;
+  const depsCacheDir = getDepsCacheDirPrefix(config);
+  const depsCacheDirRelative = normalizePath$3(path$n.relative(root, depsCacheDir));
+  const depsCacheDirPrefix = depsCacheDirRelative.startsWith("../") ? (
+    // if the cache directory is outside root, the url prefix would be something
+    // like '/@fs/absolute/path/to/node_modules/.vite'
+    `/@fs/${removeLeadingSlash(normalizePath$3(depsCacheDir))}`
+  ) : (
+    // if the cache directory is inside root, the url prefix would be something
+    // like '/node_modules/.vite'
+    `/${depsCacheDirRelative}`
+  );
+  return function isOptimizedDepUrl(url) {
+    return url.startsWith(depsCacheDirPrefix);
+  };
+}
+function parseDepsOptimizerMetadata(jsonMetadata, depsCacheDir) {
+  const { hash, lockfileHash, configHash, browserHash, optimized, chunks } = JSON.parse(jsonMetadata, (key, value) => {
+    if (key === "file" || key === "src") {
+      return normalizePath$3(path$n.resolve(depsCacheDir, value));
+    }
+    return value;
+  });
+  if (!chunks || Object.values(optimized).some((depInfo) => !depInfo.fileHash)) {
+    return;
+  }
+  const metadata = {
+    hash,
+    lockfileHash,
+    configHash,
+    browserHash,
+    optimized: {},
+    discovered: {},
+    chunks: {},
+    depInfoList: []
+  };
+  for (const id of Object.keys(optimized)) {
+    addOptimizedDepInfo(metadata, "optimized", {
+      ...optimized[id],
+      id,
+      browserHash
+    });
+  }
+  for (const id of Object.keys(chunks)) {
+    addOptimizedDepInfo(metadata, "chunks", {
+      ...chunks[id],
+      id,
+      browserHash,
+      needsInterop: false
+    });
+  }
+  return metadata;
+}
+function stringifyDepsOptimizerMetadata(metadata, depsCacheDir) {
+  const { hash, configHash, lockfileHash, browserHash, optimized, chunks } = metadata;
+  return JSON.stringify(
+    {
+      hash,
+      configHash,
+      lockfileHash,
+      browserHash,
+      optimized: Object.fromEntries(
+        Object.values(optimized).map(
+          ({ id, src, file, fileHash, needsInterop: needsInterop2 }) => [
+            id,
+            {
+              src,
+              file,
+              fileHash,
+              needsInterop: needsInterop2
+            }
+          ]
+        )
+      ),
+      chunks: Object.fromEntries(
+        Object.values(chunks).map(({ id, file }) => [id, { file }])
+      )
+    },
+    (key, value) => {
+      if (key === "file" || key === "src") {
+        return normalizePath$3(path$n.relative(depsCacheDir, value));
+      }
+      return value;
+    },
+    2
+  );
+}
+function esbuildOutputFromId(outputs, id, cacheDirOutputPath) {
+  const cwd = process.cwd();
+  const flatId = flattenId(id) + ".js";
+  const normalizedOutputPath = normalizePath$3(
+    path$n.relative(cwd, path$n.join(cacheDirOutputPath, flatId))
+  );
+  const output = outputs[normalizedOutputPath];
+  if (output) {
+    return output;
+  }
+  for (const [key, value] of Object.entries(outputs)) {
+    if (normalizePath$3(path$n.relative(cwd, key)) === normalizedOutputPath) {
+      return value;
+    }
+  }
+}
+async function extractExportsData(filePath, config, ssr) {
+  await init;
+  const optimizeDeps2 = getDepOptimizationConfig(config, ssr);
+  const esbuildOptions = optimizeDeps2?.esbuildOptions ?? {};
+  if (optimizeDeps2.extensions?.some((ext) => filePath.endsWith(ext))) {
+    const result = await build$3({
+      ...esbuildOptions,
+      entryPoints: [filePath],
+      write: false,
+      format: "esm"
+    });
+    const [, exports2, , hasModuleSyntax2] = parse$d(result.outputFiles[0].text);
+    return {
+      hasModuleSyntax: hasModuleSyntax2,
+      exports: exports2.map((e) => e.n)
+    };
+  }
+  let parseResult;
+  let usedJsxLoader = false;
+  const entryContent = await fsp.readFile(filePath, "utf-8");
+  try {
+    parseResult = parse$d(entryContent);
+  } catch {
+    const loader = esbuildOptions.loader?.[path$n.extname(filePath)] || "jsx";
+    debug$7?.(
+      `Unable to parse: ${filePath}.
+ Trying again with a ${loader} transform.`
+    );
+    const transformed = await transformWithEsbuild(entryContent, filePath, {
+      loader
+    });
+    parseResult = parse$d(transformed.code);
+    usedJsxLoader = true;
+  }
+  const [, exports, , hasModuleSyntax] = parseResult;
+  const exportsData = {
+    hasModuleSyntax,
+    exports: exports.map((e) => e.n),
+    jsxLoader: usedJsxLoader
+  };
+  return exportsData;
+}
+function needsInterop(config, ssr, id, exportsData, output) {
+  if (getDepOptimizationConfig(config, ssr)?.needsInterop?.includes(id)) {
+    return true;
+  }
+  const { hasModuleSyntax, exports } = exportsData;
+  if (!hasModuleSyntax) {
+    return true;
+  }
+  if (output) {
+    const generatedExports = output.exports;
+    if (!generatedExports || isSingleDefaultExport(generatedExports) && !isSingleDefaultExport(exports)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSingleDefaultExport(exports) {
+  return exports.length === 1 && exports[0] === "default";
+}
+const lockfileFormats = [
+  { name: "package-lock.json", checkPatches: true, manager: "npm" },
+  { name: "yarn.lock", checkPatches: true, manager: "yarn" },
+  // Included in lockfile for v2+
+  { name: "pnpm-lock.yaml", checkPatches: false, manager: "pnpm" },
+  // Included in lockfile
+  { name: "bun.lockb", checkPatches: true, manager: "bun" }
+].sort((_, { manager }) => {
+  return process.env.npm_config_user_agent?.startsWith(manager) ? 1 : -1;
+});
+const lockfileNames = lockfileFormats.map((l) => l.name);
+function getConfigHash(config, ssr) {
+  const optimizeDeps2 = getDepOptimizationConfig(config, ssr);
+  const content = JSON.stringify(
+    {
+      mode: process.env.NODE_ENV || config.mode,
+      root: config.root,
+      resolve: config.resolve,
+      assetsInclude: config.assetsInclude,
+      plugins: config.plugins.map((p) => p.name),
+      optimizeDeps: {
+        include: optimizeDeps2?.include ? unique(optimizeDeps2.include).sort() : void 0,
+        exclude: optimizeDeps2?.exclude ? unique(optimizeDeps2.exclude).sort() : void 0,
+        esbuildOptions: {
+          ...optimizeDeps2?.esbuildOptions,
+          plugins: optimizeDeps2?.esbuildOptions?.plugins?.map((p) => p.name)
+        }
+      }
+    },
+    (_, value) => {
+      if (typeof value === "function" || value instanceof RegExp) {
+        return value.toString();
+      }
+      return value;
+    }
+  );
+  return getHash(content);
+}
+function getLockfileHash(config, ssr) {
+  const lockfilePath = lookupFile(config.root, lockfileNames);
+  let content = lockfilePath ? fs__default.readFileSync(lockfilePath, "utf-8") : "";
+  if (lockfilePath) {
+    const lockfileName = path$n.basename(lockfilePath);
+    const { checkPatches } = lockfileFormats.find(
+      (f) => f.name === lockfileName
+    );
+    if (checkPatches) {
+      const fullPath = path$n.join(path$n.dirname(lockfilePath), "patches");
+      const stat = tryStatSync(fullPath);
+      if (stat?.isDirectory()) {
+        content += stat.mtimeMs.toString();
+      }
+    }
+  }
+  return getHash(content);
+}
+function getDepHash(config, ssr) {
+  const lockfileHash = getLockfileHash(config);
+  const configHash = getConfigHash(config, ssr);
+  const hash = getHash(lockfileHash + configHash);
+  return {
+    hash,
+    lockfileHash,
+    configHash
+  };
+}
+function getOptimizedBrowserHash(hash, deps, timestamp = "") {
+  return getHash(hash + JSON.stringify(deps) + timestamp);
+}
+function optimizedDepInfoFromId(metadata, id) {
+  return metadata.optimized[id] || metadata.discovered[id] || metadata.chunks[id];
+}
+function optimizedDepInfoFromFile(metadata, file) {
+  return metadata.depInfoList.find((depInfo) => depInfo.file === file);
+}
+function findOptimizedDepInfoInRecord(dependenciesInfo, callbackFn) {
+  for (const o of Object.keys(dependenciesInfo)) {
+    const info = dependenciesInfo[o];
+    if (callbackFn(info, o)) {
+      return info;
+    }
+  }
+}
+async function optimizedDepNeedsInterop(metadata, file, config, ssr) {
+  const depInfo = optimizedDepInfoFromFile(metadata, file);
+  if (depInfo?.src && depInfo.needsInterop === void 0) {
+    depInfo.exportsData ??= extractExportsData(depInfo.src, config, ssr);
+    depInfo.needsInterop = needsInterop(
+      config,
+      ssr,
+      depInfo.id,
+      await depInfo.exportsData
+    );
+  }
+  return depInfo?.needsInterop;
+}
+const MAX_TEMP_DIR_AGE_MS = 24 * 60 * 60 * 1e3;
+async function cleanupDepsCacheStaleDirs(config) {
+  try {
+    const cacheDir = path$n.resolve(config.cacheDir);
+    if (fs__default.existsSync(cacheDir)) {
+      const dirents = await fsp.readdir(cacheDir, { withFileTypes: true });
+      for (const dirent of dirents) {
+        if (dirent.isDirectory() && dirent.name.includes("_temp_")) {
+          const tempDirPath = path$n.resolve(config.cacheDir, dirent.name);
+          const stats = await fsp.stat(tempDirPath).catch((_) => null);
+          if (stats?.mtime && Date.now() - stats.mtime.getTime() > MAX_TEMP_DIR_AGE_MS) {
+            debug$7?.(`removing stale cache temp dir ${tempDirPath}`);
+            await fsp.rm(tempDirPath, { recursive: true, force: true });
+          }
+        }
+      }
+    }
+  } catch (err) {
+    config.logger.error(err);
+  }
+}
+const GRACEFUL_RENAME_TIMEOUT = 5e3;
+const safeRename = promisify$4(function gracefulRename(from, to, cb) {
+  const start = Date.now();
+  let backoff = 0;
+  fs__default.rename(from, to, function CB(er) {
+    if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < GRACEFUL_RENAME_TIMEOUT) {
+      setTimeout(function() {
+        fs__default.stat(to, function(stater, st) {
+          if (stater && stater.code === "ENOENT") fs__default.rename(from, to, CB);
+          else CB(er);
+        });
+      }, backoff);
+      if (backoff < 100) backoff += 10;
+      return;
+    }
+    if (cb) cb(er);
+  });
+});
+
+var index$1 = {
+	__proto__: null,
+	addManuallyIncludedOptimizeDeps: addManuallyIncludedOptimizeDeps,
+	addOptimizedDepInfo: addOptimizedDepInfo,
+	cleanupDepsCacheStaleDirs: cleanupDepsCacheStaleDirs,
+	createIsOptimizedDepFile: createIsOptimizedDepFile,
+	createIsOptimizedDepUrl: createIsOptimizedDepUrl,
+	depsFromOptimizedDepInfo: depsFromOptimizedDepInfo,
+	depsLogString: depsLogString,
+	discoverProjectDependencies: discoverProjectDependencies,
+	extractExportsData: extractExportsData,
+	getDepsCacheDir: getDepsCacheDir,
+	getDepsOptimizer: getDepsOptimizer,
+	getOptimizedDepPath: getOptimizedDepPath,
+	initDepsOptimizer: initDepsOptimizer,
+	initDepsOptimizerMetadata: initDepsOptimizerMetadata,
+	initDevSsrDepsOptimizer: initDevSsrDepsOptimizer,
+	loadCachedDepOptimizationMetadata: loadCachedDepOptimizationMetadata,
+	optimizeDeps: optimizeDeps,
+	optimizeServerSsrDeps: optimizeServerSsrDeps,
+	optimizedDepInfoFromFile: optimizedDepInfoFromFile,
+	optimizedDepInfoFromId: optimizedDepInfoFromId,
+	optimizedDepNeedsInterop: optimizedDepNeedsInterop,
+	runOptimizeDeps: runOptimizeDeps,
+	toDiscoveredDependencies: toDiscoveredDependencies
+};
+
+function totalist(dir, callback, pre='') {
+	dir = resolve$3('.', dir);
+	let arr = readdirSync(dir);
+	let i=0, abs, stats;
+	for (; i < arr.length; i++) {
+		abs = join$1(dir, arr[i]);
+		stats = statSync$1(abs);
+		stats.isDirectory()
+			? totalist(abs, callback, join$1(pre, arr[i]))
+			: callback(join$1(pre, arr[i]), abs, stats);
+	}
+}
+
+/**
+ * @typedef ParsedURL
+ * @type {import('.').ParsedURL}
+ */
+
+/**
+ * @typedef Request
+ * @property {string} url
+ * @property {ParsedURL} _parsedUrl
+ */
+
+/**
+ * @param {Request} req
+ * @returns {ParsedURL|void}
+ */
+function parse$5(req) {
+	let raw = req.url;
+	if (raw == null) return;
+
+	let prev = req._parsedUrl;
+	if (prev && prev.raw === raw) return prev;
+
+	let pathname=raw, search='', query;
+
+	if (raw.length > 1) {
+		let idx = raw.indexOf('?', 1);
+
+		if (idx !== -1) {
+			search = raw.substring(idx);
+			pathname = raw.substring(0, idx);
+			if (search.length > 1) {
+				query = qs.parse(search.substring(1));
+			}
+		}
+	}
+
+	return req._parsedUrl = { pathname, search, query, raw };
+}
+
+const noop$2 = () => {};
+
+function isMatch(uri, arr) {
+	for (let i=0; i < arr.length; i++) {
+		if (arr[i].test(uri)) return true;
+	}
+}
+
+function toAssume(uri, extns) {
+	let i=0, x, len=uri.length - 1;
+	if (uri.charCodeAt(len) === 47) {
+		uri = uri.substring(0, len);
+	}
+
+	let arr=[], tmp=`${uri}/index`;
+	for (; i < extns.length; i++) {
+		x = extns[i] ? `.${extns[i]}` : '';
+		if (uri) arr.push(uri + x);
+		arr.push(tmp + x);
+	}
+
+	return arr;
+}
+
+function viaCache(cache, uri, extns) {
+	let i=0, data, arr=toAssume(uri, extns);
+	for (; i < arr.length; i++) {
+		if (data = cache[arr[i]]) return data;
+	}
+}
+
+function viaLocal(dir, isEtag, uri, extns, shouldServe) {
+	let i=0, arr=toAssume(uri, extns);
+	let abs, stats, name, headers;
+	for (; i < arr.length; i++) {
+		abs = normalize$1(join$1(dir, name=arr[i]));
+		if (abs.startsWith(dir) && require$$0$2.existsSync(abs)) {
+			stats = require$$0$2.statSync(abs);
+			if (stats.isDirectory()) continue;
+			if (shouldServe && !shouldServe(abs)) continue;
+			headers = toHeaders(name, stats, isEtag);
+			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
+			return { abs, stats, headers };
+		}
+	}
+}
+
+function is404(req, res) {
+	return (res.statusCode=404,res.end());
+}
+
+function send$1(req, res, file, stats, headers) {
+	let code=200, tmp, opts={};
+	headers = { ...headers };
+
+	for (let key in headers) {
+		tmp = res.getHeader(key);
+		if (tmp) headers[key] = tmp;
+	}
+
+	if (tmp = res.getHeader('content-type')) {
+		headers['Content-Type'] = tmp;
+	}
+
+	if (req.headers.range) {
+		code = 206;
+		let [x, y] = req.headers.range.replace('bytes=', '').split('-');
+		let end = opts.end = parseInt(y, 10) || stats.size - 1;
+		let start = opts.start = parseInt(x, 10) || 0;
+
+		if (end >= stats.size) {
+			end = stats.size - 1;
+		}
+
+		if (start >= stats.size) {
+			res.setHeader('Content-Range', `bytes */${stats.size}`);
+			res.statusCode = 416;
+			return res.end();
+		}
+
+		headers['Content-Range'] = `bytes ${start}-${end}/${stats.size}`;
+		headers['Content-Length'] = (end - start + 1);
+		headers['Accept-Ranges'] = 'bytes';
+	}
+
+	res.writeHead(code, headers);
+	require$$0$2.createReadStream(file, opts).pipe(res);
+}
+
+const ENCODING = {
+	'.br': 'br',
+	'.gz': 'gzip',
+};
+
+function toHeaders(name, stats, isEtag) {
+	let enc = ENCODING[name.slice(-3)];
+
+	let ctype = lookup(name.slice(0, enc && -3)) || '';
+	if (ctype === 'text/html') ctype += ';charset=utf-8';
+
+	let headers = {
+		'Content-Length': stats.size,
+		'Content-Type': ctype,
+		'Last-Modified': stats.mtime.toUTCString(),
+	};
+
+	if (enc) headers['Content-Encoding'] = enc;
+	if (isEtag) headers['ETag'] = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+
+	return headers;
+}
+
+function sirv (dir, opts={}) {
+	dir = resolve$3(dir || '.');
+
+	let isNotFound = opts.onNoMatch || is404;
+	let setHeaders = opts.setHeaders || noop$2;
+
+	let extensions = opts.extensions || ['html', 'htm'];
+	let gzips = opts.gzip && extensions.map(x => `${x}.gz`).concat('gz');
+	let brots = opts.brotli && extensions.map(x => `${x}.br`).concat('br');
+
+	const FILES = {};
+
+	let fallback = '/';
+	let isEtag = !!opts.etag;
+	let isSPA = !!opts.single;
+	if (typeof opts.single === 'string') {
+		let idx = opts.single.lastIndexOf('.');
+		fallback += !!~idx ? opts.single.substring(0, idx) : opts.single;
+	}
+
+	let ignores = [];
+	if (opts.ignores !== false) {
+		ignores.push(/[/]([A-Za-z\s\d~$._-]+\.\w+){1,}$/); // any extn
+		if (opts.dotfiles) ignores.push(/\/\.\w/);
+		else ignores.push(/\/\.well-known/);
+		[].concat(opts.ignores || []).forEach(x => {
+			ignores.push(new RegExp(x, 'i'));
+		});
+	}
+
+	let cc = opts.maxAge != null && `public,max-age=${opts.maxAge}`;
+	if (cc && opts.immutable) cc += ',immutable';
+	else if (cc && opts.maxAge === 0) cc += ',must-revalidate';
+
+	if (!opts.dev) {
+		totalist(dir, (name, abs, stats) => {
+			if (/\.well-known[\\+\/]/.test(name)) ; // keep
+			else if (!opts.dotfiles && /(^\.|[\\+|\/+]\.)/.test(name)) return;
+
+			let headers = toHeaders(name, stats, isEtag);
+			if (cc) headers['Cache-Control'] = cc;
+
+			FILES['/' + name.normalize().replace(/\\+/g, '/')] = { abs, stats, headers };
+		});
+	}
+
+	let lookup = opts.dev ? viaLocal.bind(0, dir, isEtag) : viaCache.bind(0, FILES);
+
+	return function (req, res, next) {
+		let extns = [''];
+		let pathname = parse$5(req).pathname;
+		let val = req.headers['accept-encoding'] || '';
+		if (gzips && val.includes('gzip')) extns.unshift(...gzips);
+		if (brots && /(br|brotli)/i.test(val)) extns.unshift(...brots);
+		extns.push(...extensions); // [...br, ...gz, orig, ...exts]
+
+		if (pathname.indexOf('%') !== -1) {
+			try { pathname = decodeURI(pathname); }
+			catch (err) { /* malform uri */ }
+		}
+
+		let data = lookup(pathname, extns, opts.shouldServe) || isSPA && !isMatch(pathname, ignores) && lookup(fallback, extns, opts.shouldServe);
+		if (!data) return next ? next() : isNotFound(req, res);
+
+		if (isEtag && req.headers['if-none-match'] === data.headers['ETag']) {
+			res.writeHead(304);
+			return res.end();
+		}
+
+		if (gzips || brots) {
+			res.setHeader('Vary', 'Accept-Encoding');
+		}
+
+		setHeaders(res, pathname, data.stats);
+		send$1(req, res, data.abs, data.stats, data.headers);
+	};
+}
+
+const knownJavascriptExtensionRE = /\.[tj]sx?$/;
+const sirvOptions = ({
+  getHeaders
+}) => {
+  return {
+    dev: true,
+    etag: true,
+    extensions: [],
+    setHeaders(res, pathname) {
+      if (knownJavascriptExtensionRE.test(pathname)) {
+        res.setHeader("Content-Type", "text/javascript");
+      }
+      const headers = getHeaders();
+      if (headers) {
+        for (const name in headers) {
+          res.setHeader(name, headers[name]);
+        }
+      }
+    }
+  };
+};
+function servePublicMiddleware(server, publicFiles) {
+  const dir = server.config.publicDir;
+  const serve = sirv(
+    dir,
+    sirvOptions({
+      getHeaders: () => server.config.server.headers
+    })
+  );
+  const toFilePath = (url) => {
+    let filePath = cleanUrl(url);
+    if (filePath.indexOf("%") !== -1) {
+      try {
+        filePath = decodeURI(filePath);
+      } catch (err) {
+      }
+    }
+    return normalizePath$3(filePath);
+  };
+  return function viteServePublicMiddleware(req, res, next) {
+    if (publicFiles && !publicFiles.has(toFilePath(req.url)) || isImportRequest(req.url) || isInternalRequest(req.url) || // for `/public-file.js?url` to be transformed
+    urlRE.test(req.url)) {
+      return next();
+    }
+    serve(req, res, next);
+  };
+}
+function serveStaticMiddleware(server) {
+  const dir = server.config.root;
+  const serve = sirv(
+    dir,
+    sirvOptions({
+      getHeaders: () => server.config.server.headers
+    })
+  );
+  return function viteServeStaticMiddleware(req, res, next) {
+    const cleanedUrl = cleanUrl(req.url);
+    if (cleanedUrl[cleanedUrl.length - 1] === "/" || path$n.extname(cleanedUrl) === ".html" || isInternalRequest(req.url)) {
+      return next();
+    }
+    const url = new URL(req.url.replace(/^\/{2,}/, "/"), "http://example.com");
+    const pathname = decodeURI(url.pathname);
+    let redirectedPathname;
+    for (const { find, replacement } of server.config.resolve.alias) {
+      const matches = typeof find === "string" ? pathname.startsWith(find) : find.test(pathname);
+      if (matches) {
+        redirectedPathname = pathname.replace(find, replacement);
+        break;
+      }
+    }
+    if (redirectedPathname) {
+      if (redirectedPathname.startsWith(withTrailingSlash(dir))) {
+        redirectedPathname = redirectedPathname.slice(dir.length);
+      }
+    }
+    const resolvedPathname = redirectedPathname || pathname;
+    let fileUrl = path$n.resolve(dir, removeLeadingSlash(resolvedPathname));
+    if (resolvedPathname[resolvedPathname.length - 1] === "/" && fileUrl[fileUrl.length - 1] !== "/") {
+      fileUrl = withTrailingSlash(fileUrl);
+    }
+    if (!ensureServingAccess(fileUrl, server, res, next)) {
+      return;
+    }
+    if (redirectedPathname) {
+      url.pathname = encodeURI(redirectedPathname);
+      req.url = url.href.slice(url.origin.length);
+    }
+    serve(req, res, next);
+  };
+}
+function serveRawFsMiddleware(server) {
+  const serveFromRoot = sirv(
+    "/",
+    sirvOptions({ getHeaders: () => server.config.server.headers })
+  );
+  return function viteServeRawFsMiddleware(req, res, next) {
+    const url = new URL(req.url.replace(/^\/{2,}/, "/"), "http://example.com");
+    if (url.pathname.startsWith(FS_PREFIX)) {
+      const pathname = decodeURI(url.pathname);
+      if (!ensureServingAccess(
+        slash$1(path$n.resolve(fsPathFromId(pathname))),
+        server,
+        res,
+        next
+      )) {
+        return;
+      }
+      let newPathname = pathname.slice(FS_PREFIX.length);
+      if (isWindows$3) newPathname = newPathname.replace(/^[A-Z]:/i, "");
+      url.pathname = encodeURI(newPathname);
+      req.url = url.href.slice(url.origin.length);
+      serveFromRoot(req, res, next);
+    } else {
+      next();
+    }
+  };
+}
+function isFileServingAllowed(url, server) {
+  if (!server.config.server.fs.strict) return true;
+  const file = fsPathFromUrl(url);
+  if (server._fsDenyGlob(file)) return false;
+  if (server.moduleGraph.safeModulesPath.has(file)) return true;
+  if (server.config.server.fs.allow.some(
+    (uri) => isSameFileUri(uri, file) || isParentDirectory(uri, file)
+  ))
+    return true;
+  return false;
+}
+function ensureServingAccess(url, server, res, next) {
+  if (isFileServingAllowed(url, server)) {
+    return true;
+  }
+  if (isFileReadable(cleanUrl(url))) {
+    const urlMessage = `The request url "${url}" is outside of Vite serving allow list.`;
+    const hintMessage = `
+${server.config.server.fs.allow.map((i) => `- ${i}`).join("\n")}
+
+Refer to docs https://vitejs.dev/config/server-options.html#server-fs-allow for configurations and more details.`;
+    server.config.logger.error(urlMessage);
+    server.config.logger.warnOnce(hintMessage + "\n");
+    res.statusCode = 403;
+    res.write(renderRestrictedErrorHTML(urlMessage + "\n" + hintMessage));
+    res.end();
+  } else {
+    next();
+  }
+  return false;
+}
+function renderRestrictedErrorHTML(msg) {
+  const html = String.raw;
+  return html`
+    <body>
+      <h1>403 Restricted</h1>
+      <p>${escapeHtml$2(msg).replace(/\n/g, "<br/>")}</p>
+      <style>
+        body {
+          padding: 1em 2em;
+        }
+      </style>
+    </body>
+  `;
+}
+
+const ERR_LOAD_URL = "ERR_LOAD_URL";
+const ERR_LOAD_PUBLIC_URL = "ERR_LOAD_PUBLIC_URL";
+const debugLoad = createDebugger("vite:load");
+const debugTransform = createDebugger("vite:transform");
+const debugCache$1 = createDebugger("vite:cache");
+function transformRequest(url, server, options = {}) {
+  if (server._restartPromise && !options.ssr) throwClosedServerError();
+  const cacheKey = (options.ssr ? "ssr:" : options.html ? "html:" : "") + url;
+  const timestamp = Date.now();
+  const pending = server._pendingRequests.get(cacheKey);
+  if (pending) {
+    return server.moduleGraph.getModuleByUrl(removeTimestampQuery(url), options.ssr).then((module) => {
+      if (!module || pending.timestamp > module.lastInvalidationTimestamp) {
+        return pending.request;
+      } else {
+        pending.abort();
+        return transformRequest(url, server, options);
+      }
+    });
+  }
+  const request = doTransform(url, server, options, timestamp);
+  let cleared = false;
+  const clearCache = () => {
+    if (!cleared) {
+      server._pendingRequests.delete(cacheKey);
+      cleared = true;
+    }
+  };
+  server._pendingRequests.set(cacheKey, {
+    request,
+    timestamp,
+    abort: clearCache
+  });
+  return request.finally(clearCache);
+}
+async function doTransform(url, server, options, timestamp) {
+  url = removeTimestampQuery(url);
+  const { config, pluginContainer } = server;
+  const ssr = !!options.ssr;
+  if (ssr && isDepsOptimizerEnabled(config, true)) {
+    await initDevSsrDepsOptimizer(config, server);
+  }
+  let module = await server.moduleGraph.getModuleByUrl(url, ssr);
+  if (module) {
+    const cached = await getCachedTransformResult(
+      url,
+      module,
+      server,
+      ssr,
+      timestamp
+    );
+    if (cached) return cached;
+  }
+  const resolved = module ? void 0 : await pluginContainer.resolveId(url, void 0, { ssr }) ?? void 0;
+  const id = module?.id ?? resolved?.id ?? url;
+  module ??= server.moduleGraph.getModuleById(id);
+  if (module) {
+    await server.moduleGraph._ensureEntryFromUrl(url, ssr, void 0, resolved);
+    const cached = await getCachedTransformResult(
+      url,
+      module,
+      server,
+      ssr,
+      timestamp
+    );
+    if (cached) return cached;
+  }
+  const result = loadAndTransform(
+    id,
+    url,
+    server,
+    options,
+    timestamp,
+    module,
+    resolved
+  );
+  if (!ssr) {
+    const depsOptimizer = getDepsOptimizer(config, ssr);
+    if (!depsOptimizer?.isOptimizedDepFile(id)) {
+      server._registerRequestProcessing(id, () => result);
+    }
+  }
+  return result;
+}
+async function getCachedTransformResult(url, module, server, ssr, timestamp) {
+  const prettyUrl = debugCache$1 ? prettifyUrl(url, server.config.root) : "";
+  const softInvalidatedTransformResult = module && await handleModuleSoftInvalidation(module, ssr, timestamp, server);
+  if (softInvalidatedTransformResult) {
+    debugCache$1?.(`[memory-hmr] ${prettyUrl}`);
+    return softInvalidatedTransformResult;
+  }
+  const cached = module && (ssr ? module.ssrTransformResult : module.transformResult);
+  if (cached) {
+    debugCache$1?.(`[memory] ${prettyUrl}`);
+    return cached;
+  }
+}
+async function loadAndTransform(id, url, server, options, timestamp, mod, resolved) {
+  const { config, pluginContainer, moduleGraph } = server;
+  const { logger } = config;
+  const prettyUrl = debugLoad || debugTransform ? prettifyUrl(url, config.root) : "";
+  const ssr = !!options.ssr;
+  const file = cleanUrl(id);
+  let code = null;
+  let map = null;
+  const loadStart = debugLoad ? performance$1.now() : 0;
+  const loadResult = await pluginContainer.load(id, { ssr });
+  if (loadResult == null) {
+    if (options.html && !id.endsWith(".html")) {
+      return null;
+    }
+    if (options.ssr || isFileServingAllowed(file, server)) {
+      try {
+        code = await fsp.readFile(file, "utf-8");
+        debugLoad?.(`${timeFrom(loadStart)} [fs] ${prettyUrl}`);
+      } catch (e) {
+        if (e.code !== "ENOENT") {
+          if (e.code === "EISDIR") {
+            e.message = `${e.message} ${file}`;
+          }
+          throw e;
+        }
+      }
+      if (code != null) {
+        ensureWatchedFile(server.watcher, file, config.root);
+      }
+    }
+    if (code) {
+      try {
+        const extracted = await extractSourcemapFromFile(code, file);
+        if (extracted) {
+          code = extracted.code;
+          map = extracted.map;
+        }
+      } catch (e) {
+        logger.warn(`Failed to load source map for ${file}.
+${e}`, {
+          timestamp: true
+        });
+      }
+    }
+  } else {
+    debugLoad?.(`${timeFrom(loadStart)} [plugin] ${prettyUrl}`);
+    if (isObject$1(loadResult)) {
+      code = loadResult.code;
+      map = loadResult.map;
+    } else {
+      code = loadResult;
+    }
+  }
+  if (code == null) {
+    const isPublicFile = checkPublicFile(url, config);
+    let publicDirName = path$n.relative(config.root, config.publicDir);
+    if (publicDirName[0] !== ".") publicDirName = "/" + publicDirName;
+    const msg = isPublicFile ? `This file is in ${publicDirName} and will be copied as-is during build without going through the plugin transforms, and therefore should not be imported from source code. It can only be referenced via HTML tags.` : `Does the file exist?`;
+    const importerMod = server.moduleGraph.idToModuleMap.get(id)?.importers.values().next().value;
+    const importer = importerMod?.file || importerMod?.url;
+    const err = new Error(
+      `Failed to load url ${url} (resolved id: ${id})${importer ? ` in ${importer}` : ""}. ${msg}`
+    );
+    err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL;
+    throw err;
+  }
+  if (server._restartPromise && !ssr) throwClosedServerError();
+  mod ??= await moduleGraph._ensureEntryFromUrl(url, ssr, void 0, resolved);
+  const transformStart = debugTransform ? performance$1.now() : 0;
+  const transformResult = await pluginContainer.transform(code, id, {
+    inMap: map,
+    ssr
+  });
+  const originalCode = code;
+  if (transformResult == null || isObject$1(transformResult) && transformResult.code == null) {
+    debugTransform?.(
+      timeFrom(transformStart) + colors$1.dim(` [skipped] ${prettyUrl}`)
+    );
+  } else {
+    debugTransform?.(`${timeFrom(transformStart)} ${prettyUrl}`);
+    code = transformResult.code;
+    map = transformResult.map;
+  }
+  let normalizedMap;
+  if (typeof map === "string") {
+    normalizedMap = JSON.parse(map);
+  } else if (map) {
+    normalizedMap = map;
+  } else {
+    normalizedMap = null;
+  }
+  if (normalizedMap && "version" in normalizedMap && mod.file) {
+    if (normalizedMap.mappings) {
+      await injectSourcesContent(normalizedMap, mod.file, logger);
+    }
+    const sourcemapPath = `${mod.file}.map`;
+    applySourcemapIgnoreList(
+      normalizedMap,
+      sourcemapPath,
+      config.server.sourcemapIgnoreList,
+      logger
+    );
+    if (path$n.isAbsolute(mod.file)) {
+      let modDirname;
+      for (let sourcesIndex = 0; sourcesIndex < normalizedMap.sources.length; ++sourcesIndex) {
+        const sourcePath = normalizedMap.sources[sourcesIndex];
+        if (sourcePath) {
+          if (path$n.isAbsolute(sourcePath)) {
+            modDirname ??= path$n.dirname(mod.file);
+            normalizedMap.sources[sourcesIndex] = path$n.relative(
+              modDirname,
+              sourcePath
+            );
+          }
+        }
+      }
+    }
+  }
+  if (server._restartPromise && !ssr) throwClosedServerError();
+  const result = ssr && !server.config.experimental.skipSsrTransform ? await server.ssrTransform(code, normalizedMap, url, originalCode) : {
+    code,
+    map: normalizedMap,
+    etag: getEtag(code, { weak: true })
+  };
+  if (timestamp > mod.lastInvalidationTimestamp)
+    moduleGraph.updateModuleTransformResult(mod, result, ssr);
+  return result;
+}
+async function handleModuleSoftInvalidation(mod, ssr, timestamp, server) {
+  const transformResult = ssr ? mod.ssrInvalidationState : mod.invalidationState;
+  if (ssr) mod.ssrInvalidationState = void 0;
+  else mod.invalidationState = void 0;
+  if (!transformResult || transformResult === "HARD_INVALIDATED") return;
+  if (ssr ? mod.ssrTransformResult : mod.transformResult) {
+    throw new Error(
+      `Internal server error: Soft-invalidated module "${mod.url}" should not have existing transform result`
+    );
+  }
+  let result;
+  if (ssr) {
+    result = transformResult;
+  } else {
+    await init;
+    const source = transformResult.code;
+    const s = new MagicString(source);
+    const [imports] = parse$d(source, mod.id || void 0);
+    for (const imp of imports) {
+      let rawUrl = source.slice(imp.s, imp.e);
+      if (rawUrl === "import.meta") continue;
+      const hasQuotes = rawUrl[0] === '"' || rawUrl[0] === "'";
+      if (hasQuotes) {
+        rawUrl = rawUrl.slice(1, -1);
+      }
+      const urlWithoutTimestamp = removeTimestampQuery(rawUrl);
+      const hmrUrl = unwrapId$1(
+        stripBase(removeImportQuery(urlWithoutTimestamp), server.config.base)
+      );
+      for (const importedMod of mod.clientImportedModules) {
+        if (importedMod.url !== hmrUrl) continue;
+        if (importedMod.lastHMRTimestamp > 0) {
+          const replacedUrl = injectQuery(
+            urlWithoutTimestamp,
+            `t=${importedMod.lastHMRTimestamp}`
+          );
+          const start = hasQuotes ? imp.s + 1 : imp.s;
+          const end = hasQuotes ? imp.e - 1 : imp.e;
+          s.overwrite(start, end, replacedUrl);
+        }
+        if (imp.d === -1 && server.config.server.preTransformRequests) {
+          server.warmupRequest(hmrUrl, { ssr });
+        }
+        break;
+      }
+    }
+    const code = s.toString();
+    result = {
+      ...transformResult,
+      code,
+      etag: getEtag(code, { weak: true })
+    };
+  }
+  if (timestamp > mod.lastInvalidationTimestamp)
+    server.moduleGraph.updateModuleTransformResult(mod, result, ssr);
+  return result;
+}
+
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+  if (metadata?.isDynamicImport) return;
+  if (metadata?.importedNames?.length) {
+    const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+    if (missingBindings.length) {
+      const lastBinding = missingBindings[missingBindings.length - 1];
+      if (moduleType === "module") {
+        throw new SyntaxError(
+          `[vite] The requested module '${rawId}' does not provide an export named '${lastBinding}'`
+        );
+      } else {
+        throw new SyntaxError(`[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(", ")}} = pkg;
+`);
+      }
+    }
+  }
+}
+
+/**
+ * @param {import('estree').Node} param
+ * @returns {string[]}
+ */
+function extract_names(param) {
+	return extract_identifiers(param).map((node) => node.name);
+}
+
+/**
+ * @param {import('estree').Node} param
+ * @param {import('estree').Identifier[]} nodes
+ * @returns {import('estree').Identifier[]}
+ */
+function extract_identifiers(param, nodes = []) {
+	switch (param.type) {
+		case 'Identifier':
+			nodes.push(param);
+			break;
+
+		case 'MemberExpression':
+			let object = param;
+			while (object.type === 'MemberExpression') {
+				object = /** @type {any} */ (object.object);
+			}
+			nodes.push(/** @type {any} */ (object));
+			break;
+
+		case 'ObjectPattern':
+			for (const prop of param.properties) {
+				if (prop.type === 'RestElement') {
+					extract_identifiers(prop.argument, nodes);
+				} else {
+					extract_identifiers(prop.value, nodes);
+				}
+			}
+
+			break;
+
+		case 'ArrayPattern':
+			for (const element of param.elements) {
+				if (element) extract_identifiers(element, nodes);
+			}
+
+			break;
+
+		case 'RestElement':
+			extract_identifiers(param.argument, nodes);
+			break;
+
+		case 'AssignmentPattern':
+			extract_identifiers(param.left, nodes);
+			break;
+	}
+
+	return nodes;
+}
+
+/**
+ * @typedef { import('estree').Node} Node
+ * @typedef {{
+ *   skip: () => void;
+ *   remove: () => void;
+ *   replace: (node: Node) => void;
+ * }} WalkerContext
+ */
+
+class WalkerBase {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+
+		/** @type {boolean} */
+		this.should_remove = false;
+
+		/** @type {Node | null} */
+		this.replacement = null;
+
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => (this.should_skip = true),
+			remove: () => (this.should_remove = true),
+			replace: (node) => (this.replacement = node)
+		};
+	}
+
+	/**
+	 * @template {Node} Parent
+	 * @param {Parent | null | undefined} parent
+	 * @param {keyof Parent | null | undefined} prop
+	 * @param {number | null | undefined} index
+	 * @param {Node} node
+	 */
+	replace(parent, prop, index, node) {
+		if (parent && prop) {
+			if (index != null) {
+				/** @type {Array<Node>} */ (parent[prop])[index] = node;
+			} else {
+				/** @type {Node} */ (parent[prop]) = node;
+			}
+		}
+	}
+
+	/**
+	 * @template {Node} Parent
+	 * @param {Parent | null | undefined} parent
+	 * @param {keyof Parent | null | undefined} prop
+	 * @param {number | null | undefined} index
+	 */
+	remove(parent, prop, index) {
+		if (parent && prop) {
+			if (index !== null && index !== undefined) {
+				/** @type {Array<Node>} */ (parent[prop]).splice(index, 1);
+			} else {
+				delete parent[prop];
+			}
+		}
+	}
+}
+
+/**
+ * @typedef { import('estree').Node} Node
+ * @typedef { import('./walker.js').WalkerContext} WalkerContext
+ * @typedef {(
+ *    this: WalkerContext,
+ *    node: Node,
+ *    parent: Node | null,
+ *    key: string | number | symbol | null | undefined,
+ *    index: number | null | undefined
+ * ) => void} SyncHandler
+ */
+
+class SyncWalker extends WalkerBase {
+	/**
+	 *
+	 * @param {SyncHandler} [enter]
+	 * @param {SyncHandler} [leave]
+	 */
+	constructor(enter, leave) {
+		super();
+
+		/** @type {boolean} */
+		this.should_skip = false;
+
+		/** @type {boolean} */
+		this.should_remove = false;
+
+		/** @type {Node | null} */
+		this.replacement = null;
+
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => (this.should_skip = true),
+			remove: () => (this.should_remove = true),
+			replace: (node) => (this.replacement = node)
+		};
+
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+
+	/**
+	 * @template {Node} Parent
+	 * @param {Node} node
+	 * @param {Parent | null} parent
+	 * @param {keyof Parent} [prop]
+	 * @param {number | null} [index]
+	 * @returns {Node | null}
+	 */
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+
+				this.enter.call(this.context, node, parent, prop, index);
+
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+
+				if (this.should_remove) {
+					this.remove(parent, prop, index);
+				}
+
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+
+				if (skipped) return node;
+				if (removed) return null;
+			}
+
+			/** @type {keyof Node} */
+			let key;
+
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+
+				if (value && typeof value === 'object') {
+					if (Array.isArray(value)) {
+						const nodes = /** @type {Array<unknown>} */ (value);
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) {
+									// removed
+									i--;
+								}
+							}
+						}
+					} else if (isNode(value)) {
+						this.visit(value, node, key, null);
+					}
+				}
+			}
+
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+
+				this.leave.call(this.context, node, parent, prop, index);
+
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+
+				if (this.should_remove) {
+					this.remove(parent, prop, index);
+				}
+
+				const removed = this.should_remove;
+
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+
+				if (removed) return null;
+			}
+		}
+
+		return node;
+	}
+}
+
+/**
+ * Ducktype a node.
+ *
+ * @param {unknown} value
+ * @returns {value is Node}
+ */
+function isNode(value) {
+	return (
+		value !== null && typeof value === 'object' && 'type' in value && typeof value.type === 'string'
+	);
+}
+
+/**
+ * @typedef {import('estree').Node} Node
+ * @typedef {import('./sync.js').SyncHandler} SyncHandler
+ * @typedef {import('./async.js').AsyncHandler} AsyncHandler
+ */
+
+/**
+ * @param {Node} ast
+ * @param {{
+ *   enter?: SyncHandler
+ *   leave?: SyncHandler
+ * }} walker
+ * @returns {Node | null}
+ */
+function walk$1(ast, { enter, leave }) {
+	const instance = new SyncWalker(enter, leave);
+	return instance.visit(ast, null);
+}
+
+const ssrModuleExportsKey = `__vite_ssr_exports__`;
+const ssrImportKey = `__vite_ssr_import__`;
+const ssrDynamicImportKey = `__vite_ssr_dynamic_import__`;
+const ssrExportAllKey = `__vite_ssr_exportAll__`;
+const ssrImportMetaKey = `__vite_ssr_import_meta__`;
+const hashbangRE = /^#!.*\n/;
+async function ssrTransform(code, inMap, url, originalCode, options) {
+  if (options?.json?.stringify && isJSONRequest(url)) {
+    return ssrTransformJSON(code, inMap);
+  }
+  return ssrTransformScript(code, inMap, url, originalCode);
+}
+async function ssrTransformJSON(code, inMap) {
+  return {
+    code: code.replace("export default", `${ssrModuleExportsKey}.default =`),
+    map: inMap,
+    deps: [],
+    dynamicDeps: []
+  };
+}
+async function ssrTransformScript(code, inMap, url, originalCode) {
+  const s = new MagicString(code);
+  let ast;
+  try {
+    ast = await parseAstAsync(code);
+  } catch (err) {
+    if (!err.loc || !err.loc.line) throw err;
+    const line = err.loc.line;
+    throw new Error(
+      `Parse failure: ${err.message}
+At file: ${url}
+Contents of line ${line}: ${code.split("\n")[line - 1]}`
+    );
+  }
+  let uid = 0;
+  const deps = /* @__PURE__ */ new Set();
+  const dynamicDeps = /* @__PURE__ */ new Set();
+  const idToImportMap = /* @__PURE__ */ new Map();
+  const declaredConst = /* @__PURE__ */ new Set();
+  const hoistIndex = hashbangRE.exec(code)?.[0].length ?? 0;
+  function defineImport(index, source, metadata) {
+    deps.add(source);
+    const importId = `__vite_ssr_import_${uid++}__`;
+    if (metadata && (metadata.importedNames == null || metadata.importedNames.length === 0)) {
+      metadata = void 0;
+    }
+    const metadataStr = metadata ? `, ${JSON.stringify(metadata)}` : "";
+    s.appendLeft(
+      index,
+      `const ${importId} = await ${ssrImportKey}(${JSON.stringify(
+        source
+      )}${metadataStr});
+`
+    );
+    return importId;
+  }
+  function defineExport(position, name, local = name) {
+    s.appendLeft(
+      position,
+      `
+Object.defineProperty(${ssrModuleExportsKey}, "${name}", { enumerable: true, configurable: true, get(){ return ${local} }});`
+    );
+  }
+  const imports = [];
+  const exports = [];
+  for (const node of ast.body) {
+    if (node.type === "ImportDeclaration") {
+      imports.push(node);
+    } else if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") {
+      exports.push(node);
+    }
+  }
+  for (const node of imports) {
+    const importId = defineImport(hoistIndex, node.source.value, {
+      importedNames: node.specifiers.map((s2) => {
+        if (s2.type === "ImportSpecifier")
+          return s2.imported.type === "Identifier" ? s2.imported.name : (
+            // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            s2.imported.value
+          );
+        else if (s2.type === "ImportDefaultSpecifier") return "default";
+      }).filter(isDefined)
+    });
+    s.remove(node.start, node.end);
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        if (spec.imported.type === "Identifier") {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}.${spec.imported.name}`
+          );
+        } else {
+          idToImportMap.set(
+            spec.local.name,
+            `${importId}[${// @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+            JSON.stringify(spec.imported.value)}]`
+          );
+        }
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        idToImportMap.set(spec.local.name, `${importId}.default`);
+      } else {
+        idToImportMap.set(spec.local.name, importId);
+      }
+    }
+  }
+  for (const node of exports) {
+    if (node.type === "ExportNamedDeclaration") {
+      if (node.declaration) {
+        if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+          defineExport(node.end, node.declaration.id.name);
+        } else {
+          for (const declaration of node.declaration.declarations) {
+            const names = extract_names(declaration.id);
+            for (const name of names) {
+              defineExport(node.end, name);
+            }
+          }
+        }
+        s.remove(node.start, node.declaration.start);
+      } else {
+        s.remove(node.start, node.end);
+        if (node.source) {
+          const importId = defineImport(
+            node.start,
+            node.source.value,
+            {
+              importedNames: node.specifiers.map((s2) => s2.local.name)
+            }
+          );
+          for (const spec of node.specifiers) {
+            const exportedAs = spec.exported.type === "Identifier" ? spec.exported.name : (
+              // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+              spec.exported.value
+            );
+            defineExport(
+              node.start,
+              exportedAs,
+              `${importId}.${spec.local.name}`
+            );
+          }
+        } else {
+          for (const spec of node.specifiers) {
+            const local = spec.local.name;
+            const binding = idToImportMap.get(local);
+            const exportedAs = spec.exported.type === "Identifier" ? spec.exported.name : (
+              // @ts-expect-error TODO: Estree types don't consider arbitrary module namespace specifiers yet
+              spec.exported.value
+            );
+            defineExport(node.end, exportedAs, binding || local);
+          }
+        }
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      const expressionTypes = ["FunctionExpression", "ClassExpression"];
+      if ("id" in node.declaration && node.declaration.id && !expressionTypes.includes(node.declaration.type)) {
+        const { name } = node.declaration.id;
+        s.remove(
+          node.start,
+          node.start + 15
+          /* 'export default '.length */
+        );
+        s.append(
+          `
+Object.defineProperty(${ssrModuleExportsKey}, "default", { enumerable: true, configurable: true, value: ${name} });`
+        );
+      } else {
+        s.update(
+          node.start,
+          node.start + 14,
+          `${ssrModuleExportsKey}.default =`
+        );
+      }
+    }
+    if (node.type === "ExportAllDeclaration") {
+      s.remove(node.start, node.end);
+      const importId = defineImport(node.start, node.source.value);
+      if (node.exported) {
+        defineExport(node.start, node.exported.name, `${importId}`);
+      } else {
+        s.appendLeft(node.start, `${ssrExportAllKey}(${importId});
+`);
+      }
+    }
+  }
+  walk(ast, {
+    onIdentifier(id, parent, parentStack) {
+      const grandparent = parentStack[1];
+      const binding = idToImportMap.get(id.name);
+      if (!binding) {
+        return;
+      }
+      if (isStaticProperty(parent) && parent.shorthand) {
+        if (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack)) {
+          s.appendLeft(id.end, `: ${binding}`);
+        }
+      } else if (parent.type === "PropertyDefinition" && grandparent?.type === "ClassBody" || parent.type === "ClassDeclaration" && id === parent.superClass) {
+        if (!declaredConst.has(id.name)) {
+          declaredConst.add(id.name);
+          const topNode = parentStack[parentStack.length - 2];
+          s.prependRight(topNode.start, `const ${id.name} = ${binding};
+`);
+        }
+      } else if (
+        // don't transform class name identifier
+        !(parent.type === "ClassExpression" && id === parent.id)
+      ) {
+        s.update(id.start, id.end, binding);
+      }
+    },
+    onImportMeta(node) {
+      s.update(node.start, node.end, ssrImportMetaKey);
+    },
+    onDynamicImport(node) {
+      s.update(node.start, node.start + 6, ssrDynamicImportKey);
+      if (node.type === "ImportExpression" && node.source.type === "Literal") {
+        dynamicDeps.add(node.source.value);
+      }
+    }
+  });
+  let map = s.generateMap({ hires: "boundary" });
+  if (inMap && inMap.mappings && "sources" in inMap && inMap.sources.length > 0) {
+    map = combineSourcemaps(url, [
+      {
+        ...map,
+        sources: inMap.sources,
+        sourcesContent: inMap.sourcesContent
+      },
+      inMap
+    ]);
+  } else {
+    map.sources = [path$n.basename(url)];
+    map.sourcesContent = [originalCode];
+  }
+  return {
+    code: s.toString(),
+    map,
+    deps: [...deps],
+    dynamicDeps: [...dynamicDeps]
+  };
+}
+const isNodeInPatternWeakSet = /* @__PURE__ */ new WeakSet();
+const setIsNodeInPattern = (node) => isNodeInPatternWeakSet.add(node);
+const isNodeInPattern = (node) => isNodeInPatternWeakSet.has(node);
+function walk(root, { onIdentifier, onImportMeta, onDynamicImport }) {
+  const parentStack = [];
+  const varKindStack = [];
+  const scopeMap = /* @__PURE__ */ new WeakMap();
+  const identifiers = [];
+  const setScope = (node, name) => {
+    let scopeIds = scopeMap.get(node);
+    if (scopeIds && scopeIds.has(name)) {
+      return;
+    }
+    if (!scopeIds) {
+      scopeIds = /* @__PURE__ */ new Set();
+      scopeMap.set(node, scopeIds);
+    }
+    scopeIds.add(name);
+  };
+  function isInScope(name, parents) {
+    return parents.some((node) => node && scopeMap.get(node)?.has(name));
+  }
+  function handlePattern(p, parentScope) {
+    if (p.type === "Identifier") {
+      setScope(parentScope, p.name);
+    } else if (p.type === "RestElement") {
+      handlePattern(p.argument, parentScope);
+    } else if (p.type === "ObjectPattern") {
+      p.properties.forEach((property) => {
+        if (property.type === "RestElement") {
+          setScope(parentScope, property.argument.name);
+        } else {
+          handlePattern(property.value, parentScope);
+        }
+      });
+    } else if (p.type === "ArrayPattern") {
+      p.elements.forEach((element) => {
+        if (element) {
+          handlePattern(element, parentScope);
+        }
+      });
+    } else if (p.type === "AssignmentPattern") {
+      handlePattern(p.left, parentScope);
+    } else {
+      setScope(parentScope, p.name);
+    }
+  }
+  walk$1(root, {
+    enter(node, parent) {
+      if (node.type === "ImportDeclaration") {
+        return this.skip();
+      }
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
+        parentStack.unshift(parent);
+      }
+      if (node.type === "VariableDeclaration") {
+        varKindStack.unshift(node.kind);
+      }
+      if (node.type === "MetaProperty" && node.meta.name === "import") {
+        onImportMeta(node);
+      } else if (node.type === "ImportExpression") {
+        onDynamicImport(node);
+      }
+      if (node.type === "Identifier") {
+        if (!isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack)) {
+          identifiers.push([node, parentStack.slice(0)]);
+        }
+      } else if (isFunction$1(node)) {
+        if (node.type === "FunctionDeclaration") {
+          const parentScope = findParentScope(parentStack);
+          if (parentScope) {
+            setScope(parentScope, node.id.name);
+          }
+        }
+        if (node.type === "FunctionExpression" && node.id) {
+          setScope(node, node.id.name);
+        }
+        node.params.forEach((p) => {
+          if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+            handlePattern(p, node);
+            return;
+          }
+          walk$1(p.type === "AssignmentPattern" ? p.left : p, {
+            enter(child, parent2) {
+              if (parent2?.type === "AssignmentPattern" && parent2?.right === child) {
+                return this.skip();
+              }
+              if (child.type !== "Identifier") return;
+              if (isStaticPropertyKey(child, parent2)) return;
+              if (parent2?.type === "TemplateLiteral" && parent2?.expressions.includes(child) || parent2?.type === "CallExpression" && parent2?.callee === child) {
+                return;
+              }
+              setScope(node, child.name);
+            }
+          });
+        });
+      } else if (node.type === "ClassDeclaration") {
+        const parentScope = findParentScope(parentStack);
+        if (parentScope) {
+          setScope(parentScope, node.id.name);
+        }
+      } else if (node.type === "ClassExpression" && node.id) {
+        setScope(node, node.id.name);
+      } else if (node.type === "Property" && parent.type === "ObjectPattern") {
+        setIsNodeInPattern(node);
+      } else if (node.type === "VariableDeclarator") {
+        const parentFunction = findParentScope(
+          parentStack,
+          varKindStack[0] === "var"
+        );
+        if (parentFunction) {
+          handlePattern(node.id, parentFunction);
+        }
+      } else if (node.type === "CatchClause" && node.param) {
+        handlePattern(node.param, node);
+      }
+    },
+    leave(node, parent) {
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
+        parentStack.shift();
+      }
+      if (node.type === "VariableDeclaration") {
+        varKindStack.shift();
+      }
+    }
+  });
+  identifiers.forEach(([node, stack]) => {
+    if (!isInScope(node.name, stack)) onIdentifier(node, stack[0], stack);
+  });
+}
+function isRefIdentifier(id, parent, parentStack) {
+  if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id) {
+    return false;
+  }
+  if (isFunction$1(parent)) {
+    if (parent.id === id) {
+      return false;
+    }
+    if (parent.params.includes(id)) {
+      return false;
+    }
+  }
+  if (parent.type === "MethodDefinition" && !parent.computed) {
+    return false;
+  }
+  if (isStaticPropertyKey(id, parent)) {
+    return false;
+  }
+  if (isNodeInPattern(parent) && parent.value === id) {
+    return false;
+  }
+  if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack)) {
+    return false;
+  }
+  if (parent.type === "MemberExpression" && parent.property === id && !parent.computed) {
+    return false;
+  }
+  if (parent.type === "ExportSpecifier") {
+    return false;
+  }
+  if (id.name === "arguments") {
+    return false;
+  }
+  return true;
+}
+const isStaticProperty = (node) => node && node.type === "Property" && !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
+function isFunction$1(node) {
+  return functionNodeTypeRE.test(node.type);
+}
+const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/;
+function isBlock(node) {
+  return blockNodeTypeRE.test(node.type);
+}
+function findParentScope(parentStack, isVar = false) {
+  return parentStack.find(isVar ? isFunction$1 : isBlock);
+}
+function isInDestructuringAssignment(parent, parentStack) {
+  if (parent && (parent.type === "Property" || parent.type === "ArrayPattern")) {
+    return parentStack.some((i) => i.type === "AssignmentExpression");
+  }
+  return false;
+}
+
+let offset;
+function calculateOffsetOnce() {
+  if (offset !== void 0) {
+    return;
+  }
+  try {
+    new Function("throw new Error(1)")();
+  } catch (e) {
+    const match = /:(\d+):\d+\)$/.exec(e.stack.split("\n")[1]);
+    offset = match ? +match[1] - 1 : 0;
+  }
+}
+function ssrRewriteStacktrace(stack, moduleGraph) {
+  calculateOffsetOnce();
+  return stack.split("\n").map((line) => {
+    return line.replace(
+      /^ {4}at (?:(\S.*?)\s\()?(.+?):(\d+)(?::(\d+))?\)?/,
+      (input, varName, id, line2, column) => {
+        if (!id) return input;
+        const mod = moduleGraph.idToModuleMap.get(id);
+        const rawSourceMap = mod?.ssrTransformResult?.map;
+        if (!rawSourceMap) {
+          return input;
+        }
+        const traced = new TraceMap(rawSourceMap);
+        const pos = originalPositionFor$1(traced, {
+          line: Number(line2) - offset,
+          // stacktrace's column is 1-indexed, but sourcemap's one is 0-indexed
+          column: Number(column) - 1
+        });
+        if (!pos.source || pos.line == null || pos.column == null) {
+          return input;
+        }
+        const trimmedVarName = varName.trim();
+        const sourceFile = path$n.resolve(path$n.dirname(id), pos.source);
+        const source = `${sourceFile}:${pos.line}:${pos.column + 1}`;
+        if (!trimmedVarName || trimmedVarName === "eval") {
+          return `    at ${source}`;
+        } else {
+          return `    at ${trimmedVarName} (${source})`;
+        }
+      }
+    );
+  }).join("\n");
+}
+function rebindErrorStacktrace(e, stacktrace) {
+  const { configurable, writable } = Object.getOwnPropertyDescriptor(
+    e,
+    "stack"
+  );
+  if (configurable) {
+    Object.defineProperty(e, "stack", {
+      value: stacktrace,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else if (writable) {
+    e.stack = stacktrace;
+  }
+}
+const rewroteStacktraces = /* @__PURE__ */ new WeakSet();
+function ssrFixStacktrace(e, moduleGraph) {
+  if (!e.stack) return;
+  if (rewroteStacktraces.has(e)) return;
+  const stacktrace = ssrRewriteStacktrace(e.stack, moduleGraph);
+  rebindErrorStacktrace(e, stacktrace);
+  rewroteStacktraces.add(e);
+}
+
+const pendingModules = /* @__PURE__ */ new Map();
+const pendingModuleDependencyGraph = /* @__PURE__ */ new Map();
+const importErrors = /* @__PURE__ */ new WeakMap();
+async function ssrLoadModule(url, server, fixStacktrace) {
+  url = unwrapId$1(url);
+  const pending = pendingModules.get(url);
+  if (pending) {
+    return pending;
+  }
+  const modulePromise = instantiateModule(url, server, fixStacktrace);
+  pendingModules.set(url, modulePromise);
+  modulePromise.catch(() => {
+  }).finally(() => {
+    pendingModules.delete(url);
+  });
+  return modulePromise;
+}
+async function instantiateModule(url, server, fixStacktrace) {
+  const { moduleGraph } = server;
+  const mod = await moduleGraph.ensureEntryFromUrl(url, true);
+  if (mod.ssrError) {
+    throw mod.ssrError;
+  }
+  if (mod.ssrModule) {
+    return mod.ssrModule;
+  }
+  const result = mod.ssrTransformResult || await transformRequest(url, server, { ssr: true });
+  if (!result) {
+    throw new Error(`failed to load module for ssr: ${url}`);
+  }
+  const ssrModule = {
+    [Symbol.toStringTag]: "Module"
+  };
+  Object.defineProperty(ssrModule, "__esModule", { value: true });
+  mod.ssrModule = ssrModule;
+  const osNormalizedFilename = isWindows$3 ? path$n.resolve(mod.file) : mod.file;
+  const ssrImportMeta = {
+    dirname: path$n.dirname(osNormalizedFilename),
+    filename: osNormalizedFilename,
+    // The filesystem URL, matching native Node.js modules
+    url: pathToFileURL(mod.file).toString()
+  };
+  const {
+    isProduction,
+    resolve: { dedupe, preserveSymlinks },
+    root,
+    ssr
+  } = server.config;
+  const overrideConditions = ssr.resolve?.externalConditions || [];
+  const resolveOptions = {
+    mainFields: ["main"],
+    conditions: [],
+    overrideConditions: [...overrideConditions, "production", "development"],
+    extensions: [".js", ".cjs", ".json"],
+    dedupe,
+    preserveSymlinks,
+    isBuild: false,
+    isProduction,
+    root,
+    ssrConfig: ssr,
+    legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
+    packageCache: server.config.packageCache
+  };
+  const ssrImport = async (dep, metadata) => {
+    try {
+      if (dep[0] !== "." && dep[0] !== "/") {
+        return await nodeImport(dep, mod.file, resolveOptions, metadata);
+      }
+      dep = unwrapId$1(dep);
+      if (!metadata?.isDynamicImport) {
+        addPendingModuleDependency(url, dep);
+        if (checkModuleDependencyExists(dep, url)) {
+          const depSsrModule = moduleGraph.urlToModuleMap.get(dep)?.ssrModule;
+          if (!depSsrModule) {
+            throw new Error(
+              "[vite] The dependency module is not yet fully initialized due to circular dependency. This is a bug in Vite SSR"
+            );
+          }
+          return depSsrModule;
+        }
+      }
+      return ssrLoadModule(dep, server, fixStacktrace);
+    } catch (err) {
+      importErrors.set(err, { importee: dep });
+      throw err;
+    }
+  };
+  const ssrDynamicImport = (dep) => {
+    if (dep[0] === ".") {
+      dep = path$n.posix.resolve(path$n.dirname(url), dep);
+    }
+    return ssrImport(dep, { isDynamicImport: true });
+  };
+  function ssrExportAll(sourceModule) {
+    for (const key in sourceModule) {
+      if (key !== "default" && key !== "__esModule") {
+        Object.defineProperty(ssrModule, key, {
+          enumerable: true,
+          configurable: true,
+          get() {
+            return sourceModule[key];
+          }
+        });
+      }
+    }
+  }
+  let sourceMapSuffix = "";
+  if (result.map && "version" in result.map) {
+    const moduleSourceMap = Object.assign({}, result.map, {
+      mappings: ";".repeat(asyncFunctionDeclarationPaddingLineCount) + result.map.mappings
+    });
+    sourceMapSuffix = `
+//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(moduleSourceMap)}`;
+  }
+  try {
+    const initModule = new AsyncFunction(
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      '"use strict";' + result.code + `
+//# sourceURL=${mod.id}${sourceMapSuffix}`
+    );
+    await initModule(
+      ssrModule,
+      ssrImportMeta,
+      ssrImport,
+      ssrDynamicImport,
+      ssrExportAll
+    );
+  } catch (e) {
+    mod.ssrError = e;
+    const errorData = importErrors.get(e);
+    if (e.stack && fixStacktrace) {
+      ssrFixStacktrace(e, moduleGraph);
+    }
+    server.config.logger.error(
+      colors$1.red(
+        `Error when evaluating SSR module ${url}:` + (errorData?.importee ? ` failed to import "${errorData.importee}"` : "") + `
+|- ${e.stack}
+`
+      ),
+      {
+        timestamp: true,
+        clear: server.config.clearScreen,
+        error: e
+      }
+    );
+    throw e;
+  } finally {
+    pendingModuleDependencyGraph.delete(url);
+  }
+  return Object.freeze(ssrModule);
+}
+function addPendingModuleDependency(originUrl, depUrl) {
+  if (pendingModuleDependencyGraph.has(originUrl)) {
+    pendingModuleDependencyGraph.get(originUrl).add(depUrl);
+  } else {
+    pendingModuleDependencyGraph.set(originUrl, /* @__PURE__ */ new Set([depUrl]));
+  }
+}
+function checkModuleDependencyExists(originUrl, targetUrl) {
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [originUrl];
+  while (stack.length) {
+    const currentUrl = stack.pop();
+    if (currentUrl === targetUrl) {
+      return true;
+    }
+    if (!visited.has(currentUrl)) {
+      visited.add(currentUrl);
+      const dependencies = pendingModuleDependencyGraph.get(currentUrl);
+      if (dependencies) {
+        for (const depUrl of dependencies) {
+          if (!visited.has(depUrl)) {
+            stack.push(depUrl);
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+async function nodeImport(id, importer, resolveOptions, metadata) {
+  let url;
+  let filePath;
+  if (id.startsWith("data:") || isExternalUrl(id) || isBuiltin(id)) {
+    url = id;
+  } else {
+    const resolved = tryNodeResolve(
+      id,
+      importer,
+      { ...resolveOptions, tryEsmOnly: true },
+      false,
+      void 0,
+      true
+    );
+    if (!resolved) {
+      const err = new Error(
+        `Cannot find module '${id}' imported from '${importer}'`
+      );
+      err.code = "ERR_MODULE_NOT_FOUND";
+      throw err;
+    }
+    filePath = resolved.id;
+    url = pathToFileURL(resolved.id).toString();
+  }
+  const mod = await import(url);
+  if (resolveOptions.legacyProxySsrExternalModules) {
+    return proxyESM(mod);
+  } else if (filePath) {
+    analyzeImportedModDifference(
+      mod,
+      id,
+      isFilePathESM(filePath, resolveOptions.packageCache) ? "module" : void 0,
+      metadata
+    );
+    return mod;
+  } else {
+    return mod;
+  }
+}
+function proxyESM(mod) {
+  if (isPrimitive(mod)) return { default: mod };
+  let defaultExport = "default" in mod ? mod.default : mod;
+  if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+    mod = defaultExport;
+    if ("default" in defaultExport) {
+      defaultExport = defaultExport.default;
+    }
+  }
+  return new Proxy(mod, {
+    get(mod2, prop) {
+      if (prop === "default") return defaultExport;
+      return mod2[prop] ?? defaultExport?.[prop];
+    }
+  });
+}
+function isPrimitive(value) {
+  return !value || typeof value !== "object" && typeof value !== "function";
+}
+
+var isWsl$2 = {exports: {}};
+
+const fs$3 = require$$0__default;
+
+let isDocker$2;
+
+function hasDockerEnv() {
+	try {
+		fs$3.statSync('/.dockerenv');
+		return true;
+	} catch (_) {
+		return false;
+	}
+}
+
+function hasDockerCGroup() {
+	try {
+		return fs$3.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+	} catch (_) {
+		return false;
+	}
+}
+
+var isDocker_1 = () => {
+	if (isDocker$2 === undefined) {
+		isDocker$2 = hasDockerEnv() || hasDockerCGroup();
+	}
+
+	return isDocker$2;
+};
+
+const os = require$$2;
+const fs$2 = require$$0__default;
+const isDocker$1 = isDocker_1;
+
+const isWsl$1 = () => {
+	if (process.platform !== 'linux') {
+		return false;
+	}
+
+	if (os.release().toLowerCase().includes('microsoft')) {
+		if (isDocker$1()) {
+			return false;
+		}
+
+		return true;
+	}
+
+	try {
+		return fs$2.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') ?
+			!isDocker$1() : false;
+	} catch (_) {
+		return false;
+	}
+};
+
+if (process.env.__IS_WSL_TEST__) {
+	isWsl$2.exports = isWsl$1;
+} else {
+	isWsl$2.exports = isWsl$1();
+}
+
+var isWslExports = isWsl$2.exports;
+
+var defineLazyProp = (object, propertyName, fn) => {
+	const define = value => Object.defineProperty(object, propertyName, {value, enumerable: true, writable: true});
+
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = fn();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+
+	return object;
+};
+
+const path$3 = require$$0$4;
+const childProcess = require$$2$1;
+const {promises: fs$1, constants: fsConstants} = require$$0__default;
+const isWsl = isWslExports;
+const isDocker = isDocker_1;
+const defineLazyProperty = defineLazyProp;
+
+// Path to included `xdg-open`.
+const localXdgOpenPath = path$3.join(__dirname, 'xdg-open');
+
+const {platform, arch} = process;
+
+// Podman detection
+const hasContainerEnv = () => {
+	try {
+		fs$1.statSync('/run/.containerenv');
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+let cachedResult;
+function isInsideContainer() {
+	if (cachedResult === undefined) {
+		cachedResult = hasContainerEnv() || isDocker();
+	}
+
+	return cachedResult;
+}
+
+/**
+Get the mount point for fixed drives in WSL.
+
+@inner
+@returns {string} The mount point.
+*/
+const getWslDrivesMountPoint = (() => {
+	// Default value for "root" param
+	// according to https://docs.microsoft.com/en-us/windows/wsl/wsl-config
+	const defaultMountPoint = '/mnt/';
+
+	let mountPoint;
+
+	return async function () {
+		if (mountPoint) {
+			// Return memoized mount point value
+			return mountPoint;
+		}
+
+		const configFilePath = '/etc/wsl.conf';
+
+		let isConfigFileExists = false;
+		try {
+			await fs$1.access(configFilePath, fsConstants.F_OK);
+			isConfigFileExists = true;
+		} catch {}
+
+		if (!isConfigFileExists) {
+			return defaultMountPoint;
+		}
+
+		const configContent = await fs$1.readFile(configFilePath, {encoding: 'utf8'});
+		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+
+		if (!configMountPoint) {
+			return defaultMountPoint;
+		}
+
+		mountPoint = configMountPoint.groups.mountPoint.trim();
+		mountPoint = mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`;
+
+		return mountPoint;
+	};
+})();
+
+const pTryEach = async (array, mapper) => {
+	let latestError;
+
+	for (const item of array) {
+		try {
+			return await mapper(item); // eslint-disable-line no-await-in-loop
+		} catch (error) {
+			latestError = error;
+		}
+	}
+
+	throw latestError;
+};
+
+const baseOpen = async options => {
+	options = {
+		wait: false,
+		background: false,
+		newInstance: false,
+		allowNonzeroExitCode: false,
+		...options
+	};
+
+	if (Array.isArray(options.app)) {
+		return pTryEach(options.app, singleApp => baseOpen({
+			...options,
+			app: singleApp
+		}));
+	}
+
+	let {name: app, arguments: appArguments = []} = options.app || {};
+	appArguments = [...appArguments];
+
+	if (Array.isArray(app)) {
+		return pTryEach(app, appName => baseOpen({
+			...options,
+			app: {
+				name: appName,
+				arguments: appArguments
+			}
+		}));
+	}
+
+	let command;
+	const cliArguments = [];
+	const childProcessOptions = {};
+
+	if (platform === 'darwin') {
+		command = 'open';
+
+		if (options.wait) {
+			cliArguments.push('--wait-apps');
+		}
+
+		if (options.background) {
+			cliArguments.push('--background');
+		}
+
+		if (options.newInstance) {
+			cliArguments.push('--new');
+		}
+
+		if (app) {
+			cliArguments.push('-a', app);
+		}
+	} else if (platform === 'win32' || (isWsl && !isInsideContainer() && !app)) {
+		const mountPoint = await getWslDrivesMountPoint();
+
+		command = isWsl ?
+			`${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` :
+			`${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+
+		cliArguments.push(
+			'-NoProfile',
+			'-NonInteractive',
+			'–ExecutionPolicy',
+			'Bypass',
+			'-EncodedCommand'
+		);
+
+		if (!isWsl) {
+			childProcessOptions.windowsVerbatimArguments = true;
+		}
+
+		const encodedArguments = ['Start'];
+
+		if (options.wait) {
+			encodedArguments.push('-Wait');
+		}
+
+		if (app) {
+			// Double quote with double quotes to ensure the inner quotes are passed through.
+			// Inner quotes are delimited for PowerShell interpretation with backticks.
+			encodedArguments.push(`"\`"${app}\`""`, '-ArgumentList');
+			if (options.target) {
+				appArguments.unshift(options.target);
+			}
+		} else if (options.target) {
+			encodedArguments.push(`"${options.target}"`);
+		}
+
+		if (appArguments.length > 0) {
+			appArguments = appArguments.map(arg => `"\`"${arg}\`""`);
+			encodedArguments.push(appArguments.join(','));
+		}
+
+		// Using Base64-encoded command, accepted by PowerShell, to allow special characters.
+		options.target = Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+	} else {
+		if (app) {
+			command = app;
+		} else {
+			// When bundled by Webpack, there's no actual package file path and no local `xdg-open`.
+			const isBundled = !__dirname || __dirname === '/';
+
+			// Check if local `xdg-open` exists and is executable.
+			let exeLocalXdgOpen = false;
+			try {
+				await fs$1.access(localXdgOpenPath, fsConstants.X_OK);
+				exeLocalXdgOpen = true;
+			} catch {}
+
+			const useSystemXdgOpen = process.versions.electron ||
+				platform === 'android' || isBundled || !exeLocalXdgOpen;
+			command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
+		}
+
+		if (appArguments.length > 0) {
+			cliArguments.push(...appArguments);
+		}
+
+		if (!options.wait) {
+			// `xdg-open` will block the process unless stdio is ignored
+			// and it's detached from the parent even if it's unref'd.
+			childProcessOptions.stdio = 'ignore';
+			childProcessOptions.detached = true;
+		}
+	}
+
+	if (options.target) {
+		cliArguments.push(options.target);
+	}
+
+	if (platform === 'darwin' && appArguments.length > 0) {
+		cliArguments.push('--args', ...appArguments);
+	}
+
+	const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+
+	if (options.wait) {
+		return new Promise((resolve, reject) => {
+			subprocess.once('error', reject);
+
+			subprocess.once('close', exitCode => {
+				if (!options.allowNonzeroExitCode && exitCode > 0) {
+					reject(new Error(`Exited with code ${exitCode}`));
+					return;
+				}
+
+				resolve(subprocess);
+			});
+		});
+	}
+
+	subprocess.unref();
+
+	return subprocess;
+};
+
+const open = (target, options) => {
+	if (typeof target !== 'string') {
+		throw new TypeError('Expected a `target`');
+	}
+
+	return baseOpen({
+		...options,
+		target
+	});
+};
+
+const openApp = (name, options) => {
+	if (typeof name !== 'string') {
+		throw new TypeError('Expected a `name`');
+	}
+
+	const {arguments: appArguments = []} = options || {};
+	if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
+		throw new TypeError('Expected `appArguments` as Array type');
+	}
+
+	return baseOpen({
+		...options,
+		app: {
+			name,
+			arguments: appArguments
+		}
+	});
+};
+
+function detectArchBinary(binary) {
+	if (typeof binary === 'string' || Array.isArray(binary)) {
+		return binary;
+	}
+
+	const {[arch]: archBinary} = binary;
+
+	if (!archBinary) {
+		throw new Error(`${arch} is not supported`);
+	}
+
+	return archBinary;
+}
+
+function detectPlatformBinary({[platform]: platformBinary}, {wsl}) {
+	if (wsl && isWsl) {
+		return detectArchBinary(wsl);
+	}
+
+	if (!platformBinary) {
+		throw new Error(`${platform} is not supported`);
+	}
+
+	return detectArchBinary(platformBinary);
+}
+
+const apps = {};
+
+defineLazyProperty(apps, 'chrome', () => detectPlatformBinary({
+	darwin: 'google chrome',
+	win32: 'chrome',
+	linux: ['google-chrome', 'google-chrome-stable', 'chromium']
+}, {
+	wsl: {
+		ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+		x64: ['/mnt/c/Program Files/Google/Chrome/Application/chrome.exe', '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe']
+	}
+}));
+
+defineLazyProperty(apps, 'firefox', () => detectPlatformBinary({
+	darwin: 'firefox',
+	win32: 'C:\\Program Files\\Mozilla Firefox\\firefox.exe',
+	linux: 'firefox'
+}, {
+	wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+}));
+
+defineLazyProperty(apps, 'edge', () => detectPlatformBinary({
+	darwin: 'microsoft edge',
+	win32: 'msedge',
+	linux: ['microsoft-edge', 'microsoft-edge-dev']
+}, {
+	wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+}));
+
+open.apps = apps;
+open.openApp = openApp;
+
+var open_1 = open;
+
+var open$1 = /*@__PURE__*/getDefaultExportFromCjs(open_1);
+
+var crossSpawn = {exports: {}};
+
+var windows;
+var hasRequiredWindows;
+
+function requireWindows () {
+	if (hasRequiredWindows) return windows;
+	hasRequiredWindows = 1;
+	windows = isexe;
+	isexe.sync = sync;
+
+	var fs = require$$0__default;
+
+	function checkPathExt (path, options) {
+	  var pathext = options.pathExt !== undefined ?
+	    options.pathExt : process.env.PATHEXT;
+
+	  if (!pathext) {
+	    return true
+	  }
+
+	  pathext = pathext.split(';');
+	  if (pathext.indexOf('') !== -1) {
+	    return true
+	  }
+	  for (var i = 0; i < pathext.length; i++) {
+	    var p = pathext[i].toLowerCase();
+	    if (p && path.substr(-p.length).toLowerCase() === p) {
+	      return true
+	    }
+	  }
+	  return false
+	}
+
+	function checkStat (stat, path, options) {
+	  if (!stat.isSymbolicLink() && !stat.isFile()) {
+	    return false
+	  }
+	  return checkPathExt(path, options)
+	}
+
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, path, options));
+	  });
+	}
+
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), path, options)
+	}
+	return windows;
+}
+
+var mode;
+var hasRequiredMode;
+
+function requireMode () {
+	if (hasRequiredMode) return mode;
+	hasRequiredMode = 1;
+	mode = isexe;
+	isexe.sync = sync;
+
+	var fs = require$$0__default;
+
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, options));
+	  });
+	}
+
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), options)
+	}
+
+	function checkStat (stat, options) {
+	  return stat.isFile() && checkMode(stat, options)
+	}
+
+	function checkMode (stat, options) {
+	  var mod = stat.mode;
+	  var uid = stat.uid;
+	  var gid = stat.gid;
+
+	  var myUid = options.uid !== undefined ?
+	    options.uid : process.getuid && process.getuid();
+	  var myGid = options.gid !== undefined ?
+	    options.gid : process.getgid && process.getgid();
+
+	  var u = parseInt('100', 8);
+	  var g = parseInt('010', 8);
+	  var o = parseInt('001', 8);
+	  var ug = u | g;
+
+	  var ret = (mod & o) ||
+	    (mod & g) && gid === myGid ||
+	    (mod & u) && uid === myUid ||
+	    (mod & ug) && myUid === 0;
+
+	  return ret
+	}
+	return mode;
+}
+
+var core;
+if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
+  core = requireWindows();
+} else {
+  core = requireMode();
+}
+
+var isexe_1 = isexe$1;
+isexe$1.sync = sync;
+
+function isexe$1 (path, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+
+  if (!cb) {
+    if (typeof Promise !== 'function') {
+      throw new TypeError('callback not provided')
+    }
+
+    return new Promise(function (resolve, reject) {
+      isexe$1(path, options || {}, function (er, is) {
+        if (er) {
+          reject(er);
+        } else {
+          resolve(is);
+        }
+      });
+    })
+  }
+
+  core(path, options || {}, function (er, is) {
+    // ignore EACCES because that just means we aren't allowed to run it
+    if (er) {
+      if (er.code === 'EACCES' || options && options.ignoreErrors) {
+        er = null;
+        is = false;
+      }
+    }
+    cb(er, is);
+  });
+}
+
+function sync (path, options) {
+  // my kingdom for a filtered catch
+  try {
+    return core.sync(path, options || {})
+  } catch (er) {
+    if (options && options.ignoreErrors || er.code === 'EACCES') {
+      return false
+    } else {
+      throw er
+    }
+  }
+}
+
+const isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys';
+
+const path$2 = require$$0$4;
+const COLON = isWindows ? ';' : ':';
+const isexe = isexe_1;
+
+const getNotFoundError = (cmd) =>
+  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
+
+const getPathInfo = (cmd, opt) => {
+  const colon = opt.colon || COLON;
+
+  // If it has a slash, then we don't bother searching the pathenv.
+  // just check the file itself, and that's it.
+  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
+    : (
+      [
+        // windows always checks the cwd first
+        ...(isWindows ? [process.cwd()] : []),
+        ...(opt.path || process.env.PATH ||
+          /* istanbul ignore next: very unusual */ '').split(colon),
+      ]
+    );
+  const pathExtExe = isWindows
+    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
+    : '';
+  const pathExt = isWindows ? pathExtExe.split(colon) : [''];
+
+  if (isWindows) {
+    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
+      pathExt.unshift('');
+  }
+
+  return {
+    pathEnv,
+    pathExt,
+    pathExtExe,
+  }
+};
+
+const which$1 = (cmd, opt, cb) => {
+  if (typeof opt === 'function') {
+    cb = opt;
+    opt = {};
+  }
+  if (!opt)
+    opt = {};
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  const step = i => new Promise((resolve, reject) => {
+    if (i === pathEnv.length)
+      return opt.all && found.length ? resolve(found)
+        : reject(getNotFoundError(cmd))
+
+    const ppRaw = pathEnv[i];
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+
+    const pCmd = path$2.join(pathPart, cmd);
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd;
+
+    resolve(subStep(p, i, 0));
+  });
+
+  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+    if (ii === pathExt.length)
+      return resolve(step(i + 1))
+    const ext = pathExt[ii];
+    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+      if (!er && is) {
+        if (opt.all)
+          found.push(p + ext);
+        else
+          return resolve(p + ext)
+      }
+      return resolve(subStep(p, i, ii + 1))
+    });
+  });
+
+  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
+};
+
+const whichSync = (cmd, opt) => {
+  opt = opt || {};
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  for (let i = 0; i < pathEnv.length; i ++) {
+    const ppRaw = pathEnv[i];
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+
+    const pCmd = path$2.join(pathPart, cmd);
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd;
+
+    for (let j = 0; j < pathExt.length; j ++) {
+      const cur = p + pathExt[j];
+      try {
+        const is = isexe.sync(cur, { pathExt: pathExtExe });
+        if (is) {
+          if (opt.all)
+            found.push(cur);
+          else
+            return cur
+        }
+      } catch (ex) {}
+    }
+  }
+
+  if (opt.all && found.length)
+    return found
+
+  if (opt.nothrow)
+    return null
+
+  throw getNotFoundError(cmd)
+};
+
+var which_1 = which$1;
+which$1.sync = whichSync;
+
+var pathKey$1 = {exports: {}};
+
+const pathKey = (options = {}) => {
+	const environment = options.env || process.env;
+	const platform = options.platform || process.platform;
+
+	if (platform !== 'win32') {
+		return 'PATH';
+	}
+
+	return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
+};
+
+pathKey$1.exports = pathKey;
+// TODO: Remove this for the next major release
+pathKey$1.exports.default = pathKey;
+
+var pathKeyExports = pathKey$1.exports;
+
+const path$1 = require$$0$4;
+const which = which_1;
+const getPathKey = pathKeyExports;
+
+function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    // Worker threads do not have process.chdir()
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+
+    // If a custom `cwd` was specified, we need to change the process cwd
+    // because `which` will do stat calls but does not support a custom cwd
+    if (shouldSwitchCwd) {
+        try {
+            process.chdir(parsed.options.cwd);
+        } catch (err) {
+            /* Empty */
+        }
+    }
+
+    let resolved;
+
+    try {
+        resolved = which.sync(parsed.command, {
+            path: env[getPathKey({ env })],
+            pathExt: withoutPathExt ? path$1.delimiter : undefined,
+        });
+    } catch (e) {
+        /* Empty */
+    } finally {
+        if (shouldSwitchCwd) {
+            process.chdir(cwd);
+        }
+    }
+
+    // If we successfully resolved, ensure that an absolute path is returned
+    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
+    if (resolved) {
+        resolved = path$1.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+    }
+
+    return resolved;
+}
+
+function resolveCommand$1(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+}
+
+var resolveCommand_1 = resolveCommand$1;
+
+var _escape = {};
+
+// See http://www.robvanderwoude.com/escapechars.php
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+
+function escapeCommand(arg) {
+    // Escape meta chars
+    arg = arg.replace(metaCharsRegExp, '^$1');
+
+    return arg;
+}
+
+function escapeArgument(arg, doubleEscapeMetaChars) {
+    // Convert to string
+    arg = `${arg}`;
+
+    // Algorithm below is based on https://qntm.org/cmd
+
+    // Sequence of backslashes followed by a double quote:
+    // double up all the backslashes and escape the double quote
+    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+
+    // Sequence of backslashes followed by the end of the string
+    // (which will become a double quote later):
+    // double up all the backslashes
+    arg = arg.replace(/(\\*)$/, '$1$1');
+
+    // All other backslashes occur literally
+
+    // Quote the whole thing:
+    arg = `"${arg}"`;
+
+    // Escape meta chars
+    arg = arg.replace(metaCharsRegExp, '^$1');
+
+    // Double escape meta chars if necessary
+    if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, '^$1');
+    }
+
+    return arg;
+}
+
+_escape.command = escapeCommand;
+_escape.argument = escapeArgument;
+
+var shebangRegex$1 = /^#!(.*)/;
+
+const shebangRegex = shebangRegex$1;
+
+var shebangCommand$1 = (string = '') => {
+	const match = string.match(shebangRegex);
+
+	if (!match) {
+		return null;
+	}
+
+	const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+	const binary = path.split('/').pop();
+
+	if (binary === 'env') {
+		return argument;
+	}
+
+	return argument ? `${binary} ${argument}` : binary;
+};
+
+const fs = require$$0__default;
+const shebangCommand = shebangCommand$1;
+
+function readShebang$1(command) {
+    // Read the first 150 bytes from the file
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+
+    let fd;
+
+    try {
+        fd = fs.openSync(command, 'r');
+        fs.readSync(fd, buffer, 0, size, 0);
+        fs.closeSync(fd);
+    } catch (e) { /* Empty */ }
+
+    // Attempt to extract shebang (null is returned if not a shebang)
+    return shebangCommand(buffer.toString());
+}
+
+var readShebang_1 = readShebang$1;
+
+const path = require$$0$4;
+const resolveCommand = resolveCommand_1;
+const escape$1 = _escape;
+const readShebang = readShebang_1;
+
+const isWin$1 = process.platform === 'win32';
+const isExecutableRegExp = /\.(?:com|exe)$/i;
+const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+
+function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+
+    const shebang = parsed.file && readShebang(parsed.file);
+
+    if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+
+        return resolveCommand(parsed);
+    }
+
+    return parsed.file;
+}
+
+function parseNonShell(parsed) {
+    if (!isWin$1) {
+        return parsed;
+    }
+
+    // Detect & add support for shebangs
+    const commandFile = detectShebang(parsed);
+
+    // We don't need a shell if the command filename is an executable
+    const needsShell = !isExecutableRegExp.test(commandFile);
+
+    // If a shell is required, use cmd.exe and take care of escaping everything correctly
+    // Note that `forceShell` is an hidden option used only in tests
+    if (parsed.options.forceShell || needsShell) {
+        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
+        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
+        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
+        // we need to double escape them
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+
+        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
+        // This is necessary otherwise it will always fail with ENOENT in those cases
+        parsed.command = path.normalize(parsed.command);
+
+        // Escape command & arguments
+        parsed.command = escape$1.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape$1.argument(arg, needsDoubleEscapeMetaChars));
+
+        const shellCommand = [parsed.command].concat(parsed.args).join(' ');
+
+        parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
+        parsed.command = process.env.comspec || 'cmd.exe';
+        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
+    }
+
+    return parsed;
+}
+
+function parse$4(command, args, options) {
+    // Normalize arguments, similar to nodejs
+    if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+    }
+
+    args = args ? args.slice(0) : []; // Clone array to avoid changing the original
+    options = Object.assign({}, options); // Clone object to avoid changing the original
+
+    // Build our parsed object
+    const parsed = {
+        command,
+        args,
+        options,
+        file: undefined,
+        original: {
+            command,
+            args,
+        },
+    };
+
+    // Delegate further parsing to shell or non-shell
+    return options.shell ? parsed : parseNonShell(parsed);
+}
+
+var parse_1 = parse$4;
+
+const isWin = process.platform === 'win32';
+
+function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: 'ENOENT',
+        errno: 'ENOENT',
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args,
+    });
+}
+
+function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+        return;
+    }
+
+    const originalEmit = cp.emit;
+
+    cp.emit = function (name, arg1) {
+        // If emitting "exit" event and exit code is 1, we need to check if
+        // the command exists and emit an "error" instead
+        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
+        if (name === 'exit') {
+            const err = verifyENOENT(arg1, parsed);
+
+            if (err) {
+                return originalEmit.call(cp, 'error', err);
+            }
+        }
+
+        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
+    };
+}
+
+function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawn');
+    }
+
+    return null;
+}
+
+function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, 'spawnSync');
+    }
+
+    return null;
+}
+
+var enoent$1 = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError,
+};
+
+const cp = require$$2$1;
+const parse$3 = parse_1;
+const enoent = enoent$1;
+
+function spawn(command, args, options) {
+    // Parse the arguments
+    const parsed = parse$3(command, args, options);
+
+    // Spawn the child process
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+
+    // Hook into child process "exit" event to emit an error if the command
+    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+    enoent.hookChildProcess(spawned, parsed);
+
+    return spawned;
+}
+
+function spawnSync(command, args, options) {
+    // Parse the arguments
+    const parsed = parse$3(command, args, options);
+
+    // Spawn the child process
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+
+    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+
+    return result;
+}
+
+crossSpawn.exports = spawn;
+crossSpawn.exports.spawn = spawn;
+crossSpawn.exports.sync = spawnSync;
+
+crossSpawn.exports._parse = parse$3;
+crossSpawn.exports._enoent = enoent;
+
+var crossSpawnExports = crossSpawn.exports;
+var spawn$1 = /*@__PURE__*/getDefaultExportFromCjs(crossSpawnExports);
+
+function openBrowser(url, opt, logger) {
+  const browser = process.env.BROWSER || "";
+  if (browser.toLowerCase().endsWith(".js")) {
+    executeNodeScript(browser, url, logger);
+  } else if (browser.toLowerCase() !== "none") {
+    const browserArgs = process.env.BROWSER_ARGS ? process.env.BROWSER_ARGS.split(" ") : [];
+    startBrowserProcess(browser, browserArgs, url, logger);
+  }
+}
+function executeNodeScript(scriptPath, url, logger) {
+  const extraArgs = process.argv.slice(2);
+  const child = spawn$1(process.execPath, [scriptPath, ...extraArgs, url], {
+    stdio: "inherit"
+  });
+  child.on("close", (code) => {
+    if (code !== 0) {
+      logger.error(
+        colors$1.red(
+          `
+The script specified as BROWSER environment variable failed.
+
+${colors$1.cyan(
+            scriptPath
+          )} exited with code ${code}.`
+        ),
+        { error: null }
+      );
+    }
+  });
+}
+const supportedChromiumBrowsers = [
+  "Google Chrome Canary",
+  "Google Chrome Dev",
+  "Google Chrome Beta",
+  "Google Chrome",
+  "Microsoft Edge",
+  "Brave Browser",
+  "Vivaldi",
+  "Chromium"
+];
+async function startBrowserProcess(browser, browserArgs, url, logger) {
+  const preferredOSXBrowser = browser === "google chrome" ? "Google Chrome" : browser;
+  const shouldTryOpenChromeWithAppleScript = process.platform === "darwin" && (!preferredOSXBrowser || supportedChromiumBrowsers.includes(preferredOSXBrowser));
+  if (shouldTryOpenChromeWithAppleScript) {
+    try {
+      const ps = await execAsync("ps cax");
+      const openedBrowser = preferredOSXBrowser && ps.includes(preferredOSXBrowser) ? preferredOSXBrowser : supportedChromiumBrowsers.find((b) => ps.includes(b));
+      if (openedBrowser) {
+        await execAsync(
+          `osascript openChrome.applescript "${encodeURI(
+            url
+          )}" "${openedBrowser}"`,
+          {
+            cwd: join$2(VITE_PACKAGE_DIR, "bin")
+          }
+        );
+        return true;
+      }
+    } catch (err) {
+    }
+  }
+  if (process.platform === "darwin" && browser === "open") {
+    browser = void 0;
+  }
+  try {
+    const options = browser ? { app: { name: browser, arguments: browserArgs } } : {};
+    new Promise((_, reject) => {
+      open$1(url, options).then((subprocess) => {
+        subprocess.on("error", reject);
+      }).catch(reject);
+    }).catch((err) => {
+      logger.error(err.stack || err.message);
+    });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+function execAsync(command, options) {
+  return new Promise((resolve, reject) => {
+    exec(command, options, (error, stdout) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(stdout.toString());
+      }
+    });
+  });
+}
+
+function bindCLIShortcuts(server, opts) {
+  if (!server.httpServer || !process.stdin.isTTY || process.env.CI) {
+    return;
+  }
+  const isDev = isDevServer(server);
+  if (isDev) {
+    server._shortcutsOptions = opts;
+  }
+  if (opts?.print) {
+    server.config.logger.info(
+      colors$1.dim(colors$1.green("  \u279C")) + colors$1.dim("  press ") + colors$1.bold("h + enter") + colors$1.dim(" to show help")
+    );
+  }
+  const shortcuts = (opts?.customShortcuts ?? []).concat(
+    isDev ? BASE_DEV_SHORTCUTS : BASE_PREVIEW_SHORTCUTS
+  );
+  let actionRunning = false;
+  const onInput = async (input) => {
+    if (actionRunning) return;
+    if (input === "h") {
+      const loggedKeys = /* @__PURE__ */ new Set();
+      server.config.logger.info("\n  Shortcuts");
+      for (const shortcut2 of shortcuts) {
+        if (loggedKeys.has(shortcut2.key)) continue;
+        loggedKeys.add(shortcut2.key);
+        if (shortcut2.action == null) continue;
+        server.config.logger.info(
+          colors$1.dim("  press ") + colors$1.bold(`${shortcut2.key} + enter`) + colors$1.dim(` to ${shortcut2.description}`)
+        );
+      }
+      return;
+    }
+    const shortcut = shortcuts.find((shortcut2) => shortcut2.key === input);
+    if (!shortcut || shortcut.action == null) return;
+    actionRunning = true;
+    await shortcut.action(server);
+    actionRunning = false;
+  };
+  const rl = readline.createInterface({ input: process.stdin });
+  rl.on("line", onInput);
+  server.httpServer.on("close", () => rl.close());
+}
+const BASE_DEV_SHORTCUTS = [
+  {
+    key: "r",
+    description: "restart the server",
+    async action(server) {
+      await restartServerWithUrls(server);
+    }
+  },
+  {
+    key: "u",
+    description: "show server url",
+    action(server) {
+      server.config.logger.info("");
+      server.printUrls();
+    }
+  },
+  {
+    key: "o",
+    description: "open in browser",
+    action(server) {
+      server.openBrowser();
+    }
+  },
+  {
+    key: "c",
+    description: "clear console",
+    action(server) {
+      server.config.logger.clearScreen("error");
+    }
+  },
+  {
+    key: "q",
+    description: "quit",
+    async action(server) {
+      try {
+        await server.close();
+      } finally {
+        process.exit();
+      }
+    }
+  }
+];
+const BASE_PREVIEW_SHORTCUTS = [
+  {
+    key: "o",
+    description: "open in browser",
+    action(server) {
+      const url = server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
+      if (url) {
+        openBrowser(url, true, server.config.logger);
+      } else {
+        server.config.logger.warn("No URL available to open in browser");
+      }
+    }
+  },
+  {
+    key: "q",
+    description: "quit",
+    async action(server) {
+      try {
+        await server.close();
+      } finally {
+        process.exit();
+      }
+    }
+  }
+];
+
+function getResolvedOutDirs(root, outDir, outputOptions) {
+  const resolvedOutDir = path$n.resolve(root, outDir);
+  if (!outputOptions) return /* @__PURE__ */ new Set([resolvedOutDir]);
+  return new Set(
+    arraify(outputOptions).map(
+      ({ dir }) => dir ? path$n.resolve(root, dir) : resolvedOutDir
+    )
+  );
+}
+function resolveEmptyOutDir(emptyOutDir, root, outDirs, logger) {
+  if (emptyOutDir != null) return emptyOutDir;
+  for (const outDir of outDirs) {
+    if (!normalizePath$3(outDir).startsWith(withTrailingSlash(root))) {
+      logger?.warn(
+        colors$1.yellow(
+          `
+${colors$1.bold(`(!)`)} outDir ${colors$1.white(
+            colors$1.dim(outDir)
+          )} is not inside project root and will not be emptied.
+Use --emptyOutDir to override.
+`
+        )
+      );
+      return false;
+    }
+  }
+  return true;
+}
+function resolveChokidarOptions(options, resolvedOutDirs, emptyOutDir, cacheDir) {
+  const { ignored: ignoredList, ...otherOptions } = options ?? {};
+  const ignored = [
+    "**/.git/**",
+    "**/node_modules/**",
+    "**/test-results/**",
+    // Playwright
+    glob.escapePath(cacheDir) + "/**",
+    ...arraify(ignoredList || [])
+  ];
+  if (emptyOutDir) {
+    ignored.push(
+      ...[...resolvedOutDirs].map((outDir) => glob.escapePath(outDir) + "/**")
+    );
+  }
+  const resolvedWatchOptions = {
+    ignored,
+    ignoreInitial: true,
+    ignorePermissionErrors: true,
+    ...otherOptions
+  };
+  return resolvedWatchOptions;
+}
+class NoopWatcher extends EventEmitter$4 {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  add() {
+    return this;
+  }
+  unwatch() {
+    return this;
+  }
+  getWatched() {
+    return {};
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  async close() {
+  }
+}
+function createNoopWatcher(options) {
+  return new NoopWatcher(options);
+}
+
+async function fetchModule(server, url, importer, options = {}) {
+  if (url.startsWith("data:") || isBuiltin(url)) {
+    return { externalize: url, type: "builtin" };
+  }
+  if (isExternalUrl(url)) {
+    return { externalize: url, type: "network" };
+  }
+  if (url[0] !== "." && url[0] !== "/") {
+    const {
+      isProduction,
+      resolve: { dedupe, preserveSymlinks },
+      root,
+      ssr
+    } = server.config;
+    const overrideConditions = ssr.resolve?.externalConditions || [];
+    const resolveOptions = {
+      mainFields: ["main"],
+      conditions: [],
+      overrideConditions: [...overrideConditions, "production", "development"],
+      extensions: [".js", ".cjs", ".json"],
+      dedupe,
+      preserveSymlinks,
+      isBuild: false,
+      isProduction,
+      root,
+      ssrConfig: ssr,
+      packageCache: server.config.packageCache
+    };
+    const resolved = tryNodeResolve(
+      url,
+      importer,
+      { ...resolveOptions, tryEsmOnly: true },
+      false,
+      void 0,
+      true
+    );
+    if (!resolved) {
+      const err = new Error(
+        `Cannot find module '${url}' imported from '${importer}'`
+      );
+      err.code = "ERR_MODULE_NOT_FOUND";
+      throw err;
+    }
+    const file = pathToFileURL(resolved.id).toString();
+    const type = isFilePathESM(resolved.id, server.config.packageCache) ? "module" : "commonjs";
+    return { externalize: file, type };
+  }
+  url = unwrapId$1(url);
+  let result = await server.transformRequest(url, { ssr: true });
+  if (!result) {
+    throw new Error(
+      `[vite] transform failed for module '${url}'${importer ? ` imported from '${importer}'` : ""}.`
+    );
+  }
+  const mod = await server.moduleGraph.getModuleByUrl(url, true);
+  if (!mod) {
+    throw new Error(
+      `[vite] cannot find module '${url}' ${importer ? ` imported from '${importer}'` : ""}.`
+    );
+  }
+  if (options.inlineSourceMap !== false) {
+    result = inlineSourceMap(mod, result, options.processSourceMap);
+  }
+  if (result.code[0] === "#")
+    result.code = result.code.replace(/^#!.*/, (s) => " ".repeat(s.length));
+  return { code: result.code, file: mod.file };
+}
+const OTHER_SOURCE_MAP_REGEXP = new RegExp(
+  `//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`,
+  "gm"
+);
+function inlineSourceMap(mod, result, processSourceMap) {
+  const map = result.map;
+  let code = result.code;
+  if (!map || !("version" in map) || code.includes(VITE_RUNTIME_SOURCEMAPPING_SOURCE))
+    return result;
+  OTHER_SOURCE_MAP_REGEXP.lastIndex = 0;
+  if (OTHER_SOURCE_MAP_REGEXP.test(code))
+    code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
+  const sourceMap = processSourceMap?.(map) || map;
+  result.code = `${code.trimEnd()}
+//# sourceURL=${mod.id}
+${VITE_RUNTIME_SOURCEMAPPING_SOURCE}
+//# ${SOURCEMAPPING_URL}=${genSourceMapUrl(sourceMap)}
+`;
+  return result;
+}
+
+function ssrFetchModule(server, id, importer) {
+  return fetchModule(server, id, importer, {
+    processSourceMap(map) {
+      return Object.assign({}, map, {
+        mappings: ";".repeat(asyncFunctionDeclarationPaddingLineCount) + map.mappings
+      });
+    }
+  });
+}
+
+var bufferUtil$1 = {exports: {}};
+
+const BINARY_TYPES$2 = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob$1 = typeof Blob !== 'undefined';
+
+if (hasBlob$1) BINARY_TYPES$2.push('blob');
+
+var constants = {
+  BINARY_TYPES: BINARY_TYPES$2,
+  EMPTY_BUFFER: Buffer.alloc(0),
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob: hasBlob$1,
+  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+  kListener: Symbol('kListener'),
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  NOOP: () => {}
+};
+
+const { EMPTY_BUFFER: EMPTY_BUFFER$3 } = constants;
+
+const FastBuffer$2 = Buffer[Symbol.species];
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat$1(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER$3;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  if (offset < totalLength) {
+    return new FastBuffer$2(target.buffer, target.byteOffset, offset);
+  }
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  for (let i = 0; i < buffer.length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer$1(buf) {
+  if (buf.length === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer$2(data) {
+  toBuffer$2.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = new FastBuffer$2(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = new FastBuffer$2(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer$2.readOnly = false;
+  }
+
+  return buf;
+}
+
+bufferUtil$1.exports = {
+  concat: concat$1,
+  mask: _mask,
+  toArrayBuffer: toArrayBuffer$1,
+  toBuffer: toBuffer$2,
+  unmask: _unmask
+};
+
+/* istanbul ignore else  */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+  try {
+    const bufferUtil = require('bufferutil');
+
+    bufferUtil$1.exports.mask = function (source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bufferUtil.mask(source, mask, output, offset, length);
+    };
+
+    bufferUtil$1.exports.unmask = function (buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bufferUtil.unmask(buffer, mask);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}
+
+var bufferUtilExports = bufferUtil$1.exports;
+
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
+
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+let Limiter$1 = class Limiter {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(concurrency) {
+    this[kDone] = () => {
+      this.pending--;
+      this[kRun]();
+    };
+    this.concurrency = concurrency || Infinity;
+    this.jobs = [];
+    this.pending = 0;
+  }
+
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(job) {
+    this.jobs.push(job);
+    this[kRun]();
+  }
+
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [kRun]() {
+    if (this.pending === this.concurrency) return;
+
+    if (this.jobs.length) {
+      const job = this.jobs.shift();
+
+      this.pending++;
+      job(this[kDone]);
+    }
+  }
+};
+
+var limiter = Limiter$1;
+
+const zlib = zlib$1;
+
+const bufferUtil = bufferUtilExports;
+const Limiter = limiter;
+const { kStatusCode: kStatusCode$2 } = constants;
+
+const FastBuffer$1 = Buffer[Symbol.species];
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError$1 = Symbol('error');
+
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
+
+/**
+ * permessage-deflate implementation.
+ */
+let PerMessageDeflate$4 = class PerMessageDeflate {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed if context takeover is disabled
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(options, isServer, maxPayload) {
+    this._maxPayload = maxPayload | 0;
+    this._options = options || {};
+    this._threshold =
+      this._options.threshold !== undefined ? this._options.threshold : 1024;
+    this._isServer = !!isServer;
+    this._deflate = null;
+    this._inflate = null;
+
+    this.params = null;
+
+    if (!zlibLimiter) {
+      const concurrency =
+        this._options.concurrencyLimit !== undefined
+          ? this._options.concurrencyLimit
+          : 10;
+      zlibLimiter = new Limiter(concurrency);
+    }
+  }
+
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return 'permessage-deflate';
+  }
+
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const params = {};
+
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+
+    return params;
+  }
+
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(configurations) {
+    configurations = this.normalizeParams(configurations);
+
+    this.params = this._isServer
+      ? this.acceptAsServer(configurations)
+      : this.acceptAsClient(configurations);
+
+    return this.params;
+  }
+
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate) {
+      this._inflate.close();
+      this._inflate = null;
+    }
+
+    if (this._deflate) {
+      const callback = this._deflate[kCallback];
+
+      this._deflate.close();
+      this._deflate = null;
+
+      if (callback) {
+        callback(
+          new Error(
+            'The deflate stream was closed while data was being processed'
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(offers) {
+    const opts = this._options;
+    const accepted = offers.find((params) => {
+      if (
+        (opts.serverNoContextTakeover === false &&
+          params.server_no_context_takeover) ||
+        (params.server_max_window_bits &&
+          (opts.serverMaxWindowBits === false ||
+            (typeof opts.serverMaxWindowBits === 'number' &&
+              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
+        (typeof opts.clientMaxWindowBits === 'number' &&
+          !params.client_max_window_bits)
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!accepted) {
+      throw new Error('None of the extension offers can be accepted');
+    }
+
+    if (opts.serverNoContextTakeover) {
+      accepted.server_no_context_takeover = true;
+    }
+    if (opts.clientNoContextTakeover) {
+      accepted.client_no_context_takeover = true;
+    }
+    if (typeof opts.serverMaxWindowBits === 'number') {
+      accepted.server_max_window_bits = opts.serverMaxWindowBits;
+    }
+    if (typeof opts.clientMaxWindowBits === 'number') {
+      accepted.client_max_window_bits = opts.clientMaxWindowBits;
+    } else if (
+      accepted.client_max_window_bits === true ||
+      opts.clientMaxWindowBits === false
+    ) {
+      delete accepted.client_max_window_bits;
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(response) {
+    const params = response[0];
+
+    if (
+      this._options.clientNoContextTakeover === false &&
+      params.client_no_context_takeover
+    ) {
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    }
+
+    if (!params.client_max_window_bits) {
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      }
+    } else if (
+      this._options.clientMaxWindowBits === false ||
+      (typeof this._options.clientMaxWindowBits === 'number' &&
+        params.client_max_window_bits > this._options.clientMaxWindowBits)
+    ) {
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    }
+
+    return params;
+  }
+
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(configurations) {
+    configurations.forEach((params) => {
+      Object.keys(params).forEach((key) => {
+        let value = params[key];
+
+        if (value.length > 1) {
+          throw new Error(`Parameter "${key}" must have only a single value`);
+        }
+
+        value = value[0];
+
+        if (key === 'client_max_window_bits') {
+          if (value !== true) {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(
+                `Invalid value for parameter "${key}": ${value}`
+              );
+            }
+            value = num;
+          } else if (!this._isServer) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else if (key === 'server_max_window_bits') {
+          const num = +value;
+          if (!Number.isInteger(num) || num < 8 || num > 15) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+          value = num;
+        } else if (
+          key === 'client_no_context_takeover' ||
+          key === 'server_no_context_takeover'
+        ) {
+          if (value !== true) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else {
+          throw new Error(`Unknown parameter "${key}"`);
+        }
+
+        params[key] = value;
+      });
+    });
+
+    return configurations;
+  }
+
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._decompress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._compress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._inflate = zlib.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits
+      });
+      this._inflate[kPerMessageDeflate] = this;
+      this._inflate[kTotalLength] = 0;
+      this._inflate[kBuffers] = [];
+      this._inflate.on('error', inflateOnError);
+      this._inflate.on('data', inflateOnData);
+    }
+
+    this._inflate[kCallback] = callback;
+
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      const err = this._inflate[kError$1];
+
+      if (err) {
+        this._inflate.close();
+        this._inflate = null;
+        callback(err);
+        return;
+      }
+
+      const data = bufferUtil.concat(
+        this._inflate[kBuffers],
+        this._inflate[kTotalLength]
+      );
+
+      if (this._inflate._readableState.endEmitted) {
+        this._inflate.close();
+        this._inflate = null;
+      } else {
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._inflate.reset();
+        }
+      }
+
+      callback(null, data);
+    });
+  }
+
+  /**
+   * Compress data.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(data, fin, callback) {
+    const endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._deflate = zlib.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits
+      });
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      this._deflate.on('data', deflateOnData);
+    }
+
+    this._deflate[kCallback] = callback;
+
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      if (!this._deflate) {
+        //
+        // The deflate stream was closed while data was being processed.
+        //
+        return;
+      }
+
+      let data = bufferUtil.concat(
+        this._deflate[kBuffers],
+        this._deflate[kTotalLength]
+      );
+
+      if (fin) {
+        data = new FastBuffer$1(data.buffer, data.byteOffset, data.length - 4);
+      }
+
+      //
+      // Ensure that the callback will not be called again in
+      // `PerMessageDeflate#cleanup()`.
+      //
+      this._deflate[kCallback] = null;
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+        this._deflate.reset();
+      }
+
+      callback(null, data);
+    });
+  }
+};
+
+var permessageDeflate = PerMessageDeflate$4;
+
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+  this[kBuffers].push(chunk);
+  this[kTotalLength] += chunk.length;
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+  this[kTotalLength] += chunk.length;
+
+  if (
+    this[kPerMessageDeflate]._maxPayload < 1 ||
+    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+  ) {
+    this[kBuffers].push(chunk);
+    return;
+  }
+
+  this[kError$1] = new RangeError('Max payload size exceeded');
+  this[kError$1].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
+  this[kError$1][kStatusCode$2] = 1009;
+  this.removeListener('data', inflateOnData);
+  this.reset();
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+  //
+  // There is no need to call `Zlib#close()` as the handle is automatically
+  // closed when an error is emitted.
+  //
+  this[kPerMessageDeflate]._inflate = null;
+  err[kStatusCode$2] = 1007;
+  this[kCallback](err);
+}
+
+var validation = {exports: {}};
+
+const { isUtf8 } = require$$0$a;
+
+const { hasBlob } = constants;
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars$2 = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode$2(code) {
+  return (
+    (code >= 1000 &&
+      code <= 1014 &&
+      code !== 1004 &&
+      code !== 1005 &&
+      code !== 1006) ||
+    (code >= 3000 && code <= 4999)
+  );
+}
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0) {
+      // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {
+      // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0 // Overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {
+      // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+        buf[i] > 0xf4 // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+function isBlob$2(value) {
+  return (
+    hasBlob &&
+    typeof value === 'object' &&
+    typeof value.arrayBuffer === 'function' &&
+    typeof value.type === 'string' &&
+    typeof value.stream === 'function' &&
+    (value[Symbol.toStringTag] === 'Blob' ||
+      value[Symbol.toStringTag] === 'File')
+  );
+}
+
+validation.exports = {
+  isBlob: isBlob$2,
+  isValidStatusCode: isValidStatusCode$2,
+  isValidUTF8: _isValidUTF8,
+  tokenChars: tokenChars$2
+};
+
+if (isUtf8) {
+  validation.exports.isValidUTF8 = function (buf) {
+    return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
+  };
+} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
+  try {
+    const isValidUTF8 = require('utf-8-validate');
+
+    validation.exports.isValidUTF8 = function (buf) {
+      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
+}
+
+var validationExports = validation.exports;
+
+const { Writable: Writable$1 } = require$$0$6;
+
+const PerMessageDeflate$3 = permessageDeflate;
+const {
+  BINARY_TYPES: BINARY_TYPES$1,
+  EMPTY_BUFFER: EMPTY_BUFFER$2,
+  kStatusCode: kStatusCode$1,
+  kWebSocket: kWebSocket$3
+} = constants;
+const { concat, toArrayBuffer, unmask } = bufferUtilExports;
+const { isValidStatusCode: isValidStatusCode$1, isValidUTF8 } = validationExports;
+
+const FastBuffer = Buffer[Symbol.species];
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+const DEFER_EVENT = 6;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+let Receiver$1 = class Receiver extends Writable$1 {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {String} [options.binaryType=nodebuffer] The type for binary data
+   * @param {Object} [options.extensions] An object containing the negotiated
+   *     extensions
+   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+   *     client or server mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   */
+  constructor(options = {}) {
+    super();
+
+    this._allowSynchronousEvents =
+      options.allowSynchronousEvents !== undefined
+        ? options.allowSynchronousEvents
+        : true;
+    this._binaryType = options.binaryType || BINARY_TYPES$1[0];
+    this._extensions = options.extensions || {};
+    this._isServer = !!options.isServer;
+    this._maxPayload = options.maxPayload | 0;
+    this._skipUTF8Validation = !!options.skipUTF8Validation;
+    this[kWebSocket$3] = undefined;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._errored = false;
+    this._loop = false;
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = new FastBuffer(
+        buf.buffer,
+        buf.byteOffset + n,
+        buf.length - n
+      );
+
+      return new FastBuffer(buf.buffer, buf.byteOffset, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = new FastBuffer(
+          buf.buffer,
+          buf.byteOffset + n,
+          buf.length - n
+        );
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          this.getInfo(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          this.getPayloadLength16(cb);
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          this.getPayloadLength64(cb);
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          this.getData(cb);
+          break;
+        case INFLATING:
+        case DEFER_EVENT:
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    if (!this._errored) cb();
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getInfo(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      const error = this.createError(
+        RangeError,
+        'RSV2 and RSV3 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_2_3'
+      );
+
+      cb(error);
+      return;
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate$3.extensionName]) {
+      const error = this.createError(
+        RangeError,
+        'RSV1 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_1'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (!this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          'invalid opcode 0',
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        const error = this.createError(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+
+        cb(error);
+        return;
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        const error = this.createError(
+          RangeError,
+          'FIN must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_FIN'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (compressed) {
+        const error = this.createError(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (
+        this._payloadLength > 0x7d ||
+        (this._opcode === 0x08 && this._payloadLength === 1)
+      ) {
+        const error = this.createError(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    } else {
+      const error = this.createError(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        true,
+        1002,
+        'WS_ERR_INVALID_OPCODE'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._isServer) {
+      if (!this._masked) {
+        const error = this.createError(
+          RangeError,
+          'MASK must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_MASK'
+        );
+
+        cb(error);
+        return;
+      }
+    } else if (this._masked) {
+      const error = this.createError(
+        RangeError,
+        'MASK must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_MASK'
+      );
+
+      cb(error);
+      return;
+    }
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength16(cb) {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getPayloadLength64(cb) {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      const error = this.createError(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009,
+        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+      );
+
+      cb(error);
+      return;
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    this.haveLength(cb);
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  haveLength(cb) {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        const error = this.createError(
+          RangeError,
+          'Max payload size exceeded',
+          false,
+          1009,
+          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+        );
+
+        cb(error);
+        return;
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER$2;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+
+      if (
+        this._masked &&
+        (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0
+      ) {
+        unmask(data, this._mask);
+      }
+    }
+
+    if (this._opcode > 0x07) {
+      this.controlMessage(data, cb);
+      return;
+    }
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its length is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    this.dataMessage(cb);
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate$3.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          const error = this.createError(
+            RangeError,
+            'Max payload size exceeded',
+            false,
+            1009,
+            'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._fragments.push(buf);
+      }
+
+      this.dataMessage(cb);
+      if (this._state === GET_INFO) this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  dataMessage(cb) {
+    if (!this._fin) {
+      this._state = GET_INFO;
+      return;
+    }
+
+    const messageLength = this._messageLength;
+    const fragments = this._fragments;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragmented = 0;
+    this._fragments = [];
+
+    if (this._opcode === 2) {
+      let data;
+
+      if (this._binaryType === 'nodebuffer') {
+        data = concat(fragments, messageLength);
+      } else if (this._binaryType === 'arraybuffer') {
+        data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
+      } else {
+        data = fragments;
+      }
+
+      if (this._allowSynchronousEvents) {
+        this.emit('message', data, true);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', data, true);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    } else {
+      const buf = concat(fragments, messageLength);
+
+      if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+        const error = this.createError(
+          Error,
+          'invalid UTF-8 sequence',
+          true,
+          1007,
+          'WS_ERR_INVALID_UTF8'
+        );
+
+        cb(error);
+        return;
+      }
+
+      if (this._state === INFLATING || this._allowSynchronousEvents) {
+        this.emit('message', buf, false);
+        this._state = GET_INFO;
+      } else {
+        this._state = DEFER_EVENT;
+        setImmediate(() => {
+          this.emit('message', buf, false);
+          this._state = GET_INFO;
+          this.startLoop(cb);
+        });
+      }
+    }
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data, cb) {
+    if (this._opcode === 0x08) {
+      if (data.length === 0) {
+        this._loop = false;
+        this.emit('conclude', 1005, EMPTY_BUFFER$2);
+        this.end();
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode$1(code)) {
+          const error = this.createError(
+            RangeError,
+            `invalid status code ${code}`,
+            true,
+            1002,
+            'WS_ERR_INVALID_CLOSE_CODE'
+          );
+
+          cb(error);
+          return;
+        }
+
+        const buf = new FastBuffer(
+          data.buffer,
+          data.byteOffset + 2,
+          data.length - 2
+        );
+
+        if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+          const error = this.createError(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+
+          cb(error);
+          return;
+        }
+
+        this._loop = false;
+        this.emit('conclude', code, buf);
+        this.end();
+      }
+
+      this._state = GET_INFO;
+      return;
+    }
+
+    if (this._allowSynchronousEvents) {
+      this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+      this._state = GET_INFO;
+    } else {
+      this._state = DEFER_EVENT;
+      setImmediate(() => {
+        this.emit(this._opcode === 0x09 ? 'ping' : 'pong', data);
+        this._state = GET_INFO;
+        this.startLoop(cb);
+      });
+    }
+  }
+
+  /**
+   * Builds an error object.
+   *
+   * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+   * @param {String} message The error message
+   * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+   *     `message`
+   * @param {Number} statusCode The status code
+   * @param {String} errorCode The exposed error code
+   * @return {(Error|RangeError)} The error
+   * @private
+   */
+  createError(ErrorCtor, message, prefix, statusCode, errorCode) {
+    this._loop = false;
+    this._errored = true;
+
+    const err = new ErrorCtor(
+      prefix ? `Invalid WebSocket frame: ${message}` : message
+    );
+
+    Error.captureStackTrace(err, this.createError);
+    err.code = errorCode;
+    err[kStatusCode$1] = statusCode;
+    return err;
+  }
+};
+
+var receiver = Receiver$1;
+
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
+const { randomFillSync } = require$$3$1;
+
+const PerMessageDeflate$2 = permessageDeflate;
+const { EMPTY_BUFFER: EMPTY_BUFFER$1, kWebSocket: kWebSocket$2, NOOP: NOOP$2 } = constants;
+const { isBlob: isBlob$1, isValidStatusCode } = validationExports;
+const { mask: applyMask, toBuffer: toBuffer$1 } = bufferUtilExports;
+
+const kByteLength = Symbol('kByteLength');
+const maskBuffer = Buffer.alloc(4);
+const RANDOM_POOL_SIZE = 8 * 1024;
+let randomPool;
+let randomPoolPointer = RANDOM_POOL_SIZE;
+
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
+
+/**
+ * HyBi Sender implementation.
+ */
+let Sender$1 = class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {Duplex} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   * @param {Function} [generateMask] The function used to generate the masking
+   *     key
+   */
+  constructor(socket, extensions, generateMask) {
+    this._extensions = extensions || {};
+
+    if (generateMask) {
+      this._generateMask = generateMask;
+      this._maskBuffer = Buffer.alloc(4);
+    }
+
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._queue = [];
+    this._state = DEFAULT;
+    this.onerror = NOOP$2;
+    this[kWebSocket$2] = undefined;
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {(Buffer|String)} data The data to frame
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {(Buffer|String)[]} The framed data
+   * @public
+   */
+  static frame(data, options) {
+    let mask;
+    let merge = false;
+    let offset = 2;
+    let skipMasking = false;
+
+    if (options.mask) {
+      mask = options.maskBuffer || maskBuffer;
+
+      if (options.generateMask) {
+        options.generateMask(mask);
+      } else {
+        if (randomPoolPointer === RANDOM_POOL_SIZE) {
+          /* istanbul ignore else  */
+          if (randomPool === undefined) {
+            //
+            // This is lazily initialized because server-sent frames must not
+            // be masked so it may never be used.
+            //
+            randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
+          }
+
+          randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
+          randomPoolPointer = 0;
+        }
+
+        mask[0] = randomPool[randomPoolPointer++];
+        mask[1] = randomPool[randomPoolPointer++];
+        mask[2] = randomPool[randomPoolPointer++];
+        mask[3] = randomPool[randomPoolPointer++];
+      }
+
+      skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+      offset = 6;
+    }
+
+    let dataLength;
+
+    if (typeof data === 'string') {
+      if (
+        (!options.mask || skipMasking) &&
+        options[kByteLength] !== undefined
+      ) {
+        dataLength = options[kByteLength];
+      } else {
+        data = Buffer.from(data);
+        dataLength = data.length;
+      }
+    } else {
+      dataLength = data.length;
+      merge = options.mask && options.readOnly && !skipMasking;
+    }
+
+    let payloadLength = dataLength;
+
+    if (dataLength >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (dataLength > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(dataLength, 2);
+    } else if (payloadLength === 127) {
+      target[2] = target[3] = 0;
+      target.writeUIntBE(dataLength, 4, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (skipMasking) return [target, data];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, dataLength);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, dataLength);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {(String|Buffer)} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER$1;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || !data.length) {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      const length = Buffer.byteLength(data);
+
+      if (length > 123) {
+        throw new RangeError('The message must not be greater than 123 bytes');
+      }
+
+      buf = Buffer.allocUnsafe(2 + length);
+      buf.writeUInt16BE(code, 0);
+
+      if (typeof data === 'string') {
+        buf.write(data, 2);
+      } else {
+        buf.set(data, 2);
+      }
+    }
+
+    const options = {
+      [kByteLength]: buf.length,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x08,
+      readOnly: false,
+      rsv1: false
+    };
+
+    if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, buf, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(buf, options), cb);
+    }
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer$1(data);
+      byteLength = data.length;
+      readOnly = toBuffer$1.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x09,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer$1(data);
+      byteLength = data.length;
+      readOnly = toBuffer$1.readOnly;
+    }
+
+    if (byteLength > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    const options = {
+      [kByteLength]: byteLength,
+      fin: true,
+      generateMask: this._generateMask,
+      mask,
+      maskBuffer: this._maskBuffer,
+      opcode: 0x0a,
+      readOnly,
+      rsv1: false
+    };
+
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, false, options, cb]);
+    } else {
+      this.sendFrame(Sender.frame(data, options), cb);
+    }
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate$2.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    let byteLength;
+    let readOnly;
+
+    if (typeof data === 'string') {
+      byteLength = Buffer.byteLength(data);
+      readOnly = false;
+    } else if (isBlob$1(data)) {
+      byteLength = data.size;
+      readOnly = false;
+    } else {
+      data = toBuffer$1(data);
+      byteLength = data.length;
+      readOnly = toBuffer$1.readOnly;
+    }
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (
+        rsv1 &&
+        perMessageDeflate &&
+        perMessageDeflate.params[
+          perMessageDeflate._isServer
+            ? 'server_no_context_takeover'
+            : 'client_no_context_takeover'
+        ]
+      ) {
+        rsv1 = byteLength >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    const opts = {
+      [kByteLength]: byteLength,
+      fin: options.fin,
+      generateMask: this._generateMask,
+      mask: options.mask,
+      maskBuffer: this._maskBuffer,
+      opcode,
+      readOnly,
+      rsv1
+    };
+
+    if (isBlob$1(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
+      } else {
+        this.getBlobData(data, this._compress, opts, cb);
+      }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+    } else {
+      this.dispatch(data, this._compress, opts, cb);
+    }
+  }
+
+  /**
+   * Gets the contents of a blob as binary data.
+   *
+   * @param {Blob} blob The blob
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     the data
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  getBlobData(blob, compress, options, cb) {
+    this._bufferedBytes += options[kByteLength];
+    this._state = GET_BLOB_DATA;
+
+    blob
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error(
+            'The socket was closed while the blob was being read'
+          );
+
+          //
+          // `callCallbacks` is called in the next tick to ensure that errors
+          // that might be thrown in the callbacks behave like errors thrown
+          // outside the promise chain.
+          //
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer$1(arrayBuffer);
+
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      })
+      .catch((err) => {
+        //
+        // `onError` is called in the next tick for the same reason that
+        // `callCallbacks` above is.
+        //
+        process.nextTick(onError, this, err, cb);
+      });
+  }
+
+  /**
+   * Dispatches a message.
+   *
+   * @param {(Buffer|String)} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate$2.extensionName];
+
+    this._bufferedBytes += options[kByteLength];
+    this._state = DEFLATING;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      if (this._socket.destroyed) {
+        const err = new Error(
+          'The socket was closed while data was being compressed'
+        );
+
+        callCallbacks(this, err, cb);
+        return;
+      }
+
+      this._bufferedBytes -= options[kByteLength];
+      this._state = DEFAULT;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (this._state === DEFAULT && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[3][kByteLength];
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[3][kByteLength];
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {Buffer[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+};
+
+var sender = Sender$1;
+
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+  if (typeof cb === 'function') cb(err);
+
+  for (let i = 0; i < sender._queue.length; i++) {
+    const params = sender._queue[i];
+    const callback = params[params.length - 1];
+
+    if (typeof callback === 'function') callback(err);
+  }
+}
+
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+  callCallbacks(sender, err, cb);
+  sender.onerror(err);
+}
+
+const { kForOnEventAttribute: kForOnEventAttribute$1, kListener: kListener$1 } = constants;
+
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+
+/**
+ * Class representing an event.
+ */
+let Event$1 = class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @throws {TypeError} If the `type` argument is not specified
+   */
+  constructor(type) {
+    this[kTarget] = null;
+    this[kType] = type;
+  }
+
+  /**
+   * @type {*}
+   */
+  get target() {
+    return this[kTarget];
+  }
+
+  /**
+   * @type {String}
+   */
+  get type() {
+    return this[kType];
+  }
+};
+
+Object.defineProperty(Event$1.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event$1.prototype, 'type', { enumerable: true });
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+class CloseEvent extends Event$1 {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {Number} [options.code=0] The status code explaining why the
+   *     connection was closed
+   * @param {String} [options.reason=''] A human-readable string explaining why
+   *     the connection was closed
+   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+   *     connection was cleanly closed
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kCode] = options.code === undefined ? 0 : options.code;
+    this[kReason] = options.reason === undefined ? '' : options.reason;
+    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get code() {
+    return this[kCode];
+  }
+
+  /**
+   * @type {String}
+   */
+  get reason() {
+    return this[kReason];
+  }
+
+  /**
+   * @type {Boolean}
+   */
+  get wasClean() {
+    return this[kWasClean];
+  }
+}
+
+Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+class ErrorEvent extends Event$1 {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.error=null] The error that generated this event
+   * @param {String} [options.message=''] The error message
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kError] = options.error === undefined ? null : options.error;
+    this[kMessage] = options.message === undefined ? '' : options.message;
+  }
+
+  /**
+   * @type {*}
+   */
+  get error() {
+    return this[kError];
+  }
+
+  /**
+   * @type {String}
+   */
+  get message() {
+    return this[kMessage];
+  }
+}
+
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event$1 {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.data=null] The message content
+   */
+  constructor(type, options = {}) {
+    super(type);
+
+    this[kData] = options.data === undefined ? null : options.data;
+  }
+
+  /**
+   * @type {*}
+   */
+  get data() {
+    return this[kData];
+  }
+}
+
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {(Function|Object)} handler The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(type, handler, options = {}) {
+    for (const listener of this.listeners(type)) {
+      if (
+        !options[kForOnEventAttribute$1] &&
+        listener[kListener$1] === handler &&
+        !listener[kForOnEventAttribute$1]
+      ) {
+        return;
+      }
+    }
+
+    let wrapper;
+
+    if (type === 'message') {
+      wrapper = function onMessage(data, isBinary) {
+        const event = new MessageEvent('message', {
+          data: isBinary ? data : data.toString()
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'close') {
+      wrapper = function onClose(code, message) {
+        const event = new CloseEvent('close', {
+          code,
+          reason: message.toString(),
+          wasClean: this._closeFrameReceived && this._closeFrameSent
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'error') {
+      wrapper = function onError(error) {
+        const event = new ErrorEvent('error', {
+          error,
+          message: error.message
+        });
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else if (type === 'open') {
+      wrapper = function onOpen() {
+        const event = new Event$1('open');
+
+        event[kTarget] = this;
+        callListener(handler, this, event);
+      };
+    } else {
+      return;
+    }
+
+    wrapper[kForOnEventAttribute$1] = !!options[kForOnEventAttribute$1];
+    wrapper[kListener$1] = handler;
+
+    if (options.once) {
+      this.once(type, wrapper);
+    } else {
+      this.on(type, wrapper);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {(Function|Object)} handler The listener to remove
+   * @public
+   */
+  removeEventListener(type, handler) {
+    for (const listener of this.listeners(type)) {
+      if (listener[kListener$1] === handler && !listener[kForOnEventAttribute$1]) {
+        this.removeListener(type, listener);
+        break;
+      }
+    }
+  }
+};
+
+var eventTarget = {
+  CloseEvent,
+  ErrorEvent,
+  Event: Event$1,
+  EventTarget,
+  MessageEvent
+};
+
+/**
+ * Call an event listener
+ *
+ * @param {(Function|Object)} listener The listener to call
+ * @param {*} thisArg The value to use as `this`` when calling the listener
+ * @param {Event} event The event to pass to the listener
+ * @private
+ */
+function callListener(listener, thisArg, event) {
+  if (typeof listener === 'object' && listener.handleEvent) {
+    listener.handleEvent.call(listener, event);
+  } else {
+    listener.call(thisArg, event);
+  }
+}
+
+const { tokenChars: tokenChars$1 } = validationExports;
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse$2(header) {
+  const offers = Object.create(null);
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let code = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars$1[code] === 1) {
+        if (start === -1) start = i;
+      } else if (
+        i !== 0 &&
+        (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+      ) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars$1[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars$1[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars$1[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars$1[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes || code === 0x20 || code === 0x09) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format$1(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+var extension$1 = { format: format$1, parse: parse$2 };
+
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
+
+const EventEmitter$1 = require$$0$7;
+const https$2 = require$$1$1;
+const http$3 = require$$1;
+const net = require$$4$1;
+const tls = require$$4$2;
+const { randomBytes, createHash: createHash$1 } = require$$3$1;
+const { URL: URL$2 } = require$$0$9;
+
+const PerMessageDeflate$1 = permessageDeflate;
+const Receiver = receiver;
+const Sender = sender;
+const { isBlob } = validationExports;
+
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  GUID: GUID$1,
+  kForOnEventAttribute,
+  kListener,
+  kStatusCode,
+  kWebSocket: kWebSocket$1,
+  NOOP: NOOP$1
+} = constants;
+const {
+  EventTarget: { addEventListener, removeEventListener }
+} = eventTarget;
+const { format, parse: parse$1 } = extension$1;
+const { toBuffer } = bufferUtilExports;
+
+const closeTimeout = 30 * 1000;
+const kAborted = Symbol('kAborted');
+const protocolVersions = [8, 13];
+const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+
+/**
+ * Class representing a WebSocket.
+ *
+ * @extends EventEmitter
+ */
+let WebSocket$1 = class WebSocket extends EventEmitter$1 {
+  /**
+   * Create a new `WebSocket`.
+   *
+   * @param {(String|URL)} address The URL to which to connect
+   * @param {(String|String[])} [protocols] The subprotocols
+   * @param {Object} [options] Connection options
+   */
+  constructor(address, protocols, options) {
+    super();
+
+    this._binaryType = BINARY_TYPES[0];
+    this._closeCode = 1006;
+    this._closeFrameReceived = false;
+    this._closeFrameSent = false;
+    this._closeMessage = EMPTY_BUFFER;
+    this._closeTimer = null;
+    this._errorEmitted = false;
+    this._extensions = {};
+    this._paused = false;
+    this._protocol = '';
+    this._readyState = WebSocket.CONNECTING;
+    this._receiver = null;
+    this._sender = null;
+    this._socket = null;
+
+    if (address !== null) {
+      this._bufferedAmount = 0;
+      this._isServer = false;
+      this._redirects = 0;
+
+      if (protocols === undefined) {
+        protocols = [];
+      } else if (!Array.isArray(protocols)) {
+        if (typeof protocols === 'object' && protocols !== null) {
+          options = protocols;
+          protocols = [];
+        } else {
+          protocols = [protocols];
+        }
+      }
+
+      initAsClient(this, address, protocols, options);
+    } else {
+      this._autoPong = options.autoPong;
+      this._isServer = true;
+    }
+  }
+
+  /**
+   * For historical reasons, the custom "nodebuffer" type is used by the default
+   * instead of "blob".
+   *
+   * @type {String}
+   */
+  get binaryType() {
+    return this._binaryType;
+  }
+
+  set binaryType(type) {
+    if (!BINARY_TYPES.includes(type)) return;
+
+    this._binaryType = type;
+
+    //
+    // Allow to change `binaryType` on the fly.
+    //
+    if (this._receiver) this._receiver._binaryType = type;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get bufferedAmount() {
+    if (!this._socket) return this._bufferedAmount;
+
+    return this._socket._writableState.length + this._sender._bufferedBytes;
+  }
+
+  /**
+   * @type {String}
+   */
+  get extensions() {
+    return Object.keys(this._extensions).join();
+  }
+
+  /**
+   * @type {Boolean}
+   */
+  get isPaused() {
+    return this._paused;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onclose() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onerror() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onopen() {
+    return null;
+  }
+
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onmessage() {
+    return null;
+  }
+
+  /**
+   * @type {String}
+   */
+  get protocol() {
+    return this._protocol;
+  }
+
+  /**
+   * @type {Number}
+   */
+  get readyState() {
+    return this._readyState;
+  }
+
+  /**
+   * @type {String}
+   */
+  get url() {
+    return this._url;
+  }
+
+  /**
+   * Set up the socket and the internal resources.
+   *
+   * @param {Duplex} socket The network socket between the server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Object} options Options object
+   * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Number} [options.maxPayload=0] The maximum allowed message size
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @private
+   */
+  setSocket(socket, head, options) {
+    const receiver = new Receiver({
+      allowSynchronousEvents: options.allowSynchronousEvents,
+      binaryType: this.binaryType,
+      extensions: this._extensions,
+      isServer: this._isServer,
+      maxPayload: options.maxPayload,
+      skipUTF8Validation: options.skipUTF8Validation
+    });
+
+    const sender = new Sender(socket, this._extensions, options.generateMask);
+
+    this._receiver = receiver;
+    this._sender = sender;
+    this._socket = socket;
+
+    receiver[kWebSocket$1] = this;
+    sender[kWebSocket$1] = this;
+    socket[kWebSocket$1] = this;
+
+    receiver.on('conclude', receiverOnConclude);
+    receiver.on('drain', receiverOnDrain);
+    receiver.on('error', receiverOnError);
+    receiver.on('message', receiverOnMessage);
+    receiver.on('ping', receiverOnPing);
+    receiver.on('pong', receiverOnPong);
+
+    sender.onerror = senderOnError;
+
+    //
+    // These methods may not be available if `socket` is just a `Duplex`.
+    //
+    if (socket.setTimeout) socket.setTimeout(0);
+    if (socket.setNoDelay) socket.setNoDelay();
+
+    if (head.length > 0) socket.unshift(head);
+
+    socket.on('close', socketOnClose);
+    socket.on('data', socketOnData);
+    socket.on('end', socketOnEnd);
+    socket.on('error', socketOnError$1);
+
+    this._readyState = WebSocket.OPEN;
+    this.emit('open');
+  }
+
+  /**
+   * Emit the `'close'` event.
+   *
+   * @private
+   */
+  emitClose() {
+    if (!this._socket) {
+      this._readyState = WebSocket.CLOSED;
+      this.emit('close', this._closeCode, this._closeMessage);
+      return;
+    }
+
+    if (this._extensions[PerMessageDeflate$1.extensionName]) {
+      this._extensions[PerMessageDeflate$1.extensionName].cleanup();
+    }
+
+    this._receiver.removeAllListeners();
+    this._readyState = WebSocket.CLOSED;
+    this.emit('close', this._closeCode, this._closeMessage);
+  }
+
+  /**
+   * Start a closing handshake.
+   *
+   *          +----------+   +-----------+   +----------+
+   *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+   *    |     +----------+   +-----------+   +----------+     |
+   *          +----------+   +-----------+         |
+   * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
+   *          +----------+   +-----------+   |
+   *    |           |                        |   +---+        |
+   *                +------------------------+-->|fin| - - - -
+   *    |         +---+                      |   +---+
+   *     - - - - -|fin|<---------------------+
+   *              +---+
+   *
+   * @param {Number} [code] Status code explaining why the connection is closing
+   * @param {(String|Buffer)} [data] The reason why the connection is
+   *     closing
+   * @public
+   */
+  close(code, data) {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      abortHandshake$1(this, this._req, msg);
+      return;
+    }
+
+    if (this.readyState === WebSocket.CLOSING) {
+      if (
+        this._closeFrameSent &&
+        (this._closeFrameReceived || this._receiver._writableState.errorEmitted)
+      ) {
+        this._socket.end();
+      }
+
+      return;
+    }
+
+    this._readyState = WebSocket.CLOSING;
+    this._sender.close(code, data, !this._isServer, (err) => {
+      //
+      // This error is handled by the `'error'` listener on the socket. We only
+      // want to know if the close frame has been sent here.
+      //
+      if (err) return;
+
+      this._closeFrameSent = true;
+
+      if (
+        this._closeFrameReceived ||
+        this._receiver._writableState.errorEmitted
+      ) {
+        this._socket.end();
+      }
+    });
+
+    setCloseTimer(this);
+  }
+
+  /**
+   * Pause the socket.
+   *
+   * @public
+   */
+  pause() {
+    if (
+      this.readyState === WebSocket.CONNECTING ||
+      this.readyState === WebSocket.CLOSED
+    ) {
+      return;
+    }
+
+    this._paused = true;
+    this._socket.pause();
+  }
+
+  /**
+   * Send a ping.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the ping is sent
+   * @public
+   */
+  ping(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+   * Send a pong.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the pong is sent
+   * @public
+   */
+  pong(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+   * Resume the socket.
+   *
+   * @public
+   */
+  resume() {
+    if (
+      this.readyState === WebSocket.CONNECTING ||
+      this.readyState === WebSocket.CLOSED
+    ) {
+      return;
+    }
+
+    this._paused = false;
+    if (!this._receiver._writableState.needDrain) this._socket.resume();
+  }
+
+  /**
+   * Send a data message.
+   *
+   * @param {*} data The message to send
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+   *     text
+   * @param {Boolean} [options.compress] Specifies whether or not to compress
+   *     `data`
+   * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when data is written out
+   * @public
+   */
+  send(data, options, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof options === 'function') {
+      cb = options;
+      options = {};
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    const opts = {
+      binary: typeof data !== 'string',
+      mask: !this._isServer,
+      compress: true,
+      fin: true,
+      ...options
+    };
+
+    if (!this._extensions[PerMessageDeflate$1.extensionName]) {
+      opts.compress = false;
+    }
+
+    this._sender.send(data || EMPTY_BUFFER, opts, cb);
+  }
+
+  /**
+   * Forcibly close the connection.
+   *
+   * @public
+   */
+  terminate() {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      abortHandshake$1(this, this._req, msg);
+      return;
+    }
+
+    if (this._socket) {
+      this._readyState = WebSocket.CLOSING;
+      this._socket.destroy();
+    }
+  }
+};
+
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket$1, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+ * @constant {Number} CONNECTING
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket$1.prototype, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket$1, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+ * @constant {Number} OPEN
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket$1.prototype, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+ * @constant {Number} CLOSING
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket$1, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+ * @constant {Number} CLOSING
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket$1.prototype, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket
+ */
+Object.defineProperty(WebSocket$1, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+/**
+ * @constant {Number} CLOSED
+ * @memberof WebSocket.prototype
+ */
+Object.defineProperty(WebSocket$1.prototype, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+[
+  'binaryType',
+  'bufferedAmount',
+  'extensions',
+  'isPaused',
+  'protocol',
+  'readyState',
+  'url'
+].forEach((property) => {
+  Object.defineProperty(WebSocket$1.prototype, property, { enumerable: true });
+});
+
+//
+// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.
+// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
+//
+['open', 'error', 'close', 'message'].forEach((method) => {
+  Object.defineProperty(WebSocket$1.prototype, `on${method}`, {
+    enumerable: true,
+    get() {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) return listener[kListener];
+      }
+
+      return null;
+    },
+    set(handler) {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) {
+          this.removeListener(method, listener);
+          break;
+        }
+      }
+
+      if (typeof handler !== 'function') return;
+
+      this.addEventListener(method, handler, {
+        [kForOnEventAttribute]: true
+      });
+    }
+  });
+});
+
+WebSocket$1.prototype.addEventListener = addEventListener;
+WebSocket$1.prototype.removeEventListener = removeEventListener;
+
+var websocket = WebSocket$1;
+
+/**
+ * Initialize a WebSocket client.
+ *
+ * @param {WebSocket} websocket The client to initialize
+ * @param {(String|URL)} address The URL to which to connect
+ * @param {Array} protocols The subprotocols
+ * @param {Object} [options] Connection options
+ * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether any
+ *     of the `'message'`, `'ping'`, and `'pong'` events can be emitted multiple
+ *     times in the same tick
+ * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+ *     automatically send a pong in response to a ping
+ * @param {Function} [options.finishRequest] A function which can be used to
+ *     customize the headers of each http request before it is sent
+ * @param {Boolean} [options.followRedirects=false] Whether or not to follow
+ *     redirects
+ * @param {Function} [options.generateMask] The function used to generate the
+ *     masking key
+ * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+ *     handshake request
+ * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+ *     size
+ * @param {Number} [options.maxRedirects=10] The maximum number of redirects
+ *     allowed
+ * @param {String} [options.origin] Value of the `Origin` or
+ *     `Sec-WebSocket-Origin` header
+ * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+ *     permessage-deflate
+ * @param {Number} [options.protocolVersion=13] Value of the
+ *     `Sec-WebSocket-Version` header
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ *     not to skip UTF-8 validation for text and close messages
+ * @private
+ */
+function initAsClient(websocket, address, protocols, options) {
+  const opts = {
+    allowSynchronousEvents: true,
+    autoPong: true,
+    protocolVersion: protocolVersions[1],
+    maxPayload: 100 * 1024 * 1024,
+    skipUTF8Validation: false,
+    perMessageDeflate: true,
+    followRedirects: false,
+    maxRedirects: 10,
+    ...options,
+    socketPath: undefined,
+    hostname: undefined,
+    protocol: undefined,
+    timeout: undefined,
+    method: 'GET',
+    host: undefined,
+    path: undefined,
+    port: undefined
+  };
+
+  websocket._autoPong = opts.autoPong;
+
+  if (!protocolVersions.includes(opts.protocolVersion)) {
+    throw new RangeError(
+      `Unsupported protocol version: ${opts.protocolVersion} ` +
+        `(supported versions: ${protocolVersions.join(', ')})`
+    );
+  }
+
+  let parsedUrl;
+
+  if (address instanceof URL$2) {
+    parsedUrl = address;
+  } else {
+    try {
+      parsedUrl = new URL$2(address);
+    } catch (e) {
+      throw new SyntaxError(`Invalid URL: ${address}`);
+    }
+  }
+
+  if (parsedUrl.protocol === 'http:') {
+    parsedUrl.protocol = 'ws:';
+  } else if (parsedUrl.protocol === 'https:') {
+    parsedUrl.protocol = 'wss:';
+  }
+
+  websocket._url = parsedUrl.href;
+
+  const isSecure = parsedUrl.protocol === 'wss:';
+  const isIpcUrl = parsedUrl.protocol === 'ws+unix:';
+  let invalidUrlMessage;
+
+  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {
+    invalidUrlMessage =
+      'The URL\'s protocol must be one of "ws:", "wss:", ' +
+      '"http:", "https", or "ws+unix:"';
+  } else if (isIpcUrl && !parsedUrl.pathname) {
+    invalidUrlMessage = "The URL's pathname is empty";
+  } else if (parsedUrl.hash) {
+    invalidUrlMessage = 'The URL contains a fragment identifier';
+  }
+
+  if (invalidUrlMessage) {
+    const err = new SyntaxError(invalidUrlMessage);
+
+    if (websocket._redirects === 0) {
+      throw err;
+    } else {
+      emitErrorAndClose(websocket, err);
+      return;
+    }
+  }
+
+  const defaultPort = isSecure ? 443 : 80;
+  const key = randomBytes(16).toString('base64');
+  const request = isSecure ? https$2.request : http$3.request;
+  const protocolSet = new Set();
+  let perMessageDeflate;
+
+  opts.createConnection =
+    opts.createConnection || (isSecure ? tlsConnect : netConnect);
+  opts.defaultPort = opts.defaultPort || defaultPort;
+  opts.port = parsedUrl.port || defaultPort;
+  opts.host = parsedUrl.hostname.startsWith('[')
+    ? parsedUrl.hostname.slice(1, -1)
+    : parsedUrl.hostname;
+  opts.headers = {
+    ...opts.headers,
+    'Sec-WebSocket-Version': opts.protocolVersion,
+    'Sec-WebSocket-Key': key,
+    Connection: 'Upgrade',
+    Upgrade: 'websocket'
+  };
+  opts.path = parsedUrl.pathname + parsedUrl.search;
+  opts.timeout = opts.handshakeTimeout;
+
+  if (opts.perMessageDeflate) {
+    perMessageDeflate = new PerMessageDeflate$1(
+      opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
+      false,
+      opts.maxPayload
+    );
+    opts.headers['Sec-WebSocket-Extensions'] = format({
+      [PerMessageDeflate$1.extensionName]: perMessageDeflate.offer()
+    });
+  }
+  if (protocols.length) {
+    for (const protocol of protocols) {
+      if (
+        typeof protocol !== 'string' ||
+        !subprotocolRegex.test(protocol) ||
+        protocolSet.has(protocol)
+      ) {
+        throw new SyntaxError(
+          'An invalid or duplicated subprotocol was specified'
+        );
+      }
+
+      protocolSet.add(protocol);
+    }
+
+    opts.headers['Sec-WebSocket-Protocol'] = protocols.join(',');
+  }
+  if (opts.origin) {
+    if (opts.protocolVersion < 13) {
+      opts.headers['Sec-WebSocket-Origin'] = opts.origin;
+    } else {
+      opts.headers.Origin = opts.origin;
+    }
+  }
+  if (parsedUrl.username || parsedUrl.password) {
+    opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+  }
+
+  if (isIpcUrl) {
+    const parts = opts.path.split(':');
+
+    opts.socketPath = parts[0];
+    opts.path = parts[1];
+  }
+
+  let req;
+
+  if (opts.followRedirects) {
+    if (websocket._redirects === 0) {
+      websocket._originalIpc = isIpcUrl;
+      websocket._originalSecure = isSecure;
+      websocket._originalHostOrSocketPath = isIpcUrl
+        ? opts.socketPath
+        : parsedUrl.host;
+
+      const headers = options && options.headers;
+
+      //
+      // Shallow copy the user provided options so that headers can be changed
+      // without mutating the original object.
+      //
+      options = { ...options, headers: {} };
+
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          options.headers[key.toLowerCase()] = value;
+        }
+      }
+    } else if (websocket.listenerCount('redirect') === 0) {
+      const isSameHost = isIpcUrl
+        ? websocket._originalIpc
+          ? opts.socketPath === websocket._originalHostOrSocketPath
+          : false
+        : websocket._originalIpc
+          ? false
+          : parsedUrl.host === websocket._originalHostOrSocketPath;
+
+      if (!isSameHost || (websocket._originalSecure && !isSecure)) {
+        //
+        // Match curl 7.77.0 behavior and drop the following headers. These
+        // headers are also dropped when following a redirect to a subdomain.
+        //
+        delete opts.headers.authorization;
+        delete opts.headers.cookie;
+
+        if (!isSameHost) delete opts.headers.host;
+
+        opts.auth = undefined;
+      }
+    }
+
+    //
+    // Match curl 7.77.0 behavior and make the first `Authorization` header win.
+    // If the `Authorization` header is set, then there is nothing to do as it
+    // will take precedence.
+    //
+    if (opts.auth && !options.headers.authorization) {
+      options.headers.authorization =
+        'Basic ' + Buffer.from(opts.auth).toString('base64');
+    }
+
+    req = websocket._req = request(opts);
+
+    if (websocket._redirects) {
+      //
+      // Unlike what is done for the `'upgrade'` event, no early exit is
+      // triggered here if the user calls `websocket.close()` or
+      // `websocket.terminate()` from a listener of the `'redirect'` event. This
+      // is because the user can also call `request.destroy()` with an error
+      // before calling `websocket.close()` or `websocket.terminate()` and this
+      // would result in an error being emitted on the `request` object with no
+      // `'error'` event listeners attached.
+      //
+      websocket.emit('redirect', websocket.url, req);
+    }
+  } else {
+    req = websocket._req = request(opts);
+  }
+
+  if (opts.timeout) {
+    req.on('timeout', () => {
+      abortHandshake$1(websocket, req, 'Opening handshake has timed out');
+    });
+  }
+
+  req.on('error', (err) => {
+    if (req === null || req[kAborted]) return;
+
+    req = websocket._req = null;
+    emitErrorAndClose(websocket, err);
+  });
+
+  req.on('response', (res) => {
+    const location = res.headers.location;
+    const statusCode = res.statusCode;
+
+    if (
+      location &&
+      opts.followRedirects &&
+      statusCode >= 300 &&
+      statusCode < 400
+    ) {
+      if (++websocket._redirects > opts.maxRedirects) {
+        abortHandshake$1(websocket, req, 'Maximum redirects exceeded');
+        return;
+      }
+
+      req.abort();
+
+      let addr;
+
+      try {
+        addr = new URL$2(location, address);
+      } catch (e) {
+        const err = new SyntaxError(`Invalid URL: ${location}`);
+        emitErrorAndClose(websocket, err);
+        return;
+      }
+
+      initAsClient(websocket, addr, protocols, options);
+    } else if (!websocket.emit('unexpected-response', req, res)) {
+      abortHandshake$1(
+        websocket,
+        req,
+        `Unexpected server response: ${res.statusCode}`
+      );
+    }
+  });
+
+  req.on('upgrade', (res, socket, head) => {
+    websocket.emit('upgrade', res);
+
+    //
+    // The user may have closed the connection from a listener of the
+    // `'upgrade'` event.
+    //
+    if (websocket.readyState !== WebSocket$1.CONNECTING) return;
+
+    req = websocket._req = null;
+
+    const upgrade = res.headers.upgrade;
+
+    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+      abortHandshake$1(websocket, socket, 'Invalid Upgrade header');
+      return;
+    }
+
+    const digest = createHash$1('sha1')
+      .update(key + GUID$1)
+      .digest('base64');
+
+    if (res.headers['sec-websocket-accept'] !== digest) {
+      abortHandshake$1(websocket, socket, 'Invalid Sec-WebSocket-Accept header');
+      return;
+    }
+
+    const serverProt = res.headers['sec-websocket-protocol'];
+    let protError;
+
+    if (serverProt !== undefined) {
+      if (!protocolSet.size) {
+        protError = 'Server sent a subprotocol but none was requested';
+      } else if (!protocolSet.has(serverProt)) {
+        protError = 'Server sent an invalid subprotocol';
+      }
+    } else if (protocolSet.size) {
+      protError = 'Server sent no subprotocol';
+    }
+
+    if (protError) {
+      abortHandshake$1(websocket, socket, protError);
+      return;
+    }
+
+    if (serverProt) websocket._protocol = serverProt;
+
+    const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
+
+    if (secWebSocketExtensions !== undefined) {
+      if (!perMessageDeflate) {
+        const message =
+          'Server sent a Sec-WebSocket-Extensions header but no extension ' +
+          'was requested';
+        abortHandshake$1(websocket, socket, message);
+        return;
+      }
+
+      let extensions;
+
+      try {
+        extensions = parse$1(secWebSocketExtensions);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Extensions header';
+        abortHandshake$1(websocket, socket, message);
+        return;
+      }
+
+      const extensionNames = Object.keys(extensions);
+
+      if (
+        extensionNames.length !== 1 ||
+        extensionNames[0] !== PerMessageDeflate$1.extensionName
+      ) {
+        const message = 'Server indicated an extension that was not requested';
+        abortHandshake$1(websocket, socket, message);
+        return;
+      }
+
+      try {
+        perMessageDeflate.accept(extensions[PerMessageDeflate$1.extensionName]);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Extensions header';
+        abortHandshake$1(websocket, socket, message);
+        return;
+      }
+
+      websocket._extensions[PerMessageDeflate$1.extensionName] =
+        perMessageDeflate;
+    }
+
+    websocket.setSocket(socket, head, {
+      allowSynchronousEvents: opts.allowSynchronousEvents,
+      generateMask: opts.generateMask,
+      maxPayload: opts.maxPayload,
+      skipUTF8Validation: opts.skipUTF8Validation
+    });
+  });
+
+  if (opts.finishRequest) {
+    opts.finishRequest(req, websocket);
+  } else {
+    req.end();
+  }
+}
+
+/**
+ * Emit the `'error'` and `'close'` events.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {Error} The error to emit
+ * @private
+ */
+function emitErrorAndClose(websocket, err) {
+  websocket._readyState = WebSocket$1.CLOSING;
+  //
+  // The following assignment is practically useless and is done only for
+  // consistency.
+  //
+  websocket._errorEmitted = true;
+  websocket.emit('error', err);
+  websocket.emitClose();
+}
+
+/**
+ * Create a `net.Socket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {net.Socket} The newly created socket used to start the connection
+ * @private
+ */
+function netConnect(options) {
+  options.path = options.socketPath;
+  return net.connect(options);
+}
+
+/**
+ * Create a `tls.TLSSocket` and initiate a connection.
+ *
+ * @param {Object} options Connection options
+ * @return {tls.TLSSocket} The newly created socket used to start the connection
+ * @private
+ */
+function tlsConnect(options) {
+  options.path = undefined;
+
+  if (!options.servername && options.servername !== '') {
+    options.servername = net.isIP(options.host) ? '' : options.host;
+  }
+
+  return tls.connect(options);
+}
+
+/**
+ * Abort the handshake and emit an error.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
+ *     abort or the socket to destroy
+ * @param {String} message The error message
+ * @private
+ */
+function abortHandshake$1(websocket, stream, message) {
+  websocket._readyState = WebSocket$1.CLOSING;
+
+  const err = new Error(message);
+  Error.captureStackTrace(err, abortHandshake$1);
+
+  if (stream.setHeader) {
+    stream[kAborted] = true;
+    stream.abort();
+
+    if (stream.socket && !stream.socket.destroyed) {
+      //
+      // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
+      // called after the request completed. See
+      // https://github.com/websockets/ws/issues/1869.
+      //
+      stream.socket.destroy();
+    }
+
+    process.nextTick(emitErrorAndClose, websocket, err);
+  } else {
+    stream.destroy(err);
+    stream.once('error', websocket.emit.bind(websocket, 'error'));
+    stream.once('close', websocket.emitClose.bind(websocket));
+  }
+}
+
+/**
+ * Handle cases where the `ping()`, `pong()`, or `send()` methods are called
+ * when the `readyState` attribute is `CLOSING` or `CLOSED`.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @param {*} [data] The data to send
+ * @param {Function} [cb] Callback
+ * @private
+ */
+function sendAfterClose(websocket, data, cb) {
+  if (data) {
+    const length = isBlob(data) ? data.size : toBuffer(data).length;
+
+    //
+    // The `_bufferedAmount` property is used only when the peer is a client and
+    // the opening handshake fails. Under these circumstances, in fact, the
+    // `setSocket()` method is not called, so the `_socket` and `_sender`
+    // properties are set to `null`.
+    //
+    if (websocket._socket) websocket._sender._bufferedBytes += length;
+    else websocket._bufferedAmount += length;
+  }
+
+  if (cb) {
+    const err = new Error(
+      `WebSocket is not open: readyState ${websocket.readyState} ` +
+        `(${readyStates[websocket.readyState]})`
+    );
+    process.nextTick(cb, err);
+  }
+}
+
+/**
+ * The listener of the `Receiver` `'conclude'` event.
+ *
+ * @param {Number} code The status code
+ * @param {Buffer} reason The reason for closing
+ * @private
+ */
+function receiverOnConclude(code, reason) {
+  const websocket = this[kWebSocket$1];
+
+  websocket._closeFrameReceived = true;
+  websocket._closeMessage = reason;
+  websocket._closeCode = code;
+
+  if (websocket._socket[kWebSocket$1] === undefined) return;
+
+  websocket._socket.removeListener('data', socketOnData);
+  process.nextTick(resume, websocket._socket);
+
+  if (code === 1005) websocket.close();
+  else websocket.close(code, reason);
+}
+
+/**
+ * The listener of the `Receiver` `'drain'` event.
+ *
+ * @private
+ */
+function receiverOnDrain() {
+  const websocket = this[kWebSocket$1];
+
+  if (!websocket.isPaused) websocket._socket.resume();
+}
+
+/**
+ * The listener of the `Receiver` `'error'` event.
+ *
+ * @param {(RangeError|Error)} err The emitted error
+ * @private
+ */
+function receiverOnError(err) {
+  const websocket = this[kWebSocket$1];
+
+  if (websocket._socket[kWebSocket$1] !== undefined) {
+    websocket._socket.removeListener('data', socketOnData);
+
+    //
+    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
+    // https://github.com/websockets/ws/issues/1940.
+    //
+    process.nextTick(resume, websocket._socket);
+
+    websocket.close(err[kStatusCode]);
+  }
+
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
+}
+
+/**
+ * The listener of the `Receiver` `'finish'` event.
+ *
+ * @private
+ */
+function receiverOnFinish() {
+  this[kWebSocket$1].emitClose();
+}
+
+/**
+ * The listener of the `Receiver` `'message'` event.
+ *
+ * @param {Buffer|ArrayBuffer|Buffer[])} data The message
+ * @param {Boolean} isBinary Specifies whether the message is binary or not
+ * @private
+ */
+function receiverOnMessage(data, isBinary) {
+  this[kWebSocket$1].emit('message', data, isBinary);
+}
+
+/**
+ * The listener of the `Receiver` `'ping'` event.
+ *
+ * @param {Buffer} data The data included in the ping frame
+ * @private
+ */
+function receiverOnPing(data) {
+  const websocket = this[kWebSocket$1];
+
+  if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP$1);
+  websocket.emit('ping', data);
+}
+
+/**
+ * The listener of the `Receiver` `'pong'` event.
+ *
+ * @param {Buffer} data The data included in the pong frame
+ * @private
+ */
+function receiverOnPong(data) {
+  this[kWebSocket$1].emit('pong', data);
+}
+
+/**
+ * Resume a readable stream
+ *
+ * @param {Readable} stream The readable stream
+ * @private
+ */
+function resume(stream) {
+  stream.resume();
+}
+
+/**
+ * The `Sender` error event handler.
+ *
+ * @param {Error} The error
+ * @private
+ */
+function senderOnError(err) {
+  const websocket = this[kWebSocket$1];
+
+  if (websocket.readyState === WebSocket$1.CLOSED) return;
+  if (websocket.readyState === WebSocket$1.OPEN) {
+    websocket._readyState = WebSocket$1.CLOSING;
+    setCloseTimer(websocket);
+  }
+
+  //
+  // `socket.end()` is used instead of `socket.destroy()` to allow the other
+  // peer to finish sending queued data. There is no need to set a timer here
+  // because `CLOSING` means that it is already set or not needed.
+  //
+  this._socket.end();
+
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
+}
+
+/**
+ * Set a timer to destroy the underlying raw socket of a WebSocket.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @private
+ */
+function setCloseTimer(websocket) {
+  websocket._closeTimer = setTimeout(
+    websocket._socket.destroy.bind(websocket._socket),
+    closeTimeout
+  );
+}
+
+/**
+ * The listener of the socket `'close'` event.
+ *
+ * @private
+ */
+function socketOnClose() {
+  const websocket = this[kWebSocket$1];
+
+  this.removeListener('close', socketOnClose);
+  this.removeListener('data', socketOnData);
+  this.removeListener('end', socketOnEnd);
+
+  websocket._readyState = WebSocket$1.CLOSING;
+
+  let chunk;
+
+  //
+  // The close frame might not have been received or the `'end'` event emitted,
+  // for example, if the socket was destroyed due to an error. Ensure that the
+  // `receiver` stream is closed after writing any remaining buffered data to
+  // it. If the readable side of the socket is in flowing mode then there is no
+  // buffered data as everything has been already written and `readable.read()`
+  // will return `null`. If instead, the socket is paused, any possible buffered
+  // data will be read as a single chunk.
+  //
+  if (
+    !this._readableState.endEmitted &&
+    !websocket._closeFrameReceived &&
+    !websocket._receiver._writableState.errorEmitted &&
+    (chunk = websocket._socket.read()) !== null
+  ) {
+    websocket._receiver.write(chunk);
+  }
+
+  websocket._receiver.end();
+
+  this[kWebSocket$1] = undefined;
+
+  clearTimeout(websocket._closeTimer);
+
+  if (
+    websocket._receiver._writableState.finished ||
+    websocket._receiver._writableState.errorEmitted
+  ) {
+    websocket.emitClose();
+  } else {
+    websocket._receiver.on('error', receiverOnFinish);
+    websocket._receiver.on('finish', receiverOnFinish);
+  }
+}
+
+/**
+ * The listener of the socket `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function socketOnData(chunk) {
+  if (!this[kWebSocket$1]._receiver.write(chunk)) {
+    this.pause();
+  }
+}
+
+/**
+ * The listener of the socket `'end'` event.
+ *
+ * @private
+ */
+function socketOnEnd() {
+  const websocket = this[kWebSocket$1];
+
+  websocket._readyState = WebSocket$1.CLOSING;
+  websocket._receiver.end();
+  this.end();
+}
+
+/**
+ * The listener of the socket `'error'` event.
+ *
+ * @private
+ */
+function socketOnError$1() {
+  const websocket = this[kWebSocket$1];
+
+  this.removeListener('error', socketOnError$1);
+  this.on('error', NOOP$1);
+
+  if (websocket) {
+    websocket._readyState = WebSocket$1.CLOSING;
+    this.destroy();
+  }
+}
+
+const { tokenChars } = validationExports;
+
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
+ *
+ * @param {String} header The field value of the header
+ * @return {Set} The subprotocol names
+ * @public
+ */
+function parse(header) {
+  const protocols = new Set();
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (i; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (end === -1 && tokenChars[code] === 1) {
+      if (start === -1) start = i;
+    } else if (
+      i !== 0 &&
+      (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */
+    ) {
+      if (end === -1 && start !== -1) end = i;
+    } else if (code === 0x2c /* ',' */) {
+      if (start === -1) {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+
+      if (end === -1) end = i;
+
+      const protocol = header.slice(start, end);
+
+      if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+      }
+
+      protocols.add(protocol);
+      start = end = -1;
+    } else {
+      throw new SyntaxError(`Unexpected character at index ${i}`);
+    }
+  }
+
+  if (start === -1 || end !== -1) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  const protocol = header.slice(start, i);
+
+  if (protocols.has(protocol)) {
+    throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+  }
+
+  protocols.add(protocol);
+  return protocols;
+}
+
+var subprotocol$1 = { parse };
+
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
+
+const EventEmitter = require$$0$7;
+const http$2 = require$$1;
+const { createHash } = require$$3$1;
+
+const extension = extension$1;
+const PerMessageDeflate = permessageDeflate;
+const subprotocol = subprotocol$1;
+const WebSocket = websocket;
+const { GUID, kWebSocket } = constants;
+
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
+   *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+   *     multiple times in the same tick
+   * @param {Boolean} [options.autoPong=true] Specifies whether or not to
+   *     automatically send a pong in response to a ping
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+   *     permessage-deflate
+   * @param {Number} [options.port] The port where to bind the server
+   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+   *     server to use
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+   *     class to use. It must be the `WebSocket` class or class that extends it
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(options, callback) {
+    super();
+
+    options = {
+      allowSynchronousEvents: true,
+      autoPong: true,
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: false,
+      perMessageDeflate: false,
+      handleProtocols: null,
+      clientTracking: true,
+      verifyClient: null,
+      noServer: false,
+      backlog: null, // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      WebSocket,
+      ...options
+    };
+
+    if (
+      (options.port == null && !options.server && !options.noServer) ||
+      (options.port != null && (options.server || options.noServer)) ||
+      (options.server && options.noServer)
+    ) {
+      throw new TypeError(
+        'One and only one of the "port", "server", or "noServer" options ' +
+          'must be specified'
+      );
+    }
+
+    if (options.port != null) {
+      this._server = http$2.createServer((req, res) => {
+        const body = http$2.STATUS_CODES[426];
+
+        res.writeHead(426, {
+          'Content-Length': body.length,
+          'Content-Type': 'text/plain'
+        });
+        res.end(body);
+      });
+      this._server.listen(
+        options.port,
+        options.host,
+        options.backlog,
+        callback
+      );
+    } else if (options.server) {
+      this._server = options.server;
+    }
+
+    if (this._server) {
+      const emitConnection = this.emit.bind(this, 'connection');
+
+      this._removeListeners = addListeners(this._server, {
+        listening: this.emit.bind(this, 'listening'),
+        error: this.emit.bind(this, 'error'),
+        upgrade: (req, socket, head) => {
+          this.handleUpgrade(req, socket, head, emitConnection);
+        }
+      });
+    }
+
+    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+    if (options.clientTracking) {
+      this.clients = new Set();
+      this._shouldEmitClose = false;
+    }
+
+    this.options = options;
+    this._state = RUNNING;
+  }
+
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer) {
+      throw new Error('The server is operating in "noServer" mode');
+    }
+
+    if (!this._server) return null;
+    return this._server.address();
+  }
+
+  /**
+   * Stop the server from accepting new connections and emit the `'close'` event
+   * when all existing connections are closed.
+   *
+   * @param {Function} [cb] A one-time listener for the `'close'` event
+   * @public
+   */
+  close(cb) {
+    if (this._state === CLOSED) {
+      if (cb) {
+        this.once('close', () => {
+          cb(new Error('The server is not running'));
+        });
+      }
+
+      process.nextTick(emitClose, this);
+      return;
+    }
+
+    if (cb) this.once('close', cb);
+
+    if (this._state === CLOSING) return;
+    this._state = CLOSING;
+
+    if (this.options.noServer || this.options.server) {
+      if (this._server) {
+        this._removeListeners();
+        this._removeListeners = this._server = null;
+      }
+
+      if (this.clients) {
+        if (!this.clients.size) {
+          process.nextTick(emitClose, this);
+        } else {
+          this._shouldEmitClose = true;
+        }
+      } else {
+        process.nextTick(emitClose, this);
+      }
+    } else {
+      const server = this._server;
+
+      this._removeListeners();
+      this._removeListeners = this._server = null;
+
+      //
+      // The HTTP/S server was created internally. Close it, and rely on its
+      // `'close'` event.
+      //
+      server.close(() => {
+        emitClose(this);
+      });
+    }
+  }
+
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(req) {
+    if (this.options.path) {
+      const index = req.url.indexOf('?');
+      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+
+      if (pathname !== this.options.path) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} socket The network socket between the server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(req, socket, head, cb) {
+    socket.on('error', socketOnError);
+
+    const key = req.headers['sec-websocket-key'];
+    const upgrade = req.headers.upgrade;
+    const version = +req.headers['sec-websocket-version'];
+
+    if (req.method !== 'GET') {
+      const message = 'Invalid HTTP method';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+      return;
+    }
+
+    if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+      const message = 'Invalid Upgrade header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (key === undefined || !keyRegex.test(key)) {
+      const message = 'Missing or invalid Sec-WebSocket-Key header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (version !== 8 && version !== 13) {
+      const message = 'Missing or invalid Sec-WebSocket-Version header';
+      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+      return;
+    }
+
+    if (!this.shouldHandle(req)) {
+      abortHandshake(socket, 400);
+      return;
+    }
+
+    const secWebSocketProtocol = req.headers['sec-websocket-protocol'];
+    let protocols = new Set();
+
+    if (secWebSocketProtocol !== undefined) {
+      try {
+        protocols = subprotocol.parse(secWebSocketProtocol);
+      } catch (err) {
+        const message = 'Invalid Sec-WebSocket-Protocol header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    const secWebSocketExtensions = req.headers['sec-websocket-extensions'];
+    const extensions = {};
+
+    if (
+      this.options.perMessageDeflate &&
+      secWebSocketExtensions !== undefined
+    ) {
+      const perMessageDeflate = new PerMessageDeflate(
+        this.options.perMessageDeflate,
+        true,
+        this.options.maxPayload
+      );
+
+      try {
+        const offers = extension.parse(secWebSocketExtensions);
+
+        if (offers[PerMessageDeflate.extensionName]) {
+          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      } catch (err) {
+        const message =
+          'Invalid or unacceptable Sec-WebSocket-Extensions header';
+        abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+        return;
+      }
+    }
+
+    //
+    // Optionally call external client verification handler.
+    //
+    if (this.options.verifyClient) {
+      const info = {
+        origin:
+          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+        secure: !!(req.socket.authorized || req.socket.encrypted),
+        req
+      };
+
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(info, (verified, code, message, headers) => {
+          if (!verified) {
+            return abortHandshake(socket, code || 401, message, headers);
+          }
+
+          this.completeUpgrade(
+            extensions,
+            key,
+            protocols,
+            req,
+            socket,
+            head,
+            cb
+          );
+        });
+        return;
+      }
+
+      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+    }
+
+    this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+  }
+
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {Object} extensions The accepted extensions
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Set} protocols The subprotocols
+   * @param {http.IncomingMessage} req The request object
+   * @param {Duplex} socket The network socket between the server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @throws {Error} If called more than once with the same socket
+   * @private
+   */
+  completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+    //
+    // Destroy the socket if the client has already sent a FIN packet.
+    //
+    if (!socket.readable || !socket.writable) return socket.destroy();
+
+    if (socket[kWebSocket]) {
+      throw new Error(
+        'server.handleUpgrade() was called more than once with the same ' +
+          'socket, possibly due to a misconfiguration'
+      );
+    }
+
+    if (this._state > RUNNING) return abortHandshake(socket, 503);
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+
+    const ws = new this.options.WebSocket(null, undefined, this.options);
+
+    if (protocols.size) {
+      //
+      // Optionally call external protocol selection handler.
+      //
+      const protocol = this.options.handleProtocols
+        ? this.options.handleProtocols(protocols, req)
+        : protocols.values().next().value;
+
+      if (protocol) {
+        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+        ws._protocol = protocol;
+      }
+    }
+
+    if (extensions[PerMessageDeflate.extensionName]) {
+      const params = extensions[PerMessageDeflate.extensionName].params;
+      const value = extension.format({
+        [PerMessageDeflate.extensionName]: [params]
+      });
+      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+      ws._extensions = extensions;
+    }
+
+    //
+    // Allow external modification/inspection of handshake headers.
+    //
+    this.emit('headers', headers, req);
+
+    socket.write(headers.concat('\r\n').join('\r\n'));
+    socket.removeListener('error', socketOnError);
+
+    ws.setSocket(socket, head, {
+      allowSynchronousEvents: this.options.allowSynchronousEvents,
+      maxPayload: this.options.maxPayload,
+      skipUTF8Validation: this.options.skipUTF8Validation
+    });
+
+    if (this.clients) {
+      this.clients.add(ws);
+      ws.on('close', () => {
+        this.clients.delete(ws);
+
+        if (this._shouldEmitClose && !this.clients.size) {
+          process.nextTick(emitClose, this);
+        }
+      });
+    }
+
+    cb(ws, req);
+  }
+}
+
+var websocketServer = WebSocketServer;
+
+/**
+ * Add event listeners on an `EventEmitter` using a map of <event, listener>
+ * pairs.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.<String, Function>} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ *     called
+ * @private
+ */
+function addListeners(server, map) {
+  for (const event of Object.keys(map)) server.on(event, map[event]);
+
+  return function removeListeners() {
+    for (const event of Object.keys(map)) {
+      server.removeListener(event, map[event]);
+    }
+  };
+}
+
+/**
+ * Emit a `'close'` event on an `EventEmitter`.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @private
+ */
+function emitClose(server) {
+  server._state = CLOSED;
+  server.emit('close');
+}
+
+/**
+ * Handle socket errors.
+ *
+ * @private
+ */
+function socketOnError() {
+  this.destroy();
+}
+
+/**
+ * Close the connection when preconditions are not fulfilled.
+ *
+ * @param {Duplex} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} [message] The HTTP response body
+ * @param {Object} [headers] Additional HTTP response headers
+ * @private
+ */
+function abortHandshake(socket, code, message, headers) {
+  //
+  // The socket is writable unless the user destroyed or ended it before calling
+  // `server.handleUpgrade()` or in the `verifyClient` function, which is a user
+  // error. Handling this does not make much sense as the worst that can happen
+  // is that some of the data written by the user might be discarded due to the
+  // call to `socket.end()` below, which triggers an `'error'` event that in
+  // turn causes the socket to be destroyed.
+  //
+  message = message || http$2.STATUS_CODES[code];
+  headers = {
+    Connection: 'close',
+    'Content-Type': 'text/html',
+    'Content-Length': Buffer.byteLength(message),
+    ...headers
+  };
+
+  socket.once('finish', socket.destroy);
+
+  socket.end(
+    `HTTP/1.1 ${code} ${http$2.STATUS_CODES[code]}\r\n` +
+      Object.keys(headers)
+        .map((h) => `${h}: ${headers[h]}`)
+        .join('\r\n') +
+      '\r\n\r\n' +
+      message
+  );
+}
+
+/**
+ * Emit a `'wsClientError'` event on a `WebSocketServer` if there is at least
+ * one listener for it, otherwise call `abortHandshake()`.
+ *
+ * @param {WebSocketServer} server The WebSocket server
+ * @param {http.IncomingMessage} req The request object
+ * @param {Duplex} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} message The HTTP response body
+ * @private
+ */
+function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+  if (server.listenerCount('wsClientError')) {
+    const err = new Error(message);
+    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+
+    server.emit('wsClientError', err, socket, req);
+  } else {
+    abortHandshake(socket, code, message);
+  }
+}
+
+var WebSocketServerRaw_ = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
+
+const WebSocketServerRaw = process.versions.bun ? (
+  // @ts-expect-error: Bun defines `import.meta.require`
+  import.meta.require("ws").WebSocketServer
+) : WebSocketServerRaw_;
+const HMR_HEADER = "vite-hmr";
+const wsServerEvents = [
+  "connection",
+  "error",
+  "headers",
+  "listening",
+  "message"
+];
+function noop$1() {
+}
+function createWebSocketServer(server, config, httpsOptions) {
+  if (config.server.ws === false) {
+    return {
+      name: "ws",
+      get clients() {
+        return /* @__PURE__ */ new Set();
+      },
+      async close() {
+      },
+      on: noop$1,
+      off: noop$1,
+      listen: noop$1,
+      send: noop$1
+    };
+  }
+  let wss;
+  let wsHttpServer = void 0;
+  const hmr = isObject$1(config.server.hmr) && config.server.hmr;
+  const hmrServer = hmr && hmr.server;
+  const hmrPort = hmr && hmr.port;
+  const portsAreCompatible = !hmrPort || hmrPort === config.server.port;
+  const wsServer = hmrServer || portsAreCompatible && server;
+  let hmrServerWsListener;
+  const customListeners = /* @__PURE__ */ new Map();
+  const clientsMap = /* @__PURE__ */ new WeakMap();
+  const port = hmrPort || 24678;
+  const host = hmr && hmr.host || void 0;
+  if (wsServer) {
+    let hmrBase = config.base;
+    const hmrPath = hmr ? hmr.path : void 0;
+    if (hmrPath) {
+      hmrBase = path$n.posix.join(hmrBase, hmrPath);
+    }
+    wss = new WebSocketServerRaw({ noServer: true });
+    hmrServerWsListener = (req, socket, head) => {
+      if (req.headers["sec-websocket-protocol"] === HMR_HEADER && req.url === hmrBase) {
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          wss.emit("connection", ws, req);
+        });
+      }
+    };
+    wsServer.on("upgrade", hmrServerWsListener);
+  } else {
+    const route = (_, res) => {
+      const statusCode = 426;
+      const body = STATUS_CODES[statusCode];
+      if (!body)
+        throw new Error(`No body text found for the ${statusCode} status code`);
+      res.writeHead(statusCode, {
+        "Content-Length": body.length,
+        "Content-Type": "text/plain"
+      });
+      res.end(body);
+    };
+    if (httpsOptions) {
+      wsHttpServer = createServer$2(httpsOptions, route);
+    } else {
+      wsHttpServer = createServer$3(route);
+    }
+    wss = new WebSocketServerRaw({ server: wsHttpServer });
+  }
+  wss.on("connection", (socket) => {
+    socket.on("message", (raw) => {
+      if (!customListeners.size) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(String(raw));
+      } catch {
+      }
+      if (!parsed || parsed.type !== "custom" || !parsed.event) return;
+      const listeners = customListeners.get(parsed.event);
+      if (!listeners?.size) return;
+      const client = getSocketClient(socket);
+      listeners.forEach((listener) => listener(parsed.data, client));
+    });
+    socket.on("error", (err) => {
+      config.logger.error(`${colors$1.red(`ws error:`)}
+${err.stack}`, {
+        timestamp: true,
+        error: err
+      });
+    });
+    socket.send(JSON.stringify({ type: "connected" }));
+    if (bufferedError) {
+      socket.send(JSON.stringify(bufferedError));
+      bufferedError = null;
+    }
+  });
+  wss.on("error", (e) => {
+    if (e.code === "EADDRINUSE") {
+      config.logger.error(
+        colors$1.red(`WebSocket server error: Port is already in use`),
+        { error: e }
+      );
+    } else {
+      config.logger.error(
+        colors$1.red(`WebSocket server error:
+${e.stack || e.message}`),
+        { error: e }
+      );
+    }
+  });
+  function getSocketClient(socket) {
+    if (!clientsMap.has(socket)) {
+      clientsMap.set(socket, {
+        send: (...args) => {
+          let payload;
+          if (typeof args[0] === "string") {
+            payload = {
+              type: "custom",
+              event: args[0],
+              data: args[1]
+            };
+          } else {
+            payload = args[0];
+          }
+          socket.send(JSON.stringify(payload));
+        },
+        socket
+      });
+    }
+    return clientsMap.get(socket);
+  }
+  let bufferedError = null;
+  return {
+    name: "ws",
+    listen: () => {
+      wsHttpServer?.listen(port, host);
+    },
+    on: (event, fn) => {
+      if (wsServerEvents.includes(event)) wss.on(event, fn);
+      else {
+        if (!customListeners.has(event)) {
+          customListeners.set(event, /* @__PURE__ */ new Set());
+        }
+        customListeners.get(event).add(fn);
+      }
+    },
+    off: (event, fn) => {
+      if (wsServerEvents.includes(event)) {
+        wss.off(event, fn);
+      } else {
+        customListeners.get(event)?.delete(fn);
+      }
+    },
+    get clients() {
+      return new Set(Array.from(wss.clients).map(getSocketClient));
+    },
+    send(...args) {
+      let payload;
+      if (typeof args[0] === "string") {
+        payload = {
+          type: "custom",
+          event: args[0],
+          data: args[1]
+        };
+      } else {
+        payload = args[0];
+      }
+      if (payload.type === "error" && !wss.clients.size) {
+        bufferedError = payload;
+        return;
+      }
+      const stringified = JSON.stringify(payload);
+      wss.clients.forEach((client) => {
+        if (client.readyState === 1) {
+          client.send(stringified);
+        }
+      });
+    },
+    close() {
+      if (hmrServerWsListener && wsServer) {
+        wsServer.off("upgrade", hmrServerWsListener);
+      }
+      return new Promise((resolve, reject) => {
+        wss.clients.forEach((client) => {
+          client.terminate();
+        });
+        wss.close((err) => {
+          if (err) {
+            reject(err);
+          } else {
+            if (wsHttpServer) {
+              wsHttpServer.close((err2) => {
+                if (err2) {
+                  reject(err2);
+                } else {
+                  resolve();
+                }
+              });
+            } else {
+              resolve();
+            }
+          }
+        });
+      });
+    }
+  };
+}
+
+function baseMiddleware(rawBase, middlewareMode) {
+  return function viteBaseMiddleware(req, res, next) {
+    const url = req.url;
+    const pathname = cleanUrl(url);
+    const base = rawBase;
+    if (pathname.startsWith(base)) {
+      req.url = stripBase(url, base);
+      return next();
+    }
+    if (middlewareMode) {
+      return next();
+    }
+    if (pathname === "/" || pathname === "/index.html") {
+      res.writeHead(302, {
+        Location: base + url.slice(pathname.length)
+      });
+      res.end();
+      return;
+    }
+    const redirectPath = withTrailingSlash(url) !== base ? joinUrlSegments(base, url) : base;
+    if (req.headers.accept?.includes("text/html")) {
+      res.writeHead(404, {
+        "Content-Type": "text/html"
+      });
+      res.end(
+        `The server is configured with a public base URL of ${base} - did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`
+      );
+      return;
+    } else {
+      res.writeHead(404, {
+        "Content-Type": "text/plain"
+      });
+      res.end(
+        `The server is configured with a public base URL of ${base} - did you mean to visit ${redirectPath} instead?`
+      );
+      return;
+    }
+  };
+}
+
+var httpProxy$3 = {exports: {}};
+
+var eventemitter3 = {exports: {}};
+
+(function (module) {
+
+	var has = Object.prototype.hasOwnProperty
+	  , prefix = '~';
+
+	/**
+	 * Constructor to create a storage for our `EE` objects.
+	 * An `Events` instance is a plain object whose properties are event names.
+	 *
+	 * @constructor
+	 * @private
+	 */
+	function Events() {}
+
+	//
+	// We try to not inherit from `Object.prototype`. In some engines creating an
+	// instance in this way is faster than calling `Object.create(null)` directly.
+	// If `Object.create(null)` is not supported we prefix the event names with a
+	// character to make sure that the built-in object properties are not
+	// overridden or used as an attack vector.
+	//
+	if (Object.create) {
+	  Events.prototype = Object.create(null);
+
+	  //
+	  // This hack is needed because the `__proto__` property is still inherited in
+	  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+	  //
+	  if (!new Events().__proto__) prefix = false;
+	}
+
+	/**
+	 * Representation of a single event listener.
+	 *
+	 * @param {Function} fn The listener function.
+	 * @param {*} context The context to invoke the listener with.
+	 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+	 * @constructor
+	 * @private
+	 */
+	function EE(fn, context, once) {
+	  this.fn = fn;
+	  this.context = context;
+	  this.once = once || false;
+	}
+
+	/**
+	 * Add a listener for a given event.
+	 *
+	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} context The context to invoke the listener with.
+	 * @param {Boolean} once Specify if the listener is a one-time listener.
+	 * @returns {EventEmitter}
+	 * @private
+	 */
+	function addListener(emitter, event, fn, context, once) {
+	  if (typeof fn !== 'function') {
+	    throw new TypeError('The listener must be a function');
+	  }
+
+	  var listener = new EE(fn, context || emitter, once)
+	    , evt = prefix ? prefix + event : event;
+
+	  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+	  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+	  else emitter._events[evt] = [emitter._events[evt], listener];
+
+	  return emitter;
+	}
+
+	/**
+	 * Clear event by name.
+	 *
+	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	 * @param {(String|Symbol)} evt The Event name.
+	 * @private
+	 */
+	function clearEvent(emitter, evt) {
+	  if (--emitter._eventsCount === 0) emitter._events = new Events();
+	  else delete emitter._events[evt];
+	}
+
+	/**
+	 * Minimal `EventEmitter` interface that is molded against the Node.js
+	 * `EventEmitter` interface.
+	 *
+	 * @constructor
+	 * @public
+	 */
+	function EventEmitter() {
+	  this._events = new Events();
+	  this._eventsCount = 0;
+	}
+
+	/**
+	 * Return an array listing the events for which the emitter has registered
+	 * listeners.
+	 *
+	 * @returns {Array}
+	 * @public
+	 */
+	EventEmitter.prototype.eventNames = function eventNames() {
+	  var names = []
+	    , events
+	    , name;
+
+	  if (this._eventsCount === 0) return names;
+
+	  for (name in (events = this._events)) {
+	    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+	  }
+
+	  if (Object.getOwnPropertySymbols) {
+	    return names.concat(Object.getOwnPropertySymbols(events));
+	  }
+
+	  return names;
+	};
+
+	/**
+	 * Return the listeners registered for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Array} The registered listeners.
+	 * @public
+	 */
+	EventEmitter.prototype.listeners = function listeners(event) {
+	  var evt = prefix ? prefix + event : event
+	    , handlers = this._events[evt];
+
+	  if (!handlers) return [];
+	  if (handlers.fn) return [handlers.fn];
+
+	  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+	    ee[i] = handlers[i].fn;
+	  }
+
+	  return ee;
+	};
+
+	/**
+	 * Return the number of listeners listening to a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Number} The number of listeners.
+	 * @public
+	 */
+	EventEmitter.prototype.listenerCount = function listenerCount(event) {
+	  var evt = prefix ? prefix + event : event
+	    , listeners = this._events[evt];
+
+	  if (!listeners) return 0;
+	  if (listeners.fn) return 1;
+	  return listeners.length;
+	};
+
+	/**
+	 * Calls each of the listeners registered for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Boolean} `true` if the event had listeners, else `false`.
+	 * @public
+	 */
+	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+	  var evt = prefix ? prefix + event : event;
+
+	  if (!this._events[evt]) return false;
+
+	  var listeners = this._events[evt]
+	    , len = arguments.length
+	    , args
+	    , i;
+
+	  if (listeners.fn) {
+	    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+	    switch (len) {
+	      case 1: return listeners.fn.call(listeners.context), true;
+	      case 2: return listeners.fn.call(listeners.context, a1), true;
+	      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+	      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+	      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+	      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+	    }
+
+	    for (i = 1, args = new Array(len -1); i < len; i++) {
+	      args[i - 1] = arguments[i];
+	    }
+
+	    listeners.fn.apply(listeners.context, args);
+	  } else {
+	    var length = listeners.length
+	      , j;
+
+	    for (i = 0; i < length; i++) {
+	      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+	      switch (len) {
+	        case 1: listeners[i].fn.call(listeners[i].context); break;
+	        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+	        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+	        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+	        default:
+	          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+	            args[j - 1] = arguments[j];
+	          }
+
+	          listeners[i].fn.apply(listeners[i].context, args);
+	      }
+	    }
+	  }
+
+	  return true;
+	};
+
+	/**
+	 * Add a listener for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} [context=this] The context to invoke the listener with.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.on = function on(event, fn, context) {
+	  return addListener(this, event, fn, context, false);
+	};
+
+	/**
+	 * Add a one-time listener for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} [context=this] The context to invoke the listener with.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.once = function once(event, fn, context) {
+	  return addListener(this, event, fn, context, true);
+	};
+
+	/**
+	 * Remove the listeners of a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn Only remove the listeners that match this function.
+	 * @param {*} context Only remove the listeners that have this context.
+	 * @param {Boolean} once Only remove one-time listeners.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+	  var evt = prefix ? prefix + event : event;
+
+	  if (!this._events[evt]) return this;
+	  if (!fn) {
+	    clearEvent(this, evt);
+	    return this;
+	  }
+
+	  var listeners = this._events[evt];
+
+	  if (listeners.fn) {
+	    if (
+	      listeners.fn === fn &&
+	      (!once || listeners.once) &&
+	      (!context || listeners.context === context)
+	    ) {
+	      clearEvent(this, evt);
+	    }
+	  } else {
+	    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+	      if (
+	        listeners[i].fn !== fn ||
+	        (once && !listeners[i].once) ||
+	        (context && listeners[i].context !== context)
+	      ) {
+	        events.push(listeners[i]);
+	      }
+	    }
+
+	    //
+	    // Reset the array, or remove it completely if we have no more listeners.
+	    //
+	    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+	    else clearEvent(this, evt);
+	  }
+
+	  return this;
+	};
+
+	/**
+	 * Remove all listeners, or those of the specified event.
+	 *
+	 * @param {(String|Symbol)} [event] The event name.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+	  var evt;
+
+	  if (event) {
+	    evt = prefix ? prefix + event : event;
+	    if (this._events[evt]) clearEvent(this, evt);
+	  } else {
+	    this._events = new Events();
+	    this._eventsCount = 0;
+	  }
+
+	  return this;
+	};
+
+	//
+	// Alias methods names because people roll like that.
+	//
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+	//
+	// Expose the prefix.
+	//
+	EventEmitter.prefixed = prefix;
+
+	//
+	// Allow `EventEmitter` to be imported as module namespace.
+	//
+	EventEmitter.EventEmitter = EventEmitter;
+
+	//
+	// Expose the module.
+	//
+	{
+	  module.exports = EventEmitter;
+	} 
+} (eventemitter3));
+
+var eventemitter3Exports = eventemitter3.exports;
+
+var common$3 = {};
+
+/**
+ * Check if we're required to add a port number.
+ *
+ * @see https://url.spec.whatwg.org/#default-port
+ * @param {Number|String} port Port number we need to check
+ * @param {String} protocol Protocol we need to check against.
+ * @returns {Boolean} Is it a default port for the given protocol
+ * @api private
+ */
+var requiresPort = function required(port, protocol) {
+  protocol = protocol.split(':')[0];
+  port = +port;
+
+  if (!port) return false;
+
+  switch (protocol) {
+    case 'http':
+    case 'ws':
+    return port !== 80;
+
+    case 'https':
+    case 'wss':
+    return port !== 443;
+
+    case 'ftp':
+    return port !== 21;
+
+    case 'gopher':
+    return port !== 70;
+
+    case 'file':
+    return false;
+  }
+
+  return port !== 0;
+};
+
+(function (exports) {
+	var common   = exports,
+	    url      = require$$0$9,
+	    required = requiresPort;
+
+	var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i,
+	    isSSL = /^https|wss/;
+
+	/**
+	 * Simple Regex for testing if protocol is https
+	 */
+	common.isSSL = isSSL;
+	/**
+	 * Copies the right headers from `options` and `req` to
+	 * `outgoing` which is then used to fire the proxied
+	 * request.
+	 *
+	 * Examples:
+	 *
+	 *    common.setupOutgoing(outgoing, options, req)
+	 *    // => { host: ..., hostname: ...}
+	 *
+	 * @param {Object} Outgoing Base object to be filled with required properties
+	 * @param {Object} Options Config object passed to the proxy
+	 * @param {ClientRequest} Req Request Object
+	 * @param {String} Forward String to select forward or target
+	 * 
+	 * @return {Object} Outgoing Object with all required properties set
+	 *
+	 * @api private
+	 */
+
+	common.setupOutgoing = function(outgoing, options, req, forward) {
+	  outgoing.port = options[forward || 'target'].port ||
+	                  (isSSL.test(options[forward || 'target'].protocol) ? 443 : 80);
+
+	  ['host', 'hostname', 'socketPath', 'pfx', 'key',
+	    'passphrase', 'cert', 'ca', 'ciphers', 'secureProtocol'].forEach(
+	    function(e) { outgoing[e] = options[forward || 'target'][e]; }
+	  );
+
+	  outgoing.method = options.method || req.method;
+	  outgoing.headers = Object.assign({}, req.headers);
+
+	  if (options.headers){
+	    Object.assign(outgoing.headers, options.headers);
+	  }
+
+	  if (options.auth) {
+	    outgoing.auth = options.auth;
+	  }
+	  
+	  if (options.ca) {
+	      outgoing.ca = options.ca;
+	  }
+
+	  if (isSSL.test(options[forward || 'target'].protocol)) {
+	    outgoing.rejectUnauthorized = (typeof options.secure === "undefined") ? true : options.secure;
+	  }
+
+
+	  outgoing.agent = options.agent || false;
+	  outgoing.localAddress = options.localAddress;
+
+	  //
+	  // Remark: If we are false and not upgrading, set the connection: close. This is the right thing to do
+	  // as node core doesn't handle this COMPLETELY properly yet.
+	  //
+	  if (!outgoing.agent) {
+	    outgoing.headers = outgoing.headers || {};
+	    if (typeof outgoing.headers.connection !== 'string'
+	        || !upgradeHeader.test(outgoing.headers.connection)
+	       ) { outgoing.headers.connection = 'close'; }
+	  }
+
+
+	  // the final path is target path + relative path requested by user:
+	  var target = options[forward || 'target'];
+	  var targetPath = target && options.prependPath !== false
+	    ? (target.path || '')
+	    : '';
+
+	  //
+	  // Remark: Can we somehow not use url.parse as a perf optimization?
+	  //
+	  var outgoingPath = !options.toProxy
+	    ? (url.parse(req.url).path || '')
+	    : req.url;
+
+	  //
+	  // Remark: ignorePath will just straight up ignore whatever the request's
+	  // path is. This can be labeled as FOOT-GUN material if you do not know what
+	  // you are doing and are using conflicting options.
+	  //
+	  outgoingPath = !options.ignorePath ? outgoingPath : '';
+
+	  outgoing.path = common.urlJoin(targetPath, outgoingPath);
+
+	  if (options.changeOrigin) {
+	    outgoing.headers.host =
+	      required(outgoing.port, options[forward || 'target'].protocol) && !hasPort(outgoing.host)
+	        ? outgoing.host + ':' + outgoing.port
+	        : outgoing.host;
+	  }
+	  return outgoing;
+	};
+
+	/**
+	 * Set the proper configuration for sockets,
+	 * set no delay and set keep alive, also set
+	 * the timeout to 0.
+	 *
+	 * Examples:
+	 *
+	 *    common.setupSocket(socket)
+	 *    // => Socket
+	 *
+	 * @param {Socket} Socket instance to setup
+	 * 
+	 * @return {Socket} Return the configured socket.
+	 *
+	 * @api private
+	 */
+
+	common.setupSocket = function(socket) {
+	  socket.setTimeout(0);
+	  socket.setNoDelay(true);
+
+	  socket.setKeepAlive(true, 0);
+
+	  return socket;
+	};
+
+	/**
+	 * Get the port number from the host. Or guess it based on the connection type.
+	 *
+	 * @param {Request} req Incoming HTTP request.
+	 *
+	 * @return {String} The port number.
+	 *
+	 * @api private
+	 */
+	common.getPort = function(req) {
+	  var res = req.headers.host ? req.headers.host.match(/:(\d+)/) : '';
+
+	  return res ?
+	    res[1] :
+	    common.hasEncryptedConnection(req) ? '443' : '80';
+	};
+
+	/**
+	 * Check if the request has an encrypted connection.
+	 *
+	 * @param {Request} req Incoming HTTP request.
+	 *
+	 * @return {Boolean} Whether the connection is encrypted or not.
+	 *
+	 * @api private
+	 */
+	common.hasEncryptedConnection = function(req) {
+	  return Boolean(req.connection.encrypted || req.connection.pair);
+	};
+
+	/**
+	 * OS-agnostic join (doesn't break on URLs like path.join does on Windows)>
+	 *
+	 * @return {String} The generated path.
+	 *
+	 * @api private
+	 */
+
+	common.urlJoin = function() {
+	    //
+	    // We do not want to mess with the query string. All we want to touch is the path.
+	    //
+	  var args = Array.prototype.slice.call(arguments),
+	      lastIndex = args.length - 1,
+	      last = args[lastIndex],
+	      lastSegs = last.split('?'),
+	      retSegs;
+
+	  args[lastIndex] = lastSegs.shift();
+
+	  //
+	  // Join all strings, but remove empty strings so we don't get extra slashes from
+	  // joining e.g. ['', 'am']
+	  //
+	  retSegs = [
+	    args.filter(Boolean).join('/')
+	        .replace(/\/+/g, '/')
+	        .replace('http:/', 'http://')
+	        .replace('https:/', 'https://')
+	  ];
+
+	  // Only join the query string if it exists so we don't have trailing a '?'
+	  // on every request
+
+	  // Handle case where there could be multiple ? in the URL.
+	  retSegs.push.apply(retSegs, lastSegs);
+
+	  return retSegs.join('?')
+	};
+
+	/**
+	 * Rewrites or removes the domain of a cookie header
+	 *
+	 * @param {String|Array} Header
+	 * @param {Object} Config, mapping of domain to rewritten domain.
+	 *                 '*' key to match any domain, null value to remove the domain.
+	 *
+	 * @api private
+	 */
+	common.rewriteCookieProperty = function rewriteCookieProperty(header, config, property) {
+	  if (Array.isArray(header)) {
+	    return header.map(function (headerElement) {
+	      return rewriteCookieProperty(headerElement, config, property);
+	    });
+	  }
+	  return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", 'i'), function(match, prefix, previousValue) {
+	    var newValue;
+	    if (previousValue in config) {
+	      newValue = config[previousValue];
+	    } else if ('*' in config) {
+	      newValue = config['*'];
+	    } else {
+	      //no match, return previous value
+	      return match;
+	    }
+	    if (newValue) {
+	      //replace value
+	      return prefix + newValue;
+	    } else {
+	      //remove value
+	      return '';
+	    }
+	  });
+	};
+
+	/**
+	 * Check the host and see if it potentially has a port in it (keep it simple)
+	 *
+	 * @returns {Boolean} Whether we have one or not
+	 *
+	 * @api private
+	 */
+	function hasPort(host) {
+	  return !!~host.indexOf(':');
+	}} (common$3));
+
+var url$1    = require$$0$9,
+    common$2 = common$3;
+
+
+var redirectRegex = /^201|30(1|2|7|8)$/;
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+var webOutgoing = { // <--
+
+  /**
+   * If is a HTTP 1.0 request, remove chunk headers
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {proxyResponse} Res Response object from the proxy request
+   *
+   * @api private
+   */
+  removeChunked: function removeChunked(req, res, proxyRes) {
+    if (req.httpVersion === '1.0') {
+      delete proxyRes.headers['transfer-encoding'];
+    }
+  },
+
+  /**
+   * If is a HTTP 1.0 request, set the correct connection header
+   * or if connection header not present, then use `keep-alive`
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {proxyResponse} Res Response object from the proxy request
+   *
+   * @api private
+   */
+  setConnection: function setConnection(req, res, proxyRes) {
+    if (req.httpVersion === '1.0') {
+      proxyRes.headers.connection = req.headers.connection || 'close';
+    } else if (req.httpVersion !== '2.0' && !proxyRes.headers.connection) {
+      proxyRes.headers.connection = req.headers.connection || 'keep-alive';
+    }
+  },
+
+  setRedirectHostRewrite: function setRedirectHostRewrite(req, res, proxyRes, options) {
+    if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite)
+        && proxyRes.headers['location']
+        && redirectRegex.test(proxyRes.statusCode)) {
+      var target = url$1.parse(options.target);
+      var u = url$1.parse(proxyRes.headers['location']);
+
+      // make sure the redirected host matches the target host before rewriting
+      if (target.host != u.host) {
+        return;
+      }
+
+      if (options.hostRewrite) {
+        u.host = options.hostRewrite;
+      } else if (options.autoRewrite) {
+        u.host = req.headers['host'];
+      }
+      if (options.protocolRewrite) {
+        u.protocol = options.protocolRewrite;
+      }
+
+      proxyRes.headers['location'] = u.format();
+    }
+  },
+  /**
+   * Copy headers from proxyResponse to response
+   * set each header in response object.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {proxyResponse} Res Response object from the proxy request
+   * @param {Object} Options options.cookieDomainRewrite: Config to rewrite cookie domain
+   *
+   * @api private
+   */
+  writeHeaders: function writeHeaders(req, res, proxyRes, options) {
+    var rewriteCookieDomainConfig = options.cookieDomainRewrite,
+        rewriteCookiePathConfig = options.cookiePathRewrite,
+        preserveHeaderKeyCase = options.preserveHeaderKeyCase,
+        rawHeaderKeyMap,
+        setHeader = function(key, header) {
+          if (header == undefined) return;
+          if (rewriteCookieDomainConfig && key.toLowerCase() === 'set-cookie') {
+            header = common$2.rewriteCookieProperty(header, rewriteCookieDomainConfig, 'domain');
+          }
+          if (rewriteCookiePathConfig && key.toLowerCase() === 'set-cookie') {
+            header = common$2.rewriteCookieProperty(header, rewriteCookiePathConfig, 'path');
+          }
+          res.setHeader(String(key).trim(), header);
+        };
+
+    if (typeof rewriteCookieDomainConfig === 'string') { //also test for ''
+      rewriteCookieDomainConfig = { '*': rewriteCookieDomainConfig };
+    }
+
+    if (typeof rewriteCookiePathConfig === 'string') { //also test for ''
+      rewriteCookiePathConfig = { '*': rewriteCookiePathConfig };
+    }
+
+    // message.rawHeaders is added in: v0.11.6
+    // https://nodejs.org/api/http.html#http_message_rawheaders
+    if (preserveHeaderKeyCase && proxyRes.rawHeaders != undefined) {
+      rawHeaderKeyMap = {};
+      for (var i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+        var key = proxyRes.rawHeaders[i];
+        rawHeaderKeyMap[key.toLowerCase()] = key;
+      }
+    }
+
+    Object.keys(proxyRes.headers).forEach(function(key) {
+      var header = proxyRes.headers[key];
+      if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+        key = rawHeaderKeyMap[key] || key;
+      }
+      setHeader(key, header);
+    });
+  },
+
+  /**
+   * Set the statusCode from the proxyResponse
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {proxyResponse} Res Response object from the proxy request
+   *
+   * @api private
+   */
+  writeStatusCode: function writeStatusCode(req, res, proxyRes) {
+    // From Node.js docs: response.writeHead(statusCode[, statusMessage][, headers])
+    if(proxyRes.statusMessage) {
+      res.statusCode = proxyRes.statusCode;
+      res.statusMessage = proxyRes.statusMessage;
+    } else {
+      res.statusCode = proxyRes.statusCode;
+    }
+  }
+
+};
+
+var followRedirects$1 = {exports: {}};
+
+var debug$6;
+
+var debug_1 = function () {
+  if (!debug$6) {
+    try {
+      /* eslint global-require: off */
+      debug$6 = srcExports$1("follow-redirects");
+    }
+    catch (error) { /* */ }
+    if (typeof debug$6 !== "function") {
+      debug$6 = function () { /* */ };
+    }
+  }
+  debug$6.apply(null, arguments);
+};
+
+var url = require$$0$9;
+var URL$1 = url.URL;
+var http$1 = require$$1;
+var https$1 = require$$1$1;
+var Writable = require$$0$6.Writable;
+var assert = require$$4$3;
+var debug$5 = debug_1;
+
+// Whether to use the native URL object or the legacy url module
+var useNativeURL = false;
+try {
+  assert(new URL$1());
+}
+catch (error) {
+  useNativeURL = error.code === "ERR_INVALID_URL";
+}
+
+// URL fields to preserve in copy operations
+var preservedUrlFields = [
+  "auth",
+  "host",
+  "hostname",
+  "href",
+  "path",
+  "pathname",
+  "port",
+  "protocol",
+  "query",
+  "search",
+  "hash",
+];
+
+// Create handlers that pass events from native requests
+var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
+var eventHandlers = Object.create(null);
+events.forEach(function (event) {
+  eventHandlers[event] = function (arg1, arg2, arg3) {
+    this._redirectable.emit(event, arg1, arg2, arg3);
+  };
+});
+
+// Error types with codes
+var InvalidUrlError = createErrorType(
+  "ERR_INVALID_URL",
+  "Invalid URL",
+  TypeError
+);
+var RedirectionError = createErrorType(
+  "ERR_FR_REDIRECTION_FAILURE",
+  "Redirected request failed"
+);
+var TooManyRedirectsError = createErrorType(
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "Maximum number of redirects exceeded",
+  RedirectionError
+);
+var MaxBodyLengthExceededError = createErrorType(
+  "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
+  "Request body larger than maxBodyLength limit"
+);
+var WriteAfterEndError = createErrorType(
+  "ERR_STREAM_WRITE_AFTER_END",
+  "write after end"
+);
+
+// istanbul ignore next
+var destroy = Writable.prototype.destroy || noop;
+
+// An HTTP(S) request that can be redirected
+function RedirectableRequest(options, responseCallback) {
+  // Initialize the request
+  Writable.call(this);
+  this._sanitizeOptions(options);
+  this._options = options;
+  this._ended = false;
+  this._ending = false;
+  this._redirectCount = 0;
+  this._redirects = [];
+  this._requestBodyLength = 0;
+  this._requestBodyBuffers = [];
+
+  // Attach a callback if passed
+  if (responseCallback) {
+    this.on("response", responseCallback);
+  }
+
+  // React to responses of native requests
+  var self = this;
+  this._onNativeResponse = function (response) {
+    try {
+      self._processResponse(response);
+    }
+    catch (cause) {
+      self.emit("error", cause instanceof RedirectionError ?
+        cause : new RedirectionError({ cause: cause }));
+    }
+  };
+
+  // Perform the first request
+  this._performRequest();
+}
+RedirectableRequest.prototype = Object.create(Writable.prototype);
+
+RedirectableRequest.prototype.abort = function () {
+  destroyRequest(this._currentRequest);
+  this._currentRequest.abort();
+  this.emit("abort");
+};
+
+RedirectableRequest.prototype.destroy = function (error) {
+  destroyRequest(this._currentRequest, error);
+  destroy.call(this, error);
+  return this;
+};
+
+// Writes buffered data to the current native request
+RedirectableRequest.prototype.write = function (data, encoding, callback) {
+  // Writing is not allowed if end has been called
+  if (this._ending) {
+    throw new WriteAfterEndError();
+  }
+
+  // Validate input and shift parameters if necessary
+  if (!isString(data) && !isBuffer(data)) {
+    throw new TypeError("data should be a string, Buffer or Uint8Array");
+  }
+  if (isFunction(encoding)) {
+    callback = encoding;
+    encoding = null;
+  }
+
+  // Ignore empty buffers, since writing them doesn't invoke the callback
+  // https://github.com/nodejs/node/issues/22066
+  if (data.length === 0) {
+    if (callback) {
+      callback();
+    }
+    return;
+  }
+  // Only write when we don't exceed the maximum body length
+  if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+    this._requestBodyLength += data.length;
+    this._requestBodyBuffers.push({ data: data, encoding: encoding });
+    this._currentRequest.write(data, encoding, callback);
+  }
+  // Error when we exceed the maximum body length
+  else {
+    this.emit("error", new MaxBodyLengthExceededError());
+    this.abort();
+  }
+};
+
+// Ends the current native request
+RedirectableRequest.prototype.end = function (data, encoding, callback) {
+  // Shift parameters if necessary
+  if (isFunction(data)) {
+    callback = data;
+    data = encoding = null;
+  }
+  else if (isFunction(encoding)) {
+    callback = encoding;
+    encoding = null;
+  }
+
+  // Write data if needed and end
+  if (!data) {
+    this._ended = this._ending = true;
+    this._currentRequest.end(null, null, callback);
+  }
+  else {
+    var self = this;
+    var currentRequest = this._currentRequest;
+    this.write(data, encoding, function () {
+      self._ended = true;
+      currentRequest.end(null, null, callback);
+    });
+    this._ending = true;
+  }
+};
+
+// Sets a header value on the current native request
+RedirectableRequest.prototype.setHeader = function (name, value) {
+  this._options.headers[name] = value;
+  this._currentRequest.setHeader(name, value);
+};
+
+// Clears a header value on the current native request
+RedirectableRequest.prototype.removeHeader = function (name) {
+  delete this._options.headers[name];
+  this._currentRequest.removeHeader(name);
+};
+
+// Global timeout for all underlying requests
+RedirectableRequest.prototype.setTimeout = function (msecs, callback) {
+  var self = this;
+
+  // Destroys the socket on timeout
+  function destroyOnTimeout(socket) {
+    socket.setTimeout(msecs);
+    socket.removeListener("timeout", socket.destroy);
+    socket.addListener("timeout", socket.destroy);
+  }
+
+  // Sets up a timer to trigger a timeout event
+  function startTimer(socket) {
+    if (self._timeout) {
+      clearTimeout(self._timeout);
+    }
+    self._timeout = setTimeout(function () {
+      self.emit("timeout");
+      clearTimer();
+    }, msecs);
+    destroyOnTimeout(socket);
+  }
+
+  // Stops a timeout from triggering
+  function clearTimer() {
+    // Clear the timeout
+    if (self._timeout) {
+      clearTimeout(self._timeout);
+      self._timeout = null;
+    }
+
+    // Clean up all attached listeners
+    self.removeListener("abort", clearTimer);
+    self.removeListener("error", clearTimer);
+    self.removeListener("response", clearTimer);
+    self.removeListener("close", clearTimer);
+    if (callback) {
+      self.removeListener("timeout", callback);
+    }
+    if (!self.socket) {
+      self._currentRequest.removeListener("socket", startTimer);
+    }
+  }
+
+  // Attach callback if passed
+  if (callback) {
+    this.on("timeout", callback);
+  }
+
+  // Start the timer if or when the socket is opened
+  if (this.socket) {
+    startTimer(this.socket);
+  }
+  else {
+    this._currentRequest.once("socket", startTimer);
+  }
+
+  // Clean up on events
+  this.on("socket", destroyOnTimeout);
+  this.on("abort", clearTimer);
+  this.on("error", clearTimer);
+  this.on("response", clearTimer);
+  this.on("close", clearTimer);
+
+  return this;
+};
+
+// Proxy all other public ClientRequest methods
+[
+  "flushHeaders", "getHeader",
+  "setNoDelay", "setSocketKeepAlive",
+].forEach(function (method) {
+  RedirectableRequest.prototype[method] = function (a, b) {
+    return this._currentRequest[method](a, b);
+  };
+});
+
+// Proxy all public ClientRequest properties
+["aborted", "connection", "socket"].forEach(function (property) {
+  Object.defineProperty(RedirectableRequest.prototype, property, {
+    get: function () { return this._currentRequest[property]; },
+  });
+});
+
+RedirectableRequest.prototype._sanitizeOptions = function (options) {
+  // Ensure headers are always present
+  if (!options.headers) {
+    options.headers = {};
+  }
+
+  // Since http.request treats host as an alias of hostname,
+  // but the url module interprets host as hostname plus port,
+  // eliminate the host property to avoid confusion.
+  if (options.host) {
+    // Use hostname if set, because it has precedence
+    if (!options.hostname) {
+      options.hostname = options.host;
+    }
+    delete options.host;
+  }
+
+  // Complete the URL object when necessary
+  if (!options.pathname && options.path) {
+    var searchPos = options.path.indexOf("?");
+    if (searchPos < 0) {
+      options.pathname = options.path;
+    }
+    else {
+      options.pathname = options.path.substring(0, searchPos);
+      options.search = options.path.substring(searchPos);
+    }
+  }
+};
+
+
+// Executes the next native request (initial or redirect)
+RedirectableRequest.prototype._performRequest = function () {
+  // Load the native protocol
+  var protocol = this._options.protocol;
+  var nativeProtocol = this._options.nativeProtocols[protocol];
+  if (!nativeProtocol) {
+    throw new TypeError("Unsupported protocol " + protocol);
+  }
+
+  // If specified, use the agent corresponding to the protocol
+  // (HTTP and HTTPS use different types of agents)
+  if (this._options.agents) {
+    var scheme = protocol.slice(0, -1);
+    this._options.agent = this._options.agents[scheme];
+  }
+
+  // Create the native request and set up its event handlers
+  var request = this._currentRequest =
+        nativeProtocol.request(this._options, this._onNativeResponse);
+  request._redirectable = this;
+  for (var event of events) {
+    request.on(event, eventHandlers[event]);
+  }
+
+  // RFC7230§5.3.1: When making a request directly to an origin server, […]
+  // a client MUST send only the absolute path […] as the request-target.
+  this._currentUrl = /^\//.test(this._options.path) ?
+    url.format(this._options) :
+    // When making a request to a proxy, […]
+    // a client MUST send the target URI in absolute-form […].
+    this._options.path;
+
+  // End a redirected request
+  // (The first request must be ended explicitly with RedirectableRequest#end)
+  if (this._isRedirect) {
+    // Write the request entity and end
+    var i = 0;
+    var self = this;
+    var buffers = this._requestBodyBuffers;
+    (function writeNext(error) {
+      // Only write if this request has not been redirected yet
+      /* istanbul ignore else */
+      if (request === self._currentRequest) {
+        // Report any write errors
+        /* istanbul ignore if */
+        if (error) {
+          self.emit("error", error);
+        }
+        // Write the next buffer if there are still left
+        else if (i < buffers.length) {
+          var buffer = buffers[i++];
+          /* istanbul ignore else */
+          if (!request.finished) {
+            request.write(buffer.data, buffer.encoding, writeNext);
+          }
+        }
+        // End the request if `end` has been called on us
+        else if (self._ended) {
+          request.end();
+        }
+      }
+    }());
+  }
+};
+
+// Processes a response from the current native request
+RedirectableRequest.prototype._processResponse = function (response) {
+  // Store the redirected response
+  var statusCode = response.statusCode;
+  if (this._options.trackRedirects) {
+    this._redirects.push({
+      url: this._currentUrl,
+      headers: response.headers,
+      statusCode: statusCode,
+    });
+  }
+
+  // RFC7231§6.4: The 3xx (Redirection) class of status code indicates
+  // that further action needs to be taken by the user agent in order to
+  // fulfill the request. If a Location header field is provided,
+  // the user agent MAY automatically redirect its request to the URI
+  // referenced by the Location field value,
+  // even if the specific status code is not understood.
+
+  // If the response is not a redirect; return it as-is
+  var location = response.headers.location;
+  if (!location || this._options.followRedirects === false ||
+      statusCode < 300 || statusCode >= 400) {
+    response.responseUrl = this._currentUrl;
+    response.redirects = this._redirects;
+    this.emit("response", response);
+
+    // Clean up
+    this._requestBodyBuffers = [];
+    return;
+  }
+
+  // The response is a redirect, so abort the current request
+  destroyRequest(this._currentRequest);
+  // Discard the remainder of the response to avoid waiting for data
+  response.destroy();
+
+  // RFC7231§6.4: A client SHOULD detect and intervene
+  // in cyclical redirections (i.e., "infinite" redirection loops).
+  if (++this._redirectCount > this._options.maxRedirects) {
+    throw new TooManyRedirectsError();
+  }
+
+  // Store the request headers if applicable
+  var requestHeaders;
+  var beforeRedirect = this._options.beforeRedirect;
+  if (beforeRedirect) {
+    requestHeaders = Object.assign({
+      // The Host header was set by nativeProtocol.request
+      Host: response.req.getHeader("host"),
+    }, this._options.headers);
+  }
+
+  // RFC7231§6.4: Automatic redirection needs to done with
+  // care for methods not known to be safe, […]
+  // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change
+  // the request method from POST to GET for the subsequent request.
+  var method = this._options.method;
+  if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" ||
+      // RFC7231§6.4.4: The 303 (See Other) status code indicates that
+      // the server is redirecting the user agent to a different resource […]
+      // A user agent can perform a retrieval request targeting that URI
+      // (a GET or HEAD request if using HTTP) […]
+      (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+    this._options.method = "GET";
+    // Drop a possible entity and headers related to it
+    this._requestBodyBuffers = [];
+    removeMatchingHeaders(/^content-/i, this._options.headers);
+  }
+
+  // Drop the Host header, as the redirect might lead to a different host
+  var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+
+  // If the redirect is relative, carry over the host of the last request
+  var currentUrlParts = parseUrl(this._currentUrl);
+  var currentHost = currentHostHeader || currentUrlParts.host;
+  var currentUrl = /^\w+:/.test(location) ? this._currentUrl :
+    url.format(Object.assign(currentUrlParts, { host: currentHost }));
+
+  // Create the redirected request
+  var redirectUrl = resolveUrl(location, currentUrl);
+  debug$5("redirecting to", redirectUrl.href);
+  this._isRedirect = true;
+  spreadUrlObject(redirectUrl, this._options);
+
+  // Drop confidential headers when redirecting to a less secure protocol
+  // or to a different domain that is not a superdomain
+  if (redirectUrl.protocol !== currentUrlParts.protocol &&
+     redirectUrl.protocol !== "https:" ||
+     redirectUrl.host !== currentHost &&
+     !isSubdomain(redirectUrl.host, currentHost)) {
+    removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+  }
+
+  // Evaluate the beforeRedirect callback
+  if (isFunction(beforeRedirect)) {
+    var responseDetails = {
+      headers: response.headers,
+      statusCode: statusCode,
+    };
+    var requestDetails = {
+      url: currentUrl,
+      method: method,
+      headers: requestHeaders,
+    };
+    beforeRedirect(this._options, responseDetails, requestDetails);
+    this._sanitizeOptions(this._options);
+  }
+
+  // Perform the redirected request
+  this._performRequest();
+};
+
+// Wraps the key/value object of protocols with redirect functionality
+function wrap(protocols) {
+  // Default settings
+  var exports = {
+    maxRedirects: 21,
+    maxBodyLength: 10 * 1024 * 1024,
+  };
+
+  // Wrap each protocol
+  var nativeProtocols = {};
+  Object.keys(protocols).forEach(function (scheme) {
+    var protocol = scheme + ":";
+    var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+    var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
+
+    // Executes a request, following redirects
+    function request(input, options, callback) {
+      // Parse parameters, ensuring that input is an object
+      if (isURL(input)) {
+        input = spreadUrlObject(input);
+      }
+      else if (isString(input)) {
+        input = spreadUrlObject(parseUrl(input));
+      }
+      else {
+        callback = options;
+        options = validateUrl(input);
+        input = { protocol: protocol };
+      }
+      if (isFunction(options)) {
+        callback = options;
+        options = null;
+      }
+
+      // Set defaults
+      options = Object.assign({
+        maxRedirects: exports.maxRedirects,
+        maxBodyLength: exports.maxBodyLength,
+      }, input, options);
+      options.nativeProtocols = nativeProtocols;
+      if (!isString(options.host) && !isString(options.hostname)) {
+        options.hostname = "::1";
+      }
+
+      assert.equal(options.protocol, protocol, "protocol mismatch");
+      debug$5("options", options);
+      return new RedirectableRequest(options, callback);
+    }
+
+    // Executes a GET request, following redirects
+    function get(input, options, callback) {
+      var wrappedRequest = wrappedProtocol.request(input, options, callback);
+      wrappedRequest.end();
+      return wrappedRequest;
+    }
+
+    // Expose the properties on the wrapped protocol
+    Object.defineProperties(wrappedProtocol, {
+      request: { value: request, configurable: true, enumerable: true, writable: true },
+      get: { value: get, configurable: true, enumerable: true, writable: true },
+    });
+  });
+  return exports;
+}
+
+function noop() { /* empty */ }
+
+function parseUrl(input) {
+  var parsed;
+  /* istanbul ignore else */
+  if (useNativeURL) {
+    parsed = new URL$1(input);
+  }
+  else {
+    // Ensure the URL is valid and absolute
+    parsed = validateUrl(url.parse(input));
+    if (!isString(parsed.protocol)) {
+      throw new InvalidUrlError({ input });
+    }
+  }
+  return parsed;
+}
+
+function resolveUrl(relative, base) {
+  /* istanbul ignore next */
+  return useNativeURL ? new URL$1(relative, base) : parseUrl(url.resolve(base, relative));
+}
+
+function validateUrl(input) {
+  if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+    throw new InvalidUrlError({ input: input.href || input });
+  }
+  if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+    throw new InvalidUrlError({ input: input.href || input });
+  }
+  return input;
+}
+
+function spreadUrlObject(urlObject, target) {
+  var spread = target || {};
+  for (var key of preservedUrlFields) {
+    spread[key] = urlObject[key];
+  }
+
+  // Fix IPv6 hostname
+  if (spread.hostname.startsWith("[")) {
+    spread.hostname = spread.hostname.slice(1, -1);
+  }
+  // Ensure port is a number
+  if (spread.port !== "") {
+    spread.port = Number(spread.port);
+  }
+  // Concatenate path
+  spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+
+  return spread;
+}
+
+function removeMatchingHeaders(regex, headers) {
+  var lastValue;
+  for (var header in headers) {
+    if (regex.test(header)) {
+      lastValue = headers[header];
+      delete headers[header];
+    }
+  }
+  return (lastValue === null || typeof lastValue === "undefined") ?
+    undefined : String(lastValue).trim();
+}
+
+function createErrorType(code, message, baseClass) {
+  // Create constructor
+  function CustomError(properties) {
+    Error.captureStackTrace(this, this.constructor);
+    Object.assign(this, properties || {});
+    this.code = code;
+    this.message = this.cause ? message + ": " + this.cause.message : message;
+  }
+
+  // Attach constructor and set default properties
+  CustomError.prototype = new (baseClass || Error)();
+  Object.defineProperties(CustomError.prototype, {
+    constructor: {
+      value: CustomError,
+      enumerable: false,
+    },
+    name: {
+      value: "Error [" + code + "]",
+      enumerable: false,
+    },
+  });
+  return CustomError;
+}
+
+function destroyRequest(request, error) {
+  for (var event of events) {
+    request.removeListener(event, eventHandlers[event]);
+  }
+  request.on("error", noop);
+  request.destroy(error);
+}
+
+function isSubdomain(subdomain, domain) {
+  assert(isString(subdomain) && isString(domain));
+  var dot = subdomain.length - domain.length - 1;
+  return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
+}
+
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+function isBuffer(value) {
+  return typeof value === "object" && ("length" in value);
+}
+
+function isURL(value) {
+  return URL$1 && value instanceof URL$1;
+}
+
+// Exports
+followRedirects$1.exports = wrap({ http: http$1, https: https$1 });
+followRedirects$1.exports.wrap = wrap;
+
+var followRedirectsExports = followRedirects$1.exports;
+
+var httpNative   = require$$1,
+    httpsNative  = require$$1$1,
+    web_o  = webOutgoing,
+    common$1 = common$3,
+    followRedirects = followRedirectsExports;
+
+web_o = Object.keys(web_o).map(function(pass) {
+  return web_o[pass];
+});
+
+var nativeAgents = { http: httpNative, https: httpsNative };
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+
+var webIncoming = {
+
+  /**
+   * Sets `content-length` to '0' if request is of DELETE type.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  deleteLength: function deleteLength(req, res, options) {
+    if((req.method === 'DELETE' || req.method === 'OPTIONS')
+       && !req.headers['content-length']) {
+      req.headers['content-length'] = '0';
+      delete req.headers['transfer-encoding'];
+    }
+  },
+
+  /**
+   * Sets timeout in request socket if it was specified in options.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  timeout: function timeout(req, res, options) {
+    if(options.timeout) {
+      req.socket.setTimeout(options.timeout);
+    }
+  },
+
+  /**
+   * Sets `x-forwarded-*` headers if specified in config.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  XHeaders: function XHeaders(req, res, options) {
+    if(!options.xfwd) return;
+
+    var encrypted = req.isSpdy || common$1.hasEncryptedConnection(req);
+    var values = {
+      for  : req.connection.remoteAddress || req.socket.remoteAddress,
+      port : common$1.getPort(req),
+      proto: encrypted ? 'https' : 'http'
+    };
+
+    ['for', 'port', 'proto'].forEach(function(header) {
+      req.headers['x-forwarded-' + header] =
+        (req.headers['x-forwarded-' + header] || '') +
+        (req.headers['x-forwarded-' + header] ? ',' : '') +
+        values[header];
+    });
+
+    req.headers['x-forwarded-host'] = req.headers['x-forwarded-host'] || req.headers['host'] || '';
+  },
+
+  /**
+   * Does the actual proxying. If `forward` is enabled fires up
+   * a ForwardStream, same happens for ProxyStream. The request
+   * just dies otherwise.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {IncomingMessage} Res Response object
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  stream: function stream(req, res, options, _, server, clb) {
+
+    // And we begin!
+    server.emit('start', req, res, options.target || options.forward);
+
+    var agents = options.followRedirects ? followRedirects : nativeAgents;
+    var http = agents.http;
+    var https = agents.https;
+
+    if(options.forward) {
+      // If forward enable, so just pipe the request
+      var forwardReq = (options.forward.protocol === 'https:' ? https : http).request(
+        common$1.setupOutgoing(options.ssl || {}, options, req, 'forward')
+      );
+
+      // error handler (e.g. ECONNRESET, ECONNREFUSED)
+      // Handle errors on incoming request as well as it makes sense to
+      var forwardError = createErrorHandler(forwardReq, options.forward);
+      req.on('error', forwardError);
+      forwardReq.on('error', forwardError);
+
+      (options.buffer || req).pipe(forwardReq);
+      if(!options.target) { return res.end(); }
+    }
+
+    // Request initalization
+    var proxyReq = (options.target.protocol === 'https:' ? https : http).request(
+      common$1.setupOutgoing(options.ssl || {}, options, req)
+    );
+
+    // Enable developers to modify the proxyReq before headers are sent
+    proxyReq.on('socket', function(socket) {
+      if(server && !proxyReq.getHeader('expect')) {
+        server.emit('proxyReq', proxyReq, req, res, options);
+      }
+    });
+
+    // allow outgoing socket to timeout so that we could
+    // show an error page at the initial request
+    if(options.proxyTimeout) {
+      proxyReq.setTimeout(options.proxyTimeout, function() {
+         proxyReq.abort();
+      });
+    }
+
+    // Ensure we abort proxy if request is aborted
+    req.on('aborted', function () {
+      proxyReq.abort();
+    });
+
+    // handle errors in proxy and incoming request, just like for forward proxy
+    var proxyError = createErrorHandler(proxyReq, options.target);
+    req.on('error', proxyError);
+    proxyReq.on('error', proxyError);
+
+    function createErrorHandler(proxyReq, url) {
+      return function proxyError(err) {
+        if (req.socket.destroyed && err.code === 'ECONNRESET') {
+          server.emit('econnreset', err, req, res, url);
+          return proxyReq.abort();
+        }
+
+        if (clb) {
+          clb(err, req, res, url);
+        } else {
+          server.emit('error', err, req, res, url);
+        }
+      }
+    }
+
+    (options.buffer || req).pipe(proxyReq);
+
+    proxyReq.on('response', function(proxyRes) {
+      if(server) { server.emit('proxyRes', proxyRes, req, res); }
+
+      if(!res.headersSent && !options.selfHandleResponse) {
+        for(var i=0; i < web_o.length; i++) {
+          if(web_o[i](req, res, proxyRes, options)) { break; }
+        }
+      }
+
+      if (!res.finished) {
+        // Allow us to listen when the proxy has completed
+        proxyRes.on('end', function () {
+          if (server) server.emit('end', req, res, proxyRes);
+        });
+        // We pipe to the response unless its expected to be handled by the user
+        if (!options.selfHandleResponse) proxyRes.pipe(res);
+      } else {
+        if (server) server.emit('end', req, res, proxyRes);
+      }
+    });
+  }
+
+};
+
+var http   = require$$1,
+    https  = require$$1$1,
+    common = common$3;
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+/*
+ * Websockets Passes
+ *
+ */
+
+
+var wsIncoming = {
+  /**
+   * WebSocket requests must have the `GET` method and
+   * the `upgrade:websocket` header
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {Socket} Websocket
+   *
+   * @api private
+   */
+
+  checkMethodAndHeader : function checkMethodAndHeader(req, socket) {
+    if (req.method !== 'GET' || !req.headers.upgrade) {
+      socket.destroy();
+      return true;
+    }
+
+    if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+      socket.destroy();
+      return true;
+    }
+  },
+
+  /**
+   * Sets `x-forwarded-*` headers if specified in config.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {Socket} Websocket
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+
+  XHeaders : function XHeaders(req, socket, options) {
+    if(!options.xfwd) return;
+
+    var values = {
+      for  : req.connection.remoteAddress || req.socket.remoteAddress,
+      port : common.getPort(req),
+      proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws'
+    };
+
+    ['for', 'port', 'proto'].forEach(function(header) {
+      req.headers['x-forwarded-' + header] =
+        (req.headers['x-forwarded-' + header] || '') +
+        (req.headers['x-forwarded-' + header] ? ',' : '') +
+        values[header];
+    });
+  },
+
+  /**
+   * Does the actual proxying. Make the request and upgrade it
+   * send the Switching Protocols request and pipe the sockets.
+   *
+   * @param {ClientRequest} Req Request object
+   * @param {Socket} Websocket
+   * @param {Object} Options Config object passed to the proxy
+   *
+   * @api private
+   */
+  stream : function stream(req, socket, options, head, server, clb) {
+
+    var createHttpHeader = function(line, headers) {
+      return Object.keys(headers).reduce(function (head, key) {
+        var value = headers[key];
+
+        if (!Array.isArray(value)) {
+          head.push(key + ': ' + value);
+          return head;
+        }
+
+        for (var i = 0; i < value.length; i++) {
+          head.push(key + ': ' + value[i]);
+        }
+        return head;
+      }, [line])
+      .join('\r\n') + '\r\n\r\n';
+    };
+
+    common.setupSocket(socket);
+
+    if (head && head.length) socket.unshift(head);
+
+
+    var proxyReq = (common.isSSL.test(options.target.protocol) ? https : http).request(
+      common.setupOutgoing(options.ssl || {}, options, req)
+    );
+
+    // Enable developers to modify the proxyReq before headers are sent
+    if (server) { server.emit('proxyReqWs', proxyReq, req, socket, options, head); }
+
+    // Error Handler
+    proxyReq.on('error', onOutgoingError);
+    proxyReq.on('response', function (res) {
+      // if upgrade event isn't going to happen, close the socket
+      if (!res.upgrade) {
+        socket.write(createHttpHeader('HTTP/' + res.httpVersion + ' ' + res.statusCode + ' ' + res.statusMessage, res.headers));
+        res.pipe(socket);
+      }
+    });
+
+    proxyReq.on('upgrade', function(proxyRes, proxySocket, proxyHead) {
+      proxySocket.on('error', onOutgoingError);
+
+      // Allow us to listen when the websocket has completed
+      proxySocket.on('end', function () {
+        server.emit('close', proxyRes, proxySocket, proxyHead);
+      });
+
+      // The pipe below will end proxySocket if socket closes cleanly, but not
+      // if it errors (eg, vanishes from the net and starts returning
+      // EHOSTUNREACH). We need to do that explicitly.
+      socket.on('error', function () {
+        proxySocket.end();
+      });
+
+      common.setupSocket(proxySocket);
+
+      if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
+
+      //
+      // Remark: Handle writing the headers to the socket when switching protocols
+      // Also handles when a header is an array
+      //
+      socket.write(createHttpHeader('HTTP/1.1 101 Switching Protocols', proxyRes.headers));
+
+      proxySocket.pipe(socket).pipe(proxySocket);
+
+      server.emit('open', proxySocket);
+      server.emit('proxySocket', proxySocket);  //DEPRECATED.
+    });
+
+    return proxyReq.end(); // XXX: CHECK IF THIS IS THIS CORRECT
+
+    function onOutgoingError(err) {
+      if (clb) {
+        clb(err, req, socket);
+      } else {
+        server.emit('error', err, req, socket);
+      }
+      socket.end();
+    }
+  }
+};
+
+(function (module) {
+	var httpProxy = module.exports,
+	    parse_url = require$$0$9.parse,
+	    EE3       = eventemitter3Exports,
+	    http      = require$$1,
+	    https     = require$$1$1,
+	    web       = webIncoming,
+	    ws        = wsIncoming;
+
+	httpProxy.Server = ProxyServer;
+
+	/**
+	 * Returns a function that creates the loader for
+	 * either `ws` or `web`'s  passes.
+	 *
+	 * Examples:
+	 *
+	 *    httpProxy.createRightProxy('ws')
+	 *    // => [Function]
+	 *
+	 * @param {String} Type Either 'ws' or 'web'
+	 * 
+	 * @return {Function} Loader Function that when called returns an iterator for the right passes
+	 *
+	 * @api private
+	 */
+
+	function createRightProxy(type) {
+
+	  return function(options) {
+	    return function(req, res /*, [head], [opts] */) {
+	      var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
+	          args = [].slice.call(arguments),
+	          cntr = args.length - 1,
+	          head, cbl;
+
+	      /* optional args parse begin */
+	      if(typeof args[cntr] === 'function') {
+	        cbl = args[cntr];
+
+	        cntr--;
+	      }
+
+	      var requestOptions = options;
+	      if(
+	        !(args[cntr] instanceof Buffer) &&
+	        args[cntr] !== res
+	      ) {
+	        //Copy global options
+	        requestOptions = Object.assign({}, options);
+	        //Overwrite with request options
+	        Object.assign(requestOptions, args[cntr]);
+
+	        cntr--;
+	      }
+
+	      if(args[cntr] instanceof Buffer) {
+	        head = args[cntr];
+	      }
+
+	      /* optional args parse end */
+
+	      ['target', 'forward'].forEach(function(e) {
+	        if (typeof requestOptions[e] === 'string')
+	          requestOptions[e] = parse_url(requestOptions[e]);
+	      });
+
+	      if (!requestOptions.target && !requestOptions.forward) {
+	        return this.emit('error', new Error('Must provide a proper URL as target'));
+	      }
+
+	      for(var i=0; i < passes.length; i++) {
+	        /**
+	         * Call of passes functions
+	         * pass(req, res, options, head)
+	         *
+	         * In WebSockets case the `res` variable
+	         * refer to the connection socket
+	         * pass(req, socket, options, head)
+	         */
+	        if(passes[i](req, res, requestOptions, head, this, cbl)) { // passes can return a truthy value to halt the loop
+	          break;
+	        }
+	      }
+	    };
+	  };
+	}
+	httpProxy.createRightProxy = createRightProxy;
+
+	function ProxyServer(options) {
+	  EE3.call(this);
+
+	  options = options || {};
+	  options.prependPath = options.prependPath === false ? false : true;
+
+	  this.web = this.proxyRequest           = createRightProxy('web')(options);
+	  this.ws  = this.proxyWebsocketRequest  = createRightProxy('ws')(options);
+	  this.options = options;
+
+	  this.webPasses = Object.keys(web).map(function(pass) {
+	    return web[pass];
+	  });
+
+	  this.wsPasses = Object.keys(ws).map(function(pass) {
+	    return ws[pass];
+	  });
+
+	  this.on('error', this.onError, this);
+
+	}
+
+	require$$0$5.inherits(ProxyServer, EE3);
+
+	ProxyServer.prototype.onError = function (err) {
+	  //
+	  // Remark: Replicate node core behavior using EE3
+	  // so we force people to handle their own errors
+	  //
+	  if(this.listeners('error').length === 1) {
+	    throw err;
+	  }
+	};
+
+	ProxyServer.prototype.listen = function(port, hostname) {
+	  var self    = this,
+	      closure = function(req, res) { self.web(req, res); };
+
+	  this._server  = this.options.ssl ?
+	    https.createServer(this.options.ssl, closure) :
+	    http.createServer(closure);
+
+	  if(this.options.ws) {
+	    this._server.on('upgrade', function(req, socket, head) { self.ws(req, socket, head); });
+	  }
+
+	  this._server.listen(port, hostname);
+
+	  return this;
+	};
+
+	ProxyServer.prototype.close = function(callback) {
+	  var self = this;
+	  if (this._server) {
+	    this._server.close(done);
+	  }
+
+	  // Wrap callback to nullify server after all open connections are closed.
+	  function done() {
+	    self._server = null;
+	    if (callback) {
+	      callback.apply(null, arguments);
+	    }
+	  }	};
+
+	ProxyServer.prototype.before = function(type, passName, callback) {
+	  if (type !== 'ws' && type !== 'web') {
+	    throw new Error('type must be `web` or `ws`');
+	  }
+	  var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
+	      i = false;
+
+	  passes.forEach(function(v, idx) {
+	    if(v.name === passName) i = idx;
+	  });
+
+	  if(i === false) throw new Error('No such pass');
+
+	  passes.splice(i, 0, callback);
+	};
+	ProxyServer.prototype.after = function(type, passName, callback) {
+	  if (type !== 'ws' && type !== 'web') {
+	    throw new Error('type must be `web` or `ws`');
+	  }
+	  var passes = (type === 'ws') ? this.wsPasses : this.webPasses,
+	      i = false;
+
+	  passes.forEach(function(v, idx) {
+	    if(v.name === passName) i = idx;
+	  });
+
+	  if(i === false) throw new Error('No such pass');
+
+	  passes.splice(i++, 0, callback);
+	}; 
+} (httpProxy$3));
+
+var httpProxyExports = httpProxy$3.exports;
+
+// Use explicit /index.js to help browserify negociation in require '/lib/http-proxy' (!)
+var ProxyServer = httpProxyExports.Server;
+
+
+/**
+ * Creates the proxy server.
+ *
+ * Examples:
+ *
+ *    httpProxy.createProxyServer({ .. }, 8000)
+ *    // => '{ web: [Function], ws: [Function] ... }'
+ *
+ * @param {Object} Options Config object passed to the proxy
+ *
+ * @return {Object} Proxy Proxy object with handlers for `ws` and `web` requests
+ *
+ * @api public
+ */
+
+
+function createProxyServer(options) {
+  /*
+   *  `options` is needed and it must have the following layout:
+   *
+   *  {
+   *    target : <url string to be parsed with the url module>
+   *    forward: <url string to be parsed with the url module>
+   *    agent  : <object to be passed to http(s).request>
+   *    ssl    : <object to be passed to https.createServer()>
+   *    ws     : <true/false, if you want to proxy websockets>
+   *    xfwd   : <true/false, adds x-forward headers>
+   *    secure : <true/false, verify SSL certificate>
+   *    toProxy: <true/false, explicitly specify if we are proxying to another proxy>
+   *    prependPath: <true/false, Default: true - specify whether you want to prepend the target's path to the proxy path>
+   *    ignorePath: <true/false, Default: false - specify whether you want to ignore the proxy path of the incoming request>
+   *    localAddress : <Local interface string to bind for outgoing connections>
+   *    changeOrigin: <true/false, Default: false - changes the origin of the host header to the target URL>
+   *    preserveHeaderKeyCase: <true/false, Default: false - specify whether you want to keep letter case of response header key >
+   *    auth   : Basic authentication i.e. 'user:password' to compute an Authorization header.
+   *    hostRewrite: rewrites the location hostname on (201/301/302/307/308) redirects, Default: null.
+   *    autoRewrite: rewrites the location host/port on (201/301/302/307/308) redirects based on requested host/port. Default: false.
+   *    protocolRewrite: rewrites the location protocol on (201/301/302/307/308) redirects to 'http' or 'https'. Default: null.
+   *  }
+   *
+   *  NOTE: `options.ws` and `options.ssl` are optional.
+   *    `options.target and `options.forward` cannot be
+   *    both missing
+   *  }
+   */
+
+  return new ProxyServer(options);
+}
+
+
+ProxyServer.createProxyServer = createProxyServer;
+ProxyServer.createServer      = createProxyServer;
+ProxyServer.createProxy       = createProxyServer;
+
+
+
+
+/**
+ * Export the proxy "Server" as the main export.
+ */
+var httpProxy$2 = ProxyServer;
+
+/*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia 
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *          
+ *          Dante - The Divine Comedy (Canto III)
+ */
+
+var httpProxy = httpProxy$2;
+
+var httpProxy$1 = /*@__PURE__*/getDefaultExportFromCjs(httpProxy);
+
+const debug$4 = createDebugger("vite:proxy");
+const rewriteOriginHeader = (proxyReq, options, config) => {
+  if (options.rewriteWsOrigin) {
+    const { target } = options;
+    if (proxyReq.headersSent) {
+      config.logger.warn(
+        colors$1.yellow(
+          `Unable to rewrite Origin header as headers are already sent.`
+        )
+      );
+      return;
+    }
+    if (proxyReq.getHeader("origin") && target) {
+      const changedOrigin = typeof target === "object" ? `${target.protocol}//${target.host}` : target;
+      proxyReq.setHeader("origin", changedOrigin);
+    }
+  }
+};
+function proxyMiddleware(httpServer, options, config) {
+  const proxies = {};
+  Object.keys(options).forEach((context) => {
+    let opts = options[context];
+    if (!opts) {
+      return;
+    }
+    if (typeof opts === "string") {
+      opts = { target: opts, changeOrigin: true };
+    }
+    const proxy = httpProxy$1.createProxyServer(opts);
+    if (opts.configure) {
+      opts.configure(proxy, opts);
+    }
+    proxy.on("error", (err, req, originalRes) => {
+      const res = originalRes;
+      if (!res) {
+        config.logger.error(
+          `${colors$1.red(`http proxy error: ${err.message}`)}
+${err.stack}`,
+          {
+            timestamp: true,
+            error: err
+          }
+        );
+      } else if ("req" in res) {
+        config.logger.error(
+          `${colors$1.red(`http proxy error: ${originalRes.req.url}`)}
+${err.stack}`,
+          {
+            timestamp: true,
+            error: err
+          }
+        );
+        if (!res.headersSent && !res.writableEnded) {
+          res.writeHead(500, {
+            "Content-Type": "text/plain"
+          }).end();
+        }
+      } else {
+        config.logger.error(`${colors$1.red(`ws proxy error:`)}
+${err.stack}`, {
+          timestamp: true,
+          error: err
+        });
+        res.end();
+      }
+    });
+    proxy.on("proxyReqWs", (proxyReq, req, socket, options2, head) => {
+      rewriteOriginHeader(proxyReq, options2, config);
+      socket.on("error", (err) => {
+        config.logger.error(
+          `${colors$1.red(`ws proxy socket error:`)}
+${err.stack}`,
+          {
+            timestamp: true,
+            error: err
+          }
+        );
+      });
+    });
+    proxy.on("proxyRes", (proxyRes, req, res) => {
+      res.on("close", () => {
+        if (!res.writableEnded) {
+          debug$4?.("destroying proxyRes in proxyRes close event");
+          proxyRes.destroy();
+        }
+      });
+    });
+    proxies[context] = [proxy, { ...opts }];
+  });
+  if (httpServer) {
+    httpServer.on("upgrade", (req, socket, head) => {
+      const url = req.url;
+      for (const context in proxies) {
+        if (doesProxyContextMatchUrl(context, url)) {
+          const [proxy, opts] = proxies[context];
+          if (opts.ws || opts.target?.toString().startsWith("ws:") || opts.target?.toString().startsWith("wss:")) {
+            if (opts.rewrite) {
+              req.url = opts.rewrite(url);
+            }
+            debug$4?.(`${req.url} -> ws ${opts.target}`);
+            proxy.ws(req, socket, head);
+            return;
+          }
+        }
+      }
+    });
+  }
+  return function viteProxyMiddleware(req, res, next) {
+    const url = req.url;
+    for (const context in proxies) {
+      if (doesProxyContextMatchUrl(context, url)) {
+        const [proxy, opts] = proxies[context];
+        const options2 = {};
+        if (opts.bypass) {
+          const bypassResult = opts.bypass(req, res, opts);
+          if (typeof bypassResult === "string") {
+            req.url = bypassResult;
+            debug$4?.(`bypass: ${req.url} -> ${bypassResult}`);
+            return next();
+          } else if (bypassResult === false) {
+            debug$4?.(`bypass: ${req.url} -> 404`);
+            res.statusCode = 404;
+            return res.end();
+          }
+        }
+        debug$4?.(`${req.url} -> ${opts.target || opts.forward}`);
+        if (opts.rewrite) {
+          req.url = opts.rewrite(req.url);
+        }
+        proxy.web(req, res, options2);
+        return;
+      }
+    }
+    next();
+  };
+}
+function doesProxyContextMatchUrl(context, url) {
+  return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
+}
+
+const debug$3 = createDebugger("vite:html-fallback");
+function htmlFallbackMiddleware(root, spaFallback, fsUtils = commonFsUtils) {
+  return function viteHtmlFallbackMiddleware(req, res, next) {
+    if (
+      // Only accept GET or HEAD
+      req.method !== "GET" && req.method !== "HEAD" || // Exclude default favicon requests
+      req.url === "/favicon.ico" || // Require Accept: text/html or */*
+      !(req.headers.accept === void 0 || // equivalent to `Accept: */*`
+      req.headers.accept === "" || // equivalent to `Accept: */*`
+      req.headers.accept.includes("text/html") || req.headers.accept.includes("*/*"))
+    ) {
+      return next();
+    }
+    const url = cleanUrl(req.url);
+    const pathname = decodeURIComponent(url);
+    if (pathname.endsWith(".html")) {
+      const filePath = path$n.join(root, pathname);
+      if (fsUtils.existsSync(filePath)) {
+        debug$3?.(`Rewriting ${req.method} ${req.url} to ${url}`);
+        req.url = url;
+        return next();
+      }
+    } else if (pathname[pathname.length - 1] === "/") {
+      const filePath = path$n.join(root, pathname, "index.html");
+      if (fsUtils.existsSync(filePath)) {
+        const newUrl = url + "index.html";
+        debug$3?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+        req.url = newUrl;
+        return next();
+      }
+    } else {
+      const filePath = path$n.join(root, pathname + ".html");
+      if (fsUtils.existsSync(filePath)) {
+        const newUrl = url + ".html";
+        debug$3?.(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+        req.url = newUrl;
+        return next();
+      }
+    }
+    if (spaFallback) {
+      debug$3?.(`Rewriting ${req.method} ${req.url} to /index.html`);
+      req.url = "/index.html";
+    }
+    next();
+  };
+}
+
+const debug$2 = createDebugger("vite:send", {
+  onlyWhenFocused: true
+});
+const alias = {
+  js: "text/javascript",
+  css: "text/css",
+  html: "text/html",
+  json: "application/json"
+};
+function send(req, res, content, type, options) {
+  const {
+    etag = getEtag(content, { weak: true }),
+    cacheControl = "no-cache",
+    headers,
+    map
+  } = options;
+  if (res.writableEnded) {
+    return;
+  }
+  if (req.headers["if-none-match"] === etag) {
+    res.statusCode = 304;
+    res.end();
+    return;
+  }
+  res.setHeader("Content-Type", alias[type] || type);
+  res.setHeader("Cache-Control", cacheControl);
+  res.setHeader("Etag", etag);
+  if (headers) {
+    for (const name in headers) {
+      res.setHeader(name, headers[name]);
+    }
+  }
+  if (map && "version" in map && map.mappings) {
+    if (type === "js" || type === "css") {
+      content = getCodeWithSourcemap(type, content.toString(), map);
+    }
+  } else if (type === "js" && (!map || map.mappings !== "")) {
+    const code = content.toString();
+    if (convertSourceMap.mapFileCommentRegex.test(code)) {
+      debug$2?.(`Skipped injecting fallback sourcemap for ${req.url}`);
+    } else {
+      const urlWithoutTimestamp = removeTimestampQuery(req.url);
+      const ms = new MagicString(code);
+      content = getCodeWithSourcemap(
+        type,
+        code,
+        ms.generateMap({
+          source: path$n.basename(urlWithoutTimestamp),
+          hires: "boundary",
+          includeContent: true
+        })
+      );
+    }
+  }
+  res.statusCode = 200;
+  res.end(content);
+  return;
+}
+
+const debugCache = createDebugger("vite:cache");
+const knownIgnoreList = /* @__PURE__ */ new Set(["/", "/favicon.ico"]);
+function cachedTransformMiddleware(server) {
+  return function viteCachedTransformMiddleware(req, res, next) {
+    const ifNoneMatch = req.headers["if-none-match"];
+    if (ifNoneMatch) {
+      const moduleByEtag = server.moduleGraph.getModuleByEtag(ifNoneMatch);
+      if (moduleByEtag?.transformResult?.etag === ifNoneMatch && moduleByEtag?.url === req.url) {
+        const maybeMixedEtag = isCSSRequest(req.url);
+        if (!maybeMixedEtag) {
+          debugCache?.(`[304] ${prettifyUrl(req.url, server.config.root)}`);
+          res.statusCode = 304;
+          return res.end();
+        }
+      }
+    }
+    next();
+  };
+}
+function transformMiddleware(server) {
+  const { root, publicDir } = server.config;
+  const publicDirInRoot = publicDir.startsWith(withTrailingSlash(root));
+  const publicPath = `${publicDir.slice(root.length)}/`;
+  return async function viteTransformMiddleware(req, res, next) {
+    if (req.method !== "GET" || knownIgnoreList.has(req.url)) {
+      return next();
+    }
+    let url;
+    try {
+      url = decodeURI(removeTimestampQuery(req.url)).replace(
+        NULL_BYTE_PLACEHOLDER,
+        "\0"
+      );
+    } catch (e) {
+      return next(e);
+    }
+    const withoutQuery = cleanUrl(url);
+    try {
+      const isSourceMap = withoutQuery.endsWith(".map");
+      if (isSourceMap) {
+        const depsOptimizer = getDepsOptimizer(server.config, false);
+        if (depsOptimizer?.isOptimizedDepUrl(url)) {
+          const sourcemapPath = url.startsWith(FS_PREFIX) ? fsPathFromId(url) : normalizePath$3(path$n.resolve(server.config.root, url.slice(1)));
+          try {
+            const map = JSON.parse(
+              await fsp.readFile(sourcemapPath, "utf-8")
+            );
+            applySourcemapIgnoreList(
+              map,
+              sourcemapPath,
+              server.config.server.sourcemapIgnoreList,
+              server.config.logger
+            );
+            return send(req, res, JSON.stringify(map), "json", {
+              headers: server.config.server.headers
+            });
+          } catch (e) {
+            const dummySourceMap = {
+              version: 3,
+              file: sourcemapPath.replace(/\.map$/, ""),
+              sources: [],
+              sourcesContent: [],
+              names: [],
+              mappings: ";;;;;;;;;"
+            };
+            return send(req, res, JSON.stringify(dummySourceMap), "json", {
+              cacheControl: "no-cache",
+              headers: server.config.server.headers
+            });
+          }
+        } else {
+          const originalUrl = url.replace(/\.map($|\?)/, "$1");
+          const map = (await server.moduleGraph.getModuleByUrl(originalUrl, false))?.transformResult?.map;
+          if (map) {
+            return send(req, res, JSON.stringify(map), "json", {
+              headers: server.config.server.headers
+            });
+          } else {
+            return next();
+          }
+        }
+      }
+      if (publicDirInRoot && url.startsWith(publicPath)) {
+        warnAboutExplicitPublicPathInUrl(url);
+      }
+      if ((rawRE.test(url) || urlRE.test(url)) && !ensureServingAccess(url, server, res, next)) {
+        return;
+      }
+      if (isJSRequest(url) || isImportRequest(url) || isCSSRequest(url) || isHTMLProxy(url)) {
+        url = removeImportQuery(url);
+        url = unwrapId$1(url);
+        if (isCSSRequest(url)) {
+          if (req.headers.accept?.includes("text/css") && !isDirectRequest(url)) {
+            url = injectQuery(url, "direct");
+          }
+          const ifNoneMatch = req.headers["if-none-match"];
+          if (ifNoneMatch && (await server.moduleGraph.getModuleByUrl(url, false))?.transformResult?.etag === ifNoneMatch) {
+            debugCache?.(`[304] ${prettifyUrl(url, server.config.root)}`);
+            res.statusCode = 304;
+            return res.end();
+          }
+        }
+        const result = await transformRequest(url, server, {
+          html: req.headers.accept?.includes("text/html")
+        });
+        if (result) {
+          const depsOptimizer = getDepsOptimizer(server.config, false);
+          const type = isDirectCSSRequest(url) ? "css" : "js";
+          const isDep = DEP_VERSION_RE.test(url) || depsOptimizer?.isOptimizedDepUrl(url);
+          return send(req, res, result.code, type, {
+            etag: result.etag,
+            // allow browser to cache npm deps!
+            cacheControl: isDep ? "max-age=31536000,immutable" : "no-cache",
+            headers: server.config.server.headers,
+            map: result.map
+          });
+        }
+      }
+    } catch (e) {
+      if (e?.code === ERR_OPTIMIZE_DEPS_PROCESSING_ERROR) {
+        if (!res.writableEnded) {
+          res.statusCode = 504;
+          res.statusMessage = "Optimize Deps Processing Error";
+          res.end();
+        }
+        server.config.logger.error(e.message);
+        return;
+      }
+      if (e?.code === ERR_OUTDATED_OPTIMIZED_DEP) {
+        if (!res.writableEnded) {
+          res.statusCode = 504;
+          res.statusMessage = "Outdated Optimize Dep";
+          res.end();
+        }
+        return;
+      }
+      if (e?.code === ERR_CLOSED_SERVER) {
+        if (!res.writableEnded) {
+          res.statusCode = 504;
+          res.statusMessage = "Outdated Request";
+          res.end();
+        }
+        return;
+      }
+      if (e?.code === ERR_FILE_NOT_FOUND_IN_OPTIMIZED_DEP_DIR) {
+        if (!res.writableEnded) {
+          res.statusCode = 404;
+          res.end();
+        }
+        server.config.logger.warn(colors$1.yellow(e.message));
+        return;
+      }
+      if (e?.code === ERR_LOAD_URL) {
+        return next();
+      }
+      return next(e);
+    }
+    next();
+  };
+  function warnAboutExplicitPublicPathInUrl(url) {
+    let warning;
+    if (isImportRequest(url)) {
+      const rawUrl = removeImportQuery(url);
+      if (urlRE.test(url)) {
+        warning = `Assets in the public directory are served at the root path.
+Instead of ${colors$1.cyan(rawUrl)}, use ${colors$1.cyan(
+          rawUrl.replace(publicPath, "/")
+        )}.`;
+      } else {
+        warning = `Assets in public directory cannot be imported from JavaScript.
+If you intend to import that asset, put the file in the src directory, and use ${colors$1.cyan(
+          rawUrl.replace(publicPath, "/src/")
+        )} instead of ${colors$1.cyan(rawUrl)}.
+If you intend to use the URL of that asset, use ${colors$1.cyan(
+          injectQuery(rawUrl.replace(publicPath, "/"), "url")
+        )}.`;
+      }
+    } else {
+      warning = `Files in the public directory are served at the root path.
+Instead of ${colors$1.cyan(url)}, use ${colors$1.cyan(
+        url.replace(publicPath, "/")
+      )}.`;
+    }
+    server.config.logger.warn(colors$1.yellow(warning));
+  }
+}
+
+function createDevHtmlTransformFn(config) {
+  const [preHooks, normalHooks, postHooks] = resolveHtmlTransforms(
+    config.plugins,
+    config.logger
+  );
+  const transformHooks = [
+    preImportMapHook(config),
+    injectCspNonceMetaTagHook(config),
+    ...preHooks,
+    htmlEnvHook(config),
+    devHtmlHook,
+    ...normalHooks,
+    ...postHooks,
+    injectNonceAttributeTagHook(config),
+    postImportMapHook()
+  ];
+  return (server, url, html, originalUrl) => {
+    return applyHtmlTransforms(html, transformHooks, {
+      path: url,
+      filename: getHtmlFilename(url, server),
+      server,
+      originalUrl
+    });
+  };
+}
+function getHtmlFilename(url, server) {
+  if (url.startsWith(FS_PREFIX)) {
+    return decodeURIComponent(fsPathFromId(url));
+  } else {
+    return decodeURIComponent(
+      normalizePath$3(path$n.join(server.config.root, url.slice(1)))
+    );
+  }
+}
+function shouldPreTransform(url, config) {
+  return !checkPublicFile(url, config) && (isJSRequest(url) || isCSSRequest(url));
+}
+const wordCharRE = /\w/;
+function isBareRelative(url) {
+  return wordCharRE.test(url[0]) && !url.includes(":");
+}
+const isSrcSet = (attr) => attr.name === "srcset" && attr.prefix === void 0;
+const processNodeUrl = (url, useSrcSetReplacer, config, htmlPath, originalUrl, server, isClassicScriptLink) => {
+  const replacer = (url2) => {
+    if (server?.moduleGraph) {
+      const mod = server.moduleGraph.urlToModuleMap.get(url2);
+      if (mod && mod.lastHMRTimestamp > 0) {
+        url2 = injectQuery(url2, `t=${mod.lastHMRTimestamp}`);
+      }
+    }
+    if (url2[0] === "/" && url2[1] !== "/" || // #3230 if some request url (localhost:3000/a/b) return to fallback html, the relative assets
+    // path will add `/a/` prefix, it will caused 404.
+    //
+    // skip if url contains `:` as it implies a url protocol or Windows path that we don't want to replace.
+    //
+    // rewrite `./index.js` -> `localhost:5173/a/index.js`.
+    // rewrite `../index.js` -> `localhost:5173/index.js`.
+    // rewrite `relative/index.js` -> `localhost:5173/a/relative/index.js`.
+    (url2[0] === "." || isBareRelative(url2)) && originalUrl && originalUrl !== "/" && htmlPath === "/index.html") {
+      url2 = path$n.posix.join(config.base, url2);
+    }
+    if (server && !isClassicScriptLink && shouldPreTransform(url2, config)) {
+      let preTransformUrl;
+      if (url2[0] === "/" && url2[1] !== "/") {
+        preTransformUrl = url2;
+      } else if (url2[0] === "." || isBareRelative(url2)) {
+        preTransformUrl = path$n.posix.join(
+          config.base,
+          path$n.posix.dirname(htmlPath),
+          url2
+        );
+      }
+      if (preTransformUrl) {
+        try {
+          preTransformUrl = decodeURI(preTransformUrl);
+        } catch (err) {
+          return url2;
+        }
+        preTransformRequest(server, preTransformUrl, config.decodedBase);
+      }
+    }
+    return url2;
+  };
+  const processedUrl = useSrcSetReplacer ? processSrcSetSync(url, ({ url: url2 }) => replacer(url2)) : replacer(url);
+  return processedUrl;
+};
+const devHtmlHook = async (html, { path: htmlPath, filename, server, originalUrl }) => {
+  const { config, moduleGraph, watcher } = server;
+  const base = config.base || "/";
+  const decodedBase = config.decodedBase || "/";
+  let proxyModulePath;
+  let proxyModuleUrl;
+  const trailingSlash = htmlPath.endsWith("/");
+  if (!trailingSlash && getFsUtils(config).existsSync(filename)) {
+    proxyModulePath = htmlPath;
+    proxyModuleUrl = proxyModulePath;
+  } else {
+    const validPath = `${htmlPath}${trailingSlash ? "index.html" : ""}`;
+    proxyModulePath = `\0${validPath}`;
+    proxyModuleUrl = wrapId$1(proxyModulePath);
+  }
+  proxyModuleUrl = joinUrlSegments(decodedBase, proxyModuleUrl);
+  const s = new MagicString(html);
+  let inlineModuleIndex = -1;
+  const proxyCacheUrl = decodeURI(
+    cleanUrl(proxyModulePath).replace(normalizePath$3(config.root), "")
+  );
+  const styleUrl = [];
+  const inlineStyles = [];
+  const addInlineModule = (node, ext) => {
+    inlineModuleIndex++;
+    const contentNode = node.childNodes[0];
+    const code = contentNode.value;
+    let map;
+    if (proxyModulePath[0] !== "\0") {
+      map = new MagicString(html).snip(
+        contentNode.sourceCodeLocation.startOffset,
+        contentNode.sourceCodeLocation.endOffset
+      ).generateMap({ hires: "boundary" });
+      map.sources = [filename];
+      map.file = filename;
+    }
+    addToHTMLProxyCache(config, proxyCacheUrl, inlineModuleIndex, { code, map });
+    const modulePath = `${proxyModuleUrl}?html-proxy&index=${inlineModuleIndex}.${ext}`;
+    const module = server?.moduleGraph.getModuleById(modulePath);
+    if (module) {
+      server?.moduleGraph.invalidateModule(module);
+    }
+    s.update(
+      node.sourceCodeLocation.startOffset,
+      node.sourceCodeLocation.endOffset,
+      `<script type="module" src="${modulePath}"><\/script>`
+    );
+    preTransformRequest(server, modulePath, decodedBase);
+  };
+  await traverseHtml(html, filename, (node) => {
+    if (!nodeIsElement(node)) {
+      return;
+    }
+    if (node.nodeName === "script") {
+      const { src, sourceCodeLocation, isModule } = getScriptInfo(node);
+      if (src) {
+        const processedUrl = processNodeUrl(
+          src.value,
+          isSrcSet(src),
+          config,
+          htmlPath,
+          originalUrl,
+          server,
+          !isModule
+        );
+        if (processedUrl !== src.value) {
+          overwriteAttrValue(s, sourceCodeLocation, processedUrl);
+        }
+      } else if (isModule && node.childNodes.length) {
+        addInlineModule(node, "js");
+      } else if (node.childNodes.length) {
+        const scriptNode = node.childNodes[node.childNodes.length - 1];
+        for (const {
+          url,
+          start,
+          end
+        } of extractImportExpressionFromClassicScript(scriptNode)) {
+          const processedUrl = processNodeUrl(
+            url,
+            false,
+            config,
+            htmlPath,
+            originalUrl
+          );
+          if (processedUrl !== url) {
+            s.update(start, end, processedUrl);
+          }
+        }
+      }
+    }
+    const inlineStyle = findNeedTransformStyleAttribute(node);
+    if (inlineStyle) {
+      inlineModuleIndex++;
+      inlineStyles.push({
+        index: inlineModuleIndex,
+        location: inlineStyle.location,
+        code: inlineStyle.attr.value
+      });
+    }
+    if (node.nodeName === "style" && node.childNodes.length) {
+      const children = node.childNodes[0];
+      styleUrl.push({
+        start: children.sourceCodeLocation.startOffset,
+        end: children.sourceCodeLocation.endOffset,
+        code: children.value
+      });
+    }
+    const assetAttrs = assetAttrsConfig[node.nodeName];
+    if (assetAttrs) {
+      for (const p of node.attrs) {
+        const attrKey = getAttrKey(p);
+        if (p.value && assetAttrs.includes(attrKey)) {
+          const processedUrl = processNodeUrl(
+            p.value,
+            isSrcSet(p),
+            config,
+            htmlPath,
+            originalUrl
+          );
+          if (processedUrl !== p.value) {
+            overwriteAttrValue(
+              s,
+              node.sourceCodeLocation.attrs[attrKey],
+              processedUrl
+            );
+          }
+        }
+      }
+    }
+  });
+  await Promise.all([
+    ...styleUrl.map(async ({ start, end, code }, index) => {
+      const url = `${proxyModulePath}?html-proxy&direct&index=${index}.css`;
+      const mod = await moduleGraph.ensureEntryFromUrl(url, false);
+      ensureWatchedFile(watcher, mod.file, config.root);
+      const result = await server.pluginContainer.transform(code, mod.id);
+      let content = "";
+      if (result) {
+        if (result.map && "version" in result.map) {
+          if (result.map.mappings) {
+            await injectSourcesContent(
+              result.map,
+              proxyModulePath,
+              config.logger
+            );
+          }
+          content = getCodeWithSourcemap("css", result.code, result.map);
+        } else {
+          content = result.code;
+        }
+      }
+      s.overwrite(start, end, content);
+    }),
+    ...inlineStyles.map(async ({ index, location, code }) => {
+      const url = `${proxyModulePath}?html-proxy&inline-css&style-attr&index=${index}.css`;
+      const mod = await moduleGraph.ensureEntryFromUrl(url, false);
+      ensureWatchedFile(watcher, mod.file, config.root);
+      await server?.pluginContainer.transform(code, mod.id);
+      const hash = getHash(cleanUrl(mod.id));
+      const result = htmlProxyResult.get(`${hash}_${index}`);
+      overwriteAttrValue(s, location, result ?? "");
+    })
+  ]);
+  html = s.toString();
+  return {
+    html,
+    tags: [
+      {
+        tag: "script",
+        attrs: {
+          type: "module",
+          src: path$n.posix.join(base, CLIENT_PUBLIC_PATH)
+        },
+        injectTo: "head-prepend"
+      }
+    ]
+  };
+};
+function indexHtmlMiddleware(root, server) {
+  const isDev = isDevServer(server);
+  const fsUtils = getFsUtils(server.config);
+  return async function viteIndexHtmlMiddleware(req, res, next) {
+    if (res.writableEnded) {
+      return next();
+    }
+    const url = req.url && cleanUrl(req.url);
+    if (url?.endsWith(".html") && req.headers["sec-fetch-dest"] !== "script") {
+      let filePath;
+      if (isDev && url.startsWith(FS_PREFIX)) {
+        filePath = decodeURIComponent(fsPathFromId(url));
+      } else {
+        filePath = path$n.join(root, decodeURIComponent(url));
+      }
+      if (fsUtils.existsSync(filePath)) {
+        const headers = isDev ? server.config.server.headers : server.config.preview.headers;
+        try {
+          let html = await fsp.readFile(filePath, "utf-8");
+          if (isDev) {
+            html = await server.transformIndexHtml(url, html, req.originalUrl);
+          }
+          return send(req, res, html, "html", { headers });
+        } catch (e) {
+          return next(e);
+        }
+      }
+    }
+    next();
+  };
+}
+function preTransformRequest(server, decodedUrl, decodedBase) {
+  if (!server.config.server.preTransformRequests) return;
+  decodedUrl = unwrapId$1(stripBase(decodedUrl, decodedBase));
+  server.warmupRequest(decodedUrl);
+}
+
+const logTime = createDebugger("vite:time");
+function timeMiddleware(root) {
+  return function viteTimeMiddleware(req, res, next) {
+    const start = performance$1.now();
+    const end = res.end;
+    res.end = (...args) => {
+      logTime?.(`${timeFrom(start)} ${prettifyUrl(req.url, root)}`);
+      return end.call(res, ...args);
+    };
+    next();
+  };
+}
+
+class ModuleNode {
+  /**
+   * Public served url path, starts with /
+   */
+  url;
+  /**
+   * Resolved file system path + query
+   */
+  id = null;
+  file = null;
+  type;
+  info;
+  meta;
+  importers = /* @__PURE__ */ new Set();
+  clientImportedModules = /* @__PURE__ */ new Set();
+  ssrImportedModules = /* @__PURE__ */ new Set();
+  acceptedHmrDeps = /* @__PURE__ */ new Set();
+  acceptedHmrExports = null;
+  importedBindings = null;
+  isSelfAccepting;
+  transformResult = null;
+  ssrTransformResult = null;
+  ssrModule = null;
+  ssrError = null;
+  lastHMRTimestamp = 0;
+  /**
+   * `import.meta.hot.invalidate` is called by the client.
+   * If there's multiple clients, multiple `invalidate` request is received.
+   * This property is used to dedupe those request to avoid multiple updates happening.
+   * @internal
+   */
+  lastHMRInvalidationReceived = false;
+  lastInvalidationTimestamp = 0;
+  /**
+   * If the module only needs to update its imports timestamp (e.g. within an HMR chain),
+   * it is considered soft-invalidated. In this state, its `transformResult` should exist,
+   * and the next `transformRequest` for this module will replace the timestamps.
+   *
+   * By default the value is `undefined` if it's not soft/hard-invalidated. If it gets
+   * soft-invalidated, this will contain the previous `transformResult` value. If it gets
+   * hard-invalidated, this will be set to `'HARD_INVALIDATED'`.
+   * @internal
+   */
+  invalidationState;
+  /**
+   * @internal
+   */
+  ssrInvalidationState;
+  /**
+   * The module urls that are statically imported in the code. This information is separated
+   * out from `importedModules` as only importers that statically import the module can be
+   * soft invalidated. Other imports (e.g. watched files) needs the importer to be hard invalidated.
+   * @internal
+   */
+  staticImportedUrls;
+  /**
+   * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+   */
+  constructor(url, setIsSelfAccepting = true) {
+    this.url = url;
+    this.type = isDirectCSSRequest(url) ? "css" : "js";
+    if (setIsSelfAccepting) {
+      this.isSelfAccepting = false;
+    }
+  }
+  get importedModules() {
+    const importedModules = new Set(this.clientImportedModules);
+    for (const module of this.ssrImportedModules) {
+      importedModules.add(module);
+    }
+    return importedModules;
+  }
+}
+class ModuleGraph {
+  constructor(resolveId) {
+    this.resolveId = resolveId;
+  }
+  urlToModuleMap = /* @__PURE__ */ new Map();
+  idToModuleMap = /* @__PURE__ */ new Map();
+  etagToModuleMap = /* @__PURE__ */ new Map();
+  // a single file may corresponds to multiple modules with different queries
+  fileToModulesMap = /* @__PURE__ */ new Map();
+  safeModulesPath = /* @__PURE__ */ new Set();
+  /**
+   * @internal
+   */
+  _unresolvedUrlToModuleMap = /* @__PURE__ */ new Map();
+  /**
+   * @internal
+   */
+  _ssrUnresolvedUrlToModuleMap = /* @__PURE__ */ new Map();
+  /** @internal */
+  _hasResolveFailedErrorModules = /* @__PURE__ */ new Set();
+  async getModuleByUrl(rawUrl, ssr) {
+    rawUrl = removeImportQuery(removeTimestampQuery(rawUrl));
+    const mod = this._getUnresolvedUrlToModule(rawUrl, ssr);
+    if (mod) {
+      return mod;
+    }
+    const [url] = await this._resolveUrl(rawUrl, ssr);
+    return this.urlToModuleMap.get(url);
+  }
+  getModuleById(id) {
+    return this.idToModuleMap.get(removeTimestampQuery(id));
+  }
+  getModulesByFile(file) {
+    return this.fileToModulesMap.get(file);
+  }
+  onFileChange(file) {
+    const mods = this.getModulesByFile(file);
+    if (mods) {
+      const seen = /* @__PURE__ */ new Set();
+      mods.forEach((mod) => {
+        this.invalidateModule(mod, seen);
+      });
+    }
+  }
+  onFileDelete(file) {
+    const mods = this.getModulesByFile(file);
+    if (mods) {
+      mods.forEach((mod) => {
+        mod.importedModules.forEach((importedMod) => {
+          importedMod.importers.delete(mod);
+        });
+      });
+    }
+  }
+  invalidateModule(mod, seen = /* @__PURE__ */ new Set(), timestamp = Date.now(), isHmr = false, softInvalidate = false) {
+    const prevInvalidationState = mod.invalidationState;
+    const prevSsrInvalidationState = mod.ssrInvalidationState;
+    if (softInvalidate) {
+      mod.invalidationState ??= mod.transformResult ?? "HARD_INVALIDATED";
+      mod.ssrInvalidationState ??= mod.ssrTransformResult ?? "HARD_INVALIDATED";
+    } else {
+      mod.invalidationState = "HARD_INVALIDATED";
+      mod.ssrInvalidationState = "HARD_INVALIDATED";
+    }
+    if (seen.has(mod) && prevInvalidationState === mod.invalidationState && prevSsrInvalidationState === mod.ssrInvalidationState) {
+      return;
+    }
+    seen.add(mod);
+    if (isHmr) {
+      mod.lastHMRTimestamp = timestamp;
+      mod.lastHMRInvalidationReceived = false;
+    } else {
+      mod.lastInvalidationTimestamp = timestamp;
+    }
+    const etag = mod.transformResult?.etag;
+    if (etag) this.etagToModuleMap.delete(etag);
+    mod.transformResult = null;
+    mod.ssrTransformResult = null;
+    mod.ssrModule = null;
+    mod.ssrError = null;
+    mod.importers.forEach((importer) => {
+      if (!importer.acceptedHmrDeps.has(mod)) {
+        const shouldSoftInvalidateImporter = importer.staticImportedUrls?.has(mod.url) || softInvalidate;
+        this.invalidateModule(
+          importer,
+          seen,
+          timestamp,
+          isHmr,
+          shouldSoftInvalidateImporter
+        );
+      }
+    });
+    this._hasResolveFailedErrorModules.delete(mod);
+  }
+  invalidateAll() {
+    const timestamp = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    this.idToModuleMap.forEach((mod) => {
+      this.invalidateModule(mod, seen, timestamp);
+    });
+  }
+  /**
+   * Update the module graph based on a module's updated imports information
+   * If there are dependencies that no longer have any importers, they are
+   * returned as a Set.
+   *
+   * @param staticImportedUrls Subset of `importedModules` where they're statically imported in code.
+   *   This is only used for soft invalidations so `undefined` is fine but may cause more runtime processing.
+   */
+  async updateModuleInfo(mod, importedModules, importedBindings, acceptedModules, acceptedExports, isSelfAccepting, ssr, staticImportedUrls) {
+    mod.isSelfAccepting = isSelfAccepting;
+    const prevImports = ssr ? mod.ssrImportedModules : mod.clientImportedModules;
+    let noLongerImported;
+    let resolvePromises = [];
+    let resolveResults = new Array(importedModules.size);
+    let index = 0;
+    for (const imported of importedModules) {
+      const nextIndex = index++;
+      if (typeof imported === "string") {
+        resolvePromises.push(
+          this.ensureEntryFromUrl(imported, ssr).then((dep) => {
+            dep.importers.add(mod);
+            resolveResults[nextIndex] = dep;
+          })
+        );
+      } else {
+        imported.importers.add(mod);
+        resolveResults[nextIndex] = imported;
+      }
+    }
+    if (resolvePromises.length) {
+      await Promise.all(resolvePromises);
+    }
+    const nextImports = new Set(resolveResults);
+    if (ssr) {
+      mod.ssrImportedModules = nextImports;
+    } else {
+      mod.clientImportedModules = nextImports;
+    }
+    prevImports.forEach((dep) => {
+      if (!mod.clientImportedModules.has(dep) && !mod.ssrImportedModules.has(dep)) {
+        dep.importers.delete(mod);
+        if (!dep.importers.size) {
+          (noLongerImported || (noLongerImported = /* @__PURE__ */ new Set())).add(dep);
+        }
+      }
+    });
+    resolvePromises = [];
+    resolveResults = new Array(acceptedModules.size);
+    index = 0;
+    for (const accepted of acceptedModules) {
+      const nextIndex = index++;
+      if (typeof accepted === "string") {
+        resolvePromises.push(
+          this.ensureEntryFromUrl(accepted, ssr).then((dep) => {
+            resolveResults[nextIndex] = dep;
+          })
+        );
+      } else {
+        resolveResults[nextIndex] = accepted;
+      }
+    }
+    if (resolvePromises.length) {
+      await Promise.all(resolvePromises);
+    }
+    mod.acceptedHmrDeps = new Set(resolveResults);
+    mod.staticImportedUrls = staticImportedUrls;
+    mod.acceptedHmrExports = acceptedExports;
+    mod.importedBindings = importedBindings;
+    return noLongerImported;
+  }
+  async ensureEntryFromUrl(rawUrl, ssr, setIsSelfAccepting = true) {
+    return this._ensureEntryFromUrl(rawUrl, ssr, setIsSelfAccepting);
+  }
+  /**
+   * @internal
+   */
+  async _ensureEntryFromUrl(rawUrl, ssr, setIsSelfAccepting = true, resolved) {
+    rawUrl = removeImportQuery(removeTimestampQuery(rawUrl));
+    let mod = this._getUnresolvedUrlToModule(rawUrl, ssr);
+    if (mod) {
+      return mod;
+    }
+    const modPromise = (async () => {
+      const [url, resolvedId, meta] = await this._resolveUrl(
+        rawUrl,
+        ssr,
+        resolved
+      );
+      mod = this.idToModuleMap.get(resolvedId);
+      if (!mod) {
+        mod = new ModuleNode(url, setIsSelfAccepting);
+        if (meta) mod.meta = meta;
+        this.urlToModuleMap.set(url, mod);
+        mod.id = resolvedId;
+        this.idToModuleMap.set(resolvedId, mod);
+        const file = mod.file = cleanUrl(resolvedId);
+        let fileMappedModules = this.fileToModulesMap.get(file);
+        if (!fileMappedModules) {
+          fileMappedModules = /* @__PURE__ */ new Set();
+          this.fileToModulesMap.set(file, fileMappedModules);
+        }
+        fileMappedModules.add(mod);
+      } else if (!this.urlToModuleMap.has(url)) {
+        this.urlToModuleMap.set(url, mod);
+      }
+      this._setUnresolvedUrlToModule(rawUrl, mod, ssr);
+      return mod;
+    })();
+    this._setUnresolvedUrlToModule(rawUrl, modPromise, ssr);
+    return modPromise;
+  }
+  // some deps, like a css file referenced via @import, don't have its own
+  // url because they are inlined into the main css import. But they still
+  // need to be represented in the module graph so that they can trigger
+  // hmr in the importing css file.
+  createFileOnlyEntry(file) {
+    file = normalizePath$3(file);
+    let fileMappedModules = this.fileToModulesMap.get(file);
+    if (!fileMappedModules) {
+      fileMappedModules = /* @__PURE__ */ new Set();
+      this.fileToModulesMap.set(file, fileMappedModules);
+    }
+    const url = `${FS_PREFIX}${file}`;
+    for (const m of fileMappedModules) {
+      if (m.url === url || m.id === file) {
+        return m;
+      }
+    }
+    const mod = new ModuleNode(url);
+    mod.file = file;
+    fileMappedModules.add(mod);
+    return mod;
+  }
+  // for incoming urls, it is important to:
+  // 1. remove the HMR timestamp query (?t=xxxx) and the ?import query
+  // 2. resolve its extension so that urls with or without extension all map to
+  // the same module
+  async resolveUrl(url, ssr) {
+    url = removeImportQuery(removeTimestampQuery(url));
+    const mod = await this._getUnresolvedUrlToModule(url, ssr);
+    if (mod?.id) {
+      return [mod.url, mod.id, mod.meta];
+    }
+    return this._resolveUrl(url, ssr);
+  }
+  updateModuleTransformResult(mod, result, ssr) {
+    if (ssr) {
+      mod.ssrTransformResult = result;
+    } else {
+      const prevEtag = mod.transformResult?.etag;
+      if (prevEtag) this.etagToModuleMap.delete(prevEtag);
+      mod.transformResult = result;
+      if (result?.etag) this.etagToModuleMap.set(result.etag, mod);
+    }
+  }
+  getModuleByEtag(etag) {
+    return this.etagToModuleMap.get(etag);
+  }
+  /**
+   * @internal
+   */
+  _getUnresolvedUrlToModule(url, ssr) {
+    return (ssr ? this._ssrUnresolvedUrlToModuleMap : this._unresolvedUrlToModuleMap).get(url);
+  }
+  /**
+   * @internal
+   */
+  _setUnresolvedUrlToModule(url, mod, ssr) {
+    (ssr ? this._ssrUnresolvedUrlToModuleMap : this._unresolvedUrlToModuleMap).set(url, mod);
+  }
+  /**
+   * @internal
+   */
+  async _resolveUrl(url, ssr, alreadyResolved) {
+    const resolved = alreadyResolved ?? await this.resolveId(url, !!ssr);
+    const resolvedId = resolved?.id || url;
+    if (url !== resolvedId && !url.includes("\0") && !url.startsWith(`virtual:`)) {
+      const ext = extname$1(cleanUrl(resolvedId));
+      if (ext) {
+        const pathname = cleanUrl(url);
+        if (!pathname.endsWith(ext)) {
+          url = pathname + ext + url.slice(pathname.length);
+        }
+      }
+    }
+    return [url, resolvedId, resolved?.meta];
+  }
+}
+
+function notFoundMiddleware() {
+  return function vite404Middleware(_, res) {
+    res.statusCode = 404;
+    res.end();
+  };
+}
+
+const ROOT_FILES = [
+  // '.git',
+  // https://pnpm.io/workspaces/
+  "pnpm-workspace.yaml",
+  // https://rushjs.io/pages/advanced/config_files/
+  // 'rush.json',
+  // https://nx.dev/latest/react/getting-started/nx-setup
+  // 'workspace.json',
+  // 'nx.json',
+  // https://github.com/lerna/lerna#lernajson
+  "lerna.json"
+];
+function hasWorkspacePackageJSON(root) {
+  const path = join$2(root, "package.json");
+  if (!isFileReadable(path)) {
+    return false;
+  }
+  try {
+    const content = JSON.parse(fs__default.readFileSync(path, "utf-8")) || {};
+    return !!content.workspaces;
+  } catch {
+    return false;
+  }
+}
+function hasRootFile(root) {
+  return ROOT_FILES.some((file) => fs__default.existsSync(join$2(root, file)));
+}
+function hasPackageJSON(root) {
+  const path = join$2(root, "package.json");
+  return fs__default.existsSync(path);
+}
+function searchForPackageRoot(current, root = current) {
+  if (hasPackageJSON(current)) return current;
+  const dir = dirname$2(current);
+  if (!dir || dir === current) return root;
+  return searchForPackageRoot(dir, root);
+}
+function searchForWorkspaceRoot(current, root = searchForPackageRoot(current)) {
+  if (hasRootFile(current)) return current;
+  if (hasWorkspacePackageJSON(current)) return current;
+  const dir = dirname$2(current);
+  if (!dir || dir === current) return root;
+  return searchForWorkspaceRoot(dir, root);
+}
+
+function warmupFiles(server) {
+  const options = server.config.server.warmup;
+  const root = server.config.root;
+  if (options?.clientFiles?.length) {
+    mapFiles(options.clientFiles, root).then((files) => {
+      for (const file of files) {
+        warmupFile(server, file, false);
+      }
+    });
+  }
+  if (options?.ssrFiles?.length) {
+    mapFiles(options.ssrFiles, root).then((files) => {
+      for (const file of files) {
+        warmupFile(server, file, true);
+      }
+    });
+  }
+}
+async function warmupFile(server, file, ssr) {
+  if (file.endsWith(".html")) {
+    const url = htmlFileToUrl(file, server.config.root);
+    if (url) {
+      try {
+        const html = await fsp.readFile(file, "utf-8");
+        await server.transformIndexHtml(url, html);
+      } catch (e) {
+        server.config.logger.error(
+          `Pre-transform error (${colors$1.cyan(file)}): ${e.message}`,
+          {
+            error: e,
+            timestamp: true
+          }
+        );
+      }
+    }
+  } else {
+    const url = fileToUrl(file, server.config.root);
+    await server.warmupRequest(url, { ssr });
+  }
+}
+function htmlFileToUrl(file, root) {
+  const url = path$n.relative(root, file);
+  if (url[0] === ".") return;
+  return "/" + normalizePath$3(url);
+}
+function fileToUrl(file, root) {
+  const url = path$n.relative(root, file);
+  if (url[0] === ".") {
+    return path$n.posix.join(FS_PREFIX, normalizePath$3(file));
+  }
+  return "/" + normalizePath$3(url);
+}
+function mapFiles(files, root) {
+  return glob(files, {
+    cwd: root,
+    absolute: true
+  });
+}
+
+function createServer(inlineConfig = {}) {
+  return _createServer(inlineConfig, { hotListen: true });
+}
+async function _createServer(inlineConfig = {}, options) {
+  const config = await resolveConfig(inlineConfig, "serve");
+  const initPublicFilesPromise = initPublicFiles(config);
+  const { root, server: serverConfig } = config;
+  const httpsOptions = await resolveHttpsConfig(config.server.https);
+  const { middlewareMode } = serverConfig;
+  const resolvedOutDirs = getResolvedOutDirs(
+    config.root,
+    config.build.outDir,
+    config.build.rollupOptions?.output
+  );
+  const emptyOutDir = resolveEmptyOutDir(
+    config.build.emptyOutDir,
+    config.root,
+    resolvedOutDirs
+  );
+  const resolvedWatchOptions = resolveChokidarOptions(
+    {
+      disableGlobbing: true,
+      ...serverConfig.watch
+    },
+    resolvedOutDirs,
+    emptyOutDir,
+    config.cacheDir
+  );
+  const middlewares = connect$1();
+  const httpServer = middlewareMode ? null : await resolveHttpServer(serverConfig, middlewares, httpsOptions);
+  const ws = createWebSocketServer(httpServer, config, httpsOptions);
+  const hot = createHMRBroadcaster().addChannel(ws).addChannel(createServerHMRChannel());
+  if (typeof config.server.hmr === "object" && config.server.hmr.channels) {
+    config.server.hmr.channels.forEach((channel) => hot.addChannel(channel));
+  }
+  const publicFiles = await initPublicFilesPromise;
+  const { publicDir } = config;
+  if (httpServer) {
+    setClientErrorHandler(httpServer, config.logger);
+  }
+  const watchEnabled = serverConfig.watch !== null;
+  const watcher = watchEnabled ? chokidar.watch(
+    // config file dependencies and env file might be outside of root
+    [
+      root,
+      ...config.configFileDependencies,
+      ...getEnvFilesForMode(config.mode, config.envDir),
+      // Watch the public directory explicitly because it might be outside
+      // of the root directory.
+      ...publicDir && publicFiles ? [publicDir] : []
+    ],
+    resolvedWatchOptions
+  ) : createNoopWatcher(resolvedWatchOptions);
+  const moduleGraph = new ModuleGraph(
+    (url, ssr) => container.resolveId(url, void 0, { ssr })
+  );
+  const container = await createPluginContainer(config, moduleGraph, watcher);
+  const closeHttpServer = createServerCloseFn(httpServer);
+  const devHtmlTransformFn = createDevHtmlTransformFn(config);
+  const onCrawlEndCallbacks = [];
+  const crawlEndFinder = setupOnCrawlEnd(() => {
+    onCrawlEndCallbacks.forEach((cb) => cb());
+  });
+  function waitForRequestsIdle(ignoredId) {
+    return crawlEndFinder.waitForRequestsIdle(ignoredId);
+  }
+  function _registerRequestProcessing(id, done) {
+    crawlEndFinder.registerRequestProcessing(id, done);
+  }
+  function _onCrawlEnd(cb) {
+    onCrawlEndCallbacks.push(cb);
+  }
+  let server = {
+    config,
+    middlewares,
+    httpServer,
+    watcher,
+    pluginContainer: container,
+    ws,
+    hot,
+    moduleGraph,
+    resolvedUrls: null,
+    // will be set on listen
+    ssrTransform(code, inMap, url, originalCode = code) {
+      return ssrTransform(code, inMap, url, originalCode, server.config);
+    },
+    transformRequest(url, options2) {
+      return transformRequest(url, server, options2);
+    },
+    async warmupRequest(url, options2) {
+      try {
+        await transformRequest(url, server, options2);
+      } catch (e) {
+        if (e?.code === ERR_OUTDATED_OPTIMIZED_DEP || e?.code === ERR_CLOSED_SERVER) {
+          return;
+        }
+        server.config.logger.error(`Pre-transform error: ${e.message}`, {
+          error: e,
+          timestamp: true
+        });
+      }
+    },
+    transformIndexHtml(url, html, originalUrl) {
+      return devHtmlTransformFn(server, url, html, originalUrl);
+    },
+    async ssrLoadModule(url, opts) {
+      return ssrLoadModule(url, server, opts?.fixStacktrace);
+    },
+    async ssrFetchModule(url, importer) {
+      return ssrFetchModule(server, url, importer);
+    },
+    ssrFixStacktrace(e) {
+      ssrFixStacktrace(e, moduleGraph);
+    },
+    ssrRewriteStacktrace(stack) {
+      return ssrRewriteStacktrace(stack, moduleGraph);
+    },
+    async reloadModule(module) {
+      if (serverConfig.hmr !== false && module.file) {
+        updateModules(module.file, [module], Date.now(), server);
+      }
+    },
+    async listen(port, isRestart) {
+      await startServer(server, port);
+      if (httpServer) {
+        server.resolvedUrls = await resolveServerUrls(
+          httpServer,
+          config.server,
+          config
+        );
+        if (!isRestart && config.server.open) server.openBrowser();
+      }
+      return server;
+    },
+    openBrowser() {
+      const options2 = server.config.server;
+      const url = server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
+      if (url) {
+        const path2 = typeof options2.open === "string" ? new URL(options2.open, url).href : url;
+        if (server.config.server.preTransformRequests) {
+          setTimeout(() => {
+            const getMethod = path2.startsWith("https:") ? get$1 : get$2;
+            getMethod(
+              path2,
+              {
+                headers: {
+                  // Allow the history middleware to redirect to /index.html
+                  Accept: "text/html"
+                }
+              },
+              (res) => {
+                res.on("end", () => {
+                });
+              }
+            ).on("error", () => {
+            }).end();
+          }, 0);
+        }
+        openBrowser(path2, true, server.config.logger);
+      } else {
+        server.config.logger.warn("No URL available to open in browser");
+      }
+    },
+    async close() {
+      if (!middlewareMode) {
+        teardownSIGTERMListener(closeServerAndExit);
+      }
+      await Promise.allSettled([
+        watcher.close(),
+        hot.close(),
+        container.close(),
+        crawlEndFinder?.cancel(),
+        getDepsOptimizer(server.config)?.close(),
+        getDepsOptimizer(server.config, true)?.close(),
+        closeHttpServer()
+      ]);
+      while (server._pendingRequests.size > 0) {
+        await Promise.allSettled(
+          [...server._pendingRequests.values()].map(
+            (pending) => pending.request
+          )
+        );
+      }
+      server.resolvedUrls = null;
+    },
+    printUrls() {
+      if (server.resolvedUrls) {
+        printServerUrls(
+          server.resolvedUrls,
+          serverConfig.host,
+          config.logger.info
+        );
+      } else if (middlewareMode) {
+        throw new Error("cannot print server URLs in middleware mode.");
+      } else {
+        throw new Error(
+          "cannot print server URLs before server.listen is called."
+        );
+      }
+    },
+    bindCLIShortcuts(options2) {
+      bindCLIShortcuts(server, options2);
+    },
+    async restart(forceOptimize) {
+      if (!server._restartPromise) {
+        server._forceOptimizeOnRestart = !!forceOptimize;
+        server._restartPromise = restartServer(server).finally(() => {
+          server._restartPromise = null;
+          server._forceOptimizeOnRestart = false;
+        });
+      }
+      return server._restartPromise;
+    },
+    waitForRequestsIdle,
+    _registerRequestProcessing,
+    _onCrawlEnd,
+    _setInternalServer(_server) {
+      server = _server;
+    },
+    _restartPromise: null,
+    _importGlobMap: /* @__PURE__ */ new Map(),
+    _forceOptimizeOnRestart: false,
+    _pendingRequests: /* @__PURE__ */ new Map(),
+    _fsDenyGlob: picomatch$4(
+      // matchBase: true does not work as it's documented
+      // https://github.com/micromatch/picomatch/issues/89
+      // convert patterns without `/` on our side for now
+      config.server.fs.deny.map(
+        (pattern) => pattern.includes("/") ? pattern : `**/${pattern}`
+      ),
+      {
+        matchBase: false,
+        nocase: true,
+        dot: true
+      }
+    ),
+    _shortcutsOptions: void 0
+  };
+  const reflexServer = new Proxy(server, {
+    get: (_, property) => {
+      return server[property];
+    },
+    set: (_, property, value) => {
+      server[property] = value;
+      return true;
+    }
+  });
+  const closeServerAndExit = async () => {
+    try {
+      await server.close();
+    } finally {
+      process.exit();
+    }
+  };
+  if (!middlewareMode) {
+    setupSIGTERMListener(closeServerAndExit);
+  }
+  const onHMRUpdate = async (type, file) => {
+    if (serverConfig.hmr !== false) {
+      try {
+        await handleHMRUpdate(type, file, server);
+      } catch (err) {
+        hot.send({
+          type: "error",
+          err: prepareError(err)
+        });
+      }
+    }
+  };
+  const onFileAddUnlink = async (file, isUnlink) => {
+    file = normalizePath$3(file);
+    await container.watchChange(file, { event: isUnlink ? "delete" : "create" });
+    if (publicDir && publicFiles) {
+      if (file.startsWith(publicDir)) {
+        const path2 = file.slice(publicDir.length);
+        publicFiles[isUnlink ? "delete" : "add"](path2);
+        if (!isUnlink) {
+          const moduleWithSamePath = await moduleGraph.getModuleByUrl(path2);
+          const etag = moduleWithSamePath?.transformResult?.etag;
+          if (etag) {
+            moduleGraph.etagToModuleMap.delete(etag);
+          }
+        }
+      }
+    }
+    if (isUnlink) moduleGraph.onFileDelete(file);
+    await onHMRUpdate(isUnlink ? "delete" : "create", file);
+  };
+  watcher.on("change", async (file) => {
+    file = normalizePath$3(file);
+    await container.watchChange(file, { event: "update" });
+    moduleGraph.onFileChange(file);
+    await onHMRUpdate("update", file);
+  });
+  getFsUtils(config).initWatcher?.(watcher);
+  watcher.on("add", (file) => {
+    onFileAddUnlink(file, false);
+  });
+  watcher.on("unlink", (file) => {
+    onFileAddUnlink(file, true);
+  });
+  hot.on("vite:invalidate", async ({ path: path2, message }) => {
+    const mod = moduleGraph.urlToModuleMap.get(path2);
+    if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0 && !mod.lastHMRInvalidationReceived) {
+      mod.lastHMRInvalidationReceived = true;
+      config.logger.info(
+        colors$1.yellow(`hmr invalidate `) + colors$1.dim(path2) + (message ? ` ${message}` : ""),
+        { timestamp: true }
+      );
+      const file = getShortName(mod.file, config.root);
+      updateModules(
+        file,
+        [...mod.importers],
+        mod.lastHMRTimestamp,
+        server,
+        true
+      );
+    }
+  });
+  if (!middlewareMode && httpServer) {
+    httpServer.once("listening", () => {
+      serverConfig.port = httpServer.address().port;
+    });
+  }
+  const postHooks = [];
+  for (const hook of config.getSortedPluginHooks("configureServer")) {
+    postHooks.push(await hook(reflexServer));
+  }
+  if (process.env.DEBUG) {
+    middlewares.use(timeMiddleware(root));
+  }
+  const { cors } = serverConfig;
+  if (cors !== false) {
+    middlewares.use(corsMiddleware(typeof cors === "boolean" ? {} : cors));
+  }
+  middlewares.use(cachedTransformMiddleware(server));
+  const { proxy } = serverConfig;
+  if (proxy) {
+    const middlewareServer = (isObject$1(middlewareMode) ? middlewareMode.server : null) || httpServer;
+    middlewares.use(proxyMiddleware(middlewareServer, proxy, config));
+  }
+  if (config.base !== "/") {
+    middlewares.use(baseMiddleware(config.rawBase, !!middlewareMode));
+  }
+  middlewares.use("/__open-in-editor", launchEditorMiddleware$1());
+  middlewares.use(function viteHMRPingMiddleware(req, res, next) {
+    if (req.headers["accept"] === "text/x-vite-ping") {
+      res.writeHead(204).end();
+    } else {
+      next();
+    }
+  });
+  if (publicDir) {
+    middlewares.use(servePublicMiddleware(server, publicFiles));
+  }
+  middlewares.use(transformMiddleware(server));
+  middlewares.use(serveRawFsMiddleware(server));
+  middlewares.use(serveStaticMiddleware(server));
+  if (config.appType === "spa" || config.appType === "mpa") {
+    middlewares.use(
+      htmlFallbackMiddleware(
+        root,
+        config.appType === "spa",
+        getFsUtils(config)
+      )
+    );
+  }
+  postHooks.forEach((fn) => fn && fn());
+  if (config.appType === "spa" || config.appType === "mpa") {
+    middlewares.use(indexHtmlMiddleware(root, server));
+    middlewares.use(notFoundMiddleware());
+  }
+  middlewares.use(errorMiddleware(server, !!middlewareMode));
+  let initingServer;
+  let serverInited = false;
+  const initServer = async () => {
+    if (serverInited) return;
+    if (initingServer) return initingServer;
+    initingServer = async function() {
+      await container.buildStart({});
+      if (isDepsOptimizerEnabled(config, false)) {
+        await initDepsOptimizer(config, server);
+      }
+      warmupFiles(server);
+      initingServer = void 0;
+      serverInited = true;
+    }();
+    return initingServer;
+  };
+  if (!middlewareMode && httpServer) {
+    const listen = httpServer.listen.bind(httpServer);
+    httpServer.listen = async (port, ...args) => {
+      try {
+        hot.listen();
+        await initServer();
+      } catch (e) {
+        httpServer.emit("error", e);
+        return;
+      }
+      return listen(port, ...args);
+    };
+  } else {
+    if (options.hotListen) {
+      hot.listen();
+    }
+    await initServer();
+  }
+  return server;
+}
+async function startServer(server, inlinePort) {
+  const httpServer = server.httpServer;
+  if (!httpServer) {
+    throw new Error("Cannot call server.listen in middleware mode.");
+  }
+  const options = server.config.server;
+  const hostname = await resolveHostname(options.host);
+  const configPort = inlinePort ?? options.port;
+  const port = (!configPort || configPort === server._configServerPort ? server._currentServerPort : configPort) ?? DEFAULT_DEV_PORT;
+  server._configServerPort = configPort;
+  const serverPort = await httpServerStart(httpServer, {
+    port,
+    strictPort: options.strictPort,
+    host: hostname.host,
+    logger: server.config.logger
+  });
+  server._currentServerPort = serverPort;
+}
+function createServerCloseFn(server) {
+  if (!server) {
+    return () => Promise.resolve();
+  }
+  let hasListened = false;
+  const openSockets = /* @__PURE__ */ new Set();
+  server.on("connection", (socket) => {
+    openSockets.add(socket);
+    socket.on("close", () => {
+      openSockets.delete(socket);
+    });
+  });
+  server.once("listening", () => {
+    hasListened = true;
+  });
+  return () => new Promise((resolve, reject) => {
+    openSockets.forEach((s) => s.destroy());
+    if (hasListened) {
+      server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    } else {
+      resolve();
+    }
+  });
+}
+function resolvedAllowDir(root, dir) {
+  return normalizePath$3(path$n.resolve(root, dir));
+}
+function resolveServerOptions(root, raw, logger) {
+  const server = {
+    preTransformRequests: true,
+    ...raw,
+    sourcemapIgnoreList: raw?.sourcemapIgnoreList === false ? () => false : raw?.sourcemapIgnoreList || isInNodeModules$1,
+    middlewareMode: raw?.middlewareMode || false
+  };
+  let allowDirs = server.fs?.allow;
+  const deny = server.fs?.deny || [".env", ".env.*", "*.{crt,pem}"];
+  if (!allowDirs) {
+    allowDirs = [searchForWorkspaceRoot(root)];
+  }
+  if (process.versions.pnp) {
+    try {
+      const enableGlobalCache = execSync("yarn config get enableGlobalCache", { cwd: root }).toString().trim() === "true";
+      const yarnCacheDir = execSync(
+        `yarn config get ${enableGlobalCache ? "globalFolder" : "cacheFolder"}`,
+        { cwd: root }
+      ).toString().trim();
+      allowDirs.push(yarnCacheDir);
+    } catch (e) {
+      logger.warn(`Get yarn cache dir error: ${e.message}`, {
+        timestamp: true
+      });
+    }
+  }
+  allowDirs = allowDirs.map((i) => resolvedAllowDir(root, i));
+  const resolvedClientDir = resolvedAllowDir(root, CLIENT_DIR);
+  if (!allowDirs.some((dir) => isParentDirectory(dir, resolvedClientDir))) {
+    allowDirs.push(resolvedClientDir);
+  }
+  server.fs = {
+    strict: server.fs?.strict ?? true,
+    allow: allowDirs,
+    deny,
+    cachedChecks: server.fs?.cachedChecks
+  };
+  if (server.origin?.endsWith("/")) {
+    server.origin = server.origin.slice(0, -1);
+    logger.warn(
+      colors$1.yellow(
+        `${colors$1.bold("(!)")} server.origin should not end with "/". Using "${server.origin}" instead.`
+      )
+    );
+  }
+  return server;
+}
+async function restartServer(server) {
+  global.__vite_start_time = performance$1.now();
+  const shortcutsOptions = server._shortcutsOptions;
+  let inlineConfig = server.config.inlineConfig;
+  if (server._forceOptimizeOnRestart) {
+    inlineConfig = mergeConfig(inlineConfig, {
+      optimizeDeps: {
+        force: true
+      }
+    });
+  }
+  {
+    let newServer = null;
+    try {
+      newServer = await _createServer(inlineConfig, { hotListen: false });
+    } catch (err) {
+      server.config.logger.error(err.message, {
+        timestamp: true
+      });
+      server.config.logger.error("server restart failed", { timestamp: true });
+      return;
+    }
+    await server.close();
+    const middlewares = server.middlewares;
+    newServer._configServerPort = server._configServerPort;
+    newServer._currentServerPort = server._currentServerPort;
+    Object.assign(server, newServer);
+    middlewares.stack = newServer.middlewares.stack;
+    server.middlewares = middlewares;
+    newServer._setInternalServer(server);
+  }
+  const {
+    logger,
+    server: { port, middlewareMode }
+  } = server.config;
+  if (!middlewareMode) {
+    await server.listen(port, true);
+  } else {
+    server.hot.listen();
+  }
+  logger.info("server restarted.", { timestamp: true });
+  if (shortcutsOptions) {
+    shortcutsOptions.print = false;
+    bindCLIShortcuts(server, shortcutsOptions);
+  }
+}
+async function restartServerWithUrls(server) {
+  if (server.config.server.middlewareMode) {
+    await server.restart();
+    return;
+  }
+  const { port: prevPort, host: prevHost } = server.config.server;
+  const prevUrls = server.resolvedUrls;
+  await server.restart();
+  const {
+    logger,
+    server: { port, host }
+  } = server.config;
+  if ((port ?? DEFAULT_DEV_PORT) !== (prevPort ?? DEFAULT_DEV_PORT) || host !== prevHost || diffDnsOrderChange(prevUrls, server.resolvedUrls)) {
+    logger.info("");
+    server.printUrls();
+  }
+}
+const callCrawlEndIfIdleAfterMs = 50;
+function setupOnCrawlEnd(onCrawlEnd) {
+  const registeredIds = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  const onCrawlEndPromiseWithResolvers = promiseWithResolvers();
+  let timeoutHandle;
+  let cancelled = false;
+  function cancel() {
+    cancelled = true;
+  }
+  let crawlEndCalled = false;
+  function callOnCrawlEnd() {
+    if (!cancelled && !crawlEndCalled) {
+      crawlEndCalled = true;
+      onCrawlEnd();
+    }
+    onCrawlEndPromiseWithResolvers.resolve();
+  }
+  function registerRequestProcessing(id, done) {
+    if (!seenIds.has(id)) {
+      seenIds.add(id);
+      registeredIds.add(id);
+      done().catch(() => {
+      }).finally(() => markIdAsDone(id));
+    }
+  }
+  function waitForRequestsIdle(ignoredId) {
+    if (ignoredId) {
+      seenIds.add(ignoredId);
+      markIdAsDone(ignoredId);
+    } else {
+      checkIfCrawlEndAfterTimeout();
+    }
+    return onCrawlEndPromiseWithResolvers.promise;
+  }
+  function markIdAsDone(id) {
+    registeredIds.delete(id);
+    checkIfCrawlEndAfterTimeout();
+  }
+  function checkIfCrawlEndAfterTimeout() {
+    if (cancelled || registeredIds.size > 0) return;
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+    timeoutHandle = setTimeout(
+      callOnCrawlEndWhenIdle,
+      callCrawlEndIfIdleAfterMs
+    );
+  }
+  async function callOnCrawlEndWhenIdle() {
+    if (cancelled || registeredIds.size > 0) return;
+    callOnCrawlEnd();
+  }
+  return {
+    registerRequestProcessing,
+    waitForRequestsIdle,
+    cancel
+  };
+}
+
+var index = {
+	__proto__: null,
+	_createServer: _createServer,
+	createServer: createServer,
+	createServerCloseFn: createServerCloseFn,
+	resolveServerOptions: resolveServerOptions,
+	restartServerWithUrls: restartServerWithUrls
+};
+
+const debugHmr = createDebugger("vite:hmr");
+const whitespaceRE = /\s/;
+const normalizedClientDir = normalizePath$3(CLIENT_DIR);
+function getShortName(file, root) {
+  return file.startsWith(withTrailingSlash(root)) ? path$n.posix.relative(root, file) : file;
+}
+async function handleHMRUpdate(type, file, server) {
+  const { hot, config, moduleGraph } = server;
+  const shortFile = getShortName(file, config.root);
+  const isConfig = file === config.configFile;
+  const isConfigDependency = config.configFileDependencies.some(
+    (name) => file === name
+  );
+  const isEnv = config.inlineConfig.envFile !== false && getEnvFilesForMode(config.mode, config.envDir).includes(file);
+  if (isConfig || isConfigDependency || isEnv) {
+    debugHmr?.(`[config change] ${colors$1.dim(shortFile)}`);
+    config.logger.info(
+      colors$1.green(
+        `${normalizePath$3(
+          path$n.relative(process.cwd(), file)
+        )} changed, restarting server...`
+      ),
+      { clear: true, timestamp: true }
+    );
+    try {
+      await restartServerWithUrls(server);
+    } catch (e) {
+      config.logger.error(colors$1.red(e));
+    }
+    return;
+  }
+  debugHmr?.(`[file change] ${colors$1.dim(shortFile)}`);
+  if (file.startsWith(withTrailingSlash(normalizedClientDir))) {
+    hot.send({
+      type: "full-reload",
+      path: "*",
+      triggeredBy: path$n.resolve(config.root, file)
+    });
+    return;
+  }
+  const mods = new Set(moduleGraph.getModulesByFile(file));
+  if (type === "create") {
+    for (const mod of moduleGraph._hasResolveFailedErrorModules) {
+      mods.add(mod);
+    }
+  }
+  if (type === "create" || type === "delete") {
+    for (const mod of getAffectedGlobModules(file, server)) {
+      mods.add(mod);
+    }
+  }
+  const timestamp = Date.now();
+  const hmrContext = {
+    file,
+    timestamp,
+    modules: [...mods],
+    read: () => readModifiedFile(file),
+    server
+  };
+  if (type === "update") {
+    for (const hook of config.getSortedPluginHooks("handleHotUpdate")) {
+      const filteredModules = await hook(hmrContext);
+      if (filteredModules) {
+        hmrContext.modules = filteredModules;
+      }
+    }
+  }
+  if (!hmrContext.modules.length) {
+    if (file.endsWith(".html")) {
+      config.logger.info(colors$1.green(`page reload `) + colors$1.dim(shortFile), {
+        clear: true,
+        timestamp: true
+      });
+      hot.send({
+        type: "full-reload",
+        path: config.server.middlewareMode ? "*" : "/" + normalizePath$3(path$n.relative(config.root, file))
+      });
+    } else {
+      debugHmr?.(`[no modules matched] ${colors$1.dim(shortFile)}`);
+    }
+    return;
+  }
+  updateModules(shortFile, hmrContext.modules, timestamp, server);
+}
+function updateModules(file, modules, timestamp, { config, hot, moduleGraph }, afterInvalidation) {
+  const updates = [];
+  const invalidatedModules = /* @__PURE__ */ new Set();
+  const traversedModules = /* @__PURE__ */ new Set();
+  let needFullReload = modules.length === 0;
+  for (const mod of modules) {
+    const boundaries = [];
+    const hasDeadEnd = propagateUpdate(mod, traversedModules, boundaries);
+    moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+    if (needFullReload) {
+      continue;
+    }
+    if (hasDeadEnd) {
+      needFullReload = hasDeadEnd;
+      continue;
+    }
+    updates.push(
+      ...boundaries.map(
+        ({ boundary, acceptedVia, isWithinCircularImport }) => ({
+          type: `${boundary.type}-update`,
+          timestamp,
+          path: normalizeHmrUrl(boundary.url),
+          acceptedPath: normalizeHmrUrl(acceptedVia.url),
+          explicitImportRequired: boundary.type === "js" ? isExplicitImportRequired(acceptedVia.url) : false,
+          isWithinCircularImport,
+          // browser modules are invalidated by changing ?t= query,
+          // but in ssr we control the module system, so we can directly remove them form cache
+          ssrInvalidates: getSSRInvalidatedImporters(acceptedVia)
+        })
+      )
+    );
+  }
+  if (needFullReload) {
+    const reason = typeof needFullReload === "string" ? colors$1.dim(` (${needFullReload})`) : "";
+    config.logger.info(
+      colors$1.green(`page reload `) + colors$1.dim(file) + reason,
+      { clear: !afterInvalidation, timestamp: true }
+    );
+    hot.send({
+      type: "full-reload",
+      triggeredBy: path$n.resolve(config.root, file)
+    });
+    return;
+  }
+  if (updates.length === 0) {
+    debugHmr?.(colors$1.yellow(`no update happened `) + colors$1.dim(file));
+    return;
+  }
+  config.logger.info(
+    colors$1.green(`hmr update `) + colors$1.dim([...new Set(updates.map((u) => u.path))].join(", ")),
+    { clear: !afterInvalidation, timestamp: true }
+  );
+  hot.send({
+    type: "update",
+    updates
+  });
+}
+function populateSSRImporters(module, timestamp, seen = /* @__PURE__ */ new Set()) {
+  module.ssrImportedModules.forEach((importer) => {
+    if (seen.has(importer)) {
+      return;
+    }
+    if (importer.lastHMRTimestamp === timestamp || importer.lastInvalidationTimestamp === timestamp) {
+      seen.add(importer);
+      populateSSRImporters(importer, timestamp, seen);
+    }
+  });
+  return seen;
+}
+function getSSRInvalidatedImporters(module) {
+  return [...populateSSRImporters(module, module.lastHMRTimestamp)].map(
+    (m) => m.file
+  );
+}
+function areAllImportsAccepted(importedBindings, acceptedExports) {
+  for (const binding of importedBindings) {
+    if (!acceptedExports.has(binding)) {
+      return false;
+    }
+  }
+  return true;
+}
+function propagateUpdate(node, traversedModules, boundaries, currentChain = [node]) {
+  if (traversedModules.has(node)) {
+    return false;
+  }
+  traversedModules.add(node);
+  if (node.id && node.isSelfAccepting === void 0) {
+    debugHmr?.(
+      `[propagate update] stop propagation because not analyzed: ${colors$1.dim(
+        node.id
+      )}`
+    );
+    return false;
+  }
+  if (node.isSelfAccepting) {
+    boundaries.push({
+      boundary: node,
+      acceptedVia: node,
+      isWithinCircularImport: isNodeWithinCircularImports(node, currentChain)
+    });
+    for (const importer of node.importers) {
+      if (isCSSRequest(importer.url) && !currentChain.includes(importer)) {
+        propagateUpdate(
+          importer,
+          traversedModules,
+          boundaries,
+          currentChain.concat(importer)
+        );
+      }
+    }
+    return false;
+  }
+  if (node.acceptedHmrExports) {
+    boundaries.push({
+      boundary: node,
+      acceptedVia: node,
+      isWithinCircularImport: isNodeWithinCircularImports(node, currentChain)
+    });
+  } else {
+    if (!node.importers.size) {
+      return true;
+    }
+    if (!isCSSRequest(node.url) && [...node.importers].every((i) => isCSSRequest(i.url))) {
+      return true;
+    }
+  }
+  for (const importer of node.importers) {
+    const subChain = currentChain.concat(importer);
+    if (importer.acceptedHmrDeps.has(node)) {
+      boundaries.push({
+        boundary: importer,
+        acceptedVia: node,
+        isWithinCircularImport: isNodeWithinCircularImports(importer, subChain)
+      });
+      continue;
+    }
+    if (node.id && node.acceptedHmrExports && importer.importedBindings) {
+      const importedBindingsFromNode = importer.importedBindings.get(node.id);
+      if (importedBindingsFromNode && areAllImportsAccepted(importedBindingsFromNode, node.acceptedHmrExports)) {
+        continue;
+      }
+    }
+    if (!currentChain.includes(importer) && propagateUpdate(importer, traversedModules, boundaries, subChain)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isNodeWithinCircularImports(node, nodeChain, currentChain = [node], traversedModules = /* @__PURE__ */ new Set()) {
+  if (traversedModules.has(node)) {
+    return false;
+  }
+  traversedModules.add(node);
+  for (const importer of node.importers) {
+    if (importer === node) continue;
+    if (isCSSRequest(importer.url)) continue;
+    const importerIndex = nodeChain.indexOf(importer);
+    if (importerIndex > -1) {
+      if (debugHmr) {
+        const importChain = [
+          importer,
+          ...[...currentChain].reverse(),
+          ...nodeChain.slice(importerIndex, -1).reverse()
+        ];
+        debugHmr(
+          colors$1.yellow(`circular imports detected: `) + importChain.map((m) => colors$1.dim(m.url)).join(" -> ")
+        );
+      }
+      return true;
+    }
+    if (!currentChain.includes(importer)) {
+      const result = isNodeWithinCircularImports(
+        importer,
+        nodeChain,
+        currentChain.concat(importer),
+        traversedModules
+      );
+      if (result) return result;
+    }
+  }
+  return false;
+}
+function handlePrunedModules(mods, { hot }) {
+  const t = Date.now();
+  mods.forEach((mod) => {
+    mod.lastHMRTimestamp = t;
+    mod.lastHMRInvalidationReceived = false;
+    debugHmr?.(`[dispose] ${colors$1.dim(mod.file)}`);
+  });
+  hot.send({
+    type: "prune",
+    paths: [...mods].map((m) => m.url)
+  });
+}
+function lexAcceptedHmrDeps(code, start, urls) {
+  let state = 0 /* inCall */;
+  let prevState = 0 /* inCall */;
+  let currentDep = "";
+  function addDep(index) {
+    urls.add({
+      url: currentDep,
+      start: index - currentDep.length - 1,
+      end: index + 1
+    });
+    currentDep = "";
+  }
+  for (let i = start; i < code.length; i++) {
+    const char = code.charAt(i);
+    switch (state) {
+      case 0 /* inCall */:
+      case 4 /* inArray */:
+        if (char === `'`) {
+          prevState = state;
+          state = 1 /* inSingleQuoteString */;
+        } else if (char === `"`) {
+          prevState = state;
+          state = 2 /* inDoubleQuoteString */;
+        } else if (char === "`") {
+          prevState = state;
+          state = 3 /* inTemplateString */;
+        } else if (whitespaceRE.test(char)) {
+          continue;
+        } else {
+          if (state === 0 /* inCall */) {
+            if (char === `[`) {
+              state = 4 /* inArray */;
+            } else {
+              return true;
+            }
+          } else if (state === 4 /* inArray */) {
+            if (char === `]`) {
+              return false;
+            } else if (char === ",") {
+              continue;
+            } else {
+              error(i);
+            }
+          }
+        }
+        break;
+      case 1 /* inSingleQuoteString */:
+        if (char === `'`) {
+          addDep(i);
+          if (prevState === 0 /* inCall */) {
+            return false;
+          } else {
+            state = prevState;
+          }
+        } else {
+          currentDep += char;
+        }
+        break;
+      case 2 /* inDoubleQuoteString */:
+        if (char === `"`) {
+          addDep(i);
+          if (prevState === 0 /* inCall */) {
+            return false;
+          } else {
+            state = prevState;
+          }
+        } else {
+          currentDep += char;
+        }
+        break;
+      case 3 /* inTemplateString */:
+        if (char === "`") {
+          addDep(i);
+          if (prevState === 0 /* inCall */) {
+            return false;
+          } else {
+            state = prevState;
+          }
+        } else if (char === "$" && code.charAt(i + 1) === "{") {
+          error(i);
+        } else {
+          currentDep += char;
+        }
+        break;
+      default:
+        throw new Error("unknown import.meta.hot lexer state");
+    }
+  }
+  return false;
+}
+function lexAcceptedHmrExports(code, start, exportNames) {
+  const urls = /* @__PURE__ */ new Set();
+  lexAcceptedHmrDeps(code, start, urls);
+  for (const { url } of urls) {
+    exportNames.add(url);
+  }
+  return urls.size > 0;
+}
+function normalizeHmrUrl(url) {
+  if (url[0] !== "." && url[0] !== "/") {
+    url = wrapId$1(url);
+  }
+  return url;
+}
+function error(pos) {
+  const err = new Error(
+    `import.meta.hot.accept() can only accept string literals or an Array of string literals.`
+  );
+  err.pos = pos;
+  throw err;
+}
+async function readModifiedFile(file) {
+  const content = await fsp.readFile(file, "utf-8");
+  if (!content) {
+    const mtime = (await fsp.stat(file)).mtimeMs;
+    for (let n = 0; n < 10; n++) {
+      await new Promise((r) => setTimeout(r, 10));
+      const newMtime = (await fsp.stat(file)).mtimeMs;
+      if (newMtime !== mtime) {
+        break;
+      }
+    }
+    return await fsp.readFile(file, "utf-8");
+  } else {
+    return content;
+  }
+}
+function createHMRBroadcaster() {
+  const channels = [];
+  const readyChannels = /* @__PURE__ */ new WeakSet();
+  const broadcaster = {
+    get channels() {
+      return [...channels];
+    },
+    addChannel(channel) {
+      if (channels.some((c) => c.name === channel.name)) {
+        throw new Error(`HMR channel "${channel.name}" is already defined.`);
+      }
+      channels.push(channel);
+      return broadcaster;
+    },
+    on(event, listener) {
+      if (event === "connection") {
+        const channels2 = this.channels;
+        channels2.forEach(
+          (channel) => channel.on("connection", () => {
+            readyChannels.add(channel);
+            if (channels2.every((c) => readyChannels.has(c))) {
+              listener();
+            }
+          })
+        );
+        return;
+      }
+      channels.forEach((channel) => channel.on(event, listener));
+      return;
+    },
+    off(event, listener) {
+      channels.forEach((channel) => channel.off(event, listener));
+      return;
+    },
+    send(...args) {
+      channels.forEach((channel) => channel.send(...args));
+    },
+    listen() {
+      channels.forEach((channel) => channel.listen());
+    },
+    close() {
+      return Promise.all(channels.map((channel) => channel.close()));
+    }
+  };
+  return broadcaster;
+}
+function createServerHMRChannel() {
+  const innerEmitter = new EventEmitter$4();
+  const outsideEmitter = new EventEmitter$4();
+  return {
+    name: "ssr",
+    send(...args) {
+      let payload;
+      if (typeof args[0] === "string") {
+        payload = {
+          type: "custom",
+          event: args[0],
+          data: args[1]
+        };
+      } else {
+        payload = args[0];
+      }
+      outsideEmitter.emit("send", payload);
+    },
+    off(event, listener) {
+      innerEmitter.off(event, listener);
+    },
+    on: (event, listener) => {
+      innerEmitter.on(event, listener);
+    },
+    close() {
+      innerEmitter.removeAllListeners();
+      outsideEmitter.removeAllListeners();
+    },
+    listen() {
+      innerEmitter.emit("connection");
+    },
+    api: {
+      innerEmitter,
+      outsideEmitter
+    }
+  };
+}
+
+const debug$1 = createDebugger("vite:import-analysis");
+const clientDir = normalizePath$3(CLIENT_DIR);
+const skipRE = /\.(?:map|json)(?:$|\?)/;
+const canSkipImportAnalysis = (id) => skipRE.test(id) || isDirectCSSRequest(id);
+const optimizedDepChunkRE = /\/chunk-[A-Z\d]{8}\.js/;
+const optimizedDepDynamicRE = /-[A-Z\d]{8}\.js/;
+const hasViteIgnoreRE = /\/\*\s*@vite-ignore\s*\*\//;
+const urlIsStringRE = /^(?:'.*'|".*"|`.*`)$/;
+const templateLiteralRE = /^\s*`(.*)`\s*$/;
+function isExplicitImportRequired(url) {
+  return !isJSRequest(url) && !isCSSRequest(url);
+}
+function extractImportedBindings(id, source, importSpec, importedBindings) {
+  let bindings = importedBindings.get(id);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Set();
+    importedBindings.set(id, bindings);
+  }
+  const isDynamic = importSpec.d > -1;
+  const isMeta = importSpec.d === -2;
+  if (isDynamic || isMeta) {
+    bindings.add("*");
+    return;
+  }
+  const exp = source.slice(importSpec.ss, importSpec.se);
+  ESM_STATIC_IMPORT_RE.lastIndex = 0;
+  const match = ESM_STATIC_IMPORT_RE.exec(exp);
+  if (!match) {
+    return;
+  }
+  const staticImport = {
+    type: "static",
+    code: match[0],
+    start: match.index,
+    end: match.index + match[0].length,
+    imports: match.groups.imports,
+    specifier: match.groups.specifier
+  };
+  const parsed = parseStaticImport(staticImport);
+  if (!parsed) {
+    return;
+  }
+  if (parsed.namespacedImport) {
+    bindings.add("*");
+  }
+  if (parsed.defaultImport) {
+    bindings.add("default");
+  }
+  if (parsed.namedImports) {
+    for (const name of Object.keys(parsed.namedImports)) {
+      bindings.add(name);
+    }
+  }
+}
+function importAnalysisPlugin(config) {
+  const { root, base } = config;
+  const fsUtils = getFsUtils(config);
+  const clientPublicPath = path$n.posix.join(base, CLIENT_PUBLIC_PATH);
+  const enablePartialAccept = config.experimental?.hmrPartialAccept;
+  const matchAlias = getAliasPatternMatcher(config.resolve.alias);
+  let server;
+  let _env;
+  let _ssrEnv;
+  function getEnv(ssr) {
+    if (!_ssrEnv || !_env) {
+      const importMetaEnvKeys = {};
+      const userDefineEnv = {};
+      for (const key in config.env) {
+        importMetaEnvKeys[key] = JSON.stringify(config.env[key]);
+      }
+      for (const key in config.define) {
+        if (key.startsWith("import.meta.env.")) {
+          userDefineEnv[key.slice(16)] = config.define[key];
+        }
+      }
+      const env = `import.meta.env = ${serializeDefine({
+        ...importMetaEnvKeys,
+        SSR: "__vite_ssr__",
+        ...userDefineEnv
+      })};`;
+      _ssrEnv = env.replace("__vite_ssr__", "true");
+      _env = env.replace("__vite_ssr__", "false");
+    }
+    return ssr ? _ssrEnv : _env;
+  }
+  return {
+    name: "vite:import-analysis",
+    configureServer(_server) {
+      server = _server;
+    },
+    async transform(source, importer, options) {
+      if (!server) {
+        return null;
+      }
+      const ssr = options?.ssr === true;
+      if (canSkipImportAnalysis(importer)) {
+        debug$1?.(colors$1.dim(`[skipped] ${prettifyUrl(importer, root)}`));
+        return null;
+      }
+      const msAtStart = debug$1 ? performance$1.now() : 0;
+      await init;
+      let imports;
+      let exports;
+      source = stripBomTag(source);
+      try {
+        [imports, exports] = parse$d(source);
+      } catch (_e) {
+        const e = _e;
+        const { message, showCodeFrame } = createParseErrorInfo(
+          importer,
+          source
+        );
+        this.error(message, showCodeFrame ? e.idx : void 0);
+      }
+      const depsOptimizer = getDepsOptimizer(config, ssr);
+      const { moduleGraph } = server;
+      const importerModule = moduleGraph.getModuleById(importer);
+      if (!importerModule) {
+        throwOutdatedRequest(importer);
+      }
+      if (!imports.length && !this._addedImports) {
+        importerModule.isSelfAccepting = false;
+        debug$1?.(
+          `${timeFrom(msAtStart)} ${colors$1.dim(
+            `[no imports] ${prettifyUrl(importer, root)}`
+          )}`
+        );
+        return source;
+      }
+      let hasHMR = false;
+      let isSelfAccepting = false;
+      let hasEnv = false;
+      let needQueryInjectHelper = false;
+      let s;
+      const str = () => s || (s = new MagicString(source));
+      let isPartiallySelfAccepting = false;
+      const importedBindings = enablePartialAccept ? /* @__PURE__ */ new Map() : null;
+      const toAbsoluteUrl = (url) => path$n.posix.resolve(path$n.posix.dirname(importerModule.url), url);
+      const normalizeUrl = async (url, pos, forceSkipImportAnalysis = false) => {
+        url = stripBase(url, base);
+        let importerFile = importer;
+        const optimizeDeps = getDepOptimizationConfig(config, ssr);
+        if (moduleListContains(optimizeDeps?.exclude, url)) {
+          if (depsOptimizer) {
+            await depsOptimizer.scanProcessing;
+            for (const optimizedModule of depsOptimizer.metadata.depInfoList) {
+              if (!optimizedModule.src) continue;
+              if (optimizedModule.file === importerModule.file) {
+                importerFile = optimizedModule.src;
+              }
+            }
+          }
+        }
+        const resolved = await this.resolve(url, importerFile);
+        if (!resolved || resolved.meta?.["vite:alias"]?.noResolved) {
+          if (ssr) {
+            return [url, url];
+          }
+          importerModule.isSelfAccepting = false;
+          moduleGraph._hasResolveFailedErrorModules.add(importerModule);
+          return this.error(
+            `Failed to resolve import "${url}" from "${normalizePath$3(
+              path$n.relative(process.cwd(), importerFile)
+            )}". Does the file exist?`,
+            pos
+          );
+        }
+        if (isExternalUrl(resolved.id)) {
+          return [resolved.id, resolved.id];
+        }
+        const isRelative = url[0] === ".";
+        const isSelfImport = !isRelative && cleanUrl(url) === cleanUrl(importer);
+        if (resolved.id.startsWith(withTrailingSlash(root))) {
+          url = resolved.id.slice(root.length);
+        } else if (depsOptimizer?.isOptimizedDepFile(resolved.id) || // vite-plugin-react isn't following the leading \0 virtual module convention.
+        // This is a temporary hack to avoid expensive fs checks for React apps.
+        // We'll remove this as soon we're able to fix the react plugins.
+        resolved.id !== "/@react-refresh" && path$n.isAbsolute(resolved.id) && fsUtils.existsSync(cleanUrl(resolved.id))) {
+          url = path$n.posix.join(FS_PREFIX, resolved.id);
+        } else {
+          url = resolved.id;
+        }
+        if (url[0] !== "." && url[0] !== "/") {
+          url = wrapId$1(resolved.id);
+        }
+        if (!ssr) {
+          if (isExplicitImportRequired(url)) {
+            url = injectQuery(url, "import");
+          } else if ((isRelative || isSelfImport) && !DEP_VERSION_RE.test(url)) {
+            const versionMatch = DEP_VERSION_RE.exec(importer);
+            if (versionMatch) {
+              url = injectQuery(url, versionMatch[1]);
+            }
+          }
+          try {
+            const depModule = await moduleGraph._ensureEntryFromUrl(
+              unwrapId$1(url),
+              ssr,
+              canSkipImportAnalysis(url) || forceSkipImportAnalysis,
+              resolved
+            );
+            if (depModule.lastHMRTimestamp > 0) {
+              url = injectQuery(url, `t=${depModule.lastHMRTimestamp}`);
+            }
+          } catch (e) {
+            e.pos = pos;
+            throw e;
+          }
+          url = joinUrlSegments(base, url);
+        }
+        return [url, resolved.id];
+      };
+      const orderedImportedUrls = new Array(imports.length);
+      const orderedAcceptedUrls = new Array(
+        imports.length
+      );
+      const orderedAcceptedExports = new Array(
+        imports.length
+      );
+      await Promise.all(
+        imports.map(async (importSpecifier, index) => {
+          const {
+            s: start,
+            e: end,
+            ss: expStart,
+            se: expEnd,
+            d: dynamicIndex,
+            a: attributeIndex
+          } = importSpecifier;
+          let specifier = importSpecifier.n;
+          const rawUrl = source.slice(start, end);
+          if (rawUrl === "import.meta") {
+            const prop = source.slice(end, end + 4);
+            if (prop === ".hot") {
+              hasHMR = true;
+              const endHot = end + 4 + (source[end + 4] === "?" ? 1 : 0);
+              if (source.slice(endHot, endHot + 7) === ".accept") {
+                if (source.slice(endHot, endHot + 14) === ".acceptExports") {
+                  const importAcceptedExports = orderedAcceptedExports[index] = /* @__PURE__ */ new Set();
+                  lexAcceptedHmrExports(
+                    source,
+                    source.indexOf("(", endHot + 14) + 1,
+                    importAcceptedExports
+                  );
+                  isPartiallySelfAccepting = true;
+                } else {
+                  const importAcceptedUrls = orderedAcceptedUrls[index] = /* @__PURE__ */ new Set();
+                  if (lexAcceptedHmrDeps(
+                    source,
+                    source.indexOf("(", endHot + 7) + 1,
+                    importAcceptedUrls
+                  )) {
+                    isSelfAccepting = true;
+                  }
+                }
+              }
+            } else if (prop === ".env") {
+              hasEnv = true;
+            }
+            return;
+          } else if (templateLiteralRE.test(rawUrl)) {
+            if (!(rawUrl.includes("${") && rawUrl.includes("}"))) {
+              specifier = rawUrl.replace(templateLiteralRE, "$1");
+            }
+          }
+          const isDynamicImport = dynamicIndex > -1;
+          if (!isDynamicImport && attributeIndex > -1) {
+            str().remove(end + 1, expEnd);
+          }
+          if (specifier !== void 0) {
+            if (isExternalUrl(specifier) || isDataUrl(specifier)) {
+              return;
+            }
+            if (ssr && !matchAlias(specifier)) {
+              if (shouldExternalizeForSSR(specifier, importer, config)) {
+                return;
+              }
+              if (isBuiltin(specifier)) {
+                return;
+              }
+            }
+            if (specifier === clientPublicPath) {
+              return;
+            }
+            if (specifier[0] === "/" && !(config.assetsInclude(cleanUrl(specifier)) || urlRE.test(specifier)) && checkPublicFile(specifier, config)) {
+              throw new Error(
+                `Cannot import non-asset file ${specifier} which is inside /public. JS/CSS files inside /public are copied as-is on build and can only be referenced via <script src> or <link href> in html. If you want to get the URL of that file, use ${injectQuery(
+                  specifier,
+                  "url"
+                )} instead.`
+              );
+            }
+            const [url, resolvedId] = await normalizeUrl(specifier, start);
+            server?.moduleGraph.safeModulesPath.add(
+              fsPathFromUrl(stripBase(url, base))
+            );
+            if (url !== specifier) {
+              let rewriteDone = false;
+              if (depsOptimizer?.isOptimizedDepFile(resolvedId) && !optimizedDepChunkRE.test(resolvedId)) {
+                const file = cleanUrl(resolvedId);
+                const needsInterop = await optimizedDepNeedsInterop(
+                  depsOptimizer.metadata,
+                  file,
+                  config,
+                  ssr
+                );
+                if (needsInterop === void 0) {
+                  if (!optimizedDepDynamicRE.test(file)) {
+                    config.logger.error(
+                      colors$1.red(
+                        `Vite Error, ${url} optimized info should be defined`
+                      )
+                    );
+                  }
+                } else if (needsInterop) {
+                  debug$1?.(`${url} needs interop`);
+                  interopNamedImports(
+                    str(),
+                    importSpecifier,
+                    url,
+                    index,
+                    importer,
+                    config
+                  );
+                  rewriteDone = true;
+                }
+              } else if (url.includes(browserExternalId) && source.slice(expStart, start).includes("{")) {
+                interopNamedImports(
+                  str(),
+                  importSpecifier,
+                  url,
+                  index,
+                  importer,
+                  config
+                );
+                rewriteDone = true;
+              }
+              if (!rewriteDone) {
+                const rewrittenUrl = JSON.stringify(url);
+                const s2 = isDynamicImport ? start : start - 1;
+                const e = isDynamicImport ? end : end + 1;
+                str().overwrite(s2, e, rewrittenUrl, {
+                  contentOnly: true
+                });
+              }
+            }
+            const hmrUrl = unwrapId$1(stripBase(url, base));
+            const isLocalImport = !isExternalUrl(hmrUrl) && !isDataUrl(hmrUrl);
+            if (isLocalImport) {
+              orderedImportedUrls[index] = hmrUrl;
+            }
+            if (enablePartialAccept && importedBindings) {
+              extractImportedBindings(
+                resolvedId,
+                source,
+                importSpecifier,
+                importedBindings
+              );
+            }
+            if (!isDynamicImport && isLocalImport && config.server.preTransformRequests) {
+              const url2 = removeImportQuery(hmrUrl);
+              server.warmupRequest(url2, { ssr });
+            }
+          } else if (!importer.startsWith(withTrailingSlash(clientDir))) {
+            if (!isInNodeModules$1(importer)) {
+              const hasViteIgnore = hasViteIgnoreRE.test(
+                // complete expression inside parens
+                source.slice(dynamicIndex + 1, end)
+              );
+              if (!hasViteIgnore) {
+                this.warn(
+                  `
+` + colors$1.cyan(importerModule.file) + `
+` + colors$1.reset(generateCodeFrame(source, start, end)) + colors$1.yellow(
+                    `
+The above dynamic import cannot be analyzed by Vite.
+See ${colors$1.blue(
+                      `https://github.com/rollup/plugins/tree/master/packages/dynamic-import-vars#limitations`
+                    )} for supported dynamic import formats. If this is intended to be left as-is, you can use the /* @vite-ignore */ comment inside the import() call to suppress this warning.
+`
+                  )
+                );
+              }
+            }
+            if (!ssr) {
+              if (!urlIsStringRE.test(rawUrl) || isExplicitImportRequired(rawUrl.slice(1, -1))) {
+                needQueryInjectHelper = true;
+                str().overwrite(
+                  start,
+                  end,
+                  `__vite__injectQuery(${rawUrl}, 'import')`,
+                  { contentOnly: true }
+                );
+              }
+            }
+          }
+        })
+      );
+      const _orderedImportedUrls = orderedImportedUrls.filter(isDefined);
+      const importedUrls = new Set(_orderedImportedUrls);
+      const staticImportedUrls = new Set(
+        _orderedImportedUrls.map((url) => removeTimestampQuery(url))
+      );
+      const acceptedUrls = mergeAcceptedUrls(orderedAcceptedUrls);
+      const acceptedExports = mergeAcceptedUrls(orderedAcceptedExports);
+      const isClassicWorker = importer.includes(WORKER_FILE_ID) && importer.includes("type=classic");
+      if (hasEnv && !isClassicWorker) {
+        str().prepend(getEnv(ssr));
+      }
+      if (hasHMR && !ssr && !isClassicWorker) {
+        debugHmr?.(
+          `${isSelfAccepting ? `[self-accepts]` : isPartiallySelfAccepting ? `[accepts-exports]` : acceptedUrls.size ? `[accepts-deps]` : `[detected api usage]`} ${prettifyUrl(importer, root)}`
+        );
+        str().prepend(
+          `import { createHotContext as __vite__createHotContext } from "${clientPublicPath}";import.meta.hot = __vite__createHotContext(${JSON.stringify(
+            normalizeHmrUrl(importerModule.url)
+          )});`
+        );
+      }
+      if (needQueryInjectHelper) {
+        if (isClassicWorker) {
+          str().append("\n" + __vite__injectQuery.toString());
+        } else {
+          str().prepend(
+            `import { injectQuery as __vite__injectQuery } from "${clientPublicPath}";`
+          );
+        }
+      }
+      const normalizedAcceptedUrls = /* @__PURE__ */ new Set();
+      for (const { url, start, end } of acceptedUrls) {
+        const [normalized] = await moduleGraph.resolveUrl(
+          toAbsoluteUrl(url),
+          ssr
+        );
+        normalizedAcceptedUrls.add(normalized);
+        str().overwrite(start, end, JSON.stringify(normalized), {
+          contentOnly: true
+        });
+      }
+      if (!isCSSRequest(importer) || SPECIAL_QUERY_RE.test(importer)) {
+        const pluginImports = this._addedImports;
+        if (pluginImports) {
+          (await Promise.all(
+            [...pluginImports].map((id) => normalizeUrl(id, 0, true))
+          )).forEach(([url]) => importedUrls.add(url));
+        }
+        if (ssr && importerModule.isSelfAccepting) {
+          isSelfAccepting = true;
+        }
+        if (!isSelfAccepting && isPartiallySelfAccepting && acceptedExports.size >= exports.length && exports.every((e) => acceptedExports.has(e.n))) {
+          isSelfAccepting = true;
+        }
+        const prunedImports = await moduleGraph.updateModuleInfo(
+          importerModule,
+          importedUrls,
+          importedBindings,
+          normalizedAcceptedUrls,
+          isPartiallySelfAccepting ? acceptedExports : null,
+          isSelfAccepting,
+          ssr,
+          staticImportedUrls
+        );
+        if (hasHMR && prunedImports) {
+          handlePrunedModules(prunedImports, server);
+        }
+      }
+      debug$1?.(
+        `${timeFrom(msAtStart)} ${colors$1.dim(
+          `[${importedUrls.size} imports rewritten] ${prettifyUrl(
+            importer,
+            root
+          )}`
+        )}`
+      );
+      if (s) {
+        return transformStableResult(s, importer, config);
+      } else {
+        return source;
+      }
+    }
+  };
+}
+function mergeAcceptedUrls(orderedUrls) {
+  const acceptedUrls = /* @__PURE__ */ new Set();
+  for (const urls of orderedUrls) {
+    if (!urls) continue;
+    for (const url of urls) acceptedUrls.add(url);
+  }
+  return acceptedUrls;
+}
+function createParseErrorInfo(importer, source) {
+  const isVue = importer.endsWith(".vue");
+  const isJsx = importer.endsWith(".jsx") || importer.endsWith(".tsx");
+  const maybeJSX = !isVue && isJSRequest(importer);
+  const probablyBinary = source.includes(
+    "\uFFFD"
+  );
+  const msg = isVue ? `Install @vitejs/plugin-vue to handle .vue files.` : maybeJSX ? isJsx ? `If you use tsconfig.json, make sure to not set jsx to preserve.` : `If you are using JSX, make sure to name the file with the .jsx or .tsx extension.` : `You may need to install appropriate plugins to handle the ${path$n.extname(
+    importer
+  )} file format, or if it's an asset, add "**/*${path$n.extname(
+    importer
+  )}" to \`assetsInclude\` in your configuration.`;
+  return {
+    message: `Failed to parse source for import analysis because the content contains invalid JS syntax. ` + msg,
+    showCodeFrame: !probablyBinary
+  };
+}
+const interopHelper = (m) => m?.__esModule ? m : { ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {}, default: m };
+function interopNamedImports(str, importSpecifier, rewrittenUrl, importIndex, importer, config) {
+  const source = str.original;
+  const {
+    s: start,
+    e: end,
+    ss: expStart,
+    se: expEnd,
+    d: dynamicIndex
+  } = importSpecifier;
+  const exp = source.slice(expStart, expEnd);
+  if (dynamicIndex > -1) {
+    str.overwrite(
+      expStart,
+      expEnd,
+      `import('${rewrittenUrl}').then(m => (${interopHelper.toString()})(m.default))` + getLineBreaks(exp),
+      { contentOnly: true }
+    );
+  } else {
+    const rawUrl = source.slice(start, end);
+    const rewritten = transformCjsImport(
+      exp,
+      rewrittenUrl,
+      rawUrl,
+      importIndex,
+      importer,
+      config
+    );
+    if (rewritten) {
+      str.overwrite(expStart, expEnd, rewritten + getLineBreaks(exp), {
+        contentOnly: true
+      });
+    } else {
+      str.overwrite(
+        start,
+        end,
+        rewrittenUrl + getLineBreaks(source.slice(start, end)),
+        {
+          contentOnly: true
+        }
+      );
+    }
+  }
+}
+function getLineBreaks(str) {
+  return str.includes("\n") ? "\n".repeat(str.split("\n").length - 1) : "";
+}
+function transformCjsImport(importExp, url, rawUrl, importIndex, importer, config) {
+  const node = parseAst(importExp).body[0];
+  if (config.command === "serve" && node.type === "ExportAllDeclaration" && !node.exported) {
+    config.logger.warn(
+      colors$1.yellow(
+        `
+Unable to interop \`${importExp}\` in ${importer}, this may lose module exports. Please export "${rawUrl}" as ESM or use named exports instead, e.g. \`export { A, B } from "${rawUrl}"\``
+      )
+    );
+  } else if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration") {
+    if (!node.specifiers.length) {
+      return `import "${url}"`;
+    }
+    const importNames = [];
+    const exportNames = [];
+    let defaultExports = "";
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier") {
+        const importedName = spec.imported.name;
+        const localName = spec.local.name;
+        importNames.push({ importedName, localName });
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        importNames.push({
+          importedName: "default",
+          localName: spec.local.name
+        });
+      } else if (spec.type === "ImportNamespaceSpecifier") {
+        importNames.push({ importedName: "*", localName: spec.local.name });
+      } else if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") {
+        const importedName = spec.local.name;
+        const exportedName = spec.exported.name;
+        if (exportedName === "default") {
+          defaultExports = makeLegalIdentifier(
+            `__vite__cjsExportDefault_${importIndex}`
+          );
+          importNames.push({ importedName, localName: defaultExports });
+        } else {
+          const localName = makeLegalIdentifier(
+            `__vite__cjsExport_${exportedName}`
+          );
+          importNames.push({ importedName, localName });
+          exportNames.push(`${localName} as ${exportedName}`);
+        }
+      }
+    }
+    const cjsModuleName = makeLegalIdentifier(
+      `__vite__cjsImport${importIndex}_${rawUrl}`
+    );
+    const lines = [`import ${cjsModuleName} from "${url}"`];
+    importNames.forEach(({ importedName, localName }) => {
+      if (importedName === "*") {
+        lines.push(
+          `const ${localName} = (${interopHelper.toString()})(${cjsModuleName})`
+        );
+      } else if (importedName === "default") {
+        lines.push(
+          `const ${localName} = ${cjsModuleName}.__esModule ? ${cjsModuleName}.default : ${cjsModuleName}`
+        );
+      } else {
+        lines.push(`const ${localName} = ${cjsModuleName}["${importedName}"]`);
+      }
+    });
+    if (defaultExports) {
+      lines.push(`export default ${defaultExports}`);
+    }
+    if (exportNames.length) {
+      lines.push(`export { ${exportNames.join(", ")} }`);
+    }
+    return lines.join("; ");
+  }
+}
+function __vite__injectQuery(url, queryToInject) {
+  if (url[0] !== "." && url[0] !== "/") {
+    return url;
+  }
+  const pathname = url.replace(/[?#].*$/, "");
+  const { search, hash } = new URL(url, "http://vitejs.dev");
+  return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
+}
+
+const isModernFlag = `__VITE_IS_MODERN__`;
+const preloadMethod = `__vitePreload`;
+const preloadMarker = `__VITE_PRELOAD__`;
+const preloadHelperId = "\0vite/preload-helper.js";
+const preloadMarkerRE = new RegExp(preloadMarker, "g");
+const dynamicImportPrefixRE = /import\s*\(/;
+const dynamicImportTreeshakenRE = /((?:\bconst\s+|\blet\s+|\bvar\s+|,\s*)(\{[^{}.=]+\})\s*=\s*await\s+import\([^)]+\))|(\(\s*await\s+import\([^)]+\)\s*\)(\??\.[\w$]+))|\bimport\([^)]+\)(\s*\.then\(\s*(?:function\s*)?\(\s*\{([^{}.=]+)\}\))/g;
+function toRelativePath(filename, importer) {
+  const relPath = path$n.posix.relative(path$n.posix.dirname(importer), filename);
+  return relPath[0] === "." ? relPath : `./${relPath}`;
+}
+function indexOfMatchInSlice(str, reg, pos = 0) {
+  reg.lastIndex = pos;
+  const result = reg.exec(str);
+  return result?.index ?? -1;
+}
+function detectScriptRel() {
+  const relList = typeof document !== "undefined" && document.createElement("link").relList;
+  return relList && relList.supports && relList.supports("modulepreload") ? "modulepreload" : "preload";
+}
+function preload(baseModule, deps, importerUrl) {
+  let promise = Promise.resolve();
+  if (__VITE_IS_MODERN__ && deps && deps.length > 0) {
+    const links = document.getElementsByTagName("link");
+    const cspNonceMeta = document.querySelector(
+      "meta[property=csp-nonce]"
+    );
+    const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
+    promise = Promise.allSettled(
+      deps.map((dep) => {
+        dep = assetsURL(dep, importerUrl);
+        if (dep in seen) return;
+        seen[dep] = true;
+        const isCss = dep.endsWith(".css");
+        const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+        const isBaseRelative = !!importerUrl;
+        if (isBaseRelative) {
+          for (let i = links.length - 1; i >= 0; i--) {
+            const link2 = links[i];
+            if (link2.href === dep && (!isCss || link2.rel === "stylesheet")) {
+              return;
+            }
+          }
+        } else if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+          return;
+        }
+        const link = document.createElement("link");
+        link.rel = isCss ? "stylesheet" : scriptRel;
+        if (!isCss) {
+          link.as = "script";
+        }
+        link.crossOrigin = "";
+        link.href = dep;
+        if (cspNonce) {
+          link.setAttribute("nonce", cspNonce);
+        }
+        document.head.appendChild(link);
+        if (isCss) {
+          return new Promise((res, rej) => {
+            link.addEventListener("load", res);
+            link.addEventListener(
+              "error",
+              () => rej(new Error(`Unable to preload CSS for ${dep}`))
+            );
+          });
+        }
+      })
+    );
+  }
+  function handlePreloadError(err) {
+    const e = new Event("vite:preloadError", {
+      cancelable: true
+    });
+    e.payload = err;
+    window.dispatchEvent(e);
+    if (!e.defaultPrevented) {
+      throw err;
+    }
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
+  });
+}
+function buildImportAnalysisPlugin(config) {
+  const ssr = !!config.build.ssr;
+  const isWorker = config.isWorker;
+  const insertPreload = !(ssr || !!config.build.lib || isWorker);
+  const renderBuiltUrl = config.experimental.renderBuiltUrl;
+  const isRelativeBase = config.base === "./" || config.base === "";
+  const { modulePreload } = config.build;
+  const scriptRel2 = modulePreload && modulePreload.polyfill ? `'modulepreload'` : `(${detectScriptRel.toString()})()`;
+  const assetsURL2 = renderBuiltUrl || isRelativeBase ? (
+    // If `experimental.renderBuiltUrl` is used, the dependencies might be relative to the current chunk.
+    // If relative base is used, the dependencies are relative to the current chunk.
+    // The importerUrl is passed as third parameter to __vitePreload in this case
+    `function(dep, importerUrl) { return new URL(dep, importerUrl).href }`
+  ) : (
+    // If the base isn't relative, then the deps are relative to the projects `outDir` and the base
+    // is appended inside __vitePreload too.
+    `function(dep) { return ${JSON.stringify(config.base)}+dep }`
+  );
+  const preloadCode = `const scriptRel = ${scriptRel2};const assetsURL = ${assetsURL2};const seen = {};export const ${preloadMethod} = ${preload.toString()}`;
+  return {
+    name: "vite:build-import-analysis",
+    resolveId(id) {
+      if (id === preloadHelperId) {
+        return id;
+      }
+    },
+    load(id) {
+      if (id === preloadHelperId) {
+        return preloadCode;
+      }
+    },
+    async transform(source, importer) {
+      if (isInNodeModules$1(importer) && !dynamicImportPrefixRE.test(source)) {
+        return;
+      }
+      await init;
+      let imports = [];
+      try {
+        imports = parse$d(source)[0];
+      } catch (_e) {
+        const e = _e;
+        const { message, showCodeFrame } = createParseErrorInfo(
+          importer,
+          source
+        );
+        this.error(message, showCodeFrame ? e.idx : void 0);
+      }
+      if (!imports.length) {
+        return null;
+      }
+      const dynamicImports = {};
+      if (insertPreload) {
+        let match;
+        while (match = dynamicImportTreeshakenRE.exec(source)) {
+          if (match[1]) {
+            dynamicImports[dynamicImportTreeshakenRE.lastIndex] = {
+              declaration: `const ${match[2]}`,
+              names: match[2]?.trim()
+            };
+            continue;
+          }
+          if (match[3]) {
+            let names2 = /\.([^.?]+)/.exec(match[4])?.[1] || "";
+            if (names2 === "default") {
+              names2 = "default: __vite_default__";
+            }
+            dynamicImports[dynamicImportTreeshakenRE.lastIndex - match[4]?.length - 1] = { declaration: `const {${names2}}`, names: `{ ${names2} }` };
+            continue;
+          }
+          const names = match[6]?.trim();
+          dynamicImports[dynamicImportTreeshakenRE.lastIndex - match[5]?.length] = { declaration: `const {${names}}`, names: `{ ${names} }` };
+        }
+      }
+      let s;
+      const str = () => s || (s = new MagicString(source));
+      let needPreloadHelper = false;
+      for (let index = 0; index < imports.length; index++) {
+        const {
+          s: start,
+          e: end,
+          ss: expStart,
+          se: expEnd,
+          d: dynamicIndex,
+          a: attributeIndex
+        } = imports[index];
+        const isDynamicImport = dynamicIndex > -1;
+        if (!isDynamicImport && attributeIndex > -1) {
+          str().remove(end + 1, expEnd);
+        }
+        if (isDynamicImport && insertPreload && // Only preload static urls
+        (source[start] === '"' || source[start] === "'" || source[start] === "`")) {
+          needPreloadHelper = true;
+          const { declaration, names } = dynamicImports[expEnd] || {};
+          if (names) {
+            str().prependLeft(
+              expStart,
+              `${preloadMethod}(async () => { ${declaration} = await `
+            );
+            str().appendRight(expEnd, `;return ${names}}`);
+          } else {
+            str().prependLeft(expStart, `${preloadMethod}(() => `);
+          }
+          str().appendRight(
+            expEnd,
+            `,${isModernFlag}?${preloadMarker}:void 0${renderBuiltUrl || isRelativeBase ? ",import.meta.url" : ""})`
+          );
+        }
+      }
+      if (needPreloadHelper && insertPreload && !source.includes(`const ${preloadMethod} =`)) {
+        str().prepend(`import { ${preloadMethod} } from "${preloadHelperId}";`);
+      }
+      if (s) {
+        return {
+          code: s.toString(),
+          map: config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null
+        };
+      }
+    },
+    renderChunk(code, _, { format }) {
+      if (code.indexOf(isModernFlag) > -1) {
+        const re = new RegExp(isModernFlag, "g");
+        const isModern = String(format === "es");
+        if (config.build.sourcemap) {
+          const s = new MagicString(code);
+          let match;
+          while (match = re.exec(code)) {
+            s.update(match.index, match.index + isModernFlag.length, isModern);
+          }
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: "boundary" })
+          };
+        } else {
+          return code.replace(re, isModern);
+        }
+      }
+      return null;
+    },
+    generateBundle({ format }, bundle) {
+      if (format !== "es") {
+        return;
+      }
+      if (!insertPreload) {
+        const removedPureCssFiles = removedPureCssFilesCache.get(config);
+        if (removedPureCssFiles && removedPureCssFiles.size > 0) {
+          for (const file in bundle) {
+            const chunk = bundle[file];
+            if (chunk.type === "chunk" && chunk.code.includes("import")) {
+              const code = chunk.code;
+              let imports;
+              try {
+                imports = parse$d(code)[0].filter((i) => i.d > -1);
+              } catch (e) {
+                const loc = numberToPos(code, e.idx);
+                this.error({
+                  name: e.name,
+                  message: e.message,
+                  stack: e.stack,
+                  cause: e.cause,
+                  pos: e.idx,
+                  loc: { ...loc, file: chunk.fileName },
+                  frame: generateCodeFrame(code, loc)
+                });
+              }
+              for (const imp of imports) {
+                const {
+                  n: name,
+                  s: start,
+                  e: end,
+                  ss: expStart,
+                  se: expEnd
+                } = imp;
+                let url = name;
+                if (!url) {
+                  const rawUrl = code.slice(start, end);
+                  if (rawUrl[0] === `"` && rawUrl[rawUrl.length - 1] === `"`)
+                    url = rawUrl.slice(1, -1);
+                }
+                if (!url) continue;
+                const normalizedFile = path$n.posix.join(
+                  path$n.posix.dirname(chunk.fileName),
+                  url
+                );
+                if (removedPureCssFiles.has(normalizedFile)) {
+                  chunk.code = chunk.code.slice(0, expStart) + `Promise.resolve({${"".padEnd(expEnd - expStart - 19, " ")}})` + chunk.code.slice(expEnd);
+                }
+              }
+            }
+          }
+        }
+        return;
+      }
+      for (const file in bundle) {
+        const chunk = bundle[file];
+        if (chunk.type === "chunk" && chunk.code.indexOf(preloadMarker) > -1) {
+          const code = chunk.code;
+          let imports;
+          try {
+            imports = parse$d(code)[0].filter((i) => i.d > -1);
+          } catch (e) {
+            const loc = numberToPos(code, e.idx);
+            this.error({
+              name: e.name,
+              message: e.message,
+              stack: e.stack,
+              cause: e.cause,
+              pos: e.idx,
+              loc: { ...loc, file: chunk.fileName },
+              frame: generateCodeFrame(code, loc)
+            });
+          }
+          const s = new MagicString(code);
+          const rewroteMarkerStartPos = /* @__PURE__ */ new Set();
+          const fileDeps = [];
+          const addFileDep = (url, runtime = false) => {
+            const index = fileDeps.findIndex((dep) => dep.url === url);
+            if (index === -1) {
+              return fileDeps.push({ url, runtime }) - 1;
+            } else {
+              return index;
+            }
+          };
+          if (imports.length) {
+            for (let index = 0; index < imports.length; index++) {
+              const {
+                n: name,
+                s: start,
+                e: end,
+                ss: expStart,
+                se: expEnd
+              } = imports[index];
+              let url = name;
+              if (!url) {
+                const rawUrl = code.slice(start, end);
+                if (rawUrl[0] === `"` && rawUrl[rawUrl.length - 1] === `"`)
+                  url = rawUrl.slice(1, -1);
+              }
+              const deps = /* @__PURE__ */ new Set();
+              let hasRemovedPureCssChunk = false;
+              let normalizedFile = void 0;
+              if (url) {
+                normalizedFile = path$n.posix.join(
+                  path$n.posix.dirname(chunk.fileName),
+                  url
+                );
+                const ownerFilename = chunk.fileName;
+                const analyzed = /* @__PURE__ */ new Set();
+                const addDeps = (filename) => {
+                  if (filename === ownerFilename) return;
+                  if (analyzed.has(filename)) return;
+                  analyzed.add(filename);
+                  const chunk2 = bundle[filename];
+                  if (chunk2) {
+                    deps.add(chunk2.fileName);
+                    if (chunk2.type === "chunk") {
+                      chunk2.imports.forEach(addDeps);
+                      chunk2.viteMetadata.importedCss.forEach((file2) => {
+                        deps.add(file2);
+                      });
+                    }
+                  } else {
+                    const removedPureCssFiles = removedPureCssFilesCache.get(config);
+                    const chunk3 = removedPureCssFiles.get(filename);
+                    if (chunk3) {
+                      if (chunk3.viteMetadata.importedCss.size) {
+                        chunk3.viteMetadata.importedCss.forEach((file2) => {
+                          deps.add(file2);
+                        });
+                        hasRemovedPureCssChunk = true;
+                      }
+                      s.update(expStart, expEnd, "Promise.resolve({})");
+                    }
+                  }
+                };
+                addDeps(normalizedFile);
+              }
+              let markerStartPos2 = indexOfMatchInSlice(
+                code,
+                preloadMarkerRE,
+                end
+              );
+              if (markerStartPos2 === -1 && imports.length === 1) {
+                markerStartPos2 = indexOfMatchInSlice(code, preloadMarkerRE);
+              }
+              if (markerStartPos2 > 0) {
+                let depsArray = deps.size > 1 || // main chunk is removed
+                hasRemovedPureCssChunk && deps.size > 0 ? modulePreload === false ? (
+                  // CSS deps use the same mechanism as module preloads, so even if disabled,
+                  // we still need to pass these deps to the preload helper in dynamic imports.
+                  [...deps].filter((d) => d.endsWith(".css"))
+                ) : [...deps] : [];
+                const resolveDependencies = modulePreload ? modulePreload.resolveDependencies : void 0;
+                if (resolveDependencies && normalizedFile) {
+                  const cssDeps = [];
+                  const otherDeps = [];
+                  for (const dep of depsArray) {
+                    (dep.endsWith(".css") ? cssDeps : otherDeps).push(dep);
+                  }
+                  depsArray = [
+                    ...resolveDependencies(normalizedFile, otherDeps, {
+                      hostId: file,
+                      hostType: "js"
+                    }),
+                    ...cssDeps
+                  ];
+                }
+                let renderedDeps;
+                if (renderBuiltUrl) {
+                  renderedDeps = depsArray.map((dep) => {
+                    const replacement = toOutputFilePathInJS(
+                      dep,
+                      "asset",
+                      chunk.fileName,
+                      "js",
+                      config,
+                      toRelativePath
+                    );
+                    if (typeof replacement === "string") {
+                      return addFileDep(replacement);
+                    }
+                    return addFileDep(replacement.runtime, true);
+                  });
+                } else {
+                  renderedDeps = depsArray.map(
+                    (d) => (
+                      // Don't include the assets dir if the default asset file names
+                      // are used, the path will be reconstructed by the import preload helper
+                      isRelativeBase ? addFileDep(toRelativePath(d, file)) : addFileDep(d)
+                    )
+                  );
+                }
+                s.update(
+                  markerStartPos2,
+                  markerStartPos2 + preloadMarker.length,
+                  renderedDeps.length > 0 ? `__vite__mapDeps([${renderedDeps.join(",")}])` : `[]`
+                );
+                rewroteMarkerStartPos.add(markerStartPos2);
+              }
+            }
+          }
+          if (fileDeps.length > 0) {
+            const fileDepsCode = `[${fileDeps.map(
+              (fileDep) => fileDep.runtime ? fileDep.url : JSON.stringify(fileDep.url)
+            ).join(",")}]`;
+            const mapDepsCode = `const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=${fileDepsCode})))=>i.map(i=>d[i]);
+`;
+            if (code.startsWith("#!")) {
+              s.prependLeft(code.indexOf("\n") + 1, mapDepsCode);
+            } else {
+              s.prepend(mapDepsCode);
+            }
+          }
+          let markerStartPos = indexOfMatchInSlice(code, preloadMarkerRE);
+          while (markerStartPos >= 0) {
+            if (!rewroteMarkerStartPos.has(markerStartPos)) {
+              s.update(
+                markerStartPos,
+                markerStartPos + preloadMarker.length,
+                "void 0"
+              );
+            }
+            markerStartPos = indexOfMatchInSlice(
+              code,
+              preloadMarkerRE,
+              markerStartPos + preloadMarker.length
+            );
+          }
+          if (s.hasChanged()) {
+            chunk.code = s.toString();
+            if (config.build.sourcemap && chunk.map) {
+              const nextMap = s.generateMap({
+                source: chunk.fileName,
+                hires: "boundary"
+              });
+              const map = combineSourcemaps(chunk.fileName, [
+                nextMap,
+                chunk.map
+              ]);
+              map.toUrl = () => genSourceMapUrl(map);
+              chunk.map = map;
+              if (config.build.sourcemap === "inline") {
+                chunk.code = chunk.code.replace(
+                  convertSourceMap.mapFileCommentRegex,
+                  ""
+                );
+                chunk.code += `
+//# sourceMappingURL=${genSourceMapUrl(map)}`;
+              } else if (config.build.sourcemap) {
+                const mapAsset = bundle[chunk.fileName + ".map"];
+                if (mapAsset && mapAsset.type === "asset") {
+                  mapAsset.source = map.toString();
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+
+function ssrManifestPlugin(config) {
+  const ssrManifest = {};
+  const base = config.base;
+  return {
+    name: "vite:ssr-manifest",
+    generateBundle(_options, bundle) {
+      for (const file in bundle) {
+        const chunk = bundle[file];
+        if (chunk.type === "chunk") {
+          for (const id in chunk.modules) {
+            const normalizedId = normalizePath$3(relative$2(config.root, id));
+            const mappedChunks = ssrManifest[normalizedId] ?? (ssrManifest[normalizedId] = []);
+            if (!chunk.isEntry) {
+              mappedChunks.push(joinUrlSegments(base, chunk.fileName));
+              chunk.viteMetadata.importedCss.forEach((file2) => {
+                mappedChunks.push(joinUrlSegments(base, file2));
+              });
+            }
+            chunk.viteMetadata.importedAssets.forEach((file2) => {
+              mappedChunks.push(joinUrlSegments(base, file2));
+            });
+          }
+          if (chunk.code.includes(preloadMethod)) {
+            const code = chunk.code;
+            let imports = [];
+            try {
+              imports = parse$d(code)[0].filter((i) => i.n && i.d > -1);
+            } catch (_e) {
+              const e = _e;
+              const loc = numberToPos(code, e.idx);
+              this.error({
+                name: e.name,
+                message: e.message,
+                stack: e.stack,
+                cause: e.cause,
+                pos: e.idx,
+                loc: { ...loc, file: chunk.fileName },
+                frame: generateCodeFrame(code, loc)
+              });
+            }
+            if (imports.length) {
+              for (let index = 0; index < imports.length; index++) {
+                const { s: start, e: end, n: name } = imports[index];
+                const url = code.slice(start, end);
+                const deps = [];
+                const ownerFilename = chunk.fileName;
+                const analyzed = /* @__PURE__ */ new Set();
+                const addDeps = (filename) => {
+                  if (filename === ownerFilename) return;
+                  if (analyzed.has(filename)) return;
+                  analyzed.add(filename);
+                  const chunk2 = bundle[filename];
+                  if (chunk2) {
+                    chunk2.viteMetadata.importedCss.forEach((file2) => {
+                      deps.push(joinUrlSegments(base, file2));
+                    });
+                    chunk2.imports.forEach(addDeps);
+                  }
+                };
+                const normalizedFile = normalizePath$3(
+                  join$2(dirname$2(chunk.fileName), url.slice(1, -1))
+                );
+                addDeps(normalizedFile);
+                ssrManifest[basename$2(name)] = deps;
+              }
+            }
+          }
+        }
+      }
+      this.emitFile({
+        fileName: typeof config.build.ssrManifest === "string" ? config.build.ssrManifest : ".vite/ssr-manifest.json",
+        type: "asset",
+        source: JSON.stringify(sortObjectKeys(ssrManifest), void 0, 2)
+      });
+    }
+  };
+}
+
+function loadFallbackPlugin() {
+  return {
+    name: "vite:load-fallback",
+    async load(id) {
+      try {
+        const cleanedId = cleanUrl(id);
+        const content = await fsp.readFile(cleanedId, "utf-8");
+        this.addWatchFile(cleanedId);
+        return content;
+      } catch (e) {
+        const content = await fsp.readFile(id, "utf-8");
+        this.addWatchFile(id);
+        return content;
+      }
+    }
+  };
+}
+
+function completeSystemWrapPlugin() {
+  const SystemJSWrapRE = /System.register\(.*?(\(exports\)|\(\))/g;
+  return {
+    name: "vite:force-systemjs-wrap-complete",
+    renderChunk(code, chunk, opts) {
+      if (opts.format === "system") {
+        return {
+          code: code.replace(
+            SystemJSWrapRE,
+            (s, s1) => s.replace(s1, "(exports, module)")
+          ),
+          map: null
+        };
+      }
+    }
+  };
+}
+
+function resolveBuildOptions(raw, logger, root) {
+  const deprecatedPolyfillModulePreload = raw?.polyfillModulePreload;
+  if (raw) {
+    const { polyfillModulePreload, ...rest } = raw;
+    raw = rest;
+    if (deprecatedPolyfillModulePreload !== void 0) {
+      logger.warn(
+        "polyfillModulePreload is deprecated. Use modulePreload.polyfill instead."
+      );
+    }
+    if (deprecatedPolyfillModulePreload === false && raw.modulePreload === void 0) {
+      raw.modulePreload = { polyfill: false };
+    }
+  }
+  const modulePreload = raw?.modulePreload;
+  const defaultModulePreload = {
+    polyfill: true
+  };
+  const defaultBuildOptions = {
+    outDir: "dist",
+    assetsDir: "assets",
+    assetsInlineLimit: DEFAULT_ASSETS_INLINE_LIMIT,
+    cssCodeSplit: !raw?.lib,
+    sourcemap: false,
+    rollupOptions: {},
+    minify: raw?.ssr ? false : "esbuild",
+    terserOptions: {},
+    write: true,
+    emptyOutDir: null,
+    copyPublicDir: true,
+    manifest: false,
+    lib: false,
+    ssr: false,
+    ssrManifest: false,
+    ssrEmitAssets: false,
+    reportCompressedSize: true,
+    chunkSizeWarningLimit: 500,
+    watch: null
+  };
+  const userBuildOptions = raw ? mergeConfig(defaultBuildOptions, raw) : defaultBuildOptions;
+  const resolved = {
+    target: "modules",
+    cssTarget: false,
+    ...userBuildOptions,
+    commonjsOptions: {
+      include: [/node_modules/],
+      extensions: [".js", ".cjs"],
+      ...userBuildOptions.commonjsOptions
+    },
+    dynamicImportVarsOptions: {
+      warnOnError: true,
+      exclude: [/node_modules/],
+      ...userBuildOptions.dynamicImportVarsOptions
+    },
+    // Resolve to false | object
+    modulePreload: modulePreload === false ? false : typeof modulePreload === "object" ? {
+      ...defaultModulePreload,
+      ...modulePreload
+    } : defaultModulePreload
+  };
+  if (resolved.target === "modules") {
+    resolved.target = ESBUILD_MODULES_TARGET;
+  } else if (resolved.target === "esnext" && resolved.minify === "terser") {
+    try {
+      const terserPackageJsonPath = requireResolveFromRootWithFallback(
+        root,
+        "terser/package.json"
+      );
+      const terserPackageJson = JSON.parse(
+        fs__default.readFileSync(terserPackageJsonPath, "utf-8")
+      );
+      const v = terserPackageJson.version.split(".");
+      if (v[0] === "5" && v[1] < 16) {
+        resolved.target = "es2021";
+      }
+    } catch {
+    }
+  }
+  if (!resolved.cssTarget) {
+    resolved.cssTarget = resolved.target;
+  }
+  if (resolved.minify === "false") {
+    resolved.minify = false;
+  } else if (resolved.minify === true) {
+    resolved.minify = "esbuild";
+  }
+  if (resolved.cssMinify == null) {
+    resolved.cssMinify = !!resolved.minify;
+  }
+  return resolved;
+}
+async function resolveBuildPlugins(config) {
+  const options = config.build;
+  const { commonjsOptions } = options;
+  const usePluginCommonjs = !Array.isArray(commonjsOptions?.include) || commonjsOptions?.include.length !== 0;
+  const rollupOptionsPlugins = options.rollupOptions.plugins;
+  return {
+    pre: [
+      completeSystemWrapPlugin(),
+      ...usePluginCommonjs ? [commonjs(options.commonjsOptions)] : [],
+      dataURIPlugin(),
+      ...(await asyncFlatten(arraify(rollupOptionsPlugins))).filter(
+        Boolean
+      ),
+      ...config.isWorker ? [webWorkerPostPlugin()] : []
+    ],
+    post: [
+      buildImportAnalysisPlugin(config),
+      ...config.esbuild !== false ? [buildEsbuildPlugin(config)] : [],
+      ...options.minify ? [terserPlugin(config)] : [],
+      ...!config.isWorker ? [
+        ...options.manifest ? [manifestPlugin(config)] : [],
+        ...options.ssrManifest ? [ssrManifestPlugin(config)] : [],
+        buildReporterPlugin(config)
+      ] : [],
+      loadFallbackPlugin()
+    ]
+  };
+}
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(
+    inlineConfig,
+    "build",
+    "production",
+    "production"
+  );
+  const options = config.build;
+  const { root, logger, packageCache } = config;
+  const ssr = !!options.ssr;
+  const libOptions = options.lib;
+  logger.info(
+    colors$1.cyan(
+      `vite v${VERSION} ${colors$1.green(
+        `building ${ssr ? `SSR bundle ` : ``}for ${config.mode}...`
+      )}`
+    )
+  );
+  const resolve = (p) => path$n.resolve(root, p);
+  const input = libOptions ? options.rollupOptions?.input || (typeof libOptions.entry === "string" ? resolve(libOptions.entry) : Array.isArray(libOptions.entry) ? libOptions.entry.map(resolve) : Object.fromEntries(
+    Object.entries(libOptions.entry).map(([alias, file]) => [
+      alias,
+      resolve(file)
+    ])
+  )) : typeof options.ssr === "string" ? resolve(options.ssr) : options.rollupOptions?.input || resolve("index.html");
+  if (ssr && typeof input === "string" && input.endsWith(".html")) {
+    throw new Error(
+      `rollupOptions.input should not be an html file when building for SSR. Please specify a dedicated SSR entry.`
+    );
+  }
+  if (config.build.cssCodeSplit === false) {
+    const inputs = typeof input === "string" ? [input] : Array.isArray(input) ? input : Object.values(input);
+    if (inputs.some((input2) => input2.endsWith(".css"))) {
+      throw new Error(
+        `When "build.cssCodeSplit: false" is set, "rollupOptions.input" should not include CSS files.`
+      );
+    }
+  }
+  const outDir = resolve(options.outDir);
+  const plugins = ssr ? config.plugins.map((p) => injectSsrFlagToHooks(p)) : config.plugins;
+  const rollupOptions = {
+    preserveEntrySignatures: ssr ? "allow-extension" : libOptions ? "strict" : false,
+    cache: config.build.watch ? void 0 : false,
+    ...options.rollupOptions,
+    input,
+    plugins,
+    external: options.rollupOptions?.external,
+    onwarn(warning, warn) {
+      onRollupWarning(warning, warn, config);
+    }
+  };
+  function extractStack(e) {
+    const { stack, name = "Error", message } = e;
+    if (!stack) {
+      return stack;
+    }
+    const expectedPrefix = `${name}: ${message}
+`;
+    if (stack.startsWith(expectedPrefix)) {
+      return stack.slice(expectedPrefix.length);
+    }
+    return stack;
+  }
+  const normalizeCodeFrame = (frame) => {
+    const trimmedPadding = frame.replace(/^\n|\n$/g, "");
+    return `
+${trimmedPadding}
+`;
+  };
+  const enhanceRollupError = (e) => {
+    const stackOnly = extractStack(e);
+    let msg = colors$1.red((e.plugin ? `[${e.plugin}] ` : "") + e.message);
+    if (e.id) {
+      msg += `
+file: ${colors$1.cyan(
+        e.id + (e.loc ? `:${e.loc.line}:${e.loc.column}` : "")
+      )}`;
+    }
+    if (e.frame) {
+      msg += `
+` + colors$1.yellow(normalizeCodeFrame(e.frame));
+    }
+    e.message = msg;
+    if (stackOnly !== void 0) {
+      e.stack = `${e.message}
+${stackOnly}`;
+    }
+  };
+  const outputBuildError = (e) => {
+    enhanceRollupError(e);
+    clearLine();
+    logger.error(e.message, { error: e });
+  };
+  let bundle;
+  let startTime;
+  try {
+    const buildOutputOptions = (output = {}) => {
+      if (output.output) {
+        logger.warn(
+          `You've set "rollupOptions.output.output" in your config. This is deprecated and will override all Vite.js default output options. Please use "rollupOptions.output" instead.`
+        );
+      }
+      if (output.file) {
+        throw new Error(
+          `Vite does not support "rollupOptions.output.file". Please use "rollupOptions.output.dir" and "rollupOptions.output.entryFileNames" instead.`
+        );
+      }
+      if (output.sourcemap) {
+        logger.warnOnce(
+          colors$1.yellow(
+            `Vite does not support "rollupOptions.output.sourcemap". Please use "build.sourcemap" instead.`
+          )
+        );
+      }
+      const ssrNodeBuild = ssr && config.ssr.target === "node";
+      const ssrWorkerBuild = ssr && config.ssr.target === "webworker";
+      const format = output.format || "es";
+      const jsExt = ssrNodeBuild || libOptions ? resolveOutputJsExtension(
+        format,
+        findNearestPackageData(root, packageCache)?.data.type
+      ) : "js";
+      return {
+        dir: outDir,
+        // Default format is 'es' for regular and for SSR builds
+        format,
+        exports: "auto",
+        sourcemap: options.sourcemap,
+        name: libOptions ? libOptions.name : void 0,
+        hoistTransitiveImports: libOptions ? false : void 0,
+        // es2015 enables `generatedCode.symbols`
+        // - #764 add `Symbol.toStringTag` when build es module into cjs chunk
+        // - #1048 add `Symbol.toStringTag` for module default export
+        generatedCode: "es2015",
+        entryFileNames: ssr ? `[name].${jsExt}` : libOptions ? ({ name }) => resolveLibFilename(
+          libOptions,
+          format,
+          name,
+          root,
+          jsExt,
+          packageCache
+        ) : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
+        chunkFileNames: libOptions ? `[name]-[hash].${jsExt}` : path$n.posix.join(options.assetsDir, `[name]-[hash].${jsExt}`),
+        assetFileNames: libOptions ? `[name].[ext]` : path$n.posix.join(options.assetsDir, `[name]-[hash].[ext]`),
+        inlineDynamicImports: output.format === "umd" || output.format === "iife" || ssrWorkerBuild && (typeof input === "string" || Object.keys(input).length === 1),
+        ...output
+      };
+    };
+    const outputs = resolveBuildOutputs(
+      options.rollupOptions?.output,
+      libOptions,
+      logger
+    );
+    const normalizedOutputs = [];
+    if (Array.isArray(outputs)) {
+      for (const resolvedOutput of outputs) {
+        normalizedOutputs.push(buildOutputOptions(resolvedOutput));
+      }
+    } else {
+      normalizedOutputs.push(buildOutputOptions(outputs));
+    }
+    const resolvedOutDirs = getResolvedOutDirs(
+      root,
+      options.outDir,
+      options.rollupOptions?.output
+    );
+    const emptyOutDir = resolveEmptyOutDir(
+      options.emptyOutDir,
+      root,
+      resolvedOutDirs,
+      logger
+    );
+    if (config.build.watch) {
+      logger.info(colors$1.cyan(`
+watching for file changes...`));
+      const resolvedChokidarOptions = resolveChokidarOptions(
+        config.build.watch.chokidar,
+        resolvedOutDirs,
+        emptyOutDir,
+        config.cacheDir
+      );
+      const { watch } = await import('rollup');
+      const watcher = watch({
+        ...rollupOptions,
+        output: normalizedOutputs,
+        watch: {
+          ...config.build.watch,
+          chokidar: resolvedChokidarOptions
+        }
+      });
+      watcher.on("event", (event) => {
+        if (event.code === "BUNDLE_START") {
+          logger.info(colors$1.cyan(`
+build started...`));
+          if (options.write) {
+            prepareOutDir(resolvedOutDirs, emptyOutDir, config);
+          }
+        } else if (event.code === "BUNDLE_END") {
+          event.result.close();
+          logger.info(colors$1.cyan(`built in ${event.duration}ms.`));
+        } else if (event.code === "ERROR") {
+          outputBuildError(event.error);
+        }
+      });
+      return watcher;
+    }
+    const { rollup } = await import('rollup');
+    startTime = Date.now();
+    bundle = await rollup(rollupOptions);
+    if (options.write) {
+      prepareOutDir(resolvedOutDirs, emptyOutDir, config);
+    }
+    const res = [];
+    for (const output of normalizedOutputs) {
+      res.push(await bundle[options.write ? "write" : "generate"](output));
+    }
+    logger.info(
+      `${colors$1.green(`\u2713 built in ${displayTime(Date.now() - startTime)}`)}`
+    );
+    return Array.isArray(outputs) ? res : res[0];
+  } catch (e) {
+    enhanceRollupError(e);
+    clearLine();
+    if (startTime) {
+      logger.error(
+        `${colors$1.red("x")} Build failed in ${displayTime(Date.now() - startTime)}`
+      );
+      startTime = void 0;
+    }
+    throw e;
+  } finally {
+    if (bundle) await bundle.close();
+  }
+}
+function prepareOutDir(outDirs, emptyOutDir, config) {
+  const outDirsArray = [...outDirs];
+  for (const outDir of outDirs) {
+    if (emptyOutDir !== false && fs__default.existsSync(outDir)) {
+      const skipDirs = outDirsArray.map((dir) => {
+        const relative = path$n.relative(outDir, dir);
+        if (relative && !relative.startsWith("..") && !path$n.isAbsolute(relative)) {
+          return relative;
+        }
+        return "";
+      }).filter(Boolean);
+      emptyDir(outDir, [...skipDirs, ".git"]);
+    }
+    if (config.build.copyPublicDir && config.publicDir && fs__default.existsSync(config.publicDir)) {
+      if (!areSeparateFolders(outDir, config.publicDir)) {
+        config.logger.warn(
+          colors$1.yellow(
+            `
+${colors$1.bold(
+              `(!)`
+            )} The public directory feature may not work correctly. outDir ${colors$1.white(
+              colors$1.dim(outDir)
+            )} and publicDir ${colors$1.white(
+              colors$1.dim(config.publicDir)
+            )} are not separate folders.
+`
+          )
+        );
+      }
+      copyDir(config.publicDir, outDir);
+    }
+  }
+}
+function getPkgName(name) {
+  return name?.[0] === "@" ? name.split("/")[1] : name;
+}
+function resolveOutputJsExtension(format, type = "commonjs") {
+  if (type === "module") {
+    return format === "cjs" || format === "umd" ? "cjs" : "js";
+  } else {
+    return format === "es" ? "mjs" : "js";
+  }
+}
+function resolveLibFilename(libOptions, format, entryName, root, extension, packageCache) {
+  if (typeof libOptions.fileName === "function") {
+    return libOptions.fileName(format, entryName);
+  }
+  const packageJson = findNearestPackageData(root, packageCache)?.data;
+  const name = libOptions.fileName || (packageJson && typeof libOptions.entry === "string" ? getPkgName(packageJson.name) : entryName);
+  if (!name)
+    throw new Error(
+      'Name in package.json is required if option "build.lib.fileName" is not provided.'
+    );
+  extension ??= resolveOutputJsExtension(format, packageJson?.type);
+  if (format === "cjs" || format === "es") {
+    return `${name}.${extension}`;
+  }
+  return `${name}.${format}.${extension}`;
+}
+function resolveBuildOutputs(outputs, libOptions, logger) {
+  if (libOptions) {
+    const libHasMultipleEntries = typeof libOptions.entry !== "string" && Object.values(libOptions.entry).length > 1;
+    const libFormats = libOptions.formats || (libHasMultipleEntries ? ["es", "cjs"] : ["es", "umd"]);
+    if (!Array.isArray(outputs)) {
+      if (libFormats.includes("umd") || libFormats.includes("iife")) {
+        if (libHasMultipleEntries) {
+          throw new Error(
+            'Multiple entry points are not supported when output formats include "umd" or "iife".'
+          );
+        }
+        if (!libOptions.name) {
+          throw new Error(
+            'Option "build.lib.name" is required when output formats include "umd" or "iife".'
+          );
+        }
+      }
+      return libFormats.map((format) => ({ ...outputs, format }));
+    }
+    if (libOptions.formats) {
+      logger.warn(
+        colors$1.yellow(
+          '"build.lib.formats" will be ignored because "build.rollupOptions.output" is already an array format.'
+        )
+      );
+    }
+    outputs.forEach((output) => {
+      if ((output.format === "umd" || output.format === "iife") && !output.name) {
+        throw new Error(
+          'Entries in "build.rollupOptions.output" must specify "name" when the format is "umd" or "iife".'
+        );
+      }
+    });
+  }
+  return outputs;
+}
+const warningIgnoreList = [`CIRCULAR_DEPENDENCY`, `THIS_IS_UNDEFINED`];
+const dynamicImportWarningIgnoreList = [
+  `Unsupported expression`,
+  `statically analyzed`
+];
+function clearLine() {
+  const tty = process.stdout.isTTY && !process.env.CI;
+  if (tty) {
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+  }
+}
+function onRollupWarning(warning, warn, config) {
+  const viteWarn = (warnLog) => {
+    let warning2;
+    if (typeof warnLog === "function") {
+      warning2 = warnLog();
+    } else {
+      warning2 = warnLog;
+    }
+    if (typeof warning2 === "object") {
+      if (warning2.code === "UNRESOLVED_IMPORT") {
+        const id = warning2.id;
+        const exporter = warning2.exporter;
+        if (!id || !id.endsWith("?commonjs-external")) {
+          throw new Error(
+            `[vite]: Rollup failed to resolve import "${exporter}" from "${id}".
+This is most likely unintended because it can break your application at runtime.
+If you do want to externalize this module explicitly add it to
+\`build.rollupOptions.external\``
+          );
+        }
+      }
+      if (warning2.plugin === "rollup-plugin-dynamic-import-variables" && dynamicImportWarningIgnoreList.some(
+        (msg) => warning2.message.includes(msg)
+      )) {
+        return;
+      }
+      if (warningIgnoreList.includes(warning2.code)) {
+        return;
+      }
+      if (warning2.code === "PLUGIN_WARNING") {
+        config.logger.warn(
+          `${colors$1.bold(
+            colors$1.yellow(`[plugin:${warning2.plugin}]`)
+          )} ${colors$1.yellow(warning2.message)}`
+        );
+        return;
+      }
+    }
+    warn(warnLog);
+  };
+  clearLine();
+  const userOnWarn = config.build.rollupOptions?.onwarn;
+  if (userOnWarn) {
+    userOnWarn(warning, viteWarn);
+  } else {
+    viteWarn(warning);
+  }
+}
+function resolveUserExternal(user, id, parentId, isResolved) {
+  if (typeof user === "function") {
+    return user(id, parentId, isResolved);
+  } else if (Array.isArray(user)) {
+    return user.some((test) => isExternal(id, test));
+  } else {
+    return isExternal(id, user);
+  }
+}
+function isExternal(id, test) {
+  if (typeof test === "string") {
+    return id === test;
+  } else {
+    return test.test(id);
+  }
+}
+function injectSsrFlagToHooks(plugin) {
+  const { resolveId, load, transform } = plugin;
+  return {
+    ...plugin,
+    resolveId: wrapSsrResolveId(resolveId),
+    load: wrapSsrLoad(load),
+    transform: wrapSsrTransform(transform)
+  };
+}
+function wrapSsrResolveId(hook) {
+  if (!hook) return;
+  const fn = getHookHandler(hook);
+  const handler = function(id, importer, options) {
+    return fn.call(this, id, importer, injectSsrFlag(options));
+  };
+  if ("handler" in hook) {
+    return {
+      ...hook,
+      handler
+    };
+  } else {
+    return handler;
+  }
+}
+function wrapSsrLoad(hook) {
+  if (!hook) return;
+  const fn = getHookHandler(hook);
+  const handler = function(id, ...args) {
+    return fn.call(this, id, injectSsrFlag(args[0]));
+  };
+  if ("handler" in hook) {
+    return {
+      ...hook,
+      handler
+    };
+  } else {
+    return handler;
+  }
+}
+function wrapSsrTransform(hook) {
+  if (!hook) return;
+  const fn = getHookHandler(hook);
+  const handler = function(code, importer, ...args) {
+    return fn.call(this, code, importer, injectSsrFlag(args[0]));
+  };
+  if ("handler" in hook) {
+    return {
+      ...hook,
+      handler
+    };
+  } else {
+    return handler;
+  }
+}
+function injectSsrFlag(options) {
+  return { ...options ?? {}, ssr: true };
+}
+const needsEscapeRegEx = /[\n\r'\\\u2028\u2029]/;
+const quoteNewlineRegEx = /([\n\r'\u2028\u2029])/g;
+const backSlashRegEx = /\\/g;
+function escapeId(id) {
+  if (!needsEscapeRegEx.test(id)) return id;
+  return id.replace(backSlashRegEx, "\\\\").replace(quoteNewlineRegEx, "\\$1");
+}
+const getResolveUrl = (path2, URL = "URL") => `new ${URL}(${path2}).href`;
+const getRelativeUrlFromDocument = (relativePath, umd = false) => getResolveUrl(
+  `'${escapeId(partialEncodeURIPath(relativePath))}', ${umd ? `typeof document === 'undefined' ? location.href : ` : ""}document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT' && document.currentScript.src || document.baseURI`
+);
+const getFileUrlFromFullPath = (path2) => `require('u' + 'rl').pathToFileURL(${path2}).href`;
+const getFileUrlFromRelativePath = (path2) => getFileUrlFromFullPath(`__dirname + '/${escapeId(path2)}'`);
+const relativeUrlMechanisms = {
+  amd: (relativePath) => {
+    if (relativePath[0] !== ".") relativePath = "./" + relativePath;
+    return getResolveUrl(
+      `require.toUrl('${escapeId(relativePath)}'), document.baseURI`
+    );
+  },
+  cjs: (relativePath) => `(typeof document === 'undefined' ? ${getFileUrlFromRelativePath(
+    relativePath
+  )} : ${getRelativeUrlFromDocument(relativePath)})`,
+  es: (relativePath) => getResolveUrl(
+    `'${escapeId(partialEncodeURIPath(relativePath))}', import.meta.url`
+  ),
+  iife: (relativePath) => getRelativeUrlFromDocument(relativePath),
+  // NOTE: make sure rollup generate `module` params
+  system: (relativePath) => getResolveUrl(
+    `'${escapeId(partialEncodeURIPath(relativePath))}', module.meta.url`
+  ),
+  umd: (relativePath) => `(typeof document === 'undefined' && typeof location === 'undefined' ? ${getFileUrlFromRelativePath(
+    relativePath
+  )} : ${getRelativeUrlFromDocument(relativePath, true)})`
+};
+const customRelativeUrlMechanisms = {
+  ...relativeUrlMechanisms,
+  "worker-iife": (relativePath) => getResolveUrl(
+    `'${escapeId(partialEncodeURIPath(relativePath))}', self.location.href`
+  )
+};
+function toOutputFilePathInJS(filename, type, hostId, hostType, config, toRelative) {
+  const { renderBuiltUrl } = config.experimental;
+  let relative = config.base === "" || config.base === "./";
+  if (renderBuiltUrl) {
+    const result = renderBuiltUrl(filename, {
+      hostId,
+      hostType,
+      type,
+      ssr: !!config.build.ssr
+    });
+    if (typeof result === "object") {
+      if (result.runtime) {
+        return { runtime: result.runtime };
+      }
+      if (typeof result.relative === "boolean") {
+        relative = result.relative;
+      }
+    } else if (result) {
+      return result;
+    }
+  }
+  if (relative && !config.build.ssr) {
+    return toRelative(filename, hostId);
+  }
+  return joinUrlSegments(config.decodedBase, filename);
+}
+function createToImportMetaURLBasedRelativeRuntime(format, isWorker) {
+  const formatLong = isWorker && format === "iife" ? "worker-iife" : format;
+  const toRelativePath = customRelativeUrlMechanisms[formatLong];
+  return (filename, importer) => ({
+    runtime: toRelativePath(
+      path$n.posix.relative(path$n.dirname(importer), filename)
+    )
+  });
+}
+function toOutputFilePathWithoutRuntime(filename, type, hostId, hostType, config, toRelative) {
+  const { renderBuiltUrl } = config.experimental;
+  let relative = config.base === "" || config.base === "./";
+  if (renderBuiltUrl) {
+    const result = renderBuiltUrl(filename, {
+      hostId,
+      hostType,
+      type,
+      ssr: !!config.build.ssr
+    });
+    if (typeof result === "object") {
+      if (result.runtime) {
+        throw new Error(
+          `{ runtime: "${result.runtime}" } is not supported for assets in ${hostType} files: ${filename}`
+        );
+      }
+      if (typeof result.relative === "boolean") {
+        relative = result.relative;
+      }
+    } else if (result) {
+      return result;
+    }
+  }
+  if (relative && !config.build.ssr) {
+    return toRelative(filename, hostId);
+  } else {
+    return joinUrlSegments(config.decodedBase, filename);
+  }
+}
+const toOutputFilePathInCss = toOutputFilePathWithoutRuntime;
+const toOutputFilePathInHtml = toOutputFilePathWithoutRuntime;
+function areSeparateFolders(a, b) {
+  const na = normalizePath$3(a);
+  const nb = normalizePath$3(b);
+  return na !== nb && !na.startsWith(withTrailingSlash(nb)) && !nb.startsWith(withTrailingSlash(na));
+}
+
+var build$1 = {
+	__proto__: null,
+	build: build,
+	createToImportMetaURLBasedRelativeRuntime: createToImportMetaURLBasedRelativeRuntime,
+	onRollupWarning: onRollupWarning,
+	resolveBuildOptions: resolveBuildOptions,
+	resolveBuildOutputs: resolveBuildOutputs,
+	resolveBuildPlugins: resolveBuildPlugins,
+	resolveLibFilename: resolveLibFilename,
+	resolveUserExternal: resolveUserExternal,
+	toOutputFilePathInCss: toOutputFilePathInCss,
+	toOutputFilePathInHtml: toOutputFilePathInHtml,
+	toOutputFilePathInJS: toOutputFilePathInJS,
+	toOutputFilePathWithoutRuntime: toOutputFilePathWithoutRuntime
+};
+
+// NOTE: supports Node 6.x
+
+
+const NOOP = () => {};
+const MIMES = /text|javascript|\/json|xml/i;
+
+/**
+ * @param {any} chunk
+ * @param {BufferEncoding} enc
+ * @returns {number}
+ */
+function getChunkSize(chunk, enc) {
+	return chunk ? Buffer.byteLength(chunk, enc) : 0;
+}
+
+/**
+ * @param {import('./index.d.mts').Options} [options]
+ * @returns {import('./index.d.mts').Middleware}
+ */
+function compression ({ threshold = 1024, level = -1, brotli = false, gzip = true, mimes = MIMES } = {}) {
+	const brotliOpts = (typeof brotli === 'object' && brotli) || {};
+	const gzipOpts = (typeof gzip === 'object' && gzip) || {};
+
+	// disable Brotli on Node<12.7 where it is unsupported:
+	if (!zlib$1.createBrotliCompress) brotli = false;
+
+	return (req, res, next = NOOP) => {
+		const accept = req.headers['accept-encoding'] + '';
+		const encoding = ((brotli && accept.match(/\bbr\b/)) || (gzip && accept.match(/\bgzip\b/)) || [])[0];
+
+		// skip if no response body or no supported encoding:
+		if (req.method === 'HEAD' || !encoding) return next();
+
+		/** @type {zlib.Gzip | zlib.BrotliCompress} */
+		let compress;
+		/** @type {Array<[string, function]>?} */
+		let pendingListeners = [];
+		let pendingStatus = 0;
+		let started = false;
+		let size = 0;
+
+		function start() {
+			started = true;
+			// @ts-ignore
+			size = res.getHeader('Content-Length') | 0 || size;
+			const compressible = mimes.test(
+				String(res.getHeader('Content-Type') || 'text/plain')
+			);
+			const cleartext = !res.getHeader('Content-Encoding');
+			const listeners = pendingListeners || [];
+
+			if (compressible && cleartext && size >= threshold) {
+				res.setHeader('Content-Encoding', encoding);
+				res.removeHeader('Content-Length');
+				if (encoding === 'br') {
+					compress = zlib$1.createBrotliCompress({
+						params: Object.assign({
+							[zlib$1.constants.BROTLI_PARAM_QUALITY]: level,
+							[zlib$1.constants.BROTLI_PARAM_SIZE_HINT]: size,
+						}, brotliOpts)
+					});
+				} else {
+					compress = zlib$1.createGzip(
+						Object.assign({ level }, gzipOpts)
+					);
+				}
+				// backpressure
+				compress.on('data', chunk => write.call(res, chunk) || compress.pause());
+				on.call(res, 'drain', () => compress.resume());
+				compress.on('end', () => end.call(res));
+				listeners.forEach(p => compress.on.apply(compress, p));
+			} else {
+				pendingListeners = null;
+				listeners.forEach(p => on.apply(res, p));
+			}
+
+			writeHead.call(res, pendingStatus || res.statusCode);
+		}
+
+		const { end, write, on, writeHead } = res;
+
+		res.writeHead = function (status, reason, headers) {
+			if (typeof reason !== 'string') [headers, reason] = [reason, headers];
+			if (headers) for (let k in headers) res.setHeader(k, headers[k]);
+			pendingStatus = status;
+			return this;
+		};
+
+		res.write = function (chunk, enc) {
+			size += getChunkSize(chunk, enc);
+			if (!started) start();
+			if (!compress) return write.apply(this, arguments);
+			return compress.write.apply(compress, arguments);
+		};
+
+		res.end = function (chunk, enc) {
+			if (arguments.length > 0 && typeof chunk !== 'function') {
+				size += getChunkSize(chunk, enc);
+			}
+			if (!started) start();
+			if (!compress) return end.apply(this, arguments);
+			return compress.end.apply(compress, arguments);
+		};
+
+		res.on = function (type, listener) {
+			if (!pendingListeners) on.call(this, type, listener);
+			else if (compress) compress.on(type, listener);
+			else pendingListeners.push([type, listener]);
+			return this;
+		};
+
+		next();
+	};
+}
+
+function resolvePreviewOptions(preview2, server) {
+  return {
+    port: preview2?.port,
+    strictPort: preview2?.strictPort ?? server.strictPort,
+    host: preview2?.host ?? server.host,
+    https: preview2?.https ?? server.https,
+    open: preview2?.open ?? server.open,
+    proxy: preview2?.proxy ?? server.proxy,
+    cors: preview2?.cors ?? server.cors,
+    headers: preview2?.headers ?? server.headers
+  };
+}
+async function preview(inlineConfig = {}) {
+  const config = await resolveConfig(
+    inlineConfig,
+    "serve",
+    "production",
+    "production",
+    true
+  );
+  const distDir = path$n.resolve(config.root, config.build.outDir);
+  if (!fs__default.existsSync(distDir) && // error if no plugins implement `configurePreviewServer`
+  config.plugins.every((plugin) => !plugin.configurePreviewServer) && // error if called in CLI only. programmatic usage could access `httpServer`
+  // and affect file serving
+  process.argv[1]?.endsWith(path$n.normalize("bin/vite.js")) && process.argv[2] === "preview") {
+    throw new Error(
+      `The directory "${config.build.outDir}" does not exist. Did you build your project?`
+    );
+  }
+  const app = connect$1();
+  const httpServer = await resolveHttpServer(
+    config.preview,
+    app,
+    await resolveHttpsConfig(config.preview?.https)
+  );
+  setClientErrorHandler(httpServer, config.logger);
+  const options = config.preview;
+  const logger = config.logger;
+  const closeHttpServer = createServerCloseFn(httpServer);
+  const server = {
+    config,
+    middlewares: app,
+    httpServer,
+    async close() {
+      teardownSIGTERMListener(closeServerAndExit);
+      await closeHttpServer();
+    },
+    resolvedUrls: null,
+    printUrls() {
+      if (server.resolvedUrls) {
+        printServerUrls(server.resolvedUrls, options.host, logger.info);
+      } else {
+        throw new Error("cannot print server URLs before server is listening.");
+      }
+    },
+    bindCLIShortcuts(options2) {
+      bindCLIShortcuts(server, options2);
+    }
+  };
+  const closeServerAndExit = async () => {
+    try {
+      await server.close();
+    } finally {
+      process.exit();
+    }
+  };
+  setupSIGTERMListener(closeServerAndExit);
+  const postHooks = [];
+  for (const hook of config.getSortedPluginHooks("configurePreviewServer")) {
+    postHooks.push(await hook(server));
+  }
+  const { cors } = config.preview;
+  if (cors !== false) {
+    app.use(corsMiddleware(typeof cors === "boolean" ? {} : cors));
+  }
+  const { proxy } = config.preview;
+  if (proxy) {
+    app.use(proxyMiddleware(httpServer, proxy, config));
+  }
+  app.use(compression());
+  if (config.base !== "/") {
+    app.use(baseMiddleware(config.rawBase, false));
+  }
+  const headers = config.preview.headers;
+  const viteAssetMiddleware = (...args) => sirv(distDir, {
+    etag: true,
+    dev: true,
+    extensions: [],
+    ignores: false,
+    setHeaders(res) {
+      if (headers) {
+        for (const name in headers) {
+          res.setHeader(name, headers[name]);
+        }
+      }
+    },
+    shouldServe(filePath) {
+      return shouldServeFile(filePath, distDir);
+    }
+  })(...args);
+  app.use(viteAssetMiddleware);
+  if (config.appType === "spa" || config.appType === "mpa") {
+    app.use(htmlFallbackMiddleware(distDir, config.appType === "spa"));
+  }
+  postHooks.forEach((fn) => fn && fn());
+  if (config.appType === "spa" || config.appType === "mpa") {
+    app.use(indexHtmlMiddleware(distDir, server));
+    app.use(notFoundMiddleware());
+  }
+  const hostname = await resolveHostname(options.host);
+  const port = options.port ?? DEFAULT_PREVIEW_PORT;
+  await httpServerStart(httpServer, {
+    port,
+    strictPort: options.strictPort,
+    host: hostname.host,
+    logger
+  });
+  server.resolvedUrls = await resolveServerUrls(
+    httpServer,
+    config.preview,
+    config
+  );
+  if (options.open) {
+    const url = server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
+    if (url) {
+      const path2 = typeof options.open === "string" ? new URL(options.open, url).href : url;
+      openBrowser(path2, true, logger);
+    }
+  }
+  return server;
+}
+
+var preview$1 = {
+	__proto__: null,
+	preview: preview,
+	resolvePreviewOptions: resolvePreviewOptions
+};
+
+function resolveSSROptions(ssr, preserveSymlinks) {
+  ssr ??= {};
+  const optimizeDeps = ssr.optimizeDeps ?? {};
+  const target = "node";
+  return {
+    target,
+    ...ssr,
+    optimizeDeps: {
+      ...optimizeDeps,
+      noDiscovery: true,
+      // always true for ssr
+      esbuildOptions: {
+        preserveSymlinks,
+        ...optimizeDeps.esbuildOptions
+      }
+    }
+  };
+}
+
+const debug = createDebugger("vite:config");
+const promisifiedRealpath = promisify$4(fs__default.realpath);
+function defineConfig(config) {
+  return config;
+}
+function checkBadCharactersInPath(path2, logger) {
+  const badChars = [];
+  if (path2.includes("#")) {
+    badChars.push("#");
+  }
+  if (path2.includes("?")) {
+    badChars.push("?");
+  }
+  if (badChars.length > 0) {
+    const charString = badChars.map((c) => `"${c}"`).join(" and ");
+    const inflectedChars = badChars.length > 1 ? "characters" : "character";
+    logger.warn(
+      colors$1.yellow(
+        `The project root contains the ${charString} ${inflectedChars} (${colors$1.cyan(
+          path2
+        )}), which may not work when running Vite. Consider renaming the directory to remove the characters.`
+      )
+    );
+  }
+}
+async function resolveConfig(inlineConfig, command, defaultMode = "development", defaultNodeEnv = "development", isPreview = false) {
+  let config = inlineConfig;
+  let configFileDependencies = [];
+  let mode = inlineConfig.mode || defaultMode;
+  const isNodeEnvSet = !!process.env.NODE_ENV;
+  const packageCache = /* @__PURE__ */ new Map();
+  if (!isNodeEnvSet) {
+    process.env.NODE_ENV = defaultNodeEnv;
+  }
+  const configEnv = {
+    mode,
+    command,
+    isSsrBuild: command === "build" && !!config.build?.ssr,
+    isPreview
+  };
+  let { configFile } = config;
+  if (configFile !== false) {
+    const loadResult = await loadConfigFromFile(
+      configEnv,
+      configFile,
+      config.root,
+      config.logLevel,
+      config.customLogger
+    );
+    if (loadResult) {
+      config = mergeConfig(loadResult.config, config);
+      configFile = loadResult.path;
+      configFileDependencies = loadResult.dependencies;
+    }
+  }
+  mode = inlineConfig.mode || config.mode || mode;
+  configEnv.mode = mode;
+  const filterPlugin = (p) => {
+    if (!p) {
+      return false;
+    } else if (!p.apply) {
+      return true;
+    } else if (typeof p.apply === "function") {
+      return p.apply({ ...config, mode }, configEnv);
+    } else {
+      return p.apply === command;
+    }
+  };
+  const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter(filterPlugin);
+  const [prePlugins, normalPlugins, postPlugins] = sortUserPlugins(rawUserPlugins);
+  const userPlugins = [...prePlugins, ...normalPlugins, ...postPlugins];
+  config = await runConfigHook(config, userPlugins, configEnv);
+  const logger = createLogger(config.logLevel, {
+    allowClearScreen: config.clearScreen,
+    customLogger: config.customLogger
+  });
+  const resolvedRoot = normalizePath$3(
+    config.root ? path$n.resolve(config.root) : process.cwd()
+  );
+  checkBadCharactersInPath(resolvedRoot, logger);
+  const clientAlias = [
+    {
+      find: /^\/?@vite\/env/,
+      replacement: path$n.posix.join(FS_PREFIX, normalizePath$3(ENV_ENTRY))
+    },
+    {
+      find: /^\/?@vite\/client/,
+      replacement: path$n.posix.join(FS_PREFIX, normalizePath$3(CLIENT_ENTRY))
+    }
+  ];
+  const resolvedAlias = normalizeAlias(
+    mergeAlias(clientAlias, config.resolve?.alias || [])
+  );
+  const resolveOptions = {
+    mainFields: config.resolve?.mainFields ?? DEFAULT_MAIN_FIELDS,
+    conditions: config.resolve?.conditions ?? [],
+    extensions: config.resolve?.extensions ?? DEFAULT_EXTENSIONS,
+    dedupe: config.resolve?.dedupe ?? [],
+    preserveSymlinks: config.resolve?.preserveSymlinks ?? false,
+    alias: resolvedAlias
+  };
+  if (
+    // @ts-expect-error removed field
+    config.resolve?.browserField === false && resolveOptions.mainFields.includes("browser")
+  ) {
+    logger.warn(
+      colors$1.yellow(
+        `\`resolve.browserField\` is set to false, but the option is removed in favour of the 'browser' string in \`resolve.mainFields\`. You may want to update \`resolve.mainFields\` to remove the 'browser' string and preserve the previous browser behaviour.`
+      )
+    );
+  }
+  const envDir = config.envDir ? normalizePath$3(path$n.resolve(resolvedRoot, config.envDir)) : resolvedRoot;
+  const userEnv = inlineConfig.envFile !== false && loadEnv(mode, envDir, resolveEnvPrefix(config));
+  const userNodeEnv = process.env.VITE_USER_NODE_ENV;
+  if (!isNodeEnvSet && userNodeEnv) {
+    if (userNodeEnv === "development") {
+      process.env.NODE_ENV = "development";
+    } else {
+      logger.warn(
+        `NODE_ENV=${userNodeEnv} is not supported in the .env file. Only NODE_ENV=development is supported to create a development build of your project. If you need to set process.env.NODE_ENV, you can set it in the Vite config instead.`
+      );
+    }
+  }
+  const isProduction = process.env.NODE_ENV === "production";
+  const isBuild = command === "build";
+  const relativeBaseShortcut = config.base === "" || config.base === "./";
+  const resolvedBase = relativeBaseShortcut ? !isBuild || config.build?.ssr ? "/" : "./" : resolveBaseUrl(config.base, isBuild, logger) ?? "/";
+  const resolvedBuildOptions = resolveBuildOptions(
+    config.build,
+    logger,
+    resolvedRoot
+  );
+  const pkgDir = findNearestPackageData(resolvedRoot, packageCache)?.dir;
+  const cacheDir = normalizePath$3(
+    config.cacheDir ? path$n.resolve(resolvedRoot, config.cacheDir) : pkgDir ? path$n.join(pkgDir, `node_modules/.vite`) : path$n.join(resolvedRoot, `.vite`)
+  );
+  const assetsFilter = config.assetsInclude && (!Array.isArray(config.assetsInclude) || config.assetsInclude.length) ? createFilter(config.assetsInclude) : () => false;
+  const createResolver = (options) => {
+    let aliasContainer;
+    let resolverContainer;
+    return async (id, importer, aliasOnly, ssr2) => {
+      let container;
+      if (aliasOnly) {
+        container = aliasContainer || (aliasContainer = await createPluginContainer({
+          ...resolved,
+          plugins: [alias$1({ entries: resolved.resolve.alias })]
+        }));
+      } else {
+        container = resolverContainer || (resolverContainer = await createPluginContainer({
+          ...resolved,
+          plugins: [
+            alias$1({ entries: resolved.resolve.alias }),
+            resolvePlugin({
+              ...resolved.resolve,
+              root: resolvedRoot,
+              isProduction,
+              isBuild: command === "build",
+              ssrConfig: resolved.ssr,
+              asSrc: true,
+              preferRelative: false,
+              tryIndex: true,
+              ...options,
+              idOnly: true,
+              fsUtils: getFsUtils(resolved)
+            })
+          ]
+        }));
+      }
+      return (await container.resolveId(id, importer, {
+        ssr: ssr2,
+        scan: options?.scan
+      }))?.id;
+    };
+  };
+  const { publicDir } = config;
+  const resolvedPublicDir = publicDir !== false && publicDir !== "" ? normalizePath$3(
+    path$n.resolve(
+      resolvedRoot,
+      typeof publicDir === "string" ? publicDir : "public"
+    )
+  ) : "";
+  const server = resolveServerOptions(resolvedRoot, config.server, logger);
+  const ssr = resolveSSROptions(config.ssr, resolveOptions.preserveSymlinks);
+  const optimizeDeps = config.optimizeDeps || {};
+  const BASE_URL = resolvedBase;
+  let resolved;
+  let createUserWorkerPlugins = config.worker?.plugins;
+  if (Array.isArray(createUserWorkerPlugins)) {
+    createUserWorkerPlugins = () => config.worker?.plugins;
+    logger.warn(
+      colors$1.yellow(
+        `worker.plugins is now a function that returns an array of plugins. Please update your Vite config accordingly.
+`
+      )
+    );
+  }
+  const createWorkerPlugins = async function(bundleChain) {
+    const rawWorkerUserPlugins = (await asyncFlatten(createUserWorkerPlugins?.() || [])).filter(filterPlugin);
+    let workerConfig = mergeConfig({}, config);
+    const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(rawWorkerUserPlugins);
+    const workerUserPlugins = [
+      ...workerPrePlugins,
+      ...workerNormalPlugins,
+      ...workerPostPlugins
+    ];
+    workerConfig = await runConfigHook(
+      workerConfig,
+      workerUserPlugins,
+      configEnv
+    );
+    const workerResolved = {
+      ...workerConfig,
+      ...resolved,
+      isWorker: true,
+      mainConfig: resolved,
+      bundleChain
+    };
+    const resolvedWorkerPlugins = await resolvePlugins(
+      workerResolved,
+      workerPrePlugins,
+      workerNormalPlugins,
+      workerPostPlugins
+    );
+    await Promise.all(
+      createPluginHookUtils(resolvedWorkerPlugins).getSortedPluginHooks("configResolved").map((hook) => hook(workerResolved))
+    );
+    return resolvedWorkerPlugins;
+  };
+  const resolvedWorkerOptions = {
+    format: config.worker?.format || "iife",
+    plugins: createWorkerPlugins,
+    rollupOptions: config.worker?.rollupOptions || {}
+  };
+  const base = withTrailingSlash(resolvedBase);
+  resolved = {
+    configFile: configFile ? normalizePath$3(configFile) : void 0,
+    configFileDependencies: configFileDependencies.map(
+      (name) => normalizePath$3(path$n.resolve(name))
+    ),
+    inlineConfig,
+    root: resolvedRoot,
+    base,
+    decodedBase: decodeURI(base),
+    rawBase: resolvedBase,
+    resolve: resolveOptions,
+    publicDir: resolvedPublicDir,
+    cacheDir,
+    command,
+    mode,
+    ssr,
+    isWorker: false,
+    mainConfig: null,
+    bundleChain: [],
+    isProduction,
+    plugins: userPlugins,
+    css: resolveCSSOptions(config.css),
+    esbuild: config.esbuild === false ? false : {
+      jsxDev: !isProduction,
+      ...config.esbuild
+    },
+    server,
+    build: resolvedBuildOptions,
+    preview: resolvePreviewOptions(config.preview, server),
+    envDir,
+    env: {
+      ...userEnv,
+      BASE_URL,
+      MODE: mode,
+      DEV: !isProduction,
+      PROD: isProduction
+    },
+    assetsInclude(file) {
+      return DEFAULT_ASSETS_RE.test(file) || assetsFilter(file);
+    },
+    logger,
+    packageCache,
+    createResolver,
+    optimizeDeps: {
+      holdUntilCrawlEnd: true,
+      ...optimizeDeps,
+      esbuildOptions: {
+        preserveSymlinks: resolveOptions.preserveSymlinks,
+        ...optimizeDeps.esbuildOptions
+      }
+    },
+    worker: resolvedWorkerOptions,
+    appType: config.appType ?? "spa",
+    experimental: {
+      importGlobRestoreExtension: false,
+      hmrPartialAccept: false,
+      ...config.experimental
+    },
+    getSortedPlugins: void 0,
+    getSortedPluginHooks: void 0
+  };
+  resolved = {
+    ...config,
+    ...resolved
+  };
+  resolved.plugins = await resolvePlugins(
+    resolved,
+    prePlugins,
+    normalPlugins,
+    postPlugins
+  );
+  Object.assign(resolved, createPluginHookUtils(resolved.plugins));
+  await Promise.all(
+    resolved.getSortedPluginHooks("configResolved").map((hook) => hook(resolved))
+  );
+  optimizeDepsDisabledBackwardCompatibility(resolved, resolved.optimizeDeps);
+  optimizeDepsDisabledBackwardCompatibility(
+    resolved,
+    resolved.ssr.optimizeDeps,
+    "ssr."
+  );
+  debug?.(`using resolved config: %O`, {
+    ...resolved,
+    plugins: resolved.plugins.map((p) => p.name),
+    worker: {
+      ...resolved.worker,
+      plugins: `() => plugins`
+    }
+  });
+  if (config.build?.terserOptions && config.build.minify && config.build.minify !== "terser") {
+    logger.warn(
+      colors$1.yellow(
+        `build.terserOptions is specified but build.minify is not set to use Terser. Note Vite now defaults to use esbuild for minification. If you still prefer Terser, set build.minify to "terser".`
+      )
+    );
+  }
+  const outputOption = config.build?.rollupOptions?.output ?? [];
+  if (Array.isArray(outputOption)) {
+    const assetFileNamesList = outputOption.map(
+      (output) => output.assetFileNames
+    );
+    if (assetFileNamesList.length > 1) {
+      const firstAssetFileNames = assetFileNamesList[0];
+      const hasDifferentReference = assetFileNamesList.some(
+        (assetFileNames) => assetFileNames !== firstAssetFileNames
+      );
+      if (hasDifferentReference) {
+        resolved.logger.warn(
+          colors$1.yellow(`
+assetFileNames isn't equal for every build.rollupOptions.output. A single pattern across all outputs is supported by Vite.
+`)
+        );
+      }
+    }
+  }
+  if (
+    // @ts-expect-error Option removed
+    config.legacy?.buildSsrCjsExternalHeuristics || // @ts-expect-error Option removed
+    config.ssr?.format === "cjs"
+  ) {
+    resolved.logger.warn(
+      colors$1.yellow(`
+(!) Experimental legacy.buildSsrCjsExternalHeuristics and ssr.format were be removed in Vite 5.
+    The only SSR Output format is ESM. Find more information at https://github.com/vitejs/vite/discussions/13816.
+`)
+    );
+  }
+  const resolvedBuildOutDir = normalizePath$3(
+    path$n.resolve(resolved.root, resolved.build.outDir)
+  );
+  if (isParentDirectory(resolvedBuildOutDir, resolved.root) || resolvedBuildOutDir === resolved.root) {
+    resolved.logger.warn(
+      colors$1.yellow(`
+(!) build.outDir must not be the same directory of root or a parent directory of root as this could cause Vite to overwriting source files with build outputs.
+`)
+    );
+  }
+  return resolved;
+}
+function resolveBaseUrl(base = "/", isBuild, logger) {
+  if (base[0] === ".") {
+    logger.warn(
+      colors$1.yellow(
+        colors$1.bold(
+          `(!) invalid "base" option: "${base}". The value can only be an absolute URL, "./", or an empty string.`
+        )
+      )
+    );
+    return "/";
+  }
+  const isExternal = isExternalUrl(base);
+  if (!isExternal && base[0] !== "/") {
+    logger.warn(
+      colors$1.yellow(
+        colors$1.bold(`(!) "base" option should start with a slash.`)
+      )
+    );
+  }
+  if (!isBuild || !isExternal) {
+    base = new URL(base, "http://vitejs.dev").pathname;
+    if (base[0] !== "/") {
+      base = "/" + base;
+    }
+  }
+  return base;
+}
+function sortUserPlugins(plugins) {
+  const prePlugins = [];
+  const postPlugins = [];
+  const normalPlugins = [];
+  if (plugins) {
+    plugins.flat().forEach((p) => {
+      if (p.enforce === "pre") prePlugins.push(p);
+      else if (p.enforce === "post") postPlugins.push(p);
+      else normalPlugins.push(p);
+    });
+  }
+  return [prePlugins, normalPlugins, postPlugins];
+}
+async function loadConfigFromFile(configEnv, configFile, configRoot = process.cwd(), logLevel, customLogger) {
+  const start = performance$1.now();
+  const getTime = () => `${(performance$1.now() - start).toFixed(2)}ms`;
+  let resolvedPath;
+  if (configFile) {
+    resolvedPath = path$n.resolve(configFile);
+  } else {
+    for (const filename of DEFAULT_CONFIG_FILES) {
+      const filePath = path$n.resolve(configRoot, filename);
+      if (!fs__default.existsSync(filePath)) continue;
+      resolvedPath = filePath;
+      break;
+    }
+  }
+  if (!resolvedPath) {
+    debug?.("no config file found.");
+    return null;
+  }
+  const isESM = typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
+  try {
+    const bundled = await bundleConfigFile(resolvedPath, isESM);
+    const userConfig = await loadConfigFromBundledFile(
+      resolvedPath,
+      bundled.code,
+      isESM
+    );
+    debug?.(`bundled config file loaded in ${getTime()}`);
+    const config = await (typeof userConfig === "function" ? userConfig(configEnv) : userConfig);
+    if (!isObject$1(config)) {
+      throw new Error(`config must export or return an object.`);
+    }
+    return {
+      path: normalizePath$3(resolvedPath),
+      config,
+      dependencies: bundled.dependencies
+    };
+  } catch (e) {
+    createLogger(logLevel, { customLogger }).error(
+      colors$1.red(`failed to load config from ${resolvedPath}`),
+      {
+        error: e
+      }
+    );
+    throw e;
+  }
+}
+async function bundleConfigFile(fileName, isESM) {
+  const dirnameVarName = "__vite_injected_original_dirname";
+  const filenameVarName = "__vite_injected_original_filename";
+  const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
+  const result = await build$3({
+    absWorkingDir: process.cwd(),
+    entryPoints: [fileName],
+    write: false,
+    target: [`node${process.versions.node}`],
+    platform: "node",
+    bundle: true,
+    format: isESM ? "esm" : "cjs",
+    mainFields: ["main"],
+    sourcemap: "inline",
+    metafile: true,
+    define: {
+      __dirname: dirnameVarName,
+      __filename: filenameVarName,
+      "import.meta.url": importMetaUrlVarName,
+      "import.meta.dirname": dirnameVarName,
+      "import.meta.filename": filenameVarName
+    },
+    plugins: [
+      {
+        name: "externalize-deps",
+        setup(build2) {
+          const packageCache = /* @__PURE__ */ new Map();
+          const resolveByViteResolver = (id, importer, isRequire) => {
+            return tryNodeResolve(
+              id,
+              importer,
+              {
+                root: path$n.dirname(fileName),
+                isBuild: true,
+                isProduction: true,
+                preferRelative: false,
+                tryIndex: true,
+                mainFields: [],
+                conditions: [],
+                overrideConditions: ["node"],
+                dedupe: [],
+                extensions: DEFAULT_EXTENSIONS,
+                preserveSymlinks: false,
+                packageCache,
+                isRequire
+              },
+              false
+            )?.id;
+          };
+          build2.onResolve(
+            { filter: /^[^.].*/ },
+            async ({ path: id, importer, kind }) => {
+              if (kind === "entry-point" || path$n.isAbsolute(id) || isNodeBuiltin(id)) {
+                return;
+              }
+              if (isBuiltin(id)) {
+                return { external: true };
+              }
+              const isImport = isESM || kind === "dynamic-import";
+              let idFsPath;
+              try {
+                idFsPath = resolveByViteResolver(id, importer, !isImport);
+              } catch (e) {
+                if (!isImport) {
+                  let canResolveWithImport = false;
+                  try {
+                    canResolveWithImport = !!resolveByViteResolver(
+                      id,
+                      importer,
+                      false
+                    );
+                  } catch {
+                  }
+                  if (canResolveWithImport) {
+                    throw new Error(
+                      `Failed to resolve ${JSON.stringify(
+                        id
+                      )}. This package is ESM only but it was tried to load by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                    );
+                  }
+                }
+                throw e;
+              }
+              if (idFsPath && isImport) {
+                idFsPath = pathToFileURL(idFsPath).href;
+              }
+              if (idFsPath && !isImport && isFilePathESM(idFsPath, packageCache)) {
+                throw new Error(
+                  `${JSON.stringify(
+                    id
+                  )} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See https://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+                );
+              }
+              return {
+                path: idFsPath,
+                external: true
+              };
+            }
+          );
+        }
+      },
+      {
+        name: "inject-file-scope-variables",
+        setup(build2) {
+          build2.onLoad({ filter: /\.[cm]?[jt]s$/ }, async (args) => {
+            const contents = await fsp.readFile(args.path, "utf-8");
+            const injectValues = `const ${dirnameVarName} = ${JSON.stringify(
+              path$n.dirname(args.path)
+            )};const ${filenameVarName} = ${JSON.stringify(args.path)};const ${importMetaUrlVarName} = ${JSON.stringify(
+              pathToFileURL(args.path).href
+            )};`;
+            return {
+              loader: args.path.endsWith("ts") ? "ts" : "js",
+              contents: injectValues + contents
+            };
+          });
+        }
+      }
+    ]
+  });
+  const { text } = result.outputFiles[0];
+  return {
+    code: text,
+    dependencies: result.metafile ? Object.keys(result.metafile.inputs) : []
+  };
+}
+const _require = createRequire$1(import.meta.url);
+async function loadConfigFromBundledFile(fileName, bundledCode, isESM) {
+  if (isESM) {
+    const fileBase = `${fileName}.timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const fileNameTmp = `${fileBase}.mjs`;
+    const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
+    await fsp.writeFile(fileNameTmp, bundledCode);
+    try {
+      return (await import(fileUrl)).default;
+    } finally {
+      fs__default.unlink(fileNameTmp, () => {
+      });
+    }
+  } else {
+    const extension = path$n.extname(fileName);
+    const realFileName = await promisifiedRealpath(fileName);
+    const loaderExt = extension in _require.extensions ? extension : ".js";
+    const defaultLoader = _require.extensions[loaderExt];
+    _require.extensions[loaderExt] = (module, filename) => {
+      if (filename === realFileName) {
+        module._compile(bundledCode, filename);
+      } else {
+        defaultLoader(module, filename);
+      }
+    };
+    delete _require.cache[_require.resolve(fileName)];
+    const raw = _require(fileName);
+    _require.extensions[loaderExt] = defaultLoader;
+    return raw.__esModule ? raw.default : raw;
+  }
+}
+async function runConfigHook(config, plugins, configEnv) {
+  let conf = config;
+  for (const p of getSortedPluginsByHook("config", plugins)) {
+    const hook = p.config;
+    const handler = getHookHandler(hook);
+    if (handler) {
+      const res = await handler(conf, configEnv);
+      if (res) {
+        conf = mergeConfig(conf, res);
+      }
+    }
+  }
+  return conf;
+}
+function getDepOptimizationConfig(config, ssr) {
+  return ssr ? config.ssr.optimizeDeps : config.optimizeDeps;
+}
+function isDepsOptimizerEnabled(config, ssr) {
+  const optimizeDeps = getDepOptimizationConfig(config, ssr);
+  return !(optimizeDeps.noDiscovery && !optimizeDeps.include?.length);
+}
+function optimizeDepsDisabledBackwardCompatibility(resolved, optimizeDeps, optimizeDepsPath = "") {
+  const optimizeDepsDisabled = optimizeDeps.disabled;
+  if (optimizeDepsDisabled !== void 0) {
+    if (optimizeDepsDisabled === true || optimizeDepsDisabled === "dev") {
+      const commonjsOptionsInclude = resolved.build?.commonjsOptions?.include;
+      const commonjsPluginDisabled = Array.isArray(commonjsOptionsInclude) && commonjsOptionsInclude.length === 0;
+      optimizeDeps.noDiscovery = true;
+      optimizeDeps.include = void 0;
+      if (commonjsPluginDisabled) {
+        resolved.build.commonjsOptions.include = void 0;
+      }
+      resolved.logger.warn(
+        colors$1.yellow(`(!) Experimental ${optimizeDepsPath}optimizeDeps.disabled and deps pre-bundling during build were removed in Vite 5.1.
+    To disable the deps optimizer, set ${optimizeDepsPath}optimizeDeps.noDiscovery to true and ${optimizeDepsPath}optimizeDeps.include as undefined or empty.
+    Please remove ${optimizeDepsPath}optimizeDeps.disabled from your config.
+    ${commonjsPluginDisabled ? "Empty config.build.commonjsOptions.include will be ignored to support CJS during build. This config should also be removed." : ""}
+  `)
+      );
+    } else if (optimizeDepsDisabled === false || optimizeDepsDisabled === "build") {
+      resolved.logger.warn(
+        colors$1.yellow(`(!) Experimental ${optimizeDepsPath}optimizeDeps.disabled and deps pre-bundling during build were removed in Vite 5.1.
+    Setting it to ${optimizeDepsDisabled} now has no effect.
+    Please remove ${optimizeDepsPath}optimizeDeps.disabled from your config.
+  `)
+      );
+    }
+  }
+}
+
+export { colors$1 as A, getDefaultExportFromCjs as B, commonjsGlobal as C, index$1 as D, index as E, build$1 as F, preview$1 as G, arraify as a, build as b, createServer as c, defineConfig as d, preprocessCSS as e, formatPostcssSourceMap as f, buildErrorMessage as g, fetchModule as h, isInNodeModules$1 as i, mergeAlias as j, createFilter as k, loadConfigFromFile as l, mergeConfig as m, normalizePath$3 as n, optimizeDeps as o, preview as p, rollupVersion as q, resolveConfig as r, sortUserPlugins as s, transformWithEsbuild as t, send as u, createLogger as v, searchForWorkspaceRoot as w, isFileServingAllowed as x, loadEnv as y, resolveEnvPrefix as z };
diff --git a/node_modules/vite/dist/node/chunks/dep-D-7KCb9p.js b/node_modules/vite/dist/node/chunks/dep-D-7KCb9p.js
new file mode 100644
index 0000000..7041237
--- /dev/null
+++ b/node_modules/vite/dist/node/chunks/dep-D-7KCb9p.js
@@ -0,0 +1,7960 @@
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+const UNDEFINED_CODE_POINTS = new Set([
+    65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214,
+    393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894,
+    720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574,
+    1048575, 1114110, 1114111,
+]);
+const REPLACEMENT_CHARACTER = '\uFFFD';
+var CODE_POINTS;
+(function (CODE_POINTS) {
+    CODE_POINTS[CODE_POINTS["EOF"] = -1] = "EOF";
+    CODE_POINTS[CODE_POINTS["NULL"] = 0] = "NULL";
+    CODE_POINTS[CODE_POINTS["TABULATION"] = 9] = "TABULATION";
+    CODE_POINTS[CODE_POINTS["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN";
+    CODE_POINTS[CODE_POINTS["LINE_FEED"] = 10] = "LINE_FEED";
+    CODE_POINTS[CODE_POINTS["FORM_FEED"] = 12] = "FORM_FEED";
+    CODE_POINTS[CODE_POINTS["SPACE"] = 32] = "SPACE";
+    CODE_POINTS[CODE_POINTS["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
+    CODE_POINTS[CODE_POINTS["QUOTATION_MARK"] = 34] = "QUOTATION_MARK";
+    CODE_POINTS[CODE_POINTS["NUMBER_SIGN"] = 35] = "NUMBER_SIGN";
+    CODE_POINTS[CODE_POINTS["AMPERSAND"] = 38] = "AMPERSAND";
+    CODE_POINTS[CODE_POINTS["APOSTROPHE"] = 39] = "APOSTROPHE";
+    CODE_POINTS[CODE_POINTS["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS";
+    CODE_POINTS[CODE_POINTS["SOLIDUS"] = 47] = "SOLIDUS";
+    CODE_POINTS[CODE_POINTS["DIGIT_0"] = 48] = "DIGIT_0";
+    CODE_POINTS[CODE_POINTS["DIGIT_9"] = 57] = "DIGIT_9";
+    CODE_POINTS[CODE_POINTS["SEMICOLON"] = 59] = "SEMICOLON";
+    CODE_POINTS[CODE_POINTS["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN";
+    CODE_POINTS[CODE_POINTS["EQUALS_SIGN"] = 61] = "EQUALS_SIGN";
+    CODE_POINTS[CODE_POINTS["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN";
+    CODE_POINTS[CODE_POINTS["QUESTION_MARK"] = 63] = "QUESTION_MARK";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_F"] = 70] = "LATIN_CAPITAL_F";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_X"] = 88] = "LATIN_CAPITAL_X";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z";
+    CODE_POINTS[CODE_POINTS["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET";
+    CODE_POINTS[CODE_POINTS["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_F"] = 102] = "LATIN_SMALL_F";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_X"] = 120] = "LATIN_SMALL_X";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z";
+    CODE_POINTS[CODE_POINTS["REPLACEMENT_CHARACTER"] = 65533] = "REPLACEMENT_CHARACTER";
+})(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {}));
+const SEQUENCES = {
+    DASH_DASH: '--',
+    CDATA_START: '[CDATA[',
+    DOCTYPE: 'doctype',
+    SCRIPT: 'script',
+    PUBLIC: 'public',
+    SYSTEM: 'system',
+};
+//Surrogates
+function isSurrogate(cp) {
+    return cp >= 55296 && cp <= 57343;
+}
+function isSurrogatePair(cp) {
+    return cp >= 56320 && cp <= 57343;
+}
+function getSurrogatePairCodePoint(cp1, cp2) {
+    return (cp1 - 55296) * 1024 + 9216 + cp2;
+}
+//NOTE: excluding NULL and ASCII whitespace
+function isControlCodePoint(cp) {
+    return ((cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||
+        (cp >= 0x7f && cp <= 0x9f));
+}
+function isUndefinedCodePoint(cp) {
+    return (cp >= 64976 && cp <= 65007) || UNDEFINED_CODE_POINTS.has(cp);
+}
+
+var ERR;
+(function (ERR) {
+    ERR["controlCharacterInInputStream"] = "control-character-in-input-stream";
+    ERR["noncharacterInInputStream"] = "noncharacter-in-input-stream";
+    ERR["surrogateInInputStream"] = "surrogate-in-input-stream";
+    ERR["nonVoidHtmlElementStartTagWithTrailingSolidus"] = "non-void-html-element-start-tag-with-trailing-solidus";
+    ERR["endTagWithAttributes"] = "end-tag-with-attributes";
+    ERR["endTagWithTrailingSolidus"] = "end-tag-with-trailing-solidus";
+    ERR["unexpectedSolidusInTag"] = "unexpected-solidus-in-tag";
+    ERR["unexpectedNullCharacter"] = "unexpected-null-character";
+    ERR["unexpectedQuestionMarkInsteadOfTagName"] = "unexpected-question-mark-instead-of-tag-name";
+    ERR["invalidFirstCharacterOfTagName"] = "invalid-first-character-of-tag-name";
+    ERR["unexpectedEqualsSignBeforeAttributeName"] = "unexpected-equals-sign-before-attribute-name";
+    ERR["missingEndTagName"] = "missing-end-tag-name";
+    ERR["unexpectedCharacterInAttributeName"] = "unexpected-character-in-attribute-name";
+    ERR["unknownNamedCharacterReference"] = "unknown-named-character-reference";
+    ERR["missingSemicolonAfterCharacterReference"] = "missing-semicolon-after-character-reference";
+    ERR["unexpectedCharacterAfterDoctypeSystemIdentifier"] = "unexpected-character-after-doctype-system-identifier";
+    ERR["unexpectedCharacterInUnquotedAttributeValue"] = "unexpected-character-in-unquoted-attribute-value";
+    ERR["eofBeforeTagName"] = "eof-before-tag-name";
+    ERR["eofInTag"] = "eof-in-tag";
+    ERR["missingAttributeValue"] = "missing-attribute-value";
+    ERR["missingWhitespaceBetweenAttributes"] = "missing-whitespace-between-attributes";
+    ERR["missingWhitespaceAfterDoctypePublicKeyword"] = "missing-whitespace-after-doctype-public-keyword";
+    ERR["missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers"] = "missing-whitespace-between-doctype-public-and-system-identifiers";
+    ERR["missingWhitespaceAfterDoctypeSystemKeyword"] = "missing-whitespace-after-doctype-system-keyword";
+    ERR["missingQuoteBeforeDoctypePublicIdentifier"] = "missing-quote-before-doctype-public-identifier";
+    ERR["missingQuoteBeforeDoctypeSystemIdentifier"] = "missing-quote-before-doctype-system-identifier";
+    ERR["missingDoctypePublicIdentifier"] = "missing-doctype-public-identifier";
+    ERR["missingDoctypeSystemIdentifier"] = "missing-doctype-system-identifier";
+    ERR["abruptDoctypePublicIdentifier"] = "abrupt-doctype-public-identifier";
+    ERR["abruptDoctypeSystemIdentifier"] = "abrupt-doctype-system-identifier";
+    ERR["cdataInHtmlContent"] = "cdata-in-html-content";
+    ERR["incorrectlyOpenedComment"] = "incorrectly-opened-comment";
+    ERR["eofInScriptHtmlCommentLikeText"] = "eof-in-script-html-comment-like-text";
+    ERR["eofInDoctype"] = "eof-in-doctype";
+    ERR["nestedComment"] = "nested-comment";
+    ERR["abruptClosingOfEmptyComment"] = "abrupt-closing-of-empty-comment";
+    ERR["eofInComment"] = "eof-in-comment";
+    ERR["incorrectlyClosedComment"] = "incorrectly-closed-comment";
+    ERR["eofInCdata"] = "eof-in-cdata";
+    ERR["absenceOfDigitsInNumericCharacterReference"] = "absence-of-digits-in-numeric-character-reference";
+    ERR["nullCharacterReference"] = "null-character-reference";
+    ERR["surrogateCharacterReference"] = "surrogate-character-reference";
+    ERR["characterReferenceOutsideUnicodeRange"] = "character-reference-outside-unicode-range";
+    ERR["controlCharacterReference"] = "control-character-reference";
+    ERR["noncharacterCharacterReference"] = "noncharacter-character-reference";
+    ERR["missingWhitespaceBeforeDoctypeName"] = "missing-whitespace-before-doctype-name";
+    ERR["missingDoctypeName"] = "missing-doctype-name";
+    ERR["invalidCharacterSequenceAfterDoctypeName"] = "invalid-character-sequence-after-doctype-name";
+    ERR["duplicateAttribute"] = "duplicate-attribute";
+    ERR["nonConformingDoctype"] = "non-conforming-doctype";
+    ERR["missingDoctype"] = "missing-doctype";
+    ERR["misplacedDoctype"] = "misplaced-doctype";
+    ERR["endTagWithoutMatchingOpenElement"] = "end-tag-without-matching-open-element";
+    ERR["closingOfElementWithOpenChildElements"] = "closing-of-element-with-open-child-elements";
+    ERR["disallowedContentInNoscriptInHead"] = "disallowed-content-in-noscript-in-head";
+    ERR["openElementsLeftAfterEof"] = "open-elements-left-after-eof";
+    ERR["abandonedHeadElementChild"] = "abandoned-head-element-child";
+    ERR["misplacedStartTagForHeadElement"] = "misplaced-start-tag-for-head-element";
+    ERR["nestedNoscriptInHead"] = "nested-noscript-in-head";
+    ERR["eofInElementThatCanContainOnlyText"] = "eof-in-element-that-can-contain-only-text";
+})(ERR = ERR || (ERR = {}));
+
+//Const
+const DEFAULT_BUFFER_WATERLINE = 1 << 16;
+//Preprocessor
+//NOTE: HTML input preprocessing
+//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)
+class Preprocessor {
+    constructor(handler) {
+        this.handler = handler;
+        this.html = '';
+        this.pos = -1;
+        // NOTE: Initial `lastGapPos` is -2, to ensure `col` on initialisation is 0
+        this.lastGapPos = -2;
+        this.gapStack = [];
+        this.skipNextNewLine = false;
+        this.lastChunkWritten = false;
+        this.endOfChunkHit = false;
+        this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;
+        this.isEol = false;
+        this.lineStartPos = 0;
+        this.droppedBufferSize = 0;
+        this.line = 1;
+        //NOTE: avoid reporting errors twice on advance/retreat
+        this.lastErrOffset = -1;
+    }
+    /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
+    get col() {
+        return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);
+    }
+    get offset() {
+        return this.droppedBufferSize + this.pos;
+    }
+    getError(code) {
+        const { line, col, offset } = this;
+        return {
+            code,
+            startLine: line,
+            endLine: line,
+            startCol: col,
+            endCol: col,
+            startOffset: offset,
+            endOffset: offset,
+        };
+    }
+    _err(code) {
+        if (this.handler.onParseError && this.lastErrOffset !== this.offset) {
+            this.lastErrOffset = this.offset;
+            this.handler.onParseError(this.getError(code));
+        }
+    }
+    _addGap() {
+        this.gapStack.push(this.lastGapPos);
+        this.lastGapPos = this.pos;
+    }
+    _processSurrogate(cp) {
+        //NOTE: try to peek a surrogate pair
+        if (this.pos !== this.html.length - 1) {
+            const nextCp = this.html.charCodeAt(this.pos + 1);
+            if (isSurrogatePair(nextCp)) {
+                //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.
+                this.pos++;
+                //NOTE: add a gap that should be avoided during retreat
+                this._addGap();
+                return getSurrogatePairCodePoint(cp, nextCp);
+            }
+        }
+        //NOTE: we are at the end of a chunk, therefore we can't infer the surrogate pair yet.
+        else if (!this.lastChunkWritten) {
+            this.endOfChunkHit = true;
+            return CODE_POINTS.EOF;
+        }
+        //NOTE: isolated surrogate
+        this._err(ERR.surrogateInInputStream);
+        return cp;
+    }
+    willDropParsedChunk() {
+        return this.pos > this.bufferWaterline;
+    }
+    dropParsedChunk() {
+        if (this.willDropParsedChunk()) {
+            this.html = this.html.substring(this.pos);
+            this.lineStartPos -= this.pos;
+            this.droppedBufferSize += this.pos;
+            this.pos = 0;
+            this.lastGapPos = -2;
+            this.gapStack.length = 0;
+        }
+    }
+    write(chunk, isLastChunk) {
+        if (this.html.length > 0) {
+            this.html += chunk;
+        }
+        else {
+            this.html = chunk;
+        }
+        this.endOfChunkHit = false;
+        this.lastChunkWritten = isLastChunk;
+    }
+    insertHtmlAtCurrentPos(chunk) {
+        this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1);
+        this.endOfChunkHit = false;
+    }
+    startsWith(pattern, caseSensitive) {
+        // Check if our buffer has enough characters
+        if (this.pos + pattern.length > this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return false;
+        }
+        if (caseSensitive) {
+            return this.html.startsWith(pattern, this.pos);
+        }
+        for (let i = 0; i < pattern.length; i++) {
+            const cp = this.html.charCodeAt(this.pos + i) | 0x20;
+            if (cp !== pattern.charCodeAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    peek(offset) {
+        const pos = this.pos + offset;
+        if (pos >= this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return CODE_POINTS.EOF;
+        }
+        const code = this.html.charCodeAt(pos);
+        return code === CODE_POINTS.CARRIAGE_RETURN ? CODE_POINTS.LINE_FEED : code;
+    }
+    advance() {
+        this.pos++;
+        //NOTE: LF should be in the last column of the line
+        if (this.isEol) {
+            this.isEol = false;
+            this.line++;
+            this.lineStartPos = this.pos;
+        }
+        if (this.pos >= this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return CODE_POINTS.EOF;
+        }
+        let cp = this.html.charCodeAt(this.pos);
+        //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters
+        if (cp === CODE_POINTS.CARRIAGE_RETURN) {
+            this.isEol = true;
+            this.skipNextNewLine = true;
+            return CODE_POINTS.LINE_FEED;
+        }
+        //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character
+        //must be ignored.
+        if (cp === CODE_POINTS.LINE_FEED) {
+            this.isEol = true;
+            if (this.skipNextNewLine) {
+                // `line` will be bumped again in the recursive call.
+                this.line--;
+                this.skipNextNewLine = false;
+                this._addGap();
+                return this.advance();
+            }
+        }
+        this.skipNextNewLine = false;
+        if (isSurrogate(cp)) {
+            cp = this._processSurrogate(cp);
+        }
+        //OPTIMIZATION: first check if code point is in the common allowed
+        //range (ASCII alphanumeric, whitespaces, big chunk of BMP)
+        //before going into detailed performance cost validation.
+        const isCommonValidRange = this.handler.onParseError === null ||
+            (cp > 0x1f && cp < 0x7f) ||
+            cp === CODE_POINTS.LINE_FEED ||
+            cp === CODE_POINTS.CARRIAGE_RETURN ||
+            (cp > 0x9f && cp < 64976);
+        if (!isCommonValidRange) {
+            this._checkForProblematicCharacters(cp);
+        }
+        return cp;
+    }
+    _checkForProblematicCharacters(cp) {
+        if (isControlCodePoint(cp)) {
+            this._err(ERR.controlCharacterInInputStream);
+        }
+        else if (isUndefinedCodePoint(cp)) {
+            this._err(ERR.noncharacterInInputStream);
+        }
+    }
+    retreat(count) {
+        this.pos -= count;
+        while (this.pos < this.lastGapPos) {
+            this.lastGapPos = this.gapStack.pop();
+            this.pos--;
+        }
+        this.isEol = false;
+    }
+}
+
+var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["CHARACTER"] = 0] = "CHARACTER";
+    TokenType[TokenType["NULL_CHARACTER"] = 1] = "NULL_CHARACTER";
+    TokenType[TokenType["WHITESPACE_CHARACTER"] = 2] = "WHITESPACE_CHARACTER";
+    TokenType[TokenType["START_TAG"] = 3] = "START_TAG";
+    TokenType[TokenType["END_TAG"] = 4] = "END_TAG";
+    TokenType[TokenType["COMMENT"] = 5] = "COMMENT";
+    TokenType[TokenType["DOCTYPE"] = 6] = "DOCTYPE";
+    TokenType[TokenType["EOF"] = 7] = "EOF";
+    TokenType[TokenType["HIBERNATION"] = 8] = "HIBERNATION";
+})(TokenType = TokenType || (TokenType = {}));
+function getTokenAttr(token, attrName) {
+    for (let i = token.attrs.length - 1; i >= 0; i--) {
+        if (token.attrs[i].name === attrName) {
+            return token.attrs[i].value;
+        }
+    }
+    return null;
+}
+
+// Generated using scripts/write-decode-map.ts
+var htmlDecodeTree = new Uint16Array(
+// prettier-ignore
+"\u1d41<\xd5\u0131\u028a\u049d\u057b\u05d0\u0675\u06de\u07a2\u07d6\u080f\u0a4a\u0a91\u0da1\u0e6d\u0f09\u0f26\u10ca\u1228\u12e1\u1415\u149d\u14c3\u14df\u1525\0\0\0\0\0\0\u156b\u16cd\u198d\u1c12\u1ddd\u1f7e\u2060\u21b0\u228d\u23c0\u23fb\u2442\u2824\u2912\u2d08\u2e48\u2fce\u3016\u32ba\u3639\u37ac\u38fe\u3a28\u3a71\u3ae0\u3b2e\u0800EMabcfglmnoprstu\\bfms\x7f\x84\x8b\x90\x95\x98\xa6\xb3\xb9\xc8\xcflig\u803b\xc6\u40c6P\u803b&\u4026cute\u803b\xc1\u40c1reve;\u4102\u0100iyx}rc\u803b\xc2\u40c2;\u4410r;\uc000\ud835\udd04rave\u803b\xc0\u40c0pha;\u4391acr;\u4100d;\u6a53\u0100gp\x9d\xa1on;\u4104f;\uc000\ud835\udd38plyFunction;\u6061ing\u803b\xc5\u40c5\u0100cs\xbe\xc3r;\uc000\ud835\udc9cign;\u6254ilde\u803b\xc3\u40c3ml\u803b\xc4\u40c4\u0400aceforsu\xe5\xfb\xfe\u0117\u011c\u0122\u0127\u012a\u0100cr\xea\xf2kslash;\u6216\u0176\xf6\xf8;\u6ae7ed;\u6306y;\u4411\u0180crt\u0105\u010b\u0114ause;\u6235noullis;\u612ca;\u4392r;\uc000\ud835\udd05pf;\uc000\ud835\udd39eve;\u42d8c\xf2\u0113mpeq;\u624e\u0700HOacdefhilorsu\u014d\u0151\u0156\u0180\u019e\u01a2\u01b5\u01b7\u01ba\u01dc\u0215\u0273\u0278\u027ecy;\u4427PY\u803b\xa9\u40a9\u0180cpy\u015d\u0162\u017aute;\u4106\u0100;i\u0167\u0168\u62d2talDifferentialD;\u6145leys;\u612d\u0200aeio\u0189\u018e\u0194\u0198ron;\u410cdil\u803b\xc7\u40c7rc;\u4108nint;\u6230ot;\u410a\u0100dn\u01a7\u01adilla;\u40b8terDot;\u40b7\xf2\u017fi;\u43a7rcle\u0200DMPT\u01c7\u01cb\u01d1\u01d6ot;\u6299inus;\u6296lus;\u6295imes;\u6297o\u0100cs\u01e2\u01f8kwiseContourIntegral;\u6232eCurly\u0100DQ\u0203\u020foubleQuote;\u601duote;\u6019\u0200lnpu\u021e\u0228\u0247\u0255on\u0100;e\u0225\u0226\u6237;\u6a74\u0180git\u022f\u0236\u023aruent;\u6261nt;\u622fourIntegral;\u622e\u0100fr\u024c\u024e;\u6102oduct;\u6210nterClockwiseContourIntegral;\u6233oss;\u6a2fcr;\uc000\ud835\udc9ep\u0100;C\u0284\u0285\u62d3ap;\u624d\u0580DJSZacefios\u02a0\u02ac\u02b0\u02b4\u02b8\u02cb\u02d7\u02e1\u02e6\u0333\u048d\u0100;o\u0179\u02a5trahd;\u6911cy;\u4402cy;\u4405cy;\u440f\u0180grs\u02bf\u02c4\u02c7ger;\u6021r;\u61a1hv;\u6ae4\u0100ay\u02d0\u02d5ron;\u410e;\u4414l\u0100;t\u02dd\u02de\u6207a;\u4394r;\uc000\ud835\udd07\u0100af\u02eb\u0327\u0100cm\u02f0\u0322ritical\u0200ADGT\u0300\u0306\u0316\u031ccute;\u40b4o\u0174\u030b\u030d;\u42d9bleAcute;\u42ddrave;\u4060ilde;\u42dcond;\u62c4ferentialD;\u6146\u0470\u033d\0\0\0\u0342\u0354\0\u0405f;\uc000\ud835\udd3b\u0180;DE\u0348\u0349\u034d\u40a8ot;\u60dcqual;\u6250ble\u0300CDLRUV\u0363\u0372\u0382\u03cf\u03e2\u03f8ontourIntegra\xec\u0239o\u0274\u0379\0\0\u037b\xbb\u0349nArrow;\u61d3\u0100eo\u0387\u03a4ft\u0180ART\u0390\u0396\u03a1rrow;\u61d0ightArrow;\u61d4e\xe5\u02cang\u0100LR\u03ab\u03c4eft\u0100AR\u03b3\u03b9rrow;\u67f8ightArrow;\u67faightArrow;\u67f9ight\u0100AT\u03d8\u03derrow;\u61d2ee;\u62a8p\u0241\u03e9\0\0\u03efrrow;\u61d1ownArrow;\u61d5erticalBar;\u6225n\u0300ABLRTa\u0412\u042a\u0430\u045e\u047f\u037crrow\u0180;BU\u041d\u041e\u0422\u6193ar;\u6913pArrow;\u61f5reve;\u4311eft\u02d2\u043a\0\u0446\0\u0450ightVector;\u6950eeVector;\u695eector\u0100;B\u0459\u045a\u61bdar;\u6956ight\u01d4\u0467\0\u0471eeVector;\u695fector\u0100;B\u047a\u047b\u61c1ar;\u6957ee\u0100;A\u0486\u0487\u62a4rrow;\u61a7\u0100ct\u0492\u0497r;\uc000\ud835\udc9frok;\u4110\u0800NTacdfglmopqstux\u04bd\u04c0\u04c4\u04cb\u04de\u04e2\u04e7\u04ee\u04f5\u0521\u052f\u0536\u0552\u055d\u0560\u0565G;\u414aH\u803b\xd0\u40d0cute\u803b\xc9\u40c9\u0180aiy\u04d2\u04d7\u04dcron;\u411arc\u803b\xca\u40ca;\u442dot;\u4116r;\uc000\ud835\udd08rave\u803b\xc8\u40c8ement;\u6208\u0100ap\u04fa\u04fecr;\u4112ty\u0253\u0506\0\0\u0512mallSquare;\u65fberySmallSquare;\u65ab\u0100gp\u0526\u052aon;\u4118f;\uc000\ud835\udd3csilon;\u4395u\u0100ai\u053c\u0549l\u0100;T\u0542\u0543\u6a75ilde;\u6242librium;\u61cc\u0100ci\u0557\u055ar;\u6130m;\u6a73a;\u4397ml\u803b\xcb\u40cb\u0100ip\u056a\u056fsts;\u6203onentialE;\u6147\u0280cfios\u0585\u0588\u058d\u05b2\u05ccy;\u4424r;\uc000\ud835\udd09lled\u0253\u0597\0\0\u05a3mallSquare;\u65fcerySmallSquare;\u65aa\u0370\u05ba\0\u05bf\0\0\u05c4f;\uc000\ud835\udd3dAll;\u6200riertrf;\u6131c\xf2\u05cb\u0600JTabcdfgorst\u05e8\u05ec\u05ef\u05fa\u0600\u0612\u0616\u061b\u061d\u0623\u066c\u0672cy;\u4403\u803b>\u403emma\u0100;d\u05f7\u05f8\u4393;\u43dcreve;\u411e\u0180eiy\u0607\u060c\u0610dil;\u4122rc;\u411c;\u4413ot;\u4120r;\uc000\ud835\udd0a;\u62d9pf;\uc000\ud835\udd3eeater\u0300EFGLST\u0635\u0644\u064e\u0656\u065b\u0666qual\u0100;L\u063e\u063f\u6265ess;\u62dbullEqual;\u6267reater;\u6aa2ess;\u6277lantEqual;\u6a7eilde;\u6273cr;\uc000\ud835\udca2;\u626b\u0400Aacfiosu\u0685\u068b\u0696\u069b\u069e\u06aa\u06be\u06caRDcy;\u442a\u0100ct\u0690\u0694ek;\u42c7;\u405eirc;\u4124r;\u610clbertSpace;\u610b\u01f0\u06af\0\u06b2f;\u610dizontalLine;\u6500\u0100ct\u06c3\u06c5\xf2\u06a9rok;\u4126mp\u0144\u06d0\u06d8ownHum\xf0\u012fqual;\u624f\u0700EJOacdfgmnostu\u06fa\u06fe\u0703\u0707\u070e\u071a\u071e\u0721\u0728\u0744\u0778\u078b\u078f\u0795cy;\u4415lig;\u4132cy;\u4401cute\u803b\xcd\u40cd\u0100iy\u0713\u0718rc\u803b\xce\u40ce;\u4418ot;\u4130r;\u6111rave\u803b\xcc\u40cc\u0180;ap\u0720\u072f\u073f\u0100cg\u0734\u0737r;\u412ainaryI;\u6148lie\xf3\u03dd\u01f4\u0749\0\u0762\u0100;e\u074d\u074e\u622c\u0100gr\u0753\u0758ral;\u622bsection;\u62c2isible\u0100CT\u076c\u0772omma;\u6063imes;\u6062\u0180gpt\u077f\u0783\u0788on;\u412ef;\uc000\ud835\udd40a;\u4399cr;\u6110ilde;\u4128\u01eb\u079a\0\u079ecy;\u4406l\u803b\xcf\u40cf\u0280cfosu\u07ac\u07b7\u07bc\u07c2\u07d0\u0100iy\u07b1\u07b5rc;\u4134;\u4419r;\uc000\ud835\udd0dpf;\uc000\ud835\udd41\u01e3\u07c7\0\u07ccr;\uc000\ud835\udca5rcy;\u4408kcy;\u4404\u0380HJacfos\u07e4\u07e8\u07ec\u07f1\u07fd\u0802\u0808cy;\u4425cy;\u440cppa;\u439a\u0100ey\u07f6\u07fbdil;\u4136;\u441ar;\uc000\ud835\udd0epf;\uc000\ud835\udd42cr;\uc000\ud835\udca6\u0580JTaceflmost\u0825\u0829\u082c\u0850\u0863\u09b3\u09b8\u09c7\u09cd\u0a37\u0a47cy;\u4409\u803b<\u403c\u0280cmnpr\u0837\u083c\u0841\u0844\u084dute;\u4139bda;\u439bg;\u67ealacetrf;\u6112r;\u619e\u0180aey\u0857\u085c\u0861ron;\u413ddil;\u413b;\u441b\u0100fs\u0868\u0970t\u0500ACDFRTUVar\u087e\u08a9\u08b1\u08e0\u08e6\u08fc\u092f\u095b\u0390\u096a\u0100nr\u0883\u088fgleBracket;\u67e8row\u0180;BR\u0899\u089a\u089e\u6190ar;\u61e4ightArrow;\u61c6eiling;\u6308o\u01f5\u08b7\0\u08c3bleBracket;\u67e6n\u01d4\u08c8\0\u08d2eeVector;\u6961ector\u0100;B\u08db\u08dc\u61c3ar;\u6959loor;\u630aight\u0100AV\u08ef\u08f5rrow;\u6194ector;\u694e\u0100er\u0901\u0917e\u0180;AV\u0909\u090a\u0910\u62a3rrow;\u61a4ector;\u695aiangle\u0180;BE\u0924\u0925\u0929\u62b2ar;\u69cfqual;\u62b4p\u0180DTV\u0937\u0942\u094cownVector;\u6951eeVector;\u6960ector\u0100;B\u0956\u0957\u61bfar;\u6958ector\u0100;B\u0965\u0966\u61bcar;\u6952ight\xe1\u039cs\u0300EFGLST\u097e\u098b\u0995\u099d\u09a2\u09adqualGreater;\u62daullEqual;\u6266reater;\u6276ess;\u6aa1lantEqual;\u6a7dilde;\u6272r;\uc000\ud835\udd0f\u0100;e\u09bd\u09be\u62d8ftarrow;\u61daidot;\u413f\u0180npw\u09d4\u0a16\u0a1bg\u0200LRlr\u09de\u09f7\u0a02\u0a10eft\u0100AR\u09e6\u09ecrrow;\u67f5ightArrow;\u67f7ightArrow;\u67f6eft\u0100ar\u03b3\u0a0aight\xe1\u03bfight\xe1\u03caf;\uc000\ud835\udd43er\u0100LR\u0a22\u0a2ceftArrow;\u6199ightArrow;\u6198\u0180cht\u0a3e\u0a40\u0a42\xf2\u084c;\u61b0rok;\u4141;\u626a\u0400acefiosu\u0a5a\u0a5d\u0a60\u0a77\u0a7c\u0a85\u0a8b\u0a8ep;\u6905y;\u441c\u0100dl\u0a65\u0a6fiumSpace;\u605flintrf;\u6133r;\uc000\ud835\udd10nusPlus;\u6213pf;\uc000\ud835\udd44c\xf2\u0a76;\u439c\u0480Jacefostu\u0aa3\u0aa7\u0aad\u0ac0\u0b14\u0b19\u0d91\u0d97\u0d9ecy;\u440acute;\u4143\u0180aey\u0ab4\u0ab9\u0aberon;\u4147dil;\u4145;\u441d\u0180gsw\u0ac7\u0af0\u0b0eative\u0180MTV\u0ad3\u0adf\u0ae8ediumSpace;\u600bhi\u0100cn\u0ae6\u0ad8\xeb\u0ad9eryThi\xee\u0ad9ted\u0100GL\u0af8\u0b06reaterGreate\xf2\u0673essLes\xf3\u0a48Line;\u400ar;\uc000\ud835\udd11\u0200Bnpt\u0b22\u0b28\u0b37\u0b3areak;\u6060BreakingSpace;\u40a0f;\u6115\u0680;CDEGHLNPRSTV\u0b55\u0b56\u0b6a\u0b7c\u0ba1\u0beb\u0c04\u0c5e\u0c84\u0ca6\u0cd8\u0d61\u0d85\u6aec\u0100ou\u0b5b\u0b64ngruent;\u6262pCap;\u626doubleVerticalBar;\u6226\u0180lqx\u0b83\u0b8a\u0b9bement;\u6209ual\u0100;T\u0b92\u0b93\u6260ilde;\uc000\u2242\u0338ists;\u6204reater\u0380;EFGLST\u0bb6\u0bb7\u0bbd\u0bc9\u0bd3\u0bd8\u0be5\u626fqual;\u6271ullEqual;\uc000\u2267\u0338reater;\uc000\u226b\u0338ess;\u6279lantEqual;\uc000\u2a7e\u0338ilde;\u6275ump\u0144\u0bf2\u0bfdownHump;\uc000\u224e\u0338qual;\uc000\u224f\u0338e\u0100fs\u0c0a\u0c27tTriangle\u0180;BE\u0c1a\u0c1b\u0c21\u62eaar;\uc000\u29cf\u0338qual;\u62ecs\u0300;EGLST\u0c35\u0c36\u0c3c\u0c44\u0c4b\u0c58\u626equal;\u6270reater;\u6278ess;\uc000\u226a\u0338lantEqual;\uc000\u2a7d\u0338ilde;\u6274ested\u0100GL\u0c68\u0c79reaterGreater;\uc000\u2aa2\u0338essLess;\uc000\u2aa1\u0338recedes\u0180;ES\u0c92\u0c93\u0c9b\u6280qual;\uc000\u2aaf\u0338lantEqual;\u62e0\u0100ei\u0cab\u0cb9verseElement;\u620cghtTriangle\u0180;BE\u0ccb\u0ccc\u0cd2\u62ebar;\uc000\u29d0\u0338qual;\u62ed\u0100qu\u0cdd\u0d0cuareSu\u0100bp\u0ce8\u0cf9set\u0100;E\u0cf0\u0cf3\uc000\u228f\u0338qual;\u62e2erset\u0100;E\u0d03\u0d06\uc000\u2290\u0338qual;\u62e3\u0180bcp\u0d13\u0d24\u0d4eset\u0100;E\u0d1b\u0d1e\uc000\u2282\u20d2qual;\u6288ceeds\u0200;EST\u0d32\u0d33\u0d3b\u0d46\u6281qual;\uc000\u2ab0\u0338lantEqual;\u62e1ilde;\uc000\u227f\u0338erset\u0100;E\u0d58\u0d5b\uc000\u2283\u20d2qual;\u6289ilde\u0200;EFT\u0d6e\u0d6f\u0d75\u0d7f\u6241qual;\u6244ullEqual;\u6247ilde;\u6249erticalBar;\u6224cr;\uc000\ud835\udca9ilde\u803b\xd1\u40d1;\u439d\u0700Eacdfgmoprstuv\u0dbd\u0dc2\u0dc9\u0dd5\u0ddb\u0de0\u0de7\u0dfc\u0e02\u0e20\u0e22\u0e32\u0e3f\u0e44lig;\u4152cute\u803b\xd3\u40d3\u0100iy\u0dce\u0dd3rc\u803b\xd4\u40d4;\u441eblac;\u4150r;\uc000\ud835\udd12rave\u803b\xd2\u40d2\u0180aei\u0dee\u0df2\u0df6cr;\u414cga;\u43a9cron;\u439fpf;\uc000\ud835\udd46enCurly\u0100DQ\u0e0e\u0e1aoubleQuote;\u601cuote;\u6018;\u6a54\u0100cl\u0e27\u0e2cr;\uc000\ud835\udcaaash\u803b\xd8\u40d8i\u016c\u0e37\u0e3cde\u803b\xd5\u40d5es;\u6a37ml\u803b\xd6\u40d6er\u0100BP\u0e4b\u0e60\u0100ar\u0e50\u0e53r;\u603eac\u0100ek\u0e5a\u0e5c;\u63deet;\u63b4arenthesis;\u63dc\u0480acfhilors\u0e7f\u0e87\u0e8a\u0e8f\u0e92\u0e94\u0e9d\u0eb0\u0efcrtialD;\u6202y;\u441fr;\uc000\ud835\udd13i;\u43a6;\u43a0usMinus;\u40b1\u0100ip\u0ea2\u0eadncareplan\xe5\u069df;\u6119\u0200;eio\u0eb9\u0eba\u0ee0\u0ee4\u6abbcedes\u0200;EST\u0ec8\u0ec9\u0ecf\u0eda\u627aqual;\u6aaflantEqual;\u627cilde;\u627eme;\u6033\u0100dp\u0ee9\u0eeeuct;\u620fortion\u0100;a\u0225\u0ef9l;\u621d\u0100ci\u0f01\u0f06r;\uc000\ud835\udcab;\u43a8\u0200Ufos\u0f11\u0f16\u0f1b\u0f1fOT\u803b\"\u4022r;\uc000\ud835\udd14pf;\u611acr;\uc000\ud835\udcac\u0600BEacefhiorsu\u0f3e\u0f43\u0f47\u0f60\u0f73\u0fa7\u0faa\u0fad\u1096\u10a9\u10b4\u10bearr;\u6910G\u803b\xae\u40ae\u0180cnr\u0f4e\u0f53\u0f56ute;\u4154g;\u67ebr\u0100;t\u0f5c\u0f5d\u61a0l;\u6916\u0180aey\u0f67\u0f6c\u0f71ron;\u4158dil;\u4156;\u4420\u0100;v\u0f78\u0f79\u611cerse\u0100EU\u0f82\u0f99\u0100lq\u0f87\u0f8eement;\u620builibrium;\u61cbpEquilibrium;\u696fr\xbb\u0f79o;\u43a1ght\u0400ACDFTUVa\u0fc1\u0feb\u0ff3\u1022\u1028\u105b\u1087\u03d8\u0100nr\u0fc6\u0fd2gleBracket;\u67e9row\u0180;BL\u0fdc\u0fdd\u0fe1\u6192ar;\u61e5eftArrow;\u61c4eiling;\u6309o\u01f5\u0ff9\0\u1005bleBracket;\u67e7n\u01d4\u100a\0\u1014eeVector;\u695dector\u0100;B\u101d\u101e\u61c2ar;\u6955loor;\u630b\u0100er\u102d\u1043e\u0180;AV\u1035\u1036\u103c\u62a2rrow;\u61a6ector;\u695biangle\u0180;BE\u1050\u1051\u1055\u62b3ar;\u69d0qual;\u62b5p\u0180DTV\u1063\u106e\u1078ownVector;\u694feeVector;\u695cector\u0100;B\u1082\u1083\u61bear;\u6954ector\u0100;B\u1091\u1092\u61c0ar;\u6953\u0100pu\u109b\u109ef;\u611dndImplies;\u6970ightarrow;\u61db\u0100ch\u10b9\u10bcr;\u611b;\u61b1leDelayed;\u69f4\u0680HOacfhimoqstu\u10e4\u10f1\u10f7\u10fd\u1119\u111e\u1151\u1156\u1161\u1167\u11b5\u11bb\u11bf\u0100Cc\u10e9\u10eeHcy;\u4429y;\u4428FTcy;\u442ccute;\u415a\u0280;aeiy\u1108\u1109\u110e\u1113\u1117\u6abcron;\u4160dil;\u415erc;\u415c;\u4421r;\uc000\ud835\udd16ort\u0200DLRU\u112a\u1134\u113e\u1149ownArrow\xbb\u041eeftArrow\xbb\u089aightArrow\xbb\u0fddpArrow;\u6191gma;\u43a3allCircle;\u6218pf;\uc000\ud835\udd4a\u0272\u116d\0\0\u1170t;\u621aare\u0200;ISU\u117b\u117c\u1189\u11af\u65a1ntersection;\u6293u\u0100bp\u118f\u119eset\u0100;E\u1197\u1198\u628fqual;\u6291erset\u0100;E\u11a8\u11a9\u6290qual;\u6292nion;\u6294cr;\uc000\ud835\udcaear;\u62c6\u0200bcmp\u11c8\u11db\u1209\u120b\u0100;s\u11cd\u11ce\u62d0et\u0100;E\u11cd\u11d5qual;\u6286\u0100ch\u11e0\u1205eeds\u0200;EST\u11ed\u11ee\u11f4\u11ff\u627bqual;\u6ab0lantEqual;\u627dilde;\u627fTh\xe1\u0f8c;\u6211\u0180;es\u1212\u1213\u1223\u62d1rset\u0100;E\u121c\u121d\u6283qual;\u6287et\xbb\u1213\u0580HRSacfhiors\u123e\u1244\u1249\u1255\u125e\u1271\u1276\u129f\u12c2\u12c8\u12d1ORN\u803b\xde\u40deADE;\u6122\u0100Hc\u124e\u1252cy;\u440by;\u4426\u0100bu\u125a\u125c;\u4009;\u43a4\u0180aey\u1265\u126a\u126fron;\u4164dil;\u4162;\u4422r;\uc000\ud835\udd17\u0100ei\u127b\u1289\u01f2\u1280\0\u1287efore;\u6234a;\u4398\u0100cn\u128e\u1298kSpace;\uc000\u205f\u200aSpace;\u6009lde\u0200;EFT\u12ab\u12ac\u12b2\u12bc\u623cqual;\u6243ullEqual;\u6245ilde;\u6248pf;\uc000\ud835\udd4bipleDot;\u60db\u0100ct\u12d6\u12dbr;\uc000\ud835\udcafrok;\u4166\u0ae1\u12f7\u130e\u131a\u1326\0\u132c\u1331\0\0\0\0\0\u1338\u133d\u1377\u1385\0\u13ff\u1404\u140a\u1410\u0100cr\u12fb\u1301ute\u803b\xda\u40dar\u0100;o\u1307\u1308\u619fcir;\u6949r\u01e3\u1313\0\u1316y;\u440eve;\u416c\u0100iy\u131e\u1323rc\u803b\xdb\u40db;\u4423blac;\u4170r;\uc000\ud835\udd18rave\u803b\xd9\u40d9acr;\u416a\u0100di\u1341\u1369er\u0100BP\u1348\u135d\u0100ar\u134d\u1350r;\u405fac\u0100ek\u1357\u1359;\u63dfet;\u63b5arenthesis;\u63ddon\u0100;P\u1370\u1371\u62c3lus;\u628e\u0100gp\u137b\u137fon;\u4172f;\uc000\ud835\udd4c\u0400ADETadps\u1395\u13ae\u13b8\u13c4\u03e8\u13d2\u13d7\u13f3rrow\u0180;BD\u1150\u13a0\u13a4ar;\u6912ownArrow;\u61c5ownArrow;\u6195quilibrium;\u696eee\u0100;A\u13cb\u13cc\u62a5rrow;\u61a5own\xe1\u03f3er\u0100LR\u13de\u13e8eftArrow;\u6196ightArrow;\u6197i\u0100;l\u13f9\u13fa\u43d2on;\u43a5ing;\u416ecr;\uc000\ud835\udcb0ilde;\u4168ml\u803b\xdc\u40dc\u0480Dbcdefosv\u1427\u142c\u1430\u1433\u143e\u1485\u148a\u1490\u1496ash;\u62abar;\u6aeby;\u4412ash\u0100;l\u143b\u143c\u62a9;\u6ae6\u0100er\u1443\u1445;\u62c1\u0180bty\u144c\u1450\u147aar;\u6016\u0100;i\u144f\u1455cal\u0200BLST\u1461\u1465\u146a\u1474ar;\u6223ine;\u407ceparator;\u6758ilde;\u6240ThinSpace;\u600ar;\uc000\ud835\udd19pf;\uc000\ud835\udd4dcr;\uc000\ud835\udcb1dash;\u62aa\u0280cefos\u14a7\u14ac\u14b1\u14b6\u14bcirc;\u4174dge;\u62c0r;\uc000\ud835\udd1apf;\uc000\ud835\udd4ecr;\uc000\ud835\udcb2\u0200fios\u14cb\u14d0\u14d2\u14d8r;\uc000\ud835\udd1b;\u439epf;\uc000\ud835\udd4fcr;\uc000\ud835\udcb3\u0480AIUacfosu\u14f1\u14f5\u14f9\u14fd\u1504\u150f\u1514\u151a\u1520cy;\u442fcy;\u4407cy;\u442ecute\u803b\xdd\u40dd\u0100iy\u1509\u150drc;\u4176;\u442br;\uc000\ud835\udd1cpf;\uc000\ud835\udd50cr;\uc000\ud835\udcb4ml;\u4178\u0400Hacdefos\u1535\u1539\u153f\u154b\u154f\u155d\u1560\u1564cy;\u4416cute;\u4179\u0100ay\u1544\u1549ron;\u417d;\u4417ot;\u417b\u01f2\u1554\0\u155boWidt\xe8\u0ad9a;\u4396r;\u6128pf;\u6124cr;\uc000\ud835\udcb5\u0be1\u1583\u158a\u1590\0\u15b0\u15b6\u15bf\0\0\0\0\u15c6\u15db\u15eb\u165f\u166d\0\u1695\u169b\u16b2\u16b9\0\u16becute\u803b\xe1\u40e1reve;\u4103\u0300;Ediuy\u159c\u159d\u15a1\u15a3\u15a8\u15ad\u623e;\uc000\u223e\u0333;\u623frc\u803b\xe2\u40e2te\u80bb\xb4\u0306;\u4430lig\u803b\xe6\u40e6\u0100;r\xb2\u15ba;\uc000\ud835\udd1erave\u803b\xe0\u40e0\u0100ep\u15ca\u15d6\u0100fp\u15cf\u15d4sym;\u6135\xe8\u15d3ha;\u43b1\u0100ap\u15dfc\u0100cl\u15e4\u15e7r;\u4101g;\u6a3f\u0264\u15f0\0\0\u160a\u0280;adsv\u15fa\u15fb\u15ff\u1601\u1607\u6227nd;\u6a55;\u6a5clope;\u6a58;\u6a5a\u0380;elmrsz\u1618\u1619\u161b\u161e\u163f\u164f\u1659\u6220;\u69a4e\xbb\u1619sd\u0100;a\u1625\u1626\u6221\u0461\u1630\u1632\u1634\u1636\u1638\u163a\u163c\u163e;\u69a8;\u69a9;\u69aa;\u69ab;\u69ac;\u69ad;\u69ae;\u69aft\u0100;v\u1645\u1646\u621fb\u0100;d\u164c\u164d\u62be;\u699d\u0100pt\u1654\u1657h;\u6222\xbb\xb9arr;\u637c\u0100gp\u1663\u1667on;\u4105f;\uc000\ud835\udd52\u0380;Eaeiop\u12c1\u167b\u167d\u1682\u1684\u1687\u168a;\u6a70cir;\u6a6f;\u624ad;\u624bs;\u4027rox\u0100;e\u12c1\u1692\xf1\u1683ing\u803b\xe5\u40e5\u0180cty\u16a1\u16a6\u16a8r;\uc000\ud835\udcb6;\u402amp\u0100;e\u12c1\u16af\xf1\u0288ilde\u803b\xe3\u40e3ml\u803b\xe4\u40e4\u0100ci\u16c2\u16c8onin\xf4\u0272nt;\u6a11\u0800Nabcdefiklnoprsu\u16ed\u16f1\u1730\u173c\u1743\u1748\u1778\u177d\u17e0\u17e6\u1839\u1850\u170d\u193d\u1948\u1970ot;\u6aed\u0100cr\u16f6\u171ek\u0200ceps\u1700\u1705\u170d\u1713ong;\u624cpsilon;\u43f6rime;\u6035im\u0100;e\u171a\u171b\u623dq;\u62cd\u0176\u1722\u1726ee;\u62bded\u0100;g\u172c\u172d\u6305e\xbb\u172drk\u0100;t\u135c\u1737brk;\u63b6\u0100oy\u1701\u1741;\u4431quo;\u601e\u0280cmprt\u1753\u175b\u1761\u1764\u1768aus\u0100;e\u010a\u0109ptyv;\u69b0s\xe9\u170cno\xf5\u0113\u0180ahw\u176f\u1771\u1773;\u43b2;\u6136een;\u626cr;\uc000\ud835\udd1fg\u0380costuvw\u178d\u179d\u17b3\u17c1\u17d5\u17db\u17de\u0180aiu\u1794\u1796\u179a\xf0\u0760rc;\u65efp\xbb\u1371\u0180dpt\u17a4\u17a8\u17adot;\u6a00lus;\u6a01imes;\u6a02\u0271\u17b9\0\0\u17becup;\u6a06ar;\u6605riangle\u0100du\u17cd\u17d2own;\u65bdp;\u65b3plus;\u6a04e\xe5\u1444\xe5\u14adarow;\u690d\u0180ako\u17ed\u1826\u1835\u0100cn\u17f2\u1823k\u0180lst\u17fa\u05ab\u1802ozenge;\u69ebriangle\u0200;dlr\u1812\u1813\u1818\u181d\u65b4own;\u65beeft;\u65c2ight;\u65b8k;\u6423\u01b1\u182b\0\u1833\u01b2\u182f\0\u1831;\u6592;\u65914;\u6593ck;\u6588\u0100eo\u183e\u184d\u0100;q\u1843\u1846\uc000=\u20e5uiv;\uc000\u2261\u20e5t;\u6310\u0200ptwx\u1859\u185e\u1867\u186cf;\uc000\ud835\udd53\u0100;t\u13cb\u1863om\xbb\u13cctie;\u62c8\u0600DHUVbdhmptuv\u1885\u1896\u18aa\u18bb\u18d7\u18db\u18ec\u18ff\u1905\u190a\u1910\u1921\u0200LRlr\u188e\u1890\u1892\u1894;\u6557;\u6554;\u6556;\u6553\u0280;DUdu\u18a1\u18a2\u18a4\u18a6\u18a8\u6550;\u6566;\u6569;\u6564;\u6567\u0200LRlr\u18b3\u18b5\u18b7\u18b9;\u655d;\u655a;\u655c;\u6559\u0380;HLRhlr\u18ca\u18cb\u18cd\u18cf\u18d1\u18d3\u18d5\u6551;\u656c;\u6563;\u6560;\u656b;\u6562;\u655fox;\u69c9\u0200LRlr\u18e4\u18e6\u18e8\u18ea;\u6555;\u6552;\u6510;\u650c\u0280;DUdu\u06bd\u18f7\u18f9\u18fb\u18fd;\u6565;\u6568;\u652c;\u6534inus;\u629flus;\u629eimes;\u62a0\u0200LRlr\u1919\u191b\u191d\u191f;\u655b;\u6558;\u6518;\u6514\u0380;HLRhlr\u1930\u1931\u1933\u1935\u1937\u1939\u193b\u6502;\u656a;\u6561;\u655e;\u653c;\u6524;\u651c\u0100ev\u0123\u1942bar\u803b\xa6\u40a6\u0200ceio\u1951\u1956\u195a\u1960r;\uc000\ud835\udcb7mi;\u604fm\u0100;e\u171a\u171cl\u0180;bh\u1968\u1969\u196b\u405c;\u69c5sub;\u67c8\u016c\u1974\u197el\u0100;e\u1979\u197a\u6022t\xbb\u197ap\u0180;Ee\u012f\u1985\u1987;\u6aae\u0100;q\u06dc\u06db\u0ce1\u19a7\0\u19e8\u1a11\u1a15\u1a32\0\u1a37\u1a50\0\0\u1ab4\0\0\u1ac1\0\0\u1b21\u1b2e\u1b4d\u1b52\0\u1bfd\0\u1c0c\u0180cpr\u19ad\u19b2\u19ddute;\u4107\u0300;abcds\u19bf\u19c0\u19c4\u19ca\u19d5\u19d9\u6229nd;\u6a44rcup;\u6a49\u0100au\u19cf\u19d2p;\u6a4bp;\u6a47ot;\u6a40;\uc000\u2229\ufe00\u0100eo\u19e2\u19e5t;\u6041\xee\u0693\u0200aeiu\u19f0\u19fb\u1a01\u1a05\u01f0\u19f5\0\u19f8s;\u6a4don;\u410ddil\u803b\xe7\u40e7rc;\u4109ps\u0100;s\u1a0c\u1a0d\u6a4cm;\u6a50ot;\u410b\u0180dmn\u1a1b\u1a20\u1a26il\u80bb\xb8\u01adptyv;\u69b2t\u8100\xa2;e\u1a2d\u1a2e\u40a2r\xe4\u01b2r;\uc000\ud835\udd20\u0180cei\u1a3d\u1a40\u1a4dy;\u4447ck\u0100;m\u1a47\u1a48\u6713ark\xbb\u1a48;\u43c7r\u0380;Ecefms\u1a5f\u1a60\u1a62\u1a6b\u1aa4\u1aaa\u1aae\u65cb;\u69c3\u0180;el\u1a69\u1a6a\u1a6d\u42c6q;\u6257e\u0261\u1a74\0\0\u1a88rrow\u0100lr\u1a7c\u1a81eft;\u61baight;\u61bb\u0280RSacd\u1a92\u1a94\u1a96\u1a9a\u1a9f\xbb\u0f47;\u64c8st;\u629birc;\u629aash;\u629dnint;\u6a10id;\u6aefcir;\u69c2ubs\u0100;u\u1abb\u1abc\u6663it\xbb\u1abc\u02ec\u1ac7\u1ad4\u1afa\0\u1b0aon\u0100;e\u1acd\u1ace\u403a\u0100;q\xc7\xc6\u026d\u1ad9\0\0\u1ae2a\u0100;t\u1ade\u1adf\u402c;\u4040\u0180;fl\u1ae8\u1ae9\u1aeb\u6201\xee\u1160e\u0100mx\u1af1\u1af6ent\xbb\u1ae9e\xf3\u024d\u01e7\u1afe\0\u1b07\u0100;d\u12bb\u1b02ot;\u6a6dn\xf4\u0246\u0180fry\u1b10\u1b14\u1b17;\uc000\ud835\udd54o\xe4\u0254\u8100\xa9;s\u0155\u1b1dr;\u6117\u0100ao\u1b25\u1b29rr;\u61b5ss;\u6717\u0100cu\u1b32\u1b37r;\uc000\ud835\udcb8\u0100bp\u1b3c\u1b44\u0100;e\u1b41\u1b42\u6acf;\u6ad1\u0100;e\u1b49\u1b4a\u6ad0;\u6ad2dot;\u62ef\u0380delprvw\u1b60\u1b6c\u1b77\u1b82\u1bac\u1bd4\u1bf9arr\u0100lr\u1b68\u1b6a;\u6938;\u6935\u0270\u1b72\0\0\u1b75r;\u62dec;\u62dfarr\u0100;p\u1b7f\u1b80\u61b6;\u693d\u0300;bcdos\u1b8f\u1b90\u1b96\u1ba1\u1ba5\u1ba8\u622arcap;\u6a48\u0100au\u1b9b\u1b9ep;\u6a46p;\u6a4aot;\u628dr;\u6a45;\uc000\u222a\ufe00\u0200alrv\u1bb5\u1bbf\u1bde\u1be3rr\u0100;m\u1bbc\u1bbd\u61b7;\u693cy\u0180evw\u1bc7\u1bd4\u1bd8q\u0270\u1bce\0\0\u1bd2re\xe3\u1b73u\xe3\u1b75ee;\u62ceedge;\u62cfen\u803b\xa4\u40a4earrow\u0100lr\u1bee\u1bf3eft\xbb\u1b80ight\xbb\u1bbde\xe4\u1bdd\u0100ci\u1c01\u1c07onin\xf4\u01f7nt;\u6231lcty;\u632d\u0980AHabcdefhijlorstuwz\u1c38\u1c3b\u1c3f\u1c5d\u1c69\u1c75\u1c8a\u1c9e\u1cac\u1cb7\u1cfb\u1cff\u1d0d\u1d7b\u1d91\u1dab\u1dbb\u1dc6\u1dcdr\xf2\u0381ar;\u6965\u0200glrs\u1c48\u1c4d\u1c52\u1c54ger;\u6020eth;\u6138\xf2\u1133h\u0100;v\u1c5a\u1c5b\u6010\xbb\u090a\u016b\u1c61\u1c67arow;\u690fa\xe3\u0315\u0100ay\u1c6e\u1c73ron;\u410f;\u4434\u0180;ao\u0332\u1c7c\u1c84\u0100gr\u02bf\u1c81r;\u61catseq;\u6a77\u0180glm\u1c91\u1c94\u1c98\u803b\xb0\u40b0ta;\u43b4ptyv;\u69b1\u0100ir\u1ca3\u1ca8sht;\u697f;\uc000\ud835\udd21ar\u0100lr\u1cb3\u1cb5\xbb\u08dc\xbb\u101e\u0280aegsv\u1cc2\u0378\u1cd6\u1cdc\u1ce0m\u0180;os\u0326\u1cca\u1cd4nd\u0100;s\u0326\u1cd1uit;\u6666amma;\u43ddin;\u62f2\u0180;io\u1ce7\u1ce8\u1cf8\u40f7de\u8100\xf7;o\u1ce7\u1cf0ntimes;\u62c7n\xf8\u1cf7cy;\u4452c\u026f\u1d06\0\0\u1d0arn;\u631eop;\u630d\u0280lptuw\u1d18\u1d1d\u1d22\u1d49\u1d55lar;\u4024f;\uc000\ud835\udd55\u0280;emps\u030b\u1d2d\u1d37\u1d3d\u1d42q\u0100;d\u0352\u1d33ot;\u6251inus;\u6238lus;\u6214quare;\u62a1blebarwedg\xe5\xfan\u0180adh\u112e\u1d5d\u1d67ownarrow\xf3\u1c83arpoon\u0100lr\u1d72\u1d76ef\xf4\u1cb4igh\xf4\u1cb6\u0162\u1d7f\u1d85karo\xf7\u0f42\u026f\u1d8a\0\0\u1d8ern;\u631fop;\u630c\u0180cot\u1d98\u1da3\u1da6\u0100ry\u1d9d\u1da1;\uc000\ud835\udcb9;\u4455l;\u69f6rok;\u4111\u0100dr\u1db0\u1db4ot;\u62f1i\u0100;f\u1dba\u1816\u65bf\u0100ah\u1dc0\u1dc3r\xf2\u0429a\xf2\u0fa6angle;\u69a6\u0100ci\u1dd2\u1dd5y;\u445fgrarr;\u67ff\u0900Dacdefglmnopqrstux\u1e01\u1e09\u1e19\u1e38\u0578\u1e3c\u1e49\u1e61\u1e7e\u1ea5\u1eaf\u1ebd\u1ee1\u1f2a\u1f37\u1f44\u1f4e\u1f5a\u0100Do\u1e06\u1d34o\xf4\u1c89\u0100cs\u1e0e\u1e14ute\u803b\xe9\u40e9ter;\u6a6e\u0200aioy\u1e22\u1e27\u1e31\u1e36ron;\u411br\u0100;c\u1e2d\u1e2e\u6256\u803b\xea\u40ealon;\u6255;\u444dot;\u4117\u0100Dr\u1e41\u1e45ot;\u6252;\uc000\ud835\udd22\u0180;rs\u1e50\u1e51\u1e57\u6a9aave\u803b\xe8\u40e8\u0100;d\u1e5c\u1e5d\u6a96ot;\u6a98\u0200;ils\u1e6a\u1e6b\u1e72\u1e74\u6a99nters;\u63e7;\u6113\u0100;d\u1e79\u1e7a\u6a95ot;\u6a97\u0180aps\u1e85\u1e89\u1e97cr;\u4113ty\u0180;sv\u1e92\u1e93\u1e95\u6205et\xbb\u1e93p\u01001;\u1e9d\u1ea4\u0133\u1ea1\u1ea3;\u6004;\u6005\u6003\u0100gs\u1eaa\u1eac;\u414bp;\u6002\u0100gp\u1eb4\u1eb8on;\u4119f;\uc000\ud835\udd56\u0180als\u1ec4\u1ece\u1ed2r\u0100;s\u1eca\u1ecb\u62d5l;\u69e3us;\u6a71i\u0180;lv\u1eda\u1edb\u1edf\u43b5on\xbb\u1edb;\u43f5\u0200csuv\u1eea\u1ef3\u1f0b\u1f23\u0100io\u1eef\u1e31rc\xbb\u1e2e\u0269\u1ef9\0\0\u1efb\xed\u0548ant\u0100gl\u1f02\u1f06tr\xbb\u1e5dess\xbb\u1e7a\u0180aei\u1f12\u1f16\u1f1als;\u403dst;\u625fv\u0100;D\u0235\u1f20D;\u6a78parsl;\u69e5\u0100Da\u1f2f\u1f33ot;\u6253rr;\u6971\u0180cdi\u1f3e\u1f41\u1ef8r;\u612fo\xf4\u0352\u0100ah\u1f49\u1f4b;\u43b7\u803b\xf0\u40f0\u0100mr\u1f53\u1f57l\u803b\xeb\u40ebo;\u60ac\u0180cip\u1f61\u1f64\u1f67l;\u4021s\xf4\u056e\u0100eo\u1f6c\u1f74ctatio\xee\u0559nential\xe5\u0579\u09e1\u1f92\0\u1f9e\0\u1fa1\u1fa7\0\0\u1fc6\u1fcc\0\u1fd3\0\u1fe6\u1fea\u2000\0\u2008\u205allingdotse\xf1\u1e44y;\u4444male;\u6640\u0180ilr\u1fad\u1fb3\u1fc1lig;\u8000\ufb03\u0269\u1fb9\0\0\u1fbdg;\u8000\ufb00ig;\u8000\ufb04;\uc000\ud835\udd23lig;\u8000\ufb01lig;\uc000fj\u0180alt\u1fd9\u1fdc\u1fe1t;\u666dig;\u8000\ufb02ns;\u65b1of;\u4192\u01f0\u1fee\0\u1ff3f;\uc000\ud835\udd57\u0100ak\u05bf\u1ff7\u0100;v\u1ffc\u1ffd\u62d4;\u6ad9artint;\u6a0d\u0100ao\u200c\u2055\u0100cs\u2011\u2052\u03b1\u201a\u2030\u2038\u2045\u2048\0\u2050\u03b2\u2022\u2025\u2027\u202a\u202c\0\u202e\u803b\xbd\u40bd;\u6153\u803b\xbc\u40bc;\u6155;\u6159;\u615b\u01b3\u2034\0\u2036;\u6154;\u6156\u02b4\u203e\u2041\0\0\u2043\u803b\xbe\u40be;\u6157;\u615c5;\u6158\u01b6\u204c\0\u204e;\u615a;\u615d8;\u615el;\u6044wn;\u6322cr;\uc000\ud835\udcbb\u0880Eabcdefgijlnorstv\u2082\u2089\u209f\u20a5\u20b0\u20b4\u20f0\u20f5\u20fa\u20ff\u2103\u2112\u2138\u0317\u213e\u2152\u219e\u0100;l\u064d\u2087;\u6a8c\u0180cmp\u2090\u2095\u209dute;\u41f5ma\u0100;d\u209c\u1cda\u43b3;\u6a86reve;\u411f\u0100iy\u20aa\u20aerc;\u411d;\u4433ot;\u4121\u0200;lqs\u063e\u0642\u20bd\u20c9\u0180;qs\u063e\u064c\u20c4lan\xf4\u0665\u0200;cdl\u0665\u20d2\u20d5\u20e5c;\u6aa9ot\u0100;o\u20dc\u20dd\u6a80\u0100;l\u20e2\u20e3\u6a82;\u6a84\u0100;e\u20ea\u20ed\uc000\u22db\ufe00s;\u6a94r;\uc000\ud835\udd24\u0100;g\u0673\u061bmel;\u6137cy;\u4453\u0200;Eaj\u065a\u210c\u210e\u2110;\u6a92;\u6aa5;\u6aa4\u0200Eaes\u211b\u211d\u2129\u2134;\u6269p\u0100;p\u2123\u2124\u6a8arox\xbb\u2124\u0100;q\u212e\u212f\u6a88\u0100;q\u212e\u211bim;\u62e7pf;\uc000\ud835\udd58\u0100ci\u2143\u2146r;\u610am\u0180;el\u066b\u214e\u2150;\u6a8e;\u6a90\u8300>;cdlqr\u05ee\u2160\u216a\u216e\u2173\u2179\u0100ci\u2165\u2167;\u6aa7r;\u6a7aot;\u62d7Par;\u6995uest;\u6a7c\u0280adels\u2184\u216a\u2190\u0656\u219b\u01f0\u2189\0\u218epro\xf8\u209er;\u6978q\u0100lq\u063f\u2196les\xf3\u2088i\xed\u066b\u0100en\u21a3\u21adrtneqq;\uc000\u2269\ufe00\xc5\u21aa\u0500Aabcefkosy\u21c4\u21c7\u21f1\u21f5\u21fa\u2218\u221d\u222f\u2268\u227dr\xf2\u03a0\u0200ilmr\u21d0\u21d4\u21d7\u21dbrs\xf0\u1484f\xbb\u2024il\xf4\u06a9\u0100dr\u21e0\u21e4cy;\u444a\u0180;cw\u08f4\u21eb\u21efir;\u6948;\u61adar;\u610firc;\u4125\u0180alr\u2201\u220e\u2213rts\u0100;u\u2209\u220a\u6665it\xbb\u220alip;\u6026con;\u62b9r;\uc000\ud835\udd25s\u0100ew\u2223\u2229arow;\u6925arow;\u6926\u0280amopr\u223a\u223e\u2243\u225e\u2263rr;\u61fftht;\u623bk\u0100lr\u2249\u2253eftarrow;\u61a9ightarrow;\u61aaf;\uc000\ud835\udd59bar;\u6015\u0180clt\u226f\u2274\u2278r;\uc000\ud835\udcbdas\xe8\u21f4rok;\u4127\u0100bp\u2282\u2287ull;\u6043hen\xbb\u1c5b\u0ae1\u22a3\0\u22aa\0\u22b8\u22c5\u22ce\0\u22d5\u22f3\0\0\u22f8\u2322\u2367\u2362\u237f\0\u2386\u23aa\u23b4cute\u803b\xed\u40ed\u0180;iy\u0771\u22b0\u22b5rc\u803b\xee\u40ee;\u4438\u0100cx\u22bc\u22bfy;\u4435cl\u803b\xa1\u40a1\u0100fr\u039f\u22c9;\uc000\ud835\udd26rave\u803b\xec\u40ec\u0200;ino\u073e\u22dd\u22e9\u22ee\u0100in\u22e2\u22e6nt;\u6a0ct;\u622dfin;\u69dcta;\u6129lig;\u4133\u0180aop\u22fe\u231a\u231d\u0180cgt\u2305\u2308\u2317r;\u412b\u0180elp\u071f\u230f\u2313in\xe5\u078ear\xf4\u0720h;\u4131f;\u62b7ed;\u41b5\u0280;cfot\u04f4\u232c\u2331\u233d\u2341are;\u6105in\u0100;t\u2338\u2339\u621eie;\u69dddo\xf4\u2319\u0280;celp\u0757\u234c\u2350\u235b\u2361al;\u62ba\u0100gr\u2355\u2359er\xf3\u1563\xe3\u234darhk;\u6a17rod;\u6a3c\u0200cgpt\u236f\u2372\u2376\u237by;\u4451on;\u412ff;\uc000\ud835\udd5aa;\u43b9uest\u803b\xbf\u40bf\u0100ci\u238a\u238fr;\uc000\ud835\udcben\u0280;Edsv\u04f4\u239b\u239d\u23a1\u04f3;\u62f9ot;\u62f5\u0100;v\u23a6\u23a7\u62f4;\u62f3\u0100;i\u0777\u23aelde;\u4129\u01eb\u23b8\0\u23bccy;\u4456l\u803b\xef\u40ef\u0300cfmosu\u23cc\u23d7\u23dc\u23e1\u23e7\u23f5\u0100iy\u23d1\u23d5rc;\u4135;\u4439r;\uc000\ud835\udd27ath;\u4237pf;\uc000\ud835\udd5b\u01e3\u23ec\0\u23f1r;\uc000\ud835\udcbfrcy;\u4458kcy;\u4454\u0400acfghjos\u240b\u2416\u2422\u2427\u242d\u2431\u2435\u243bppa\u0100;v\u2413\u2414\u43ba;\u43f0\u0100ey\u241b\u2420dil;\u4137;\u443ar;\uc000\ud835\udd28reen;\u4138cy;\u4445cy;\u445cpf;\uc000\ud835\udd5ccr;\uc000\ud835\udcc0\u0b80ABEHabcdefghjlmnoprstuv\u2470\u2481\u2486\u248d\u2491\u250e\u253d\u255a\u2580\u264e\u265e\u2665\u2679\u267d\u269a\u26b2\u26d8\u275d\u2768\u278b\u27c0\u2801\u2812\u0180art\u2477\u247a\u247cr\xf2\u09c6\xf2\u0395ail;\u691barr;\u690e\u0100;g\u0994\u248b;\u6a8bar;\u6962\u0963\u24a5\0\u24aa\0\u24b1\0\0\0\0\0\u24b5\u24ba\0\u24c6\u24c8\u24cd\0\u24f9ute;\u413amptyv;\u69b4ra\xee\u084cbda;\u43bbg\u0180;dl\u088e\u24c1\u24c3;\u6991\xe5\u088e;\u6a85uo\u803b\xab\u40abr\u0400;bfhlpst\u0899\u24de\u24e6\u24e9\u24eb\u24ee\u24f1\u24f5\u0100;f\u089d\u24e3s;\u691fs;\u691d\xeb\u2252p;\u61abl;\u6939im;\u6973l;\u61a2\u0180;ae\u24ff\u2500\u2504\u6aabil;\u6919\u0100;s\u2509\u250a\u6aad;\uc000\u2aad\ufe00\u0180abr\u2515\u2519\u251drr;\u690crk;\u6772\u0100ak\u2522\u252cc\u0100ek\u2528\u252a;\u407b;\u405b\u0100es\u2531\u2533;\u698bl\u0100du\u2539\u253b;\u698f;\u698d\u0200aeuy\u2546\u254b\u2556\u2558ron;\u413e\u0100di\u2550\u2554il;\u413c\xec\u08b0\xe2\u2529;\u443b\u0200cqrs\u2563\u2566\u256d\u257da;\u6936uo\u0100;r\u0e19\u1746\u0100du\u2572\u2577har;\u6967shar;\u694bh;\u61b2\u0280;fgqs\u258b\u258c\u0989\u25f3\u25ff\u6264t\u0280ahlrt\u2598\u25a4\u25b7\u25c2\u25e8rrow\u0100;t\u0899\u25a1a\xe9\u24f6arpoon\u0100du\u25af\u25b4own\xbb\u045ap\xbb\u0966eftarrows;\u61c7ight\u0180ahs\u25cd\u25d6\u25derrow\u0100;s\u08f4\u08a7arpoon\xf3\u0f98quigarro\xf7\u21f0hreetimes;\u62cb\u0180;qs\u258b\u0993\u25falan\xf4\u09ac\u0280;cdgs\u09ac\u260a\u260d\u261d\u2628c;\u6aa8ot\u0100;o\u2614\u2615\u6a7f\u0100;r\u261a\u261b\u6a81;\u6a83\u0100;e\u2622\u2625\uc000\u22da\ufe00s;\u6a93\u0280adegs\u2633\u2639\u263d\u2649\u264bppro\xf8\u24c6ot;\u62d6q\u0100gq\u2643\u2645\xf4\u0989gt\xf2\u248c\xf4\u099bi\xed\u09b2\u0180ilr\u2655\u08e1\u265asht;\u697c;\uc000\ud835\udd29\u0100;E\u099c\u2663;\u6a91\u0161\u2669\u2676r\u0100du\u25b2\u266e\u0100;l\u0965\u2673;\u696alk;\u6584cy;\u4459\u0280;acht\u0a48\u2688\u268b\u2691\u2696r\xf2\u25c1orne\xf2\u1d08ard;\u696bri;\u65fa\u0100io\u269f\u26a4dot;\u4140ust\u0100;a\u26ac\u26ad\u63b0che\xbb\u26ad\u0200Eaes\u26bb\u26bd\u26c9\u26d4;\u6268p\u0100;p\u26c3\u26c4\u6a89rox\xbb\u26c4\u0100;q\u26ce\u26cf\u6a87\u0100;q\u26ce\u26bbim;\u62e6\u0400abnoptwz\u26e9\u26f4\u26f7\u271a\u272f\u2741\u2747\u2750\u0100nr\u26ee\u26f1g;\u67ecr;\u61fdr\xeb\u08c1g\u0180lmr\u26ff\u270d\u2714eft\u0100ar\u09e6\u2707ight\xe1\u09f2apsto;\u67fcight\xe1\u09fdparrow\u0100lr\u2725\u2729ef\xf4\u24edight;\u61ac\u0180afl\u2736\u2739\u273dr;\u6985;\uc000\ud835\udd5dus;\u6a2dimes;\u6a34\u0161\u274b\u274fst;\u6217\xe1\u134e\u0180;ef\u2757\u2758\u1800\u65cange\xbb\u2758ar\u0100;l\u2764\u2765\u4028t;\u6993\u0280achmt\u2773\u2776\u277c\u2785\u2787r\xf2\u08a8orne\xf2\u1d8car\u0100;d\u0f98\u2783;\u696d;\u600eri;\u62bf\u0300achiqt\u2798\u279d\u0a40\u27a2\u27ae\u27bbquo;\u6039r;\uc000\ud835\udcc1m\u0180;eg\u09b2\u27aa\u27ac;\u6a8d;\u6a8f\u0100bu\u252a\u27b3o\u0100;r\u0e1f\u27b9;\u601arok;\u4142\u8400<;cdhilqr\u082b\u27d2\u2639\u27dc\u27e0\u27e5\u27ea\u27f0\u0100ci\u27d7\u27d9;\u6aa6r;\u6a79re\xe5\u25f2mes;\u62c9arr;\u6976uest;\u6a7b\u0100Pi\u27f5\u27f9ar;\u6996\u0180;ef\u2800\u092d\u181b\u65c3r\u0100du\u2807\u280dshar;\u694ahar;\u6966\u0100en\u2817\u2821rtneqq;\uc000\u2268\ufe00\xc5\u281e\u0700Dacdefhilnopsu\u2840\u2845\u2882\u288e\u2893\u28a0\u28a5\u28a8\u28da\u28e2\u28e4\u0a83\u28f3\u2902Dot;\u623a\u0200clpr\u284e\u2852\u2863\u287dr\u803b\xaf\u40af\u0100et\u2857\u2859;\u6642\u0100;e\u285e\u285f\u6720se\xbb\u285f\u0100;s\u103b\u2868to\u0200;dlu\u103b\u2873\u2877\u287bow\xee\u048cef\xf4\u090f\xf0\u13d1ker;\u65ae\u0100oy\u2887\u288cmma;\u6a29;\u443cash;\u6014asuredangle\xbb\u1626r;\uc000\ud835\udd2ao;\u6127\u0180cdn\u28af\u28b4\u28c9ro\u803b\xb5\u40b5\u0200;acd\u1464\u28bd\u28c0\u28c4s\xf4\u16a7ir;\u6af0ot\u80bb\xb7\u01b5us\u0180;bd\u28d2\u1903\u28d3\u6212\u0100;u\u1d3c\u28d8;\u6a2a\u0163\u28de\u28e1p;\u6adb\xf2\u2212\xf0\u0a81\u0100dp\u28e9\u28eeels;\u62a7f;\uc000\ud835\udd5e\u0100ct\u28f8\u28fdr;\uc000\ud835\udcc2pos\xbb\u159d\u0180;lm\u2909\u290a\u290d\u43bctimap;\u62b8\u0c00GLRVabcdefghijlmoprstuvw\u2942\u2953\u297e\u2989\u2998\u29da\u29e9\u2a15\u2a1a\u2a58\u2a5d\u2a83\u2a95\u2aa4\u2aa8\u2b04\u2b07\u2b44\u2b7f\u2bae\u2c34\u2c67\u2c7c\u2ce9\u0100gt\u2947\u294b;\uc000\u22d9\u0338\u0100;v\u2950\u0bcf\uc000\u226b\u20d2\u0180elt\u295a\u2972\u2976ft\u0100ar\u2961\u2967rrow;\u61cdightarrow;\u61ce;\uc000\u22d8\u0338\u0100;v\u297b\u0c47\uc000\u226a\u20d2ightarrow;\u61cf\u0100Dd\u298e\u2993ash;\u62afash;\u62ae\u0280bcnpt\u29a3\u29a7\u29ac\u29b1\u29ccla\xbb\u02deute;\u4144g;\uc000\u2220\u20d2\u0280;Eiop\u0d84\u29bc\u29c0\u29c5\u29c8;\uc000\u2a70\u0338d;\uc000\u224b\u0338s;\u4149ro\xf8\u0d84ur\u0100;a\u29d3\u29d4\u666el\u0100;s\u29d3\u0b38\u01f3\u29df\0\u29e3p\u80bb\xa0\u0b37mp\u0100;e\u0bf9\u0c00\u0280aeouy\u29f4\u29fe\u2a03\u2a10\u2a13\u01f0\u29f9\0\u29fb;\u6a43on;\u4148dil;\u4146ng\u0100;d\u0d7e\u2a0aot;\uc000\u2a6d\u0338p;\u6a42;\u443dash;\u6013\u0380;Aadqsx\u0b92\u2a29\u2a2d\u2a3b\u2a41\u2a45\u2a50rr;\u61d7r\u0100hr\u2a33\u2a36k;\u6924\u0100;o\u13f2\u13f0ot;\uc000\u2250\u0338ui\xf6\u0b63\u0100ei\u2a4a\u2a4ear;\u6928\xed\u0b98ist\u0100;s\u0ba0\u0b9fr;\uc000\ud835\udd2b\u0200Eest\u0bc5\u2a66\u2a79\u2a7c\u0180;qs\u0bbc\u2a6d\u0be1\u0180;qs\u0bbc\u0bc5\u2a74lan\xf4\u0be2i\xed\u0bea\u0100;r\u0bb6\u2a81\xbb\u0bb7\u0180Aap\u2a8a\u2a8d\u2a91r\xf2\u2971rr;\u61aear;\u6af2\u0180;sv\u0f8d\u2a9c\u0f8c\u0100;d\u2aa1\u2aa2\u62fc;\u62facy;\u445a\u0380AEadest\u2ab7\u2aba\u2abe\u2ac2\u2ac5\u2af6\u2af9r\xf2\u2966;\uc000\u2266\u0338rr;\u619ar;\u6025\u0200;fqs\u0c3b\u2ace\u2ae3\u2aeft\u0100ar\u2ad4\u2ad9rro\xf7\u2ac1ightarro\xf7\u2a90\u0180;qs\u0c3b\u2aba\u2aealan\xf4\u0c55\u0100;s\u0c55\u2af4\xbb\u0c36i\xed\u0c5d\u0100;r\u0c35\u2afei\u0100;e\u0c1a\u0c25i\xe4\u0d90\u0100pt\u2b0c\u2b11f;\uc000\ud835\udd5f\u8180\xac;in\u2b19\u2b1a\u2b36\u40acn\u0200;Edv\u0b89\u2b24\u2b28\u2b2e;\uc000\u22f9\u0338ot;\uc000\u22f5\u0338\u01e1\u0b89\u2b33\u2b35;\u62f7;\u62f6i\u0100;v\u0cb8\u2b3c\u01e1\u0cb8\u2b41\u2b43;\u62fe;\u62fd\u0180aor\u2b4b\u2b63\u2b69r\u0200;ast\u0b7b\u2b55\u2b5a\u2b5flle\xec\u0b7bl;\uc000\u2afd\u20e5;\uc000\u2202\u0338lint;\u6a14\u0180;ce\u0c92\u2b70\u2b73u\xe5\u0ca5\u0100;c\u0c98\u2b78\u0100;e\u0c92\u2b7d\xf1\u0c98\u0200Aait\u2b88\u2b8b\u2b9d\u2ba7r\xf2\u2988rr\u0180;cw\u2b94\u2b95\u2b99\u619b;\uc000\u2933\u0338;\uc000\u219d\u0338ghtarrow\xbb\u2b95ri\u0100;e\u0ccb\u0cd6\u0380chimpqu\u2bbd\u2bcd\u2bd9\u2b04\u0b78\u2be4\u2bef\u0200;cer\u0d32\u2bc6\u0d37\u2bc9u\xe5\u0d45;\uc000\ud835\udcc3ort\u026d\u2b05\0\0\u2bd6ar\xe1\u2b56m\u0100;e\u0d6e\u2bdf\u0100;q\u0d74\u0d73su\u0100bp\u2beb\u2bed\xe5\u0cf8\xe5\u0d0b\u0180bcp\u2bf6\u2c11\u2c19\u0200;Ees\u2bff\u2c00\u0d22\u2c04\u6284;\uc000\u2ac5\u0338et\u0100;e\u0d1b\u2c0bq\u0100;q\u0d23\u2c00c\u0100;e\u0d32\u2c17\xf1\u0d38\u0200;Ees\u2c22\u2c23\u0d5f\u2c27\u6285;\uc000\u2ac6\u0338et\u0100;e\u0d58\u2c2eq\u0100;q\u0d60\u2c23\u0200gilr\u2c3d\u2c3f\u2c45\u2c47\xec\u0bd7lde\u803b\xf1\u40f1\xe7\u0c43iangle\u0100lr\u2c52\u2c5ceft\u0100;e\u0c1a\u2c5a\xf1\u0c26ight\u0100;e\u0ccb\u2c65\xf1\u0cd7\u0100;m\u2c6c\u2c6d\u43bd\u0180;es\u2c74\u2c75\u2c79\u4023ro;\u6116p;\u6007\u0480DHadgilrs\u2c8f\u2c94\u2c99\u2c9e\u2ca3\u2cb0\u2cb6\u2cd3\u2ce3ash;\u62adarr;\u6904p;\uc000\u224d\u20d2ash;\u62ac\u0100et\u2ca8\u2cac;\uc000\u2265\u20d2;\uc000>\u20d2nfin;\u69de\u0180Aet\u2cbd\u2cc1\u2cc5rr;\u6902;\uc000\u2264\u20d2\u0100;r\u2cca\u2ccd\uc000<\u20d2ie;\uc000\u22b4\u20d2\u0100At\u2cd8\u2cdcrr;\u6903rie;\uc000\u22b5\u20d2im;\uc000\u223c\u20d2\u0180Aan\u2cf0\u2cf4\u2d02rr;\u61d6r\u0100hr\u2cfa\u2cfdk;\u6923\u0100;o\u13e7\u13e5ear;\u6927\u1253\u1a95\0\0\0\0\0\0\0\0\0\0\0\0\0\u2d2d\0\u2d38\u2d48\u2d60\u2d65\u2d72\u2d84\u1b07\0\0\u2d8d\u2dab\0\u2dc8\u2dce\0\u2ddc\u2e19\u2e2b\u2e3e\u2e43\u0100cs\u2d31\u1a97ute\u803b\xf3\u40f3\u0100iy\u2d3c\u2d45r\u0100;c\u1a9e\u2d42\u803b\xf4\u40f4;\u443e\u0280abios\u1aa0\u2d52\u2d57\u01c8\u2d5alac;\u4151v;\u6a38old;\u69bclig;\u4153\u0100cr\u2d69\u2d6dir;\u69bf;\uc000\ud835\udd2c\u036f\u2d79\0\0\u2d7c\0\u2d82n;\u42dbave\u803b\xf2\u40f2;\u69c1\u0100bm\u2d88\u0df4ar;\u69b5\u0200acit\u2d95\u2d98\u2da5\u2da8r\xf2\u1a80\u0100ir\u2d9d\u2da0r;\u69beoss;\u69bbn\xe5\u0e52;\u69c0\u0180aei\u2db1\u2db5\u2db9cr;\u414dga;\u43c9\u0180cdn\u2dc0\u2dc5\u01cdron;\u43bf;\u69b6pf;\uc000\ud835\udd60\u0180ael\u2dd4\u2dd7\u01d2r;\u69b7rp;\u69b9\u0380;adiosv\u2dea\u2deb\u2dee\u2e08\u2e0d\u2e10\u2e16\u6228r\xf2\u1a86\u0200;efm\u2df7\u2df8\u2e02\u2e05\u6a5dr\u0100;o\u2dfe\u2dff\u6134f\xbb\u2dff\u803b\xaa\u40aa\u803b\xba\u40bagof;\u62b6r;\u6a56lope;\u6a57;\u6a5b\u0180clo\u2e1f\u2e21\u2e27\xf2\u2e01ash\u803b\xf8\u40f8l;\u6298i\u016c\u2e2f\u2e34de\u803b\xf5\u40f5es\u0100;a\u01db\u2e3as;\u6a36ml\u803b\xf6\u40f6bar;\u633d\u0ae1\u2e5e\0\u2e7d\0\u2e80\u2e9d\0\u2ea2\u2eb9\0\0\u2ecb\u0e9c\0\u2f13\0\0\u2f2b\u2fbc\0\u2fc8r\u0200;ast\u0403\u2e67\u2e72\u0e85\u8100\xb6;l\u2e6d\u2e6e\u40b6le\xec\u0403\u0269\u2e78\0\0\u2e7bm;\u6af3;\u6afdy;\u443fr\u0280cimpt\u2e8b\u2e8f\u2e93\u1865\u2e97nt;\u4025od;\u402eil;\u6030enk;\u6031r;\uc000\ud835\udd2d\u0180imo\u2ea8\u2eb0\u2eb4\u0100;v\u2ead\u2eae\u43c6;\u43d5ma\xf4\u0a76ne;\u660e\u0180;tv\u2ebf\u2ec0\u2ec8\u43c0chfork\xbb\u1ffd;\u43d6\u0100au\u2ecf\u2edfn\u0100ck\u2ed5\u2eddk\u0100;h\u21f4\u2edb;\u610e\xf6\u21f4s\u0480;abcdemst\u2ef3\u2ef4\u1908\u2ef9\u2efd\u2f04\u2f06\u2f0a\u2f0e\u402bcir;\u6a23ir;\u6a22\u0100ou\u1d40\u2f02;\u6a25;\u6a72n\u80bb\xb1\u0e9dim;\u6a26wo;\u6a27\u0180ipu\u2f19\u2f20\u2f25ntint;\u6a15f;\uc000\ud835\udd61nd\u803b\xa3\u40a3\u0500;Eaceinosu\u0ec8\u2f3f\u2f41\u2f44\u2f47\u2f81\u2f89\u2f92\u2f7e\u2fb6;\u6ab3p;\u6ab7u\xe5\u0ed9\u0100;c\u0ece\u2f4c\u0300;acens\u0ec8\u2f59\u2f5f\u2f66\u2f68\u2f7eppro\xf8\u2f43urlye\xf1\u0ed9\xf1\u0ece\u0180aes\u2f6f\u2f76\u2f7approx;\u6ab9qq;\u6ab5im;\u62e8i\xed\u0edfme\u0100;s\u2f88\u0eae\u6032\u0180Eas\u2f78\u2f90\u2f7a\xf0\u2f75\u0180dfp\u0eec\u2f99\u2faf\u0180als\u2fa0\u2fa5\u2faalar;\u632eine;\u6312urf;\u6313\u0100;t\u0efb\u2fb4\xef\u0efbrel;\u62b0\u0100ci\u2fc0\u2fc5r;\uc000\ud835\udcc5;\u43c8ncsp;\u6008\u0300fiopsu\u2fda\u22e2\u2fdf\u2fe5\u2feb\u2ff1r;\uc000\ud835\udd2epf;\uc000\ud835\udd62rime;\u6057cr;\uc000\ud835\udcc6\u0180aeo\u2ff8\u3009\u3013t\u0100ei\u2ffe\u3005rnion\xf3\u06b0nt;\u6a16st\u0100;e\u3010\u3011\u403f\xf1\u1f19\xf4\u0f14\u0a80ABHabcdefhilmnoprstux\u3040\u3051\u3055\u3059\u30e0\u310e\u312b\u3147\u3162\u3172\u318e\u3206\u3215\u3224\u3229\u3258\u326e\u3272\u3290\u32b0\u32b7\u0180art\u3047\u304a\u304cr\xf2\u10b3\xf2\u03ddail;\u691car\xf2\u1c65ar;\u6964\u0380cdenqrt\u3068\u3075\u3078\u307f\u308f\u3094\u30cc\u0100eu\u306d\u3071;\uc000\u223d\u0331te;\u4155i\xe3\u116emptyv;\u69b3g\u0200;del\u0fd1\u3089\u308b\u308d;\u6992;\u69a5\xe5\u0fd1uo\u803b\xbb\u40bbr\u0580;abcfhlpstw\u0fdc\u30ac\u30af\u30b7\u30b9\u30bc\u30be\u30c0\u30c3\u30c7\u30cap;\u6975\u0100;f\u0fe0\u30b4s;\u6920;\u6933s;\u691e\xeb\u225d\xf0\u272el;\u6945im;\u6974l;\u61a3;\u619d\u0100ai\u30d1\u30d5il;\u691ao\u0100;n\u30db\u30dc\u6236al\xf3\u0f1e\u0180abr\u30e7\u30ea\u30eer\xf2\u17e5rk;\u6773\u0100ak\u30f3\u30fdc\u0100ek\u30f9\u30fb;\u407d;\u405d\u0100es\u3102\u3104;\u698cl\u0100du\u310a\u310c;\u698e;\u6990\u0200aeuy\u3117\u311c\u3127\u3129ron;\u4159\u0100di\u3121\u3125il;\u4157\xec\u0ff2\xe2\u30fa;\u4440\u0200clqs\u3134\u3137\u313d\u3144a;\u6937dhar;\u6969uo\u0100;r\u020e\u020dh;\u61b3\u0180acg\u314e\u315f\u0f44l\u0200;ips\u0f78\u3158\u315b\u109cn\xe5\u10bbar\xf4\u0fa9t;\u65ad\u0180ilr\u3169\u1023\u316esht;\u697d;\uc000\ud835\udd2f\u0100ao\u3177\u3186r\u0100du\u317d\u317f\xbb\u047b\u0100;l\u1091\u3184;\u696c\u0100;v\u318b\u318c\u43c1;\u43f1\u0180gns\u3195\u31f9\u31fcht\u0300ahlrst\u31a4\u31b0\u31c2\u31d8\u31e4\u31eerrow\u0100;t\u0fdc\u31ada\xe9\u30c8arpoon\u0100du\u31bb\u31bfow\xee\u317ep\xbb\u1092eft\u0100ah\u31ca\u31d0rrow\xf3\u0feaarpoon\xf3\u0551ightarrows;\u61c9quigarro\xf7\u30cbhreetimes;\u62ccg;\u42daingdotse\xf1\u1f32\u0180ahm\u320d\u3210\u3213r\xf2\u0feaa\xf2\u0551;\u600foust\u0100;a\u321e\u321f\u63b1che\xbb\u321fmid;\u6aee\u0200abpt\u3232\u323d\u3240\u3252\u0100nr\u3237\u323ag;\u67edr;\u61fer\xeb\u1003\u0180afl\u3247\u324a\u324er;\u6986;\uc000\ud835\udd63us;\u6a2eimes;\u6a35\u0100ap\u325d\u3267r\u0100;g\u3263\u3264\u4029t;\u6994olint;\u6a12ar\xf2\u31e3\u0200achq\u327b\u3280\u10bc\u3285quo;\u603ar;\uc000\ud835\udcc7\u0100bu\u30fb\u328ao\u0100;r\u0214\u0213\u0180hir\u3297\u329b\u32a0re\xe5\u31f8mes;\u62cai\u0200;efl\u32aa\u1059\u1821\u32ab\u65b9tri;\u69celuhar;\u6968;\u611e\u0d61\u32d5\u32db\u32df\u332c\u3338\u3371\0\u337a\u33a4\0\0\u33ec\u33f0\0\u3428\u3448\u345a\u34ad\u34b1\u34ca\u34f1\0\u3616\0\0\u3633cute;\u415bqu\xef\u27ba\u0500;Eaceinpsy\u11ed\u32f3\u32f5\u32ff\u3302\u330b\u330f\u331f\u3326\u3329;\u6ab4\u01f0\u32fa\0\u32fc;\u6ab8on;\u4161u\xe5\u11fe\u0100;d\u11f3\u3307il;\u415frc;\u415d\u0180Eas\u3316\u3318\u331b;\u6ab6p;\u6abaim;\u62e9olint;\u6a13i\xed\u1204;\u4441ot\u0180;be\u3334\u1d47\u3335\u62c5;\u6a66\u0380Aacmstx\u3346\u334a\u3357\u335b\u335e\u3363\u336drr;\u61d8r\u0100hr\u3350\u3352\xeb\u2228\u0100;o\u0a36\u0a34t\u803b\xa7\u40a7i;\u403bwar;\u6929m\u0100in\u3369\xf0nu\xf3\xf1t;\u6736r\u0100;o\u3376\u2055\uc000\ud835\udd30\u0200acoy\u3382\u3386\u3391\u33a0rp;\u666f\u0100hy\u338b\u338fcy;\u4449;\u4448rt\u026d\u3399\0\0\u339ci\xe4\u1464ara\xec\u2e6f\u803b\xad\u40ad\u0100gm\u33a8\u33b4ma\u0180;fv\u33b1\u33b2\u33b2\u43c3;\u43c2\u0400;deglnpr\u12ab\u33c5\u33c9\u33ce\u33d6\u33de\u33e1\u33e6ot;\u6a6a\u0100;q\u12b1\u12b0\u0100;E\u33d3\u33d4\u6a9e;\u6aa0\u0100;E\u33db\u33dc\u6a9d;\u6a9fe;\u6246lus;\u6a24arr;\u6972ar\xf2\u113d\u0200aeit\u33f8\u3408\u340f\u3417\u0100ls\u33fd\u3404lsetm\xe9\u336ahp;\u6a33parsl;\u69e4\u0100dl\u1463\u3414e;\u6323\u0100;e\u341c\u341d\u6aaa\u0100;s\u3422\u3423\u6aac;\uc000\u2aac\ufe00\u0180flp\u342e\u3433\u3442tcy;\u444c\u0100;b\u3438\u3439\u402f\u0100;a\u343e\u343f\u69c4r;\u633ff;\uc000\ud835\udd64a\u0100dr\u344d\u0402es\u0100;u\u3454\u3455\u6660it\xbb\u3455\u0180csu\u3460\u3479\u349f\u0100au\u3465\u346fp\u0100;s\u1188\u346b;\uc000\u2293\ufe00p\u0100;s\u11b4\u3475;\uc000\u2294\ufe00u\u0100bp\u347f\u348f\u0180;es\u1197\u119c\u3486et\u0100;e\u1197\u348d\xf1\u119d\u0180;es\u11a8\u11ad\u3496et\u0100;e\u11a8\u349d\xf1\u11ae\u0180;af\u117b\u34a6\u05b0r\u0165\u34ab\u05b1\xbb\u117car\xf2\u1148\u0200cemt\u34b9\u34be\u34c2\u34c5r;\uc000\ud835\udcc8tm\xee\xf1i\xec\u3415ar\xe6\u11be\u0100ar\u34ce\u34d5r\u0100;f\u34d4\u17bf\u6606\u0100an\u34da\u34edight\u0100ep\u34e3\u34eapsilo\xee\u1ee0h\xe9\u2eafs\xbb\u2852\u0280bcmnp\u34fb\u355e\u1209\u358b\u358e\u0480;Edemnprs\u350e\u350f\u3511\u3515\u351e\u3523\u352c\u3531\u3536\u6282;\u6ac5ot;\u6abd\u0100;d\u11da\u351aot;\u6ac3ult;\u6ac1\u0100Ee\u3528\u352a;\u6acb;\u628alus;\u6abfarr;\u6979\u0180eiu\u353d\u3552\u3555t\u0180;en\u350e\u3545\u354bq\u0100;q\u11da\u350feq\u0100;q\u352b\u3528m;\u6ac7\u0100bp\u355a\u355c;\u6ad5;\u6ad3c\u0300;acens\u11ed\u356c\u3572\u3579\u357b\u3326ppro\xf8\u32faurlye\xf1\u11fe\xf1\u11f3\u0180aes\u3582\u3588\u331bppro\xf8\u331aq\xf1\u3317g;\u666a\u0680123;Edehlmnps\u35a9\u35ac\u35af\u121c\u35b2\u35b4\u35c0\u35c9\u35d5\u35da\u35df\u35e8\u35ed\u803b\xb9\u40b9\u803b\xb2\u40b2\u803b\xb3\u40b3;\u6ac6\u0100os\u35b9\u35bct;\u6abeub;\u6ad8\u0100;d\u1222\u35c5ot;\u6ac4s\u0100ou\u35cf\u35d2l;\u67c9b;\u6ad7arr;\u697bult;\u6ac2\u0100Ee\u35e4\u35e6;\u6acc;\u628blus;\u6ac0\u0180eiu\u35f4\u3609\u360ct\u0180;en\u121c\u35fc\u3602q\u0100;q\u1222\u35b2eq\u0100;q\u35e7\u35e4m;\u6ac8\u0100bp\u3611\u3613;\u6ad4;\u6ad6\u0180Aan\u361c\u3620\u362drr;\u61d9r\u0100hr\u3626\u3628\xeb\u222e\u0100;o\u0a2b\u0a29war;\u692alig\u803b\xdf\u40df\u0be1\u3651\u365d\u3660\u12ce\u3673\u3679\0\u367e\u36c2\0\0\0\0\0\u36db\u3703\0\u3709\u376c\0\0\0\u3787\u0272\u3656\0\0\u365bget;\u6316;\u43c4r\xeb\u0e5f\u0180aey\u3666\u366b\u3670ron;\u4165dil;\u4163;\u4442lrec;\u6315r;\uc000\ud835\udd31\u0200eiko\u3686\u369d\u36b5\u36bc\u01f2\u368b\0\u3691e\u01004f\u1284\u1281a\u0180;sv\u3698\u3699\u369b\u43b8ym;\u43d1\u0100cn\u36a2\u36b2k\u0100as\u36a8\u36aeppro\xf8\u12c1im\xbb\u12acs\xf0\u129e\u0100as\u36ba\u36ae\xf0\u12c1rn\u803b\xfe\u40fe\u01ec\u031f\u36c6\u22e7es\u8180\xd7;bd\u36cf\u36d0\u36d8\u40d7\u0100;a\u190f\u36d5r;\u6a31;\u6a30\u0180eps\u36e1\u36e3\u3700\xe1\u2a4d\u0200;bcf\u0486\u36ec\u36f0\u36f4ot;\u6336ir;\u6af1\u0100;o\u36f9\u36fc\uc000\ud835\udd65rk;\u6ada\xe1\u3362rime;\u6034\u0180aip\u370f\u3712\u3764d\xe5\u1248\u0380adempst\u3721\u374d\u3740\u3751\u3757\u375c\u375fngle\u0280;dlqr\u3730\u3731\u3736\u3740\u3742\u65b5own\xbb\u1dbbeft\u0100;e\u2800\u373e\xf1\u092e;\u625cight\u0100;e\u32aa\u374b\xf1\u105aot;\u65ecinus;\u6a3alus;\u6a39b;\u69cdime;\u6a3bezium;\u63e2\u0180cht\u3772\u377d\u3781\u0100ry\u3777\u377b;\uc000\ud835\udcc9;\u4446cy;\u445brok;\u4167\u0100io\u378b\u378ex\xf4\u1777head\u0100lr\u3797\u37a0eftarro\xf7\u084fightarrow\xbb\u0f5d\u0900AHabcdfghlmoprstuw\u37d0\u37d3\u37d7\u37e4\u37f0\u37fc\u380e\u381c\u3823\u3834\u3851\u385d\u386b\u38a9\u38cc\u38d2\u38ea\u38f6r\xf2\u03edar;\u6963\u0100cr\u37dc\u37e2ute\u803b\xfa\u40fa\xf2\u1150r\u01e3\u37ea\0\u37edy;\u445eve;\u416d\u0100iy\u37f5\u37farc\u803b\xfb\u40fb;\u4443\u0180abh\u3803\u3806\u380br\xf2\u13adlac;\u4171a\xf2\u13c3\u0100ir\u3813\u3818sht;\u697e;\uc000\ud835\udd32rave\u803b\xf9\u40f9\u0161\u3827\u3831r\u0100lr\u382c\u382e\xbb\u0957\xbb\u1083lk;\u6580\u0100ct\u3839\u384d\u026f\u383f\0\0\u384arn\u0100;e\u3845\u3846\u631cr\xbb\u3846op;\u630fri;\u65f8\u0100al\u3856\u385acr;\u416b\u80bb\xa8\u0349\u0100gp\u3862\u3866on;\u4173f;\uc000\ud835\udd66\u0300adhlsu\u114b\u3878\u387d\u1372\u3891\u38a0own\xe1\u13b3arpoon\u0100lr\u3888\u388cef\xf4\u382digh\xf4\u382fi\u0180;hl\u3899\u389a\u389c\u43c5\xbb\u13faon\xbb\u389aparrows;\u61c8\u0180cit\u38b0\u38c4\u38c8\u026f\u38b6\0\0\u38c1rn\u0100;e\u38bc\u38bd\u631dr\xbb\u38bdop;\u630eng;\u416fri;\u65f9cr;\uc000\ud835\udcca\u0180dir\u38d9\u38dd\u38e2ot;\u62f0lde;\u4169i\u0100;f\u3730\u38e8\xbb\u1813\u0100am\u38ef\u38f2r\xf2\u38a8l\u803b\xfc\u40fcangle;\u69a7\u0780ABDacdeflnoprsz\u391c\u391f\u3929\u392d\u39b5\u39b8\u39bd\u39df\u39e4\u39e8\u39f3\u39f9\u39fd\u3a01\u3a20r\xf2\u03f7ar\u0100;v\u3926\u3927\u6ae8;\u6ae9as\xe8\u03e1\u0100nr\u3932\u3937grt;\u699c\u0380eknprst\u34e3\u3946\u394b\u3952\u395d\u3964\u3996app\xe1\u2415othin\xe7\u1e96\u0180hir\u34eb\u2ec8\u3959op\xf4\u2fb5\u0100;h\u13b7\u3962\xef\u318d\u0100iu\u3969\u396dgm\xe1\u33b3\u0100bp\u3972\u3984setneq\u0100;q\u397d\u3980\uc000\u228a\ufe00;\uc000\u2acb\ufe00setneq\u0100;q\u398f\u3992\uc000\u228b\ufe00;\uc000\u2acc\ufe00\u0100hr\u399b\u399fet\xe1\u369ciangle\u0100lr\u39aa\u39afeft\xbb\u0925ight\xbb\u1051y;\u4432ash\xbb\u1036\u0180elr\u39c4\u39d2\u39d7\u0180;be\u2dea\u39cb\u39cfar;\u62bbq;\u625alip;\u62ee\u0100bt\u39dc\u1468a\xf2\u1469r;\uc000\ud835\udd33tr\xe9\u39aesu\u0100bp\u39ef\u39f1\xbb\u0d1c\xbb\u0d59pf;\uc000\ud835\udd67ro\xf0\u0efbtr\xe9\u39b4\u0100cu\u3a06\u3a0br;\uc000\ud835\udccb\u0100bp\u3a10\u3a18n\u0100Ee\u3980\u3a16\xbb\u397en\u0100Ee\u3992\u3a1e\xbb\u3990igzag;\u699a\u0380cefoprs\u3a36\u3a3b\u3a56\u3a5b\u3a54\u3a61\u3a6airc;\u4175\u0100di\u3a40\u3a51\u0100bg\u3a45\u3a49ar;\u6a5fe\u0100;q\u15fa\u3a4f;\u6259erp;\u6118r;\uc000\ud835\udd34pf;\uc000\ud835\udd68\u0100;e\u1479\u3a66at\xe8\u1479cr;\uc000\ud835\udccc\u0ae3\u178e\u3a87\0\u3a8b\0\u3a90\u3a9b\0\0\u3a9d\u3aa8\u3aab\u3aaf\0\0\u3ac3\u3ace\0\u3ad8\u17dc\u17dftr\xe9\u17d1r;\uc000\ud835\udd35\u0100Aa\u3a94\u3a97r\xf2\u03c3r\xf2\u09f6;\u43be\u0100Aa\u3aa1\u3aa4r\xf2\u03b8r\xf2\u09eba\xf0\u2713is;\u62fb\u0180dpt\u17a4\u3ab5\u3abe\u0100fl\u3aba\u17a9;\uc000\ud835\udd69im\xe5\u17b2\u0100Aa\u3ac7\u3acar\xf2\u03cer\xf2\u0a01\u0100cq\u3ad2\u17b8r;\uc000\ud835\udccd\u0100pt\u17d6\u3adcr\xe9\u17d4\u0400acefiosu\u3af0\u3afd\u3b08\u3b0c\u3b11\u3b15\u3b1b\u3b21c\u0100uy\u3af6\u3afbte\u803b\xfd\u40fd;\u444f\u0100iy\u3b02\u3b06rc;\u4177;\u444bn\u803b\xa5\u40a5r;\uc000\ud835\udd36cy;\u4457pf;\uc000\ud835\udd6acr;\uc000\ud835\udcce\u0100cm\u3b26\u3b29y;\u444el\u803b\xff\u40ff\u0500acdefhiosw\u3b42\u3b48\u3b54\u3b58\u3b64\u3b69\u3b6d\u3b74\u3b7a\u3b80cute;\u417a\u0100ay\u3b4d\u3b52ron;\u417e;\u4437ot;\u417c\u0100et\u3b5d\u3b61tr\xe6\u155fa;\u43b6r;\uc000\ud835\udd37cy;\u4436grarr;\u61ddpf;\uc000\ud835\udd6bcr;\uc000\ud835\udccf\u0100jn\u3b85\u3b87;\u600dj;\u600c"
+    .split("")
+    .map((c) => c.charCodeAt(0)));
+
+// Generated using scripts/write-decode-map.ts
+new Uint16Array(
+// prettier-ignore
+"\u0200aglq\t\x15\x18\x1b\u026d\x0f\0\0\x12p;\u4026os;\u4027t;\u403et;\u403cuot;\u4022"
+    .split("")
+    .map((c) => c.charCodeAt(0)));
+
+var CharCodes;
+(function (CharCodes) {
+    CharCodes[CharCodes["NUM"] = 35] = "NUM";
+    CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+    CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
+    CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
+    CharCodes[CharCodes["NINE"] = 57] = "NINE";
+    CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
+    CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
+    CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
+    CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+    CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+    CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+    CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes || (CharCodes = {}));
+var BinTrieFlags;
+(function (BinTrieFlags) {
+    BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+    BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
+    BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (BinTrieFlags = {}));
+var EntityDecoderState;
+(function (EntityDecoderState) {
+    EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+    EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+    EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+    EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+    EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function (DecodingMode) {
+    /** Entities in text nodes that can end with any character. */
+    DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+    /** Only allow entities terminated with a semicolon. */
+    DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+    /** Entities in attributes have limitations on ending characters. */
+    DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+/**
+ * Determines the branch of the current node that is taken given the current
+ * character. This function is used to traverse the trie.
+ *
+ * @param decodeTree The trie.
+ * @param current The current node.
+ * @param nodeIdx The index right after the current node and its value.
+ * @param char The current character.
+ * @returns The index of the next node, or -1 if no branch is taken.
+ */
+function determineBranch(decodeTree, current, nodeIdx, char) {
+    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+    // Case 1: Single branch encoded in jump offset
+    if (branchCount === 0) {
+        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
+    }
+    // Case 2: Multiple branches encoded in jump table
+    if (jumpOffset) {
+        const value = char - jumpOffset;
+        return value < 0 || value >= branchCount
+            ? -1
+            : decodeTree[nodeIdx + value] - 1;
+    }
+    // Case 3: Multiple branches encoded in dictionary
+    // Binary search for the character.
+    let lo = nodeIdx;
+    let hi = lo + branchCount - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const midVal = decodeTree[mid];
+        if (midVal < char) {
+            lo = mid + 1;
+        }
+        else if (midVal > char) {
+            hi = mid - 1;
+        }
+        else {
+            return decodeTree[mid + branchCount];
+        }
+    }
+    return -1;
+}
+
+/** All valid namespaces in HTML. */
+var NS;
+(function (NS) {
+    NS["HTML"] = "http://www.w3.org/1999/xhtml";
+    NS["MATHML"] = "http://www.w3.org/1998/Math/MathML";
+    NS["SVG"] = "http://www.w3.org/2000/svg";
+    NS["XLINK"] = "http://www.w3.org/1999/xlink";
+    NS["XML"] = "http://www.w3.org/XML/1998/namespace";
+    NS["XMLNS"] = "http://www.w3.org/2000/xmlns/";
+})(NS = NS || (NS = {}));
+var ATTRS;
+(function (ATTRS) {
+    ATTRS["TYPE"] = "type";
+    ATTRS["ACTION"] = "action";
+    ATTRS["ENCODING"] = "encoding";
+    ATTRS["PROMPT"] = "prompt";
+    ATTRS["NAME"] = "name";
+    ATTRS["COLOR"] = "color";
+    ATTRS["FACE"] = "face";
+    ATTRS["SIZE"] = "size";
+})(ATTRS = ATTRS || (ATTRS = {}));
+/**
+ * The mode of the document.
+ *
+ * @see {@link https://dom.spec.whatwg.org/#concept-document-limited-quirks}
+ */
+var DOCUMENT_MODE;
+(function (DOCUMENT_MODE) {
+    DOCUMENT_MODE["NO_QUIRKS"] = "no-quirks";
+    DOCUMENT_MODE["QUIRKS"] = "quirks";
+    DOCUMENT_MODE["LIMITED_QUIRKS"] = "limited-quirks";
+})(DOCUMENT_MODE = DOCUMENT_MODE || (DOCUMENT_MODE = {}));
+var TAG_NAMES;
+(function (TAG_NAMES) {
+    TAG_NAMES["A"] = "a";
+    TAG_NAMES["ADDRESS"] = "address";
+    TAG_NAMES["ANNOTATION_XML"] = "annotation-xml";
+    TAG_NAMES["APPLET"] = "applet";
+    TAG_NAMES["AREA"] = "area";
+    TAG_NAMES["ARTICLE"] = "article";
+    TAG_NAMES["ASIDE"] = "aside";
+    TAG_NAMES["B"] = "b";
+    TAG_NAMES["BASE"] = "base";
+    TAG_NAMES["BASEFONT"] = "basefont";
+    TAG_NAMES["BGSOUND"] = "bgsound";
+    TAG_NAMES["BIG"] = "big";
+    TAG_NAMES["BLOCKQUOTE"] = "blockquote";
+    TAG_NAMES["BODY"] = "body";
+    TAG_NAMES["BR"] = "br";
+    TAG_NAMES["BUTTON"] = "button";
+    TAG_NAMES["CAPTION"] = "caption";
+    TAG_NAMES["CENTER"] = "center";
+    TAG_NAMES["CODE"] = "code";
+    TAG_NAMES["COL"] = "col";
+    TAG_NAMES["COLGROUP"] = "colgroup";
+    TAG_NAMES["DD"] = "dd";
+    TAG_NAMES["DESC"] = "desc";
+    TAG_NAMES["DETAILS"] = "details";
+    TAG_NAMES["DIALOG"] = "dialog";
+    TAG_NAMES["DIR"] = "dir";
+    TAG_NAMES["DIV"] = "div";
+    TAG_NAMES["DL"] = "dl";
+    TAG_NAMES["DT"] = "dt";
+    TAG_NAMES["EM"] = "em";
+    TAG_NAMES["EMBED"] = "embed";
+    TAG_NAMES["FIELDSET"] = "fieldset";
+    TAG_NAMES["FIGCAPTION"] = "figcaption";
+    TAG_NAMES["FIGURE"] = "figure";
+    TAG_NAMES["FONT"] = "font";
+    TAG_NAMES["FOOTER"] = "footer";
+    TAG_NAMES["FOREIGN_OBJECT"] = "foreignObject";
+    TAG_NAMES["FORM"] = "form";
+    TAG_NAMES["FRAME"] = "frame";
+    TAG_NAMES["FRAMESET"] = "frameset";
+    TAG_NAMES["H1"] = "h1";
+    TAG_NAMES["H2"] = "h2";
+    TAG_NAMES["H3"] = "h3";
+    TAG_NAMES["H4"] = "h4";
+    TAG_NAMES["H5"] = "h5";
+    TAG_NAMES["H6"] = "h6";
+    TAG_NAMES["HEAD"] = "head";
+    TAG_NAMES["HEADER"] = "header";
+    TAG_NAMES["HGROUP"] = "hgroup";
+    TAG_NAMES["HR"] = "hr";
+    TAG_NAMES["HTML"] = "html";
+    TAG_NAMES["I"] = "i";
+    TAG_NAMES["IMG"] = "img";
+    TAG_NAMES["IMAGE"] = "image";
+    TAG_NAMES["INPUT"] = "input";
+    TAG_NAMES["IFRAME"] = "iframe";
+    TAG_NAMES["KEYGEN"] = "keygen";
+    TAG_NAMES["LABEL"] = "label";
+    TAG_NAMES["LI"] = "li";
+    TAG_NAMES["LINK"] = "link";
+    TAG_NAMES["LISTING"] = "listing";
+    TAG_NAMES["MAIN"] = "main";
+    TAG_NAMES["MALIGNMARK"] = "malignmark";
+    TAG_NAMES["MARQUEE"] = "marquee";
+    TAG_NAMES["MATH"] = "math";
+    TAG_NAMES["MENU"] = "menu";
+    TAG_NAMES["META"] = "meta";
+    TAG_NAMES["MGLYPH"] = "mglyph";
+    TAG_NAMES["MI"] = "mi";
+    TAG_NAMES["MO"] = "mo";
+    TAG_NAMES["MN"] = "mn";
+    TAG_NAMES["MS"] = "ms";
+    TAG_NAMES["MTEXT"] = "mtext";
+    TAG_NAMES["NAV"] = "nav";
+    TAG_NAMES["NOBR"] = "nobr";
+    TAG_NAMES["NOFRAMES"] = "noframes";
+    TAG_NAMES["NOEMBED"] = "noembed";
+    TAG_NAMES["NOSCRIPT"] = "noscript";
+    TAG_NAMES["OBJECT"] = "object";
+    TAG_NAMES["OL"] = "ol";
+    TAG_NAMES["OPTGROUP"] = "optgroup";
+    TAG_NAMES["OPTION"] = "option";
+    TAG_NAMES["P"] = "p";
+    TAG_NAMES["PARAM"] = "param";
+    TAG_NAMES["PLAINTEXT"] = "plaintext";
+    TAG_NAMES["PRE"] = "pre";
+    TAG_NAMES["RB"] = "rb";
+    TAG_NAMES["RP"] = "rp";
+    TAG_NAMES["RT"] = "rt";
+    TAG_NAMES["RTC"] = "rtc";
+    TAG_NAMES["RUBY"] = "ruby";
+    TAG_NAMES["S"] = "s";
+    TAG_NAMES["SCRIPT"] = "script";
+    TAG_NAMES["SECTION"] = "section";
+    TAG_NAMES["SELECT"] = "select";
+    TAG_NAMES["SOURCE"] = "source";
+    TAG_NAMES["SMALL"] = "small";
+    TAG_NAMES["SPAN"] = "span";
+    TAG_NAMES["STRIKE"] = "strike";
+    TAG_NAMES["STRONG"] = "strong";
+    TAG_NAMES["STYLE"] = "style";
+    TAG_NAMES["SUB"] = "sub";
+    TAG_NAMES["SUMMARY"] = "summary";
+    TAG_NAMES["SUP"] = "sup";
+    TAG_NAMES["TABLE"] = "table";
+    TAG_NAMES["TBODY"] = "tbody";
+    TAG_NAMES["TEMPLATE"] = "template";
+    TAG_NAMES["TEXTAREA"] = "textarea";
+    TAG_NAMES["TFOOT"] = "tfoot";
+    TAG_NAMES["TD"] = "td";
+    TAG_NAMES["TH"] = "th";
+    TAG_NAMES["THEAD"] = "thead";
+    TAG_NAMES["TITLE"] = "title";
+    TAG_NAMES["TR"] = "tr";
+    TAG_NAMES["TRACK"] = "track";
+    TAG_NAMES["TT"] = "tt";
+    TAG_NAMES["U"] = "u";
+    TAG_NAMES["UL"] = "ul";
+    TAG_NAMES["SVG"] = "svg";
+    TAG_NAMES["VAR"] = "var";
+    TAG_NAMES["WBR"] = "wbr";
+    TAG_NAMES["XMP"] = "xmp";
+})(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {}));
+/**
+ * Tag IDs are numeric IDs for known tag names.
+ *
+ * We use tag IDs to improve the performance of tag name comparisons.
+ */
+var TAG_ID;
+(function (TAG_ID) {
+    TAG_ID[TAG_ID["UNKNOWN"] = 0] = "UNKNOWN";
+    TAG_ID[TAG_ID["A"] = 1] = "A";
+    TAG_ID[TAG_ID["ADDRESS"] = 2] = "ADDRESS";
+    TAG_ID[TAG_ID["ANNOTATION_XML"] = 3] = "ANNOTATION_XML";
+    TAG_ID[TAG_ID["APPLET"] = 4] = "APPLET";
+    TAG_ID[TAG_ID["AREA"] = 5] = "AREA";
+    TAG_ID[TAG_ID["ARTICLE"] = 6] = "ARTICLE";
+    TAG_ID[TAG_ID["ASIDE"] = 7] = "ASIDE";
+    TAG_ID[TAG_ID["B"] = 8] = "B";
+    TAG_ID[TAG_ID["BASE"] = 9] = "BASE";
+    TAG_ID[TAG_ID["BASEFONT"] = 10] = "BASEFONT";
+    TAG_ID[TAG_ID["BGSOUND"] = 11] = "BGSOUND";
+    TAG_ID[TAG_ID["BIG"] = 12] = "BIG";
+    TAG_ID[TAG_ID["BLOCKQUOTE"] = 13] = "BLOCKQUOTE";
+    TAG_ID[TAG_ID["BODY"] = 14] = "BODY";
+    TAG_ID[TAG_ID["BR"] = 15] = "BR";
+    TAG_ID[TAG_ID["BUTTON"] = 16] = "BUTTON";
+    TAG_ID[TAG_ID["CAPTION"] = 17] = "CAPTION";
+    TAG_ID[TAG_ID["CENTER"] = 18] = "CENTER";
+    TAG_ID[TAG_ID["CODE"] = 19] = "CODE";
+    TAG_ID[TAG_ID["COL"] = 20] = "COL";
+    TAG_ID[TAG_ID["COLGROUP"] = 21] = "COLGROUP";
+    TAG_ID[TAG_ID["DD"] = 22] = "DD";
+    TAG_ID[TAG_ID["DESC"] = 23] = "DESC";
+    TAG_ID[TAG_ID["DETAILS"] = 24] = "DETAILS";
+    TAG_ID[TAG_ID["DIALOG"] = 25] = "DIALOG";
+    TAG_ID[TAG_ID["DIR"] = 26] = "DIR";
+    TAG_ID[TAG_ID["DIV"] = 27] = "DIV";
+    TAG_ID[TAG_ID["DL"] = 28] = "DL";
+    TAG_ID[TAG_ID["DT"] = 29] = "DT";
+    TAG_ID[TAG_ID["EM"] = 30] = "EM";
+    TAG_ID[TAG_ID["EMBED"] = 31] = "EMBED";
+    TAG_ID[TAG_ID["FIELDSET"] = 32] = "FIELDSET";
+    TAG_ID[TAG_ID["FIGCAPTION"] = 33] = "FIGCAPTION";
+    TAG_ID[TAG_ID["FIGURE"] = 34] = "FIGURE";
+    TAG_ID[TAG_ID["FONT"] = 35] = "FONT";
+    TAG_ID[TAG_ID["FOOTER"] = 36] = "FOOTER";
+    TAG_ID[TAG_ID["FOREIGN_OBJECT"] = 37] = "FOREIGN_OBJECT";
+    TAG_ID[TAG_ID["FORM"] = 38] = "FORM";
+    TAG_ID[TAG_ID["FRAME"] = 39] = "FRAME";
+    TAG_ID[TAG_ID["FRAMESET"] = 40] = "FRAMESET";
+    TAG_ID[TAG_ID["H1"] = 41] = "H1";
+    TAG_ID[TAG_ID["H2"] = 42] = "H2";
+    TAG_ID[TAG_ID["H3"] = 43] = "H3";
+    TAG_ID[TAG_ID["H4"] = 44] = "H4";
+    TAG_ID[TAG_ID["H5"] = 45] = "H5";
+    TAG_ID[TAG_ID["H6"] = 46] = "H6";
+    TAG_ID[TAG_ID["HEAD"] = 47] = "HEAD";
+    TAG_ID[TAG_ID["HEADER"] = 48] = "HEADER";
+    TAG_ID[TAG_ID["HGROUP"] = 49] = "HGROUP";
+    TAG_ID[TAG_ID["HR"] = 50] = "HR";
+    TAG_ID[TAG_ID["HTML"] = 51] = "HTML";
+    TAG_ID[TAG_ID["I"] = 52] = "I";
+    TAG_ID[TAG_ID["IMG"] = 53] = "IMG";
+    TAG_ID[TAG_ID["IMAGE"] = 54] = "IMAGE";
+    TAG_ID[TAG_ID["INPUT"] = 55] = "INPUT";
+    TAG_ID[TAG_ID["IFRAME"] = 56] = "IFRAME";
+    TAG_ID[TAG_ID["KEYGEN"] = 57] = "KEYGEN";
+    TAG_ID[TAG_ID["LABEL"] = 58] = "LABEL";
+    TAG_ID[TAG_ID["LI"] = 59] = "LI";
+    TAG_ID[TAG_ID["LINK"] = 60] = "LINK";
+    TAG_ID[TAG_ID["LISTING"] = 61] = "LISTING";
+    TAG_ID[TAG_ID["MAIN"] = 62] = "MAIN";
+    TAG_ID[TAG_ID["MALIGNMARK"] = 63] = "MALIGNMARK";
+    TAG_ID[TAG_ID["MARQUEE"] = 64] = "MARQUEE";
+    TAG_ID[TAG_ID["MATH"] = 65] = "MATH";
+    TAG_ID[TAG_ID["MENU"] = 66] = "MENU";
+    TAG_ID[TAG_ID["META"] = 67] = "META";
+    TAG_ID[TAG_ID["MGLYPH"] = 68] = "MGLYPH";
+    TAG_ID[TAG_ID["MI"] = 69] = "MI";
+    TAG_ID[TAG_ID["MO"] = 70] = "MO";
+    TAG_ID[TAG_ID["MN"] = 71] = "MN";
+    TAG_ID[TAG_ID["MS"] = 72] = "MS";
+    TAG_ID[TAG_ID["MTEXT"] = 73] = "MTEXT";
+    TAG_ID[TAG_ID["NAV"] = 74] = "NAV";
+    TAG_ID[TAG_ID["NOBR"] = 75] = "NOBR";
+    TAG_ID[TAG_ID["NOFRAMES"] = 76] = "NOFRAMES";
+    TAG_ID[TAG_ID["NOEMBED"] = 77] = "NOEMBED";
+    TAG_ID[TAG_ID["NOSCRIPT"] = 78] = "NOSCRIPT";
+    TAG_ID[TAG_ID["OBJECT"] = 79] = "OBJECT";
+    TAG_ID[TAG_ID["OL"] = 80] = "OL";
+    TAG_ID[TAG_ID["OPTGROUP"] = 81] = "OPTGROUP";
+    TAG_ID[TAG_ID["OPTION"] = 82] = "OPTION";
+    TAG_ID[TAG_ID["P"] = 83] = "P";
+    TAG_ID[TAG_ID["PARAM"] = 84] = "PARAM";
+    TAG_ID[TAG_ID["PLAINTEXT"] = 85] = "PLAINTEXT";
+    TAG_ID[TAG_ID["PRE"] = 86] = "PRE";
+    TAG_ID[TAG_ID["RB"] = 87] = "RB";
+    TAG_ID[TAG_ID["RP"] = 88] = "RP";
+    TAG_ID[TAG_ID["RT"] = 89] = "RT";
+    TAG_ID[TAG_ID["RTC"] = 90] = "RTC";
+    TAG_ID[TAG_ID["RUBY"] = 91] = "RUBY";
+    TAG_ID[TAG_ID["S"] = 92] = "S";
+    TAG_ID[TAG_ID["SCRIPT"] = 93] = "SCRIPT";
+    TAG_ID[TAG_ID["SECTION"] = 94] = "SECTION";
+    TAG_ID[TAG_ID["SELECT"] = 95] = "SELECT";
+    TAG_ID[TAG_ID["SOURCE"] = 96] = "SOURCE";
+    TAG_ID[TAG_ID["SMALL"] = 97] = "SMALL";
+    TAG_ID[TAG_ID["SPAN"] = 98] = "SPAN";
+    TAG_ID[TAG_ID["STRIKE"] = 99] = "STRIKE";
+    TAG_ID[TAG_ID["STRONG"] = 100] = "STRONG";
+    TAG_ID[TAG_ID["STYLE"] = 101] = "STYLE";
+    TAG_ID[TAG_ID["SUB"] = 102] = "SUB";
+    TAG_ID[TAG_ID["SUMMARY"] = 103] = "SUMMARY";
+    TAG_ID[TAG_ID["SUP"] = 104] = "SUP";
+    TAG_ID[TAG_ID["TABLE"] = 105] = "TABLE";
+    TAG_ID[TAG_ID["TBODY"] = 106] = "TBODY";
+    TAG_ID[TAG_ID["TEMPLATE"] = 107] = "TEMPLATE";
+    TAG_ID[TAG_ID["TEXTAREA"] = 108] = "TEXTAREA";
+    TAG_ID[TAG_ID["TFOOT"] = 109] = "TFOOT";
+    TAG_ID[TAG_ID["TD"] = 110] = "TD";
+    TAG_ID[TAG_ID["TH"] = 111] = "TH";
+    TAG_ID[TAG_ID["THEAD"] = 112] = "THEAD";
+    TAG_ID[TAG_ID["TITLE"] = 113] = "TITLE";
+    TAG_ID[TAG_ID["TR"] = 114] = "TR";
+    TAG_ID[TAG_ID["TRACK"] = 115] = "TRACK";
+    TAG_ID[TAG_ID["TT"] = 116] = "TT";
+    TAG_ID[TAG_ID["U"] = 117] = "U";
+    TAG_ID[TAG_ID["UL"] = 118] = "UL";
+    TAG_ID[TAG_ID["SVG"] = 119] = "SVG";
+    TAG_ID[TAG_ID["VAR"] = 120] = "VAR";
+    TAG_ID[TAG_ID["WBR"] = 121] = "WBR";
+    TAG_ID[TAG_ID["XMP"] = 122] = "XMP";
+})(TAG_ID = TAG_ID || (TAG_ID = {}));
+const TAG_NAME_TO_ID = new Map([
+    [TAG_NAMES.A, TAG_ID.A],
+    [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS],
+    [TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML],
+    [TAG_NAMES.APPLET, TAG_ID.APPLET],
+    [TAG_NAMES.AREA, TAG_ID.AREA],
+    [TAG_NAMES.ARTICLE, TAG_ID.ARTICLE],
+    [TAG_NAMES.ASIDE, TAG_ID.ASIDE],
+    [TAG_NAMES.B, TAG_ID.B],
+    [TAG_NAMES.BASE, TAG_ID.BASE],
+    [TAG_NAMES.BASEFONT, TAG_ID.BASEFONT],
+    [TAG_NAMES.BGSOUND, TAG_ID.BGSOUND],
+    [TAG_NAMES.BIG, TAG_ID.BIG],
+    [TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE],
+    [TAG_NAMES.BODY, TAG_ID.BODY],
+    [TAG_NAMES.BR, TAG_ID.BR],
+    [TAG_NAMES.BUTTON, TAG_ID.BUTTON],
+    [TAG_NAMES.CAPTION, TAG_ID.CAPTION],
+    [TAG_NAMES.CENTER, TAG_ID.CENTER],
+    [TAG_NAMES.CODE, TAG_ID.CODE],
+    [TAG_NAMES.COL, TAG_ID.COL],
+    [TAG_NAMES.COLGROUP, TAG_ID.COLGROUP],
+    [TAG_NAMES.DD, TAG_ID.DD],
+    [TAG_NAMES.DESC, TAG_ID.DESC],
+    [TAG_NAMES.DETAILS, TAG_ID.DETAILS],
+    [TAG_NAMES.DIALOG, TAG_ID.DIALOG],
+    [TAG_NAMES.DIR, TAG_ID.DIR],
+    [TAG_NAMES.DIV, TAG_ID.DIV],
+    [TAG_NAMES.DL, TAG_ID.DL],
+    [TAG_NAMES.DT, TAG_ID.DT],
+    [TAG_NAMES.EM, TAG_ID.EM],
+    [TAG_NAMES.EMBED, TAG_ID.EMBED],
+    [TAG_NAMES.FIELDSET, TAG_ID.FIELDSET],
+    [TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION],
+    [TAG_NAMES.FIGURE, TAG_ID.FIGURE],
+    [TAG_NAMES.FONT, TAG_ID.FONT],
+    [TAG_NAMES.FOOTER, TAG_ID.FOOTER],
+    [TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT],
+    [TAG_NAMES.FORM, TAG_ID.FORM],
+    [TAG_NAMES.FRAME, TAG_ID.FRAME],
+    [TAG_NAMES.FRAMESET, TAG_ID.FRAMESET],
+    [TAG_NAMES.H1, TAG_ID.H1],
+    [TAG_NAMES.H2, TAG_ID.H2],
+    [TAG_NAMES.H3, TAG_ID.H3],
+    [TAG_NAMES.H4, TAG_ID.H4],
+    [TAG_NAMES.H5, TAG_ID.H5],
+    [TAG_NAMES.H6, TAG_ID.H6],
+    [TAG_NAMES.HEAD, TAG_ID.HEAD],
+    [TAG_NAMES.HEADER, TAG_ID.HEADER],
+    [TAG_NAMES.HGROUP, TAG_ID.HGROUP],
+    [TAG_NAMES.HR, TAG_ID.HR],
+    [TAG_NAMES.HTML, TAG_ID.HTML],
+    [TAG_NAMES.I, TAG_ID.I],
+    [TAG_NAMES.IMG, TAG_ID.IMG],
+    [TAG_NAMES.IMAGE, TAG_ID.IMAGE],
+    [TAG_NAMES.INPUT, TAG_ID.INPUT],
+    [TAG_NAMES.IFRAME, TAG_ID.IFRAME],
+    [TAG_NAMES.KEYGEN, TAG_ID.KEYGEN],
+    [TAG_NAMES.LABEL, TAG_ID.LABEL],
+    [TAG_NAMES.LI, TAG_ID.LI],
+    [TAG_NAMES.LINK, TAG_ID.LINK],
+    [TAG_NAMES.LISTING, TAG_ID.LISTING],
+    [TAG_NAMES.MAIN, TAG_ID.MAIN],
+    [TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK],
+    [TAG_NAMES.MARQUEE, TAG_ID.MARQUEE],
+    [TAG_NAMES.MATH, TAG_ID.MATH],
+    [TAG_NAMES.MENU, TAG_ID.MENU],
+    [TAG_NAMES.META, TAG_ID.META],
+    [TAG_NAMES.MGLYPH, TAG_ID.MGLYPH],
+    [TAG_NAMES.MI, TAG_ID.MI],
+    [TAG_NAMES.MO, TAG_ID.MO],
+    [TAG_NAMES.MN, TAG_ID.MN],
+    [TAG_NAMES.MS, TAG_ID.MS],
+    [TAG_NAMES.MTEXT, TAG_ID.MTEXT],
+    [TAG_NAMES.NAV, TAG_ID.NAV],
+    [TAG_NAMES.NOBR, TAG_ID.NOBR],
+    [TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES],
+    [TAG_NAMES.NOEMBED, TAG_ID.NOEMBED],
+    [TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT],
+    [TAG_NAMES.OBJECT, TAG_ID.OBJECT],
+    [TAG_NAMES.OL, TAG_ID.OL],
+    [TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP],
+    [TAG_NAMES.OPTION, TAG_ID.OPTION],
+    [TAG_NAMES.P, TAG_ID.P],
+    [TAG_NAMES.PARAM, TAG_ID.PARAM],
+    [TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT],
+    [TAG_NAMES.PRE, TAG_ID.PRE],
+    [TAG_NAMES.RB, TAG_ID.RB],
+    [TAG_NAMES.RP, TAG_ID.RP],
+    [TAG_NAMES.RT, TAG_ID.RT],
+    [TAG_NAMES.RTC, TAG_ID.RTC],
+    [TAG_NAMES.RUBY, TAG_ID.RUBY],
+    [TAG_NAMES.S, TAG_ID.S],
+    [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT],
+    [TAG_NAMES.SECTION, TAG_ID.SECTION],
+    [TAG_NAMES.SELECT, TAG_ID.SELECT],
+    [TAG_NAMES.SOURCE, TAG_ID.SOURCE],
+    [TAG_NAMES.SMALL, TAG_ID.SMALL],
+    [TAG_NAMES.SPAN, TAG_ID.SPAN],
+    [TAG_NAMES.STRIKE, TAG_ID.STRIKE],
+    [TAG_NAMES.STRONG, TAG_ID.STRONG],
+    [TAG_NAMES.STYLE, TAG_ID.STYLE],
+    [TAG_NAMES.SUB, TAG_ID.SUB],
+    [TAG_NAMES.SUMMARY, TAG_ID.SUMMARY],
+    [TAG_NAMES.SUP, TAG_ID.SUP],
+    [TAG_NAMES.TABLE, TAG_ID.TABLE],
+    [TAG_NAMES.TBODY, TAG_ID.TBODY],
+    [TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE],
+    [TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA],
+    [TAG_NAMES.TFOOT, TAG_ID.TFOOT],
+    [TAG_NAMES.TD, TAG_ID.TD],
+    [TAG_NAMES.TH, TAG_ID.TH],
+    [TAG_NAMES.THEAD, TAG_ID.THEAD],
+    [TAG_NAMES.TITLE, TAG_ID.TITLE],
+    [TAG_NAMES.TR, TAG_ID.TR],
+    [TAG_NAMES.TRACK, TAG_ID.TRACK],
+    [TAG_NAMES.TT, TAG_ID.TT],
+    [TAG_NAMES.U, TAG_ID.U],
+    [TAG_NAMES.UL, TAG_ID.UL],
+    [TAG_NAMES.SVG, TAG_ID.SVG],
+    [TAG_NAMES.VAR, TAG_ID.VAR],
+    [TAG_NAMES.WBR, TAG_ID.WBR],
+    [TAG_NAMES.XMP, TAG_ID.XMP],
+]);
+function getTagID(tagName) {
+    var _a;
+    return (_a = TAG_NAME_TO_ID.get(tagName)) !== null && _a !== void 0 ? _a : TAG_ID.UNKNOWN;
+}
+const $ = TAG_ID;
+const SPECIAL_ELEMENTS = {
+    [NS.HTML]: new Set([
+        $.ADDRESS,
+        $.APPLET,
+        $.AREA,
+        $.ARTICLE,
+        $.ASIDE,
+        $.BASE,
+        $.BASEFONT,
+        $.BGSOUND,
+        $.BLOCKQUOTE,
+        $.BODY,
+        $.BR,
+        $.BUTTON,
+        $.CAPTION,
+        $.CENTER,
+        $.COL,
+        $.COLGROUP,
+        $.DD,
+        $.DETAILS,
+        $.DIR,
+        $.DIV,
+        $.DL,
+        $.DT,
+        $.EMBED,
+        $.FIELDSET,
+        $.FIGCAPTION,
+        $.FIGURE,
+        $.FOOTER,
+        $.FORM,
+        $.FRAME,
+        $.FRAMESET,
+        $.H1,
+        $.H2,
+        $.H3,
+        $.H4,
+        $.H5,
+        $.H6,
+        $.HEAD,
+        $.HEADER,
+        $.HGROUP,
+        $.HR,
+        $.HTML,
+        $.IFRAME,
+        $.IMG,
+        $.INPUT,
+        $.LI,
+        $.LINK,
+        $.LISTING,
+        $.MAIN,
+        $.MARQUEE,
+        $.MENU,
+        $.META,
+        $.NAV,
+        $.NOEMBED,
+        $.NOFRAMES,
+        $.NOSCRIPT,
+        $.OBJECT,
+        $.OL,
+        $.P,
+        $.PARAM,
+        $.PLAINTEXT,
+        $.PRE,
+        $.SCRIPT,
+        $.SECTION,
+        $.SELECT,
+        $.SOURCE,
+        $.STYLE,
+        $.SUMMARY,
+        $.TABLE,
+        $.TBODY,
+        $.TD,
+        $.TEMPLATE,
+        $.TEXTAREA,
+        $.TFOOT,
+        $.TH,
+        $.THEAD,
+        $.TITLE,
+        $.TR,
+        $.TRACK,
+        $.UL,
+        $.WBR,
+        $.XMP,
+    ]),
+    [NS.MATHML]: new Set([$.MI, $.MO, $.MN, $.MS, $.MTEXT, $.ANNOTATION_XML]),
+    [NS.SVG]: new Set([$.TITLE, $.FOREIGN_OBJECT, $.DESC]),
+    [NS.XLINK]: new Set(),
+    [NS.XML]: new Set(),
+    [NS.XMLNS]: new Set(),
+};
+function isNumberedHeader(tn) {
+    return tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6;
+}
+
+//C1 Unicode control character reference replacements
+const C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([
+    [0x80, 8364],
+    [0x82, 8218],
+    [0x83, 402],
+    [0x84, 8222],
+    [0x85, 8230],
+    [0x86, 8224],
+    [0x87, 8225],
+    [0x88, 710],
+    [0x89, 8240],
+    [0x8a, 352],
+    [0x8b, 8249],
+    [0x8c, 338],
+    [0x8e, 381],
+    [0x91, 8216],
+    [0x92, 8217],
+    [0x93, 8220],
+    [0x94, 8221],
+    [0x95, 8226],
+    [0x96, 8211],
+    [0x97, 8212],
+    [0x98, 732],
+    [0x99, 8482],
+    [0x9a, 353],
+    [0x9b, 8250],
+    [0x9c, 339],
+    [0x9e, 382],
+    [0x9f, 376],
+]);
+//States
+var State;
+(function (State) {
+    State[State["DATA"] = 0] = "DATA";
+    State[State["RCDATA"] = 1] = "RCDATA";
+    State[State["RAWTEXT"] = 2] = "RAWTEXT";
+    State[State["SCRIPT_DATA"] = 3] = "SCRIPT_DATA";
+    State[State["PLAINTEXT"] = 4] = "PLAINTEXT";
+    State[State["TAG_OPEN"] = 5] = "TAG_OPEN";
+    State[State["END_TAG_OPEN"] = 6] = "END_TAG_OPEN";
+    State[State["TAG_NAME"] = 7] = "TAG_NAME";
+    State[State["RCDATA_LESS_THAN_SIGN"] = 8] = "RCDATA_LESS_THAN_SIGN";
+    State[State["RCDATA_END_TAG_OPEN"] = 9] = "RCDATA_END_TAG_OPEN";
+    State[State["RCDATA_END_TAG_NAME"] = 10] = "RCDATA_END_TAG_NAME";
+    State[State["RAWTEXT_LESS_THAN_SIGN"] = 11] = "RAWTEXT_LESS_THAN_SIGN";
+    State[State["RAWTEXT_END_TAG_OPEN"] = 12] = "RAWTEXT_END_TAG_OPEN";
+    State[State["RAWTEXT_END_TAG_NAME"] = 13] = "RAWTEXT_END_TAG_NAME";
+    State[State["SCRIPT_DATA_LESS_THAN_SIGN"] = 14] = "SCRIPT_DATA_LESS_THAN_SIGN";
+    State[State["SCRIPT_DATA_END_TAG_OPEN"] = 15] = "SCRIPT_DATA_END_TAG_OPEN";
+    State[State["SCRIPT_DATA_END_TAG_NAME"] = 16] = "SCRIPT_DATA_END_TAG_NAME";
+    State[State["SCRIPT_DATA_ESCAPE_START"] = 17] = "SCRIPT_DATA_ESCAPE_START";
+    State[State["SCRIPT_DATA_ESCAPE_START_DASH"] = 18] = "SCRIPT_DATA_ESCAPE_START_DASH";
+    State[State["SCRIPT_DATA_ESCAPED"] = 19] = "SCRIPT_DATA_ESCAPED";
+    State[State["SCRIPT_DATA_ESCAPED_DASH"] = 20] = "SCRIPT_DATA_ESCAPED_DASH";
+    State[State["SCRIPT_DATA_ESCAPED_DASH_DASH"] = 21] = "SCRIPT_DATA_ESCAPED_DASH_DASH";
+    State[State["SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"] = 22] = "SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN";
+    State[State["SCRIPT_DATA_ESCAPED_END_TAG_OPEN"] = 23] = "SCRIPT_DATA_ESCAPED_END_TAG_OPEN";
+    State[State["SCRIPT_DATA_ESCAPED_END_TAG_NAME"] = 24] = "SCRIPT_DATA_ESCAPED_END_TAG_NAME";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPE_START"] = 25] = "SCRIPT_DATA_DOUBLE_ESCAPE_START";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPED"] = 26] = "SCRIPT_DATA_DOUBLE_ESCAPED";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH"] = 27] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"] = 28] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"] = 29] = "SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN";
+    State[State["SCRIPT_DATA_DOUBLE_ESCAPE_END"] = 30] = "SCRIPT_DATA_DOUBLE_ESCAPE_END";
+    State[State["BEFORE_ATTRIBUTE_NAME"] = 31] = "BEFORE_ATTRIBUTE_NAME";
+    State[State["ATTRIBUTE_NAME"] = 32] = "ATTRIBUTE_NAME";
+    State[State["AFTER_ATTRIBUTE_NAME"] = 33] = "AFTER_ATTRIBUTE_NAME";
+    State[State["BEFORE_ATTRIBUTE_VALUE"] = 34] = "BEFORE_ATTRIBUTE_VALUE";
+    State[State["ATTRIBUTE_VALUE_DOUBLE_QUOTED"] = 35] = "ATTRIBUTE_VALUE_DOUBLE_QUOTED";
+    State[State["ATTRIBUTE_VALUE_SINGLE_QUOTED"] = 36] = "ATTRIBUTE_VALUE_SINGLE_QUOTED";
+    State[State["ATTRIBUTE_VALUE_UNQUOTED"] = 37] = "ATTRIBUTE_VALUE_UNQUOTED";
+    State[State["AFTER_ATTRIBUTE_VALUE_QUOTED"] = 38] = "AFTER_ATTRIBUTE_VALUE_QUOTED";
+    State[State["SELF_CLOSING_START_TAG"] = 39] = "SELF_CLOSING_START_TAG";
+    State[State["BOGUS_COMMENT"] = 40] = "BOGUS_COMMENT";
+    State[State["MARKUP_DECLARATION_OPEN"] = 41] = "MARKUP_DECLARATION_OPEN";
+    State[State["COMMENT_START"] = 42] = "COMMENT_START";
+    State[State["COMMENT_START_DASH"] = 43] = "COMMENT_START_DASH";
+    State[State["COMMENT"] = 44] = "COMMENT";
+    State[State["COMMENT_LESS_THAN_SIGN"] = 45] = "COMMENT_LESS_THAN_SIGN";
+    State[State["COMMENT_LESS_THAN_SIGN_BANG"] = 46] = "COMMENT_LESS_THAN_SIGN_BANG";
+    State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH"] = 47] = "COMMENT_LESS_THAN_SIGN_BANG_DASH";
+    State[State["COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"] = 48] = "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH";
+    State[State["COMMENT_END_DASH"] = 49] = "COMMENT_END_DASH";
+    State[State["COMMENT_END"] = 50] = "COMMENT_END";
+    State[State["COMMENT_END_BANG"] = 51] = "COMMENT_END_BANG";
+    State[State["DOCTYPE"] = 52] = "DOCTYPE";
+    State[State["BEFORE_DOCTYPE_NAME"] = 53] = "BEFORE_DOCTYPE_NAME";
+    State[State["DOCTYPE_NAME"] = 54] = "DOCTYPE_NAME";
+    State[State["AFTER_DOCTYPE_NAME"] = 55] = "AFTER_DOCTYPE_NAME";
+    State[State["AFTER_DOCTYPE_PUBLIC_KEYWORD"] = 56] = "AFTER_DOCTYPE_PUBLIC_KEYWORD";
+    State[State["BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"] = 57] = "BEFORE_DOCTYPE_PUBLIC_IDENTIFIER";
+    State[State["DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"] = 58] = "DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED";
+    State[State["DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"] = 59] = "DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED";
+    State[State["AFTER_DOCTYPE_PUBLIC_IDENTIFIER"] = 60] = "AFTER_DOCTYPE_PUBLIC_IDENTIFIER";
+    State[State["BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"] = 61] = "BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS";
+    State[State["AFTER_DOCTYPE_SYSTEM_KEYWORD"] = 62] = "AFTER_DOCTYPE_SYSTEM_KEYWORD";
+    State[State["BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"] = 63] = "BEFORE_DOCTYPE_SYSTEM_IDENTIFIER";
+    State[State["DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"] = 64] = "DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED";
+    State[State["DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"] = 65] = "DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED";
+    State[State["AFTER_DOCTYPE_SYSTEM_IDENTIFIER"] = 66] = "AFTER_DOCTYPE_SYSTEM_IDENTIFIER";
+    State[State["BOGUS_DOCTYPE"] = 67] = "BOGUS_DOCTYPE";
+    State[State["CDATA_SECTION"] = 68] = "CDATA_SECTION";
+    State[State["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET";
+    State[State["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END";
+    State[State["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE";
+    State[State["NAMED_CHARACTER_REFERENCE"] = 72] = "NAMED_CHARACTER_REFERENCE";
+    State[State["AMBIGUOUS_AMPERSAND"] = 73] = "AMBIGUOUS_AMPERSAND";
+    State[State["NUMERIC_CHARACTER_REFERENCE"] = 74] = "NUMERIC_CHARACTER_REFERENCE";
+    State[State["HEXADEMICAL_CHARACTER_REFERENCE_START"] = 75] = "HEXADEMICAL_CHARACTER_REFERENCE_START";
+    State[State["HEXADEMICAL_CHARACTER_REFERENCE"] = 76] = "HEXADEMICAL_CHARACTER_REFERENCE";
+    State[State["DECIMAL_CHARACTER_REFERENCE"] = 77] = "DECIMAL_CHARACTER_REFERENCE";
+    State[State["NUMERIC_CHARACTER_REFERENCE_END"] = 78] = "NUMERIC_CHARACTER_REFERENCE_END";
+})(State || (State = {}));
+//Tokenizer initial states for different modes
+const TokenizerMode = {
+    DATA: State.DATA,
+    RCDATA: State.RCDATA,
+    RAWTEXT: State.RAWTEXT,
+    SCRIPT_DATA: State.SCRIPT_DATA,
+    PLAINTEXT: State.PLAINTEXT,
+    CDATA_SECTION: State.CDATA_SECTION,
+};
+//Utils
+//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline
+//this functions if they will be situated in another module due to context switch.
+//Always perform inlining check before modifying this functions ('node --trace-inlining').
+function isAsciiDigit(cp) {
+    return cp >= CODE_POINTS.DIGIT_0 && cp <= CODE_POINTS.DIGIT_9;
+}
+function isAsciiUpper(cp) {
+    return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_Z;
+}
+function isAsciiLower(cp) {
+    return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_Z;
+}
+function isAsciiLetter(cp) {
+    return isAsciiLower(cp) || isAsciiUpper(cp);
+}
+function isAsciiAlphaNumeric(cp) {
+    return isAsciiLetter(cp) || isAsciiDigit(cp);
+}
+function isAsciiUpperHexDigit(cp) {
+    return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_F;
+}
+function isAsciiLowerHexDigit(cp) {
+    return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_F;
+}
+function isAsciiHexDigit(cp) {
+    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
+}
+function toAsciiLower(cp) {
+    return cp + 32;
+}
+function isWhitespace(cp) {
+    return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED;
+}
+function isEntityInAttributeInvalidEnd(nextCp) {
+    return nextCp === CODE_POINTS.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
+}
+function isScriptDataDoubleEscapeSequenceEnd(cp) {
+    return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
+}
+//Tokenizer
+class Tokenizer {
+    constructor(options, handler) {
+        this.options = options;
+        this.handler = handler;
+        this.paused = false;
+        /** Ensures that the parsing loop isn't run multiple times at once. */
+        this.inLoop = false;
+        /**
+         * Indicates that the current adjusted node exists, is not an element in the HTML namespace,
+         * and that it is not an integration point for either MathML or HTML.
+         *
+         * @see {@link https://html.spec.whatwg.org/multipage/parsing.html#tree-construction}
+         */
+        this.inForeignNode = false;
+        this.lastStartTagName = '';
+        this.active = false;
+        this.state = State.DATA;
+        this.returnState = State.DATA;
+        this.charRefCode = -1;
+        this.consumedAfterSnapshot = -1;
+        this.currentCharacterToken = null;
+        this.currentToken = null;
+        this.currentAttr = { name: '', value: '' };
+        this.preprocessor = new Preprocessor(handler);
+        this.currentLocation = this.getCurrentLocation(-1);
+    }
+    //Errors
+    _err(code) {
+        var _a, _b;
+        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code));
+    }
+    // NOTE: `offset` may never run across line boundaries.
+    getCurrentLocation(offset) {
+        if (!this.options.sourceCodeLocationInfo) {
+            return null;
+        }
+        return {
+            startLine: this.preprocessor.line,
+            startCol: this.preprocessor.col - offset,
+            startOffset: this.preprocessor.offset - offset,
+            endLine: -1,
+            endCol: -1,
+            endOffset: -1,
+        };
+    }
+    _runParsingLoop() {
+        if (this.inLoop)
+            return;
+        this.inLoop = true;
+        while (this.active && !this.paused) {
+            this.consumedAfterSnapshot = 0;
+            const cp = this._consume();
+            if (!this._ensureHibernation()) {
+                this._callState(cp);
+            }
+        }
+        this.inLoop = false;
+    }
+    //API
+    pause() {
+        this.paused = true;
+    }
+    resume(writeCallback) {
+        if (!this.paused) {
+            throw new Error('Parser was already resumed');
+        }
+        this.paused = false;
+        // Necessary for synchronous resume.
+        if (this.inLoop)
+            return;
+        this._runParsingLoop();
+        if (!this.paused) {
+            writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();
+        }
+    }
+    write(chunk, isLastChunk, writeCallback) {
+        this.active = true;
+        this.preprocessor.write(chunk, isLastChunk);
+        this._runParsingLoop();
+        if (!this.paused) {
+            writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback();
+        }
+    }
+    insertHtmlAtCurrentPos(chunk) {
+        this.active = true;
+        this.preprocessor.insertHtmlAtCurrentPos(chunk);
+        this._runParsingLoop();
+    }
+    //Hibernation
+    _ensureHibernation() {
+        if (this.preprocessor.endOfChunkHit) {
+            this._unconsume(this.consumedAfterSnapshot);
+            this.active = false;
+            return true;
+        }
+        return false;
+    }
+    //Consumption
+    _consume() {
+        this.consumedAfterSnapshot++;
+        return this.preprocessor.advance();
+    }
+    _unconsume(count) {
+        this.consumedAfterSnapshot -= count;
+        this.preprocessor.retreat(count);
+    }
+    _reconsumeInState(state, cp) {
+        this.state = state;
+        this._callState(cp);
+    }
+    _advanceBy(count) {
+        this.consumedAfterSnapshot += count;
+        for (let i = 0; i < count; i++) {
+            this.preprocessor.advance();
+        }
+    }
+    _consumeSequenceIfMatch(pattern, caseSensitive) {
+        if (this.preprocessor.startsWith(pattern, caseSensitive)) {
+            // We will already have consumed one character before calling this method.
+            this._advanceBy(pattern.length - 1);
+            return true;
+        }
+        return false;
+    }
+    //Token creation
+    _createStartTagToken() {
+        this.currentToken = {
+            type: TokenType.START_TAG,
+            tagName: '',
+            tagID: TAG_ID.UNKNOWN,
+            selfClosing: false,
+            ackSelfClosing: false,
+            attrs: [],
+            location: this.getCurrentLocation(1),
+        };
+    }
+    _createEndTagToken() {
+        this.currentToken = {
+            type: TokenType.END_TAG,
+            tagName: '',
+            tagID: TAG_ID.UNKNOWN,
+            selfClosing: false,
+            ackSelfClosing: false,
+            attrs: [],
+            location: this.getCurrentLocation(2),
+        };
+    }
+    _createCommentToken(offset) {
+        this.currentToken = {
+            type: TokenType.COMMENT,
+            data: '',
+            location: this.getCurrentLocation(offset),
+        };
+    }
+    _createDoctypeToken(initialName) {
+        this.currentToken = {
+            type: TokenType.DOCTYPE,
+            name: initialName,
+            forceQuirks: false,
+            publicId: null,
+            systemId: null,
+            location: this.currentLocation,
+        };
+    }
+    _createCharacterToken(type, chars) {
+        this.currentCharacterToken = {
+            type,
+            chars,
+            location: this.currentLocation,
+        };
+    }
+    //Tag attributes
+    _createAttr(attrNameFirstCh) {
+        this.currentAttr = {
+            name: attrNameFirstCh,
+            value: '',
+        };
+        this.currentLocation = this.getCurrentLocation(0);
+    }
+    _leaveAttrName() {
+        var _a;
+        var _b;
+        const token = this.currentToken;
+        if (getTokenAttr(token, this.currentAttr.name) === null) {
+            token.attrs.push(this.currentAttr);
+            if (token.location && this.currentLocation) {
+                const attrLocations = ((_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : (_b.attrs = Object.create(null)));
+                attrLocations[this.currentAttr.name] = this.currentLocation;
+                // Set end location
+                this._leaveAttrValue();
+            }
+        }
+        else {
+            this._err(ERR.duplicateAttribute);
+        }
+    }
+    _leaveAttrValue() {
+        if (this.currentLocation) {
+            this.currentLocation.endLine = this.preprocessor.line;
+            this.currentLocation.endCol = this.preprocessor.col;
+            this.currentLocation.endOffset = this.preprocessor.offset;
+        }
+    }
+    //Token emission
+    prepareToken(ct) {
+        this._emitCurrentCharacterToken(ct.location);
+        this.currentToken = null;
+        if (ct.location) {
+            ct.location.endLine = this.preprocessor.line;
+            ct.location.endCol = this.preprocessor.col + 1;
+            ct.location.endOffset = this.preprocessor.offset + 1;
+        }
+        this.currentLocation = this.getCurrentLocation(-1);
+    }
+    emitCurrentTagToken() {
+        const ct = this.currentToken;
+        this.prepareToken(ct);
+        ct.tagID = getTagID(ct.tagName);
+        if (ct.type === TokenType.START_TAG) {
+            this.lastStartTagName = ct.tagName;
+            this.handler.onStartTag(ct);
+        }
+        else {
+            if (ct.attrs.length > 0) {
+                this._err(ERR.endTagWithAttributes);
+            }
+            if (ct.selfClosing) {
+                this._err(ERR.endTagWithTrailingSolidus);
+            }
+            this.handler.onEndTag(ct);
+        }
+        this.preprocessor.dropParsedChunk();
+    }
+    emitCurrentComment(ct) {
+        this.prepareToken(ct);
+        this.handler.onComment(ct);
+        this.preprocessor.dropParsedChunk();
+    }
+    emitCurrentDoctype(ct) {
+        this.prepareToken(ct);
+        this.handler.onDoctype(ct);
+        this.preprocessor.dropParsedChunk();
+    }
+    _emitCurrentCharacterToken(nextLocation) {
+        if (this.currentCharacterToken) {
+            //NOTE: if we have a pending character token, make it's end location equal to the
+            //current token's start location.
+            if (nextLocation && this.currentCharacterToken.location) {
+                this.currentCharacterToken.location.endLine = nextLocation.startLine;
+                this.currentCharacterToken.location.endCol = nextLocation.startCol;
+                this.currentCharacterToken.location.endOffset = nextLocation.startOffset;
+            }
+            switch (this.currentCharacterToken.type) {
+                case TokenType.CHARACTER: {
+                    this.handler.onCharacter(this.currentCharacterToken);
+                    break;
+                }
+                case TokenType.NULL_CHARACTER: {
+                    this.handler.onNullCharacter(this.currentCharacterToken);
+                    break;
+                }
+                case TokenType.WHITESPACE_CHARACTER: {
+                    this.handler.onWhitespaceCharacter(this.currentCharacterToken);
+                    break;
+                }
+            }
+            this.currentCharacterToken = null;
+        }
+    }
+    _emitEOFToken() {
+        const location = this.getCurrentLocation(0);
+        if (location) {
+            location.endLine = location.startLine;
+            location.endCol = location.startCol;
+            location.endOffset = location.startOffset;
+        }
+        this._emitCurrentCharacterToken(location);
+        this.handler.onEof({ type: TokenType.EOF, location });
+        this.active = false;
+    }
+    //Characters emission
+    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
+    //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
+    //If we have a sequence of characters that belong to the same group, the parser can process it
+    //as a single solid character token.
+    //So, there are 3 types of character tokens in parse5:
+    //1)TokenType.NULL_CHARACTER - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
+    //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
+    //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
+    _appendCharToCurrentCharacterToken(type, ch) {
+        if (this.currentCharacterToken) {
+            if (this.currentCharacterToken.type !== type) {
+                this.currentLocation = this.getCurrentLocation(0);
+                this._emitCurrentCharacterToken(this.currentLocation);
+                this.preprocessor.dropParsedChunk();
+            }
+            else {
+                this.currentCharacterToken.chars += ch;
+                return;
+            }
+        }
+        this._createCharacterToken(type, ch);
+    }
+    _emitCodePoint(cp) {
+        const type = isWhitespace(cp)
+            ? TokenType.WHITESPACE_CHARACTER
+            : cp === CODE_POINTS.NULL
+                ? TokenType.NULL_CHARACTER
+                : TokenType.CHARACTER;
+        this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp));
+    }
+    //NOTE: used when we emit characters explicitly.
+    //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.
+    _emitChars(ch) {
+        this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);
+    }
+    // Character reference helpers
+    _matchNamedCharacterReference(cp) {
+        let result = null;
+        let excess = 0;
+        let withoutSemicolon = false;
+        for (let i = 0, current = htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
+            i = determineBranch(htmlDecodeTree, current, i + 1, cp);
+            if (i < 0)
+                break;
+            excess += 1;
+            current = htmlDecodeTree[i];
+            const masked = current & BinTrieFlags.VALUE_LENGTH;
+            // If the branch is a value, store it and continue
+            if (masked) {
+                // The mask is the number of bytes of the value, including the current byte.
+                const valueLength = (masked >> 14) - 1;
+                // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+                // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+                if (cp !== CODE_POINTS.SEMICOLON &&
+                    this._isCharacterReferenceInAttribute() &&
+                    isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) {
+                    //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after
+                    //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes.
+                    result = [CODE_POINTS.AMPERSAND];
+                    // Skip over the value.
+                    i += valueLength;
+                }
+                else {
+                    // If this is a surrogate pair, consume the next two bytes.
+                    result =
+                        valueLength === 0
+                            ? [htmlDecodeTree[i] & ~BinTrieFlags.VALUE_LENGTH]
+                            : valueLength === 1
+                                ? [htmlDecodeTree[++i]]
+                                : [htmlDecodeTree[++i], htmlDecodeTree[++i]];
+                    excess = 0;
+                    withoutSemicolon = cp !== CODE_POINTS.SEMICOLON;
+                }
+                if (valueLength === 0) {
+                    // If the value is zero-length, we're done.
+                    this._consume();
+                    break;
+                }
+            }
+        }
+        this._unconsume(excess);
+        if (withoutSemicolon && !this.preprocessor.endOfChunkHit) {
+            this._err(ERR.missingSemicolonAfterCharacterReference);
+        }
+        // We want to emit the error above on the code point after the entity.
+        // We always consume one code point too many in the loop, and we wait to
+        // unconsume it until after the error is emitted.
+        this._unconsume(1);
+        return result;
+    }
+    _isCharacterReferenceInAttribute() {
+        return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED ||
+            this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED ||
+            this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED);
+    }
+    _flushCodePointConsumedAsCharacterReference(cp) {
+        if (this._isCharacterReferenceInAttribute()) {
+            this.currentAttr.value += String.fromCodePoint(cp);
+        }
+        else {
+            this._emitCodePoint(cp);
+        }
+    }
+    // Calling states this way turns out to be much faster than any other approach.
+    _callState(cp) {
+        switch (this.state) {
+            case State.DATA: {
+                this._stateData(cp);
+                break;
+            }
+            case State.RCDATA: {
+                this._stateRcdata(cp);
+                break;
+            }
+            case State.RAWTEXT: {
+                this._stateRawtext(cp);
+                break;
+            }
+            case State.SCRIPT_DATA: {
+                this._stateScriptData(cp);
+                break;
+            }
+            case State.PLAINTEXT: {
+                this._statePlaintext(cp);
+                break;
+            }
+            case State.TAG_OPEN: {
+                this._stateTagOpen(cp);
+                break;
+            }
+            case State.END_TAG_OPEN: {
+                this._stateEndTagOpen(cp);
+                break;
+            }
+            case State.TAG_NAME: {
+                this._stateTagName(cp);
+                break;
+            }
+            case State.RCDATA_LESS_THAN_SIGN: {
+                this._stateRcdataLessThanSign(cp);
+                break;
+            }
+            case State.RCDATA_END_TAG_OPEN: {
+                this._stateRcdataEndTagOpen(cp);
+                break;
+            }
+            case State.RCDATA_END_TAG_NAME: {
+                this._stateRcdataEndTagName(cp);
+                break;
+            }
+            case State.RAWTEXT_LESS_THAN_SIGN: {
+                this._stateRawtextLessThanSign(cp);
+                break;
+            }
+            case State.RAWTEXT_END_TAG_OPEN: {
+                this._stateRawtextEndTagOpen(cp);
+                break;
+            }
+            case State.RAWTEXT_END_TAG_NAME: {
+                this._stateRawtextEndTagName(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_LESS_THAN_SIGN: {
+                this._stateScriptDataLessThanSign(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_END_TAG_OPEN: {
+                this._stateScriptDataEndTagOpen(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_END_TAG_NAME: {
+                this._stateScriptDataEndTagName(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPE_START: {
+                this._stateScriptDataEscapeStart(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPE_START_DASH: {
+                this._stateScriptDataEscapeStartDash(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED: {
+                this._stateScriptDataEscaped(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED_DASH: {
+                this._stateScriptDataEscapedDash(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED_DASH_DASH: {
+                this._stateScriptDataEscapedDashDash(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
+                this._stateScriptDataEscapedLessThanSign(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: {
+                this._stateScriptDataEscapedEndTagOpen(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: {
+                this._stateScriptDataEscapedEndTagName(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: {
+                this._stateScriptDataDoubleEscapeStart(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPED: {
+                this._stateScriptDataDoubleEscaped(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
+                this._stateScriptDataDoubleEscapedDash(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
+                this._stateScriptDataDoubleEscapedDashDash(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
+                this._stateScriptDataDoubleEscapedLessThanSign(cp);
+                break;
+            }
+            case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: {
+                this._stateScriptDataDoubleEscapeEnd(cp);
+                break;
+            }
+            case State.BEFORE_ATTRIBUTE_NAME: {
+                this._stateBeforeAttributeName(cp);
+                break;
+            }
+            case State.ATTRIBUTE_NAME: {
+                this._stateAttributeName(cp);
+                break;
+            }
+            case State.AFTER_ATTRIBUTE_NAME: {
+                this._stateAfterAttributeName(cp);
+                break;
+            }
+            case State.BEFORE_ATTRIBUTE_VALUE: {
+                this._stateBeforeAttributeValue(cp);
+                break;
+            }
+            case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
+                this._stateAttributeValueDoubleQuoted(cp);
+                break;
+            }
+            case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: {
+                this._stateAttributeValueSingleQuoted(cp);
+                break;
+            }
+            case State.ATTRIBUTE_VALUE_UNQUOTED: {
+                this._stateAttributeValueUnquoted(cp);
+                break;
+            }
+            case State.AFTER_ATTRIBUTE_VALUE_QUOTED: {
+                this._stateAfterAttributeValueQuoted(cp);
+                break;
+            }
+            case State.SELF_CLOSING_START_TAG: {
+                this._stateSelfClosingStartTag(cp);
+                break;
+            }
+            case State.BOGUS_COMMENT: {
+                this._stateBogusComment(cp);
+                break;
+            }
+            case State.MARKUP_DECLARATION_OPEN: {
+                this._stateMarkupDeclarationOpen(cp);
+                break;
+            }
+            case State.COMMENT_START: {
+                this._stateCommentStart(cp);
+                break;
+            }
+            case State.COMMENT_START_DASH: {
+                this._stateCommentStartDash(cp);
+                break;
+            }
+            case State.COMMENT: {
+                this._stateComment(cp);
+                break;
+            }
+            case State.COMMENT_LESS_THAN_SIGN: {
+                this._stateCommentLessThanSign(cp);
+                break;
+            }
+            case State.COMMENT_LESS_THAN_SIGN_BANG: {
+                this._stateCommentLessThanSignBang(cp);
+                break;
+            }
+            case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: {
+                this._stateCommentLessThanSignBangDash(cp);
+                break;
+            }
+            case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: {
+                this._stateCommentLessThanSignBangDashDash(cp);
+                break;
+            }
+            case State.COMMENT_END_DASH: {
+                this._stateCommentEndDash(cp);
+                break;
+            }
+            case State.COMMENT_END: {
+                this._stateCommentEnd(cp);
+                break;
+            }
+            case State.COMMENT_END_BANG: {
+                this._stateCommentEndBang(cp);
+                break;
+            }
+            case State.DOCTYPE: {
+                this._stateDoctype(cp);
+                break;
+            }
+            case State.BEFORE_DOCTYPE_NAME: {
+                this._stateBeforeDoctypeName(cp);
+                break;
+            }
+            case State.DOCTYPE_NAME: {
+                this._stateDoctypeName(cp);
+                break;
+            }
+            case State.AFTER_DOCTYPE_NAME: {
+                this._stateAfterDoctypeName(cp);
+                break;
+            }
+            case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: {
+                this._stateAfterDoctypePublicKeyword(cp);
+                break;
+            }
+            case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
+                this._stateBeforeDoctypePublicIdentifier(cp);
+                break;
+            }
+            case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
+                this._stateDoctypePublicIdentifierDoubleQuoted(cp);
+                break;
+            }
+            case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
+                this._stateDoctypePublicIdentifierSingleQuoted(cp);
+                break;
+            }
+            case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
+                this._stateAfterDoctypePublicIdentifier(cp);
+                break;
+            }
+            case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
+                this._stateBetweenDoctypePublicAndSystemIdentifiers(cp);
+                break;
+            }
+            case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: {
+                this._stateAfterDoctypeSystemKeyword(cp);
+                break;
+            }
+            case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
+                this._stateBeforeDoctypeSystemIdentifier(cp);
+                break;
+            }
+            case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
+                this._stateDoctypeSystemIdentifierDoubleQuoted(cp);
+                break;
+            }
+            case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
+                this._stateDoctypeSystemIdentifierSingleQuoted(cp);
+                break;
+            }
+            case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
+                this._stateAfterDoctypeSystemIdentifier(cp);
+                break;
+            }
+            case State.BOGUS_DOCTYPE: {
+                this._stateBogusDoctype(cp);
+                break;
+            }
+            case State.CDATA_SECTION: {
+                this._stateCdataSection(cp);
+                break;
+            }
+            case State.CDATA_SECTION_BRACKET: {
+                this._stateCdataSectionBracket(cp);
+                break;
+            }
+            case State.CDATA_SECTION_END: {
+                this._stateCdataSectionEnd(cp);
+                break;
+            }
+            case State.CHARACTER_REFERENCE: {
+                this._stateCharacterReference(cp);
+                break;
+            }
+            case State.NAMED_CHARACTER_REFERENCE: {
+                this._stateNamedCharacterReference(cp);
+                break;
+            }
+            case State.AMBIGUOUS_AMPERSAND: {
+                this._stateAmbiguousAmpersand(cp);
+                break;
+            }
+            case State.NUMERIC_CHARACTER_REFERENCE: {
+                this._stateNumericCharacterReference(cp);
+                break;
+            }
+            case State.HEXADEMICAL_CHARACTER_REFERENCE_START: {
+                this._stateHexademicalCharacterReferenceStart(cp);
+                break;
+            }
+            case State.HEXADEMICAL_CHARACTER_REFERENCE: {
+                this._stateHexademicalCharacterReference(cp);
+                break;
+            }
+            case State.DECIMAL_CHARACTER_REFERENCE: {
+                this._stateDecimalCharacterReference(cp);
+                break;
+            }
+            case State.NUMERIC_CHARACTER_REFERENCE_END: {
+                this._stateNumericCharacterReferenceEnd(cp);
+                break;
+            }
+            default: {
+                throw new Error('Unknown state');
+            }
+        }
+    }
+    // State machine
+    // Data state
+    //------------------------------------------------------------------
+    _stateData(cp) {
+        switch (cp) {
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.TAG_OPEN;
+                break;
+            }
+            case CODE_POINTS.AMPERSAND: {
+                this.returnState = State.DATA;
+                this.state = State.CHARACTER_REFERENCE;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitCodePoint(cp);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    //  RCDATA state
+    //------------------------------------------------------------------
+    _stateRcdata(cp) {
+        switch (cp) {
+            case CODE_POINTS.AMPERSAND: {
+                this.returnState = State.RCDATA;
+                this.state = State.CHARACTER_REFERENCE;
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.RCDATA_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // RAWTEXT state
+    //------------------------------------------------------------------
+    _stateRawtext(cp) {
+        switch (cp) {
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.RAWTEXT_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data state
+    //------------------------------------------------------------------
+    _stateScriptData(cp) {
+        switch (cp) {
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // PLAINTEXT state
+    //------------------------------------------------------------------
+    _statePlaintext(cp) {
+        switch (cp) {
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Tag open state
+    //------------------------------------------------------------------
+    _stateTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this._createStartTagToken();
+            this.state = State.TAG_NAME;
+            this._stateTagName(cp);
+        }
+        else
+            switch (cp) {
+                case CODE_POINTS.EXCLAMATION_MARK: {
+                    this.state = State.MARKUP_DECLARATION_OPEN;
+                    break;
+                }
+                case CODE_POINTS.SOLIDUS: {
+                    this.state = State.END_TAG_OPEN;
+                    break;
+                }
+                case CODE_POINTS.QUESTION_MARK: {
+                    this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
+                    this._createCommentToken(1);
+                    this.state = State.BOGUS_COMMENT;
+                    this._stateBogusComment(cp);
+                    break;
+                }
+                case CODE_POINTS.EOF: {
+                    this._err(ERR.eofBeforeTagName);
+                    this._emitChars('<');
+                    this._emitEOFToken();
+                    break;
+                }
+                default: {
+                    this._err(ERR.invalidFirstCharacterOfTagName);
+                    this._emitChars('<');
+                    this.state = State.DATA;
+                    this._stateData(cp);
+                }
+            }
+    }
+    // End tag open state
+    //------------------------------------------------------------------
+    _stateEndTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this.state = State.TAG_NAME;
+            this._stateTagName(cp);
+        }
+        else
+            switch (cp) {
+                case CODE_POINTS.GREATER_THAN_SIGN: {
+                    this._err(ERR.missingEndTagName);
+                    this.state = State.DATA;
+                    break;
+                }
+                case CODE_POINTS.EOF: {
+                    this._err(ERR.eofBeforeTagName);
+                    this._emitChars('</');
+                    this._emitEOFToken();
+                    break;
+                }
+                default: {
+                    this._err(ERR.invalidFirstCharacterOfTagName);
+                    this._createCommentToken(2);
+                    this.state = State.BOGUS_COMMENT;
+                    this._stateBogusComment(cp);
+                }
+            }
+    }
+    // Tag name state
+    //------------------------------------------------------------------
+    _stateTagName(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                break;
+            }
+            case CODE_POINTS.SOLIDUS: {
+                this.state = State.SELF_CLOSING_START_TAG;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.tagName += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.tagName += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+            }
+        }
+    }
+    // RCDATA less-than sign state
+    //------------------------------------------------------------------
+    _stateRcdataLessThanSign(cp) {
+        if (cp === CODE_POINTS.SOLIDUS) {
+            this.state = State.RCDATA_END_TAG_OPEN;
+        }
+        else {
+            this._emitChars('<');
+            this.state = State.RCDATA;
+            this._stateRcdata(cp);
+        }
+    }
+    // RCDATA end tag open state
+    //------------------------------------------------------------------
+    _stateRcdataEndTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this.state = State.RCDATA_END_TAG_NAME;
+            this._stateRcdataEndTagName(cp);
+        }
+        else {
+            this._emitChars('</');
+            this.state = State.RCDATA;
+            this._stateRcdata(cp);
+        }
+    }
+    handleSpecialEndTag(_cp) {
+        if (!this.preprocessor.startsWith(this.lastStartTagName, false)) {
+            return !this._ensureHibernation();
+        }
+        this._createEndTagToken();
+        const token = this.currentToken;
+        token.tagName = this.lastStartTagName;
+        const cp = this.preprocessor.peek(this.lastStartTagName.length);
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this._advanceBy(this.lastStartTagName.length);
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                return false;
+            }
+            case CODE_POINTS.SOLIDUS: {
+                this._advanceBy(this.lastStartTagName.length);
+                this.state = State.SELF_CLOSING_START_TAG;
+                return false;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._advanceBy(this.lastStartTagName.length);
+                this.emitCurrentTagToken();
+                this.state = State.DATA;
+                return false;
+            }
+            default: {
+                return !this._ensureHibernation();
+            }
+        }
+    }
+    // RCDATA end tag name state
+    //------------------------------------------------------------------
+    _stateRcdataEndTagName(cp) {
+        if (this.handleSpecialEndTag(cp)) {
+            this._emitChars('</');
+            this.state = State.RCDATA;
+            this._stateRcdata(cp);
+        }
+    }
+    // RAWTEXT less-than sign state
+    //------------------------------------------------------------------
+    _stateRawtextLessThanSign(cp) {
+        if (cp === CODE_POINTS.SOLIDUS) {
+            this.state = State.RAWTEXT_END_TAG_OPEN;
+        }
+        else {
+            this._emitChars('<');
+            this.state = State.RAWTEXT;
+            this._stateRawtext(cp);
+        }
+    }
+    // RAWTEXT end tag open state
+    //------------------------------------------------------------------
+    _stateRawtextEndTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this.state = State.RAWTEXT_END_TAG_NAME;
+            this._stateRawtextEndTagName(cp);
+        }
+        else {
+            this._emitChars('</');
+            this.state = State.RAWTEXT;
+            this._stateRawtext(cp);
+        }
+    }
+    // RAWTEXT end tag name state
+    //------------------------------------------------------------------
+    _stateRawtextEndTagName(cp) {
+        if (this.handleSpecialEndTag(cp)) {
+            this._emitChars('</');
+            this.state = State.RAWTEXT;
+            this._stateRawtext(cp);
+        }
+    }
+    // Script data less-than sign state
+    //------------------------------------------------------------------
+    _stateScriptDataLessThanSign(cp) {
+        switch (cp) {
+            case CODE_POINTS.SOLIDUS: {
+                this.state = State.SCRIPT_DATA_END_TAG_OPEN;
+                break;
+            }
+            case CODE_POINTS.EXCLAMATION_MARK: {
+                this.state = State.SCRIPT_DATA_ESCAPE_START;
+                this._emitChars('<!');
+                break;
+            }
+            default: {
+                this._emitChars('<');
+                this.state = State.SCRIPT_DATA;
+                this._stateScriptData(cp);
+            }
+        }
+    }
+    // Script data end tag open state
+    //------------------------------------------------------------------
+    _stateScriptDataEndTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this.state = State.SCRIPT_DATA_END_TAG_NAME;
+            this._stateScriptDataEndTagName(cp);
+        }
+        else {
+            this._emitChars('</');
+            this.state = State.SCRIPT_DATA;
+            this._stateScriptData(cp);
+        }
+    }
+    // Script data end tag name state
+    //------------------------------------------------------------------
+    _stateScriptDataEndTagName(cp) {
+        if (this.handleSpecialEndTag(cp)) {
+            this._emitChars('</');
+            this.state = State.SCRIPT_DATA;
+            this._stateScriptData(cp);
+        }
+    }
+    // Script data escape start state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapeStart(cp) {
+        if (cp === CODE_POINTS.HYPHEN_MINUS) {
+            this.state = State.SCRIPT_DATA_ESCAPE_START_DASH;
+            this._emitChars('-');
+        }
+        else {
+            this.state = State.SCRIPT_DATA;
+            this._stateScriptData(cp);
+        }
+    }
+    // Script data escape start dash state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapeStartDash(cp) {
+        if (cp === CODE_POINTS.HYPHEN_MINUS) {
+            this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
+            this._emitChars('-');
+        }
+        else {
+            this.state = State.SCRIPT_DATA;
+            this._stateScriptData(cp);
+        }
+    }
+    // Script data escaped state
+    //------------------------------------------------------------------
+    _stateScriptDataEscaped(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.SCRIPT_DATA_ESCAPED_DASH;
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data escaped dash state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapedDash(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.SCRIPT_DATA_ESCAPED_DASH_DASH;
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.state = State.SCRIPT_DATA_ESCAPED;
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.state = State.SCRIPT_DATA_ESCAPED;
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data escaped dash dash state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapedDashDash(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA;
+                this._emitChars('>');
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.state = State.SCRIPT_DATA_ESCAPED;
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.state = State.SCRIPT_DATA_ESCAPED;
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data escaped less-than sign state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapedLessThanSign(cp) {
+        if (cp === CODE_POINTS.SOLIDUS) {
+            this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
+        }
+        else if (isAsciiLetter(cp)) {
+            this._emitChars('<');
+            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;
+            this._stateScriptDataDoubleEscapeStart(cp);
+        }
+        else {
+            this._emitChars('<');
+            this.state = State.SCRIPT_DATA_ESCAPED;
+            this._stateScriptDataEscaped(cp);
+        }
+    }
+    // Script data escaped end tag open state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapedEndTagOpen(cp) {
+        if (isAsciiLetter(cp)) {
+            this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME;
+            this._stateScriptDataEscapedEndTagName(cp);
+        }
+        else {
+            this._emitChars('</');
+            this.state = State.SCRIPT_DATA_ESCAPED;
+            this._stateScriptDataEscaped(cp);
+        }
+    }
+    // Script data escaped end tag name state
+    //------------------------------------------------------------------
+    _stateScriptDataEscapedEndTagName(cp) {
+        if (this.handleSpecialEndTag(cp)) {
+            this._emitChars('</');
+            this.state = State.SCRIPT_DATA_ESCAPED;
+            this._stateScriptDataEscaped(cp);
+        }
+    }
+    // Script data double escape start state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscapeStart(cp) {
+        if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) &&
+            isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
+            this._emitCodePoint(cp);
+            for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) {
+                this._emitCodePoint(this._consume());
+            }
+            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+        }
+        else if (!this._ensureHibernation()) {
+            this.state = State.SCRIPT_DATA_ESCAPED;
+            this._stateScriptDataEscaped(cp);
+        }
+    }
+    // Script data double escaped state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscaped(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+                this._emitChars('<');
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data double escaped dash state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscapedDash(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+                this._emitChars('<');
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data double escaped dash dash state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscapedDashDash(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this._emitChars('-');
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+                this._emitChars('<');
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.SCRIPT_DATA;
+                this._emitChars('>');
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+                this._emitChars(REPLACEMENT_CHARACTER);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInScriptHtmlCommentLikeText);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // Script data double escaped less-than sign state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscapedLessThanSign(cp) {
+        if (cp === CODE_POINTS.SOLIDUS) {
+            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END;
+            this._emitChars('/');
+        }
+        else {
+            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+            this._stateScriptDataDoubleEscaped(cp);
+        }
+    }
+    // Script data double escape end state
+    //------------------------------------------------------------------
+    _stateScriptDataDoubleEscapeEnd(cp) {
+        if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) &&
+            isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) {
+            this._emitCodePoint(cp);
+            for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) {
+                this._emitCodePoint(this._consume());
+            }
+            this.state = State.SCRIPT_DATA_ESCAPED;
+        }
+        else if (!this._ensureHibernation()) {
+            this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED;
+            this._stateScriptDataDoubleEscaped(cp);
+        }
+    }
+    // Before attribute name state
+    //------------------------------------------------------------------
+    _stateBeforeAttributeName(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.SOLIDUS:
+            case CODE_POINTS.GREATER_THAN_SIGN:
+            case CODE_POINTS.EOF: {
+                this.state = State.AFTER_ATTRIBUTE_NAME;
+                this._stateAfterAttributeName(cp);
+                break;
+            }
+            case CODE_POINTS.EQUALS_SIGN: {
+                this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
+                this._createAttr('=');
+                this.state = State.ATTRIBUTE_NAME;
+                break;
+            }
+            default: {
+                this._createAttr('');
+                this.state = State.ATTRIBUTE_NAME;
+                this._stateAttributeName(cp);
+            }
+        }
+    }
+    // Attribute name state
+    //------------------------------------------------------------------
+    _stateAttributeName(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED:
+            case CODE_POINTS.SOLIDUS:
+            case CODE_POINTS.GREATER_THAN_SIGN:
+            case CODE_POINTS.EOF: {
+                this._leaveAttrName();
+                this.state = State.AFTER_ATTRIBUTE_NAME;
+                this._stateAfterAttributeName(cp);
+                break;
+            }
+            case CODE_POINTS.EQUALS_SIGN: {
+                this._leaveAttrName();
+                this.state = State.BEFORE_ATTRIBUTE_VALUE;
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK:
+            case CODE_POINTS.APOSTROPHE:
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                this._err(ERR.unexpectedCharacterInAttributeName);
+                this.currentAttr.name += String.fromCodePoint(cp);
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.currentAttr.name += REPLACEMENT_CHARACTER;
+                break;
+            }
+            default: {
+                this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+            }
+        }
+    }
+    // After attribute name state
+    //------------------------------------------------------------------
+    _stateAfterAttributeName(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.SOLIDUS: {
+                this.state = State.SELF_CLOSING_START_TAG;
+                break;
+            }
+            case CODE_POINTS.EQUALS_SIGN: {
+                this.state = State.BEFORE_ATTRIBUTE_VALUE;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._createAttr('');
+                this.state = State.ATTRIBUTE_NAME;
+                this._stateAttributeName(cp);
+            }
+        }
+    }
+    // Before attribute value state
+    //------------------------------------------------------------------
+    _stateBeforeAttributeValue(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.missingAttributeValue);
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            default: {
+                this.state = State.ATTRIBUTE_VALUE_UNQUOTED;
+                this._stateAttributeValueUnquoted(cp);
+            }
+        }
+    }
+    // Attribute value (double-quoted) state
+    //------------------------------------------------------------------
+    _stateAttributeValueDoubleQuoted(cp) {
+        switch (cp) {
+            case CODE_POINTS.QUOTATION_MARK: {
+                this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.AMPERSAND: {
+                this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
+                this.state = State.CHARACTER_REFERENCE;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.currentAttr.value += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // Attribute value (single-quoted) state
+    //------------------------------------------------------------------
+    _stateAttributeValueSingleQuoted(cp) {
+        switch (cp) {
+            case CODE_POINTS.APOSTROPHE: {
+                this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.AMPERSAND: {
+                this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
+                this.state = State.CHARACTER_REFERENCE;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.currentAttr.value += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // Attribute value (unquoted) state
+    //------------------------------------------------------------------
+    _stateAttributeValueUnquoted(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this._leaveAttrValue();
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                break;
+            }
+            case CODE_POINTS.AMPERSAND: {
+                this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;
+                this.state = State.CHARACTER_REFERENCE;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._leaveAttrValue();
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK:
+            case CODE_POINTS.APOSTROPHE:
+            case CODE_POINTS.LESS_THAN_SIGN:
+            case CODE_POINTS.EQUALS_SIGN:
+            case CODE_POINTS.GRAVE_ACCENT: {
+                this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
+                this.currentAttr.value += String.fromCodePoint(cp);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this.currentAttr.value += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // After attribute value (quoted) state
+    //------------------------------------------------------------------
+    _stateAfterAttributeValueQuoted(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this._leaveAttrValue();
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                break;
+            }
+            case CODE_POINTS.SOLIDUS: {
+                this._leaveAttrValue();
+                this.state = State.SELF_CLOSING_START_TAG;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._leaveAttrValue();
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingWhitespaceBetweenAttributes);
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                this._stateBeforeAttributeName(cp);
+            }
+        }
+    }
+    // Self-closing start tag state
+    //------------------------------------------------------------------
+    _stateSelfClosingStartTag(cp) {
+        switch (cp) {
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                const token = this.currentToken;
+                token.selfClosing = true;
+                this.state = State.DATA;
+                this.emitCurrentTagToken();
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInTag);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.unexpectedSolidusInTag);
+                this.state = State.BEFORE_ATTRIBUTE_NAME;
+                this._stateBeforeAttributeName(cp);
+            }
+        }
+    }
+    // Bogus comment state
+    //------------------------------------------------------------------
+    _stateBogusComment(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentComment(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.data += REPLACEMENT_CHARACTER;
+                break;
+            }
+            default: {
+                token.data += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // Markup declaration open state
+    //------------------------------------------------------------------
+    _stateMarkupDeclarationOpen(cp) {
+        if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) {
+            this._createCommentToken(SEQUENCES.DASH_DASH.length + 1);
+            this.state = State.COMMENT_START;
+        }
+        else if (this._consumeSequenceIfMatch(SEQUENCES.DOCTYPE, false)) {
+            // NOTE: Doctypes tokens are created without fixed offsets. We keep track of the moment a doctype *might* start here.
+            this.currentLocation = this.getCurrentLocation(SEQUENCES.DOCTYPE.length + 1);
+            this.state = State.DOCTYPE;
+        }
+        else if (this._consumeSequenceIfMatch(SEQUENCES.CDATA_START, true)) {
+            if (this.inForeignNode) {
+                this.state = State.CDATA_SECTION;
+            }
+            else {
+                this._err(ERR.cdataInHtmlContent);
+                this._createCommentToken(SEQUENCES.CDATA_START.length + 1);
+                this.currentToken.data = '[CDATA[';
+                this.state = State.BOGUS_COMMENT;
+            }
+        }
+        //NOTE: Sequence lookups can be abrupted by hibernation. In that case, lookup
+        //results are no longer valid and we will need to start over.
+        else if (!this._ensureHibernation()) {
+            this._err(ERR.incorrectlyOpenedComment);
+            this._createCommentToken(2);
+            this.state = State.BOGUS_COMMENT;
+            this._stateBogusComment(cp);
+        }
+    }
+    // Comment start state
+    //------------------------------------------------------------------
+    _stateCommentStart(cp) {
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.COMMENT_START_DASH;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptClosingOfEmptyComment);
+                this.state = State.DATA;
+                const token = this.currentToken;
+                this.emitCurrentComment(token);
+                break;
+            }
+            default: {
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // Comment start dash state
+    //------------------------------------------------------------------
+    _stateCommentStartDash(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.COMMENT_END;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptClosingOfEmptyComment);
+                this.state = State.DATA;
+                this.emitCurrentComment(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInComment);
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.data += '-';
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // Comment state
+    //------------------------------------------------------------------
+    _stateComment(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.COMMENT_END_DASH;
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                token.data += '<';
+                this.state = State.COMMENT_LESS_THAN_SIGN;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.data += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInComment);
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.data += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // Comment less-than sign state
+    //------------------------------------------------------------------
+    _stateCommentLessThanSign(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.EXCLAMATION_MARK: {
+                token.data += '!';
+                this.state = State.COMMENT_LESS_THAN_SIGN_BANG;
+                break;
+            }
+            case CODE_POINTS.LESS_THAN_SIGN: {
+                token.data += '<';
+                break;
+            }
+            default: {
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // Comment less-than sign bang state
+    //------------------------------------------------------------------
+    _stateCommentLessThanSignBang(cp) {
+        if (cp === CODE_POINTS.HYPHEN_MINUS) {
+            this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH;
+        }
+        else {
+            this.state = State.COMMENT;
+            this._stateComment(cp);
+        }
+    }
+    // Comment less-than sign bang dash state
+    //------------------------------------------------------------------
+    _stateCommentLessThanSignBangDash(cp) {
+        if (cp === CODE_POINTS.HYPHEN_MINUS) {
+            this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH;
+        }
+        else {
+            this.state = State.COMMENT_END_DASH;
+            this._stateCommentEndDash(cp);
+        }
+    }
+    // Comment less-than sign bang dash dash state
+    //------------------------------------------------------------------
+    _stateCommentLessThanSignBangDashDash(cp) {
+        if (cp !== CODE_POINTS.GREATER_THAN_SIGN && cp !== CODE_POINTS.EOF) {
+            this._err(ERR.nestedComment);
+        }
+        this.state = State.COMMENT_END;
+        this._stateCommentEnd(cp);
+    }
+    // Comment end dash state
+    //------------------------------------------------------------------
+    _stateCommentEndDash(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                this.state = State.COMMENT_END;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInComment);
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.data += '-';
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // Comment end state
+    //------------------------------------------------------------------
+    _stateCommentEnd(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentComment(token);
+                break;
+            }
+            case CODE_POINTS.EXCLAMATION_MARK: {
+                this.state = State.COMMENT_END_BANG;
+                break;
+            }
+            case CODE_POINTS.HYPHEN_MINUS: {
+                token.data += '-';
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInComment);
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.data += '--';
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // Comment end bang state
+    //------------------------------------------------------------------
+    _stateCommentEndBang(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.HYPHEN_MINUS: {
+                token.data += '--!';
+                this.state = State.COMMENT_END_DASH;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.incorrectlyClosedComment);
+                this.state = State.DATA;
+                this.emitCurrentComment(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInComment);
+                this.emitCurrentComment(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.data += '--!';
+                this.state = State.COMMENT;
+                this._stateComment(cp);
+            }
+        }
+    }
+    // DOCTYPE state
+    //------------------------------------------------------------------
+    _stateDoctype(cp) {
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.BEFORE_DOCTYPE_NAME;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.BEFORE_DOCTYPE_NAME;
+                this._stateBeforeDoctypeName(cp);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                this._createDoctypeToken(null);
+                const token = this.currentToken;
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingWhitespaceBeforeDoctypeName);
+                this.state = State.BEFORE_DOCTYPE_NAME;
+                this._stateBeforeDoctypeName(cp);
+            }
+        }
+    }
+    // Before DOCTYPE name state
+    //------------------------------------------------------------------
+    _stateBeforeDoctypeName(cp) {
+        if (isAsciiUpper(cp)) {
+            this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp)));
+            this.state = State.DOCTYPE_NAME;
+        }
+        else
+            switch (cp) {
+                case CODE_POINTS.SPACE:
+                case CODE_POINTS.LINE_FEED:
+                case CODE_POINTS.TABULATION:
+                case CODE_POINTS.FORM_FEED: {
+                    // Ignore whitespace
+                    break;
+                }
+                case CODE_POINTS.NULL: {
+                    this._err(ERR.unexpectedNullCharacter);
+                    this._createDoctypeToken(REPLACEMENT_CHARACTER);
+                    this.state = State.DOCTYPE_NAME;
+                    break;
+                }
+                case CODE_POINTS.GREATER_THAN_SIGN: {
+                    this._err(ERR.missingDoctypeName);
+                    this._createDoctypeToken(null);
+                    const token = this.currentToken;
+                    token.forceQuirks = true;
+                    this.emitCurrentDoctype(token);
+                    this.state = State.DATA;
+                    break;
+                }
+                case CODE_POINTS.EOF: {
+                    this._err(ERR.eofInDoctype);
+                    this._createDoctypeToken(null);
+                    const token = this.currentToken;
+                    token.forceQuirks = true;
+                    this.emitCurrentDoctype(token);
+                    this._emitEOFToken();
+                    break;
+                }
+                default: {
+                    this._createDoctypeToken(String.fromCodePoint(cp));
+                    this.state = State.DOCTYPE_NAME;
+                }
+            }
+    }
+    // DOCTYPE name state
+    //------------------------------------------------------------------
+    _stateDoctypeName(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.AFTER_DOCTYPE_NAME;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.name += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp);
+            }
+        }
+    }
+    // After DOCTYPE name state
+    //------------------------------------------------------------------
+    _stateAfterDoctypeName(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                if (this._consumeSequenceIfMatch(SEQUENCES.PUBLIC, false)) {
+                    this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;
+                }
+                else if (this._consumeSequenceIfMatch(SEQUENCES.SYSTEM, false)) {
+                    this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD;
+                }
+                //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
+                //results are no longer valid and we will need to start over.
+                else if (!this._ensureHibernation()) {
+                    this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
+                    token.forceQuirks = true;
+                    this.state = State.BOGUS_DOCTYPE;
+                    this._stateBogusDoctype(cp);
+                }
+            }
+        }
+    }
+    // After DOCTYPE public keyword state
+    //------------------------------------------------------------------
+    _stateAfterDoctypePublicKeyword(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+                token.publicId = '';
+                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+                token.publicId = '';
+                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.missingDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // Before DOCTYPE public identifier state
+    //------------------------------------------------------------------
+    _stateBeforeDoctypePublicIdentifier(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                token.publicId = '';
+                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                token.publicId = '';
+                this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.missingDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // DOCTYPE public identifier (double-quoted) state
+    //------------------------------------------------------------------
+    _stateDoctypePublicIdentifierDoubleQuoted(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.QUOTATION_MARK: {
+                this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.publicId += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.publicId += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // DOCTYPE public identifier (single-quoted) state
+    //------------------------------------------------------------------
+    _stateDoctypePublicIdentifierSingleQuoted(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.APOSTROPHE: {
+                this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.publicId += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptDoctypePublicIdentifier);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.publicId += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // After DOCTYPE public identifier state
+    //------------------------------------------------------------------
+    _stateAfterDoctypePublicIdentifier(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // Between DOCTYPE public and system identifiers state
+    //------------------------------------------------------------------
+    _stateBetweenDoctypePublicAndSystemIdentifiers(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // After DOCTYPE system keyword state
+    //------------------------------------------------------------------
+    _stateAfterDoctypeSystemKeyword(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.missingDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // Before DOCTYPE system identifier state
+    //------------------------------------------------------------------
+    _stateBeforeDoctypeSystemIdentifier(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.QUOTATION_MARK: {
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.APOSTROPHE: {
+                token.systemId = '';
+                this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.missingDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.DATA;
+                this.emitCurrentDoctype(token);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // DOCTYPE system identifier (double-quoted) state
+    //------------------------------------------------------------------
+    _stateDoctypeSystemIdentifierDoubleQuoted(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.QUOTATION_MARK: {
+                this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.systemId += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.systemId += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // DOCTYPE system identifier (single-quoted) state
+    //------------------------------------------------------------------
+    _stateDoctypeSystemIdentifierSingleQuoted(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.APOSTROPHE: {
+                this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                token.systemId += REPLACEMENT_CHARACTER;
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this._err(ERR.abruptDoctypeSystemIdentifier);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                token.systemId += String.fromCodePoint(cp);
+            }
+        }
+    }
+    // After DOCTYPE system identifier state
+    //------------------------------------------------------------------
+    _stateAfterDoctypeSystemIdentifier(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.SPACE:
+            case CODE_POINTS.LINE_FEED:
+            case CODE_POINTS.TABULATION:
+            case CODE_POINTS.FORM_FEED: {
+                // Ignore whitespace
+                break;
+            }
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInDoctype);
+                token.forceQuirks = true;
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
+                this.state = State.BOGUS_DOCTYPE;
+                this._stateBogusDoctype(cp);
+            }
+        }
+    }
+    // Bogus DOCTYPE state
+    //------------------------------------------------------------------
+    _stateBogusDoctype(cp) {
+        const token = this.currentToken;
+        switch (cp) {
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.emitCurrentDoctype(token);
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.NULL: {
+                this._err(ERR.unexpectedNullCharacter);
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this.emitCurrentDoctype(token);
+                this._emitEOFToken();
+                break;
+            }
+            // Do nothing
+        }
+    }
+    // CDATA section state
+    //------------------------------------------------------------------
+    _stateCdataSection(cp) {
+        switch (cp) {
+            case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
+                this.state = State.CDATA_SECTION_BRACKET;
+                break;
+            }
+            case CODE_POINTS.EOF: {
+                this._err(ERR.eofInCdata);
+                this._emitEOFToken();
+                break;
+            }
+            default: {
+                this._emitCodePoint(cp);
+            }
+        }
+    }
+    // CDATA section bracket state
+    //------------------------------------------------------------------
+    _stateCdataSectionBracket(cp) {
+        if (cp === CODE_POINTS.RIGHT_SQUARE_BRACKET) {
+            this.state = State.CDATA_SECTION_END;
+        }
+        else {
+            this._emitChars(']');
+            this.state = State.CDATA_SECTION;
+            this._stateCdataSection(cp);
+        }
+    }
+    // CDATA section end state
+    //------------------------------------------------------------------
+    _stateCdataSectionEnd(cp) {
+        switch (cp) {
+            case CODE_POINTS.GREATER_THAN_SIGN: {
+                this.state = State.DATA;
+                break;
+            }
+            case CODE_POINTS.RIGHT_SQUARE_BRACKET: {
+                this._emitChars(']');
+                break;
+            }
+            default: {
+                this._emitChars(']]');
+                this.state = State.CDATA_SECTION;
+                this._stateCdataSection(cp);
+            }
+        }
+    }
+    // Character reference state
+    //------------------------------------------------------------------
+    _stateCharacterReference(cp) {
+        if (cp === CODE_POINTS.NUMBER_SIGN) {
+            this.state = State.NUMERIC_CHARACTER_REFERENCE;
+        }
+        else if (isAsciiAlphaNumeric(cp)) {
+            this.state = State.NAMED_CHARACTER_REFERENCE;
+            this._stateNamedCharacterReference(cp);
+        }
+        else {
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
+            this._reconsumeInState(this.returnState, cp);
+        }
+    }
+    // Named character reference state
+    //------------------------------------------------------------------
+    _stateNamedCharacterReference(cp) {
+        const matchResult = this._matchNamedCharacterReference(cp);
+        //NOTE: Matching can be abrupted by hibernation. In that case, match
+        //results are no longer valid and we will need to start over.
+        if (this._ensureHibernation()) ;
+        else if (matchResult) {
+            for (let i = 0; i < matchResult.length; i++) {
+                this._flushCodePointConsumedAsCharacterReference(matchResult[i]);
+            }
+            this.state = this.returnState;
+        }
+        else {
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
+            this.state = State.AMBIGUOUS_AMPERSAND;
+        }
+    }
+    // Ambiguos ampersand state
+    //------------------------------------------------------------------
+    _stateAmbiguousAmpersand(cp) {
+        if (isAsciiAlphaNumeric(cp)) {
+            this._flushCodePointConsumedAsCharacterReference(cp);
+        }
+        else {
+            if (cp === CODE_POINTS.SEMICOLON) {
+                this._err(ERR.unknownNamedCharacterReference);
+            }
+            this._reconsumeInState(this.returnState, cp);
+        }
+    }
+    // Numeric character reference state
+    //------------------------------------------------------------------
+    _stateNumericCharacterReference(cp) {
+        this.charRefCode = 0;
+        if (cp === CODE_POINTS.LATIN_SMALL_X || cp === CODE_POINTS.LATIN_CAPITAL_X) {
+            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START;
+        }
+        // Inlined decimal character reference start state
+        else if (isAsciiDigit(cp)) {
+            this.state = State.DECIMAL_CHARACTER_REFERENCE;
+            this._stateDecimalCharacterReference(cp);
+        }
+        else {
+            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN);
+            this._reconsumeInState(this.returnState, cp);
+        }
+    }
+    // Hexademical character reference start state
+    //------------------------------------------------------------------
+    _stateHexademicalCharacterReferenceStart(cp) {
+        if (isAsciiHexDigit(cp)) {
+            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE;
+            this._stateHexademicalCharacterReference(cp);
+        }
+        else {
+            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
+            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN);
+            this._unconsume(2);
+            this.state = this.returnState;
+        }
+    }
+    // Hexademical character reference state
+    //------------------------------------------------------------------
+    _stateHexademicalCharacterReference(cp) {
+        if (isAsciiUpperHexDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x37;
+        }
+        else if (isAsciiLowerHexDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x57;
+        }
+        else if (isAsciiDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x30;
+        }
+        else if (cp === CODE_POINTS.SEMICOLON) {
+            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
+        }
+        else {
+            this._err(ERR.missingSemicolonAfterCharacterReference);
+            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
+            this._stateNumericCharacterReferenceEnd(cp);
+        }
+    }
+    // Decimal character reference state
+    //------------------------------------------------------------------
+    _stateDecimalCharacterReference(cp) {
+        if (isAsciiDigit(cp)) {
+            this.charRefCode = this.charRefCode * 10 + cp - 0x30;
+        }
+        else if (cp === CODE_POINTS.SEMICOLON) {
+            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
+        }
+        else {
+            this._err(ERR.missingSemicolonAfterCharacterReference);
+            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
+            this._stateNumericCharacterReferenceEnd(cp);
+        }
+    }
+    // Numeric character reference end state
+    //------------------------------------------------------------------
+    _stateNumericCharacterReferenceEnd(cp) {
+        if (this.charRefCode === CODE_POINTS.NULL) {
+            this._err(ERR.nullCharacterReference);
+            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
+        }
+        else if (this.charRefCode > 1114111) {
+            this._err(ERR.characterReferenceOutsideUnicodeRange);
+            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
+        }
+        else if (isSurrogate(this.charRefCode)) {
+            this._err(ERR.surrogateCharacterReference);
+            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
+        }
+        else if (isUndefinedCodePoint(this.charRefCode)) {
+            this._err(ERR.noncharacterCharacterReference);
+        }
+        else if (isControlCodePoint(this.charRefCode) || this.charRefCode === CODE_POINTS.CARRIAGE_RETURN) {
+            this._err(ERR.controlCharacterReference);
+            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode);
+            if (replacement !== undefined) {
+                this.charRefCode = replacement;
+            }
+        }
+        this._flushCodePointConsumedAsCharacterReference(this.charRefCode);
+        this._reconsumeInState(this.returnState, cp);
+    }
+}
+
+//Element utils
+const IMPLICIT_END_TAG_REQUIRED = new Set([TAG_ID.DD, TAG_ID.DT, TAG_ID.LI, TAG_ID.OPTGROUP, TAG_ID.OPTION, TAG_ID.P, TAG_ID.RB, TAG_ID.RP, TAG_ID.RT, TAG_ID.RTC]);
+const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
+    ...IMPLICIT_END_TAG_REQUIRED,
+    TAG_ID.CAPTION,
+    TAG_ID.COLGROUP,
+    TAG_ID.TBODY,
+    TAG_ID.TD,
+    TAG_ID.TFOOT,
+    TAG_ID.TH,
+    TAG_ID.THEAD,
+    TAG_ID.TR,
+]);
+const SCOPING_ELEMENT_NS = new Map([
+    [TAG_ID.APPLET, NS.HTML],
+    [TAG_ID.CAPTION, NS.HTML],
+    [TAG_ID.HTML, NS.HTML],
+    [TAG_ID.MARQUEE, NS.HTML],
+    [TAG_ID.OBJECT, NS.HTML],
+    [TAG_ID.TABLE, NS.HTML],
+    [TAG_ID.TD, NS.HTML],
+    [TAG_ID.TEMPLATE, NS.HTML],
+    [TAG_ID.TH, NS.HTML],
+    [TAG_ID.ANNOTATION_XML, NS.MATHML],
+    [TAG_ID.MI, NS.MATHML],
+    [TAG_ID.MN, NS.MATHML],
+    [TAG_ID.MO, NS.MATHML],
+    [TAG_ID.MS, NS.MATHML],
+    [TAG_ID.MTEXT, NS.MATHML],
+    [TAG_ID.DESC, NS.SVG],
+    [TAG_ID.FOREIGN_OBJECT, NS.SVG],
+    [TAG_ID.TITLE, NS.SVG],
+]);
+const NAMED_HEADERS = [TAG_ID.H1, TAG_ID.H2, TAG_ID.H3, TAG_ID.H4, TAG_ID.H5, TAG_ID.H6];
+const TABLE_ROW_CONTEXT = [TAG_ID.TR, TAG_ID.TEMPLATE, TAG_ID.HTML];
+const TABLE_BODY_CONTEXT = [TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TEMPLATE, TAG_ID.HTML];
+const TABLE_CONTEXT = [TAG_ID.TABLE, TAG_ID.TEMPLATE, TAG_ID.HTML];
+const TABLE_CELLS = [TAG_ID.TD, TAG_ID.TH];
+//Stack of open elements
+class OpenElementStack {
+    get currentTmplContentOrNode() {
+        return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;
+    }
+    constructor(document, treeAdapter, handler) {
+        this.treeAdapter = treeAdapter;
+        this.handler = handler;
+        this.items = [];
+        this.tagIDs = [];
+        this.stackTop = -1;
+        this.tmplCount = 0;
+        this.currentTagId = TAG_ID.UNKNOWN;
+        this.current = document;
+    }
+    //Index of element
+    _indexOf(element) {
+        return this.items.lastIndexOf(element, this.stackTop);
+    }
+    //Update current element
+    _isInTemplate() {
+        return this.currentTagId === TAG_ID.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
+    }
+    _updateCurrentElement() {
+        this.current = this.items[this.stackTop];
+        this.currentTagId = this.tagIDs[this.stackTop];
+    }
+    //Mutations
+    push(element, tagID) {
+        this.stackTop++;
+        this.items[this.stackTop] = element;
+        this.current = element;
+        this.tagIDs[this.stackTop] = tagID;
+        this.currentTagId = tagID;
+        if (this._isInTemplate()) {
+            this.tmplCount++;
+        }
+        this.handler.onItemPush(element, tagID, true);
+    }
+    pop() {
+        const popped = this.current;
+        if (this.tmplCount > 0 && this._isInTemplate()) {
+            this.tmplCount--;
+        }
+        this.stackTop--;
+        this._updateCurrentElement();
+        this.handler.onItemPop(popped, true);
+    }
+    replace(oldElement, newElement) {
+        const idx = this._indexOf(oldElement);
+        this.items[idx] = newElement;
+        if (idx === this.stackTop) {
+            this.current = newElement;
+        }
+    }
+    insertAfter(referenceElement, newElement, newElementID) {
+        const insertionIdx = this._indexOf(referenceElement) + 1;
+        this.items.splice(insertionIdx, 0, newElement);
+        this.tagIDs.splice(insertionIdx, 0, newElementID);
+        this.stackTop++;
+        if (insertionIdx === this.stackTop) {
+            this._updateCurrentElement();
+        }
+        this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);
+    }
+    popUntilTagNamePopped(tagName) {
+        let targetIdx = this.stackTop + 1;
+        do {
+            targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);
+        } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);
+        this.shortenToLength(targetIdx < 0 ? 0 : targetIdx);
+    }
+    shortenToLength(idx) {
+        while (this.stackTop >= idx) {
+            const popped = this.current;
+            if (this.tmplCount > 0 && this._isInTemplate()) {
+                this.tmplCount -= 1;
+            }
+            this.stackTop--;
+            this._updateCurrentElement();
+            this.handler.onItemPop(popped, this.stackTop < idx);
+        }
+    }
+    popUntilElementPopped(element) {
+        const idx = this._indexOf(element);
+        this.shortenToLength(idx < 0 ? 0 : idx);
+    }
+    popUntilPopped(tagNames, targetNS) {
+        const idx = this._indexOfTagNames(tagNames, targetNS);
+        this.shortenToLength(idx < 0 ? 0 : idx);
+    }
+    popUntilNumberedHeaderPopped() {
+        this.popUntilPopped(NAMED_HEADERS, NS.HTML);
+    }
+    popUntilTableCellPopped() {
+        this.popUntilPopped(TABLE_CELLS, NS.HTML);
+    }
+    popAllUpToHtmlElement() {
+        //NOTE: here we assume that the root <html> element is always first in the open element stack, so
+        //we perform this fast stack clean up.
+        this.tmplCount = 0;
+        this.shortenToLength(1);
+    }
+    _indexOfTagNames(tagNames, namespace) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    clearBackTo(tagNames, targetNS) {
+        const idx = this._indexOfTagNames(tagNames, targetNS);
+        this.shortenToLength(idx + 1);
+    }
+    clearBackToTableContext() {
+        this.clearBackTo(TABLE_CONTEXT, NS.HTML);
+    }
+    clearBackToTableBodyContext() {
+        this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);
+    }
+    clearBackToTableRowContext() {
+        this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);
+    }
+    remove(element) {
+        const idx = this._indexOf(element);
+        if (idx >= 0) {
+            if (idx === this.stackTop) {
+                this.pop();
+            }
+            else {
+                this.items.splice(idx, 1);
+                this.tagIDs.splice(idx, 1);
+                this.stackTop--;
+                this._updateCurrentElement();
+                this.handler.onItemPop(element, false);
+            }
+        }
+    }
+    //Search
+    tryPeekProperlyNestedBodyElement() {
+        //Properly nested <body> element (should be second element in stack).
+        return this.stackTop >= 1 && this.tagIDs[1] === TAG_ID.BODY ? this.items[1] : null;
+    }
+    contains(element) {
+        return this._indexOf(element) > -1;
+    }
+    getCommonAncestor(element) {
+        const elementIdx = this._indexOf(element) - 1;
+        return elementIdx >= 0 ? this.items[elementIdx] : null;
+    }
+    isRootHtmlElementCurrent() {
+        return this.stackTop === 0 && this.tagIDs[0] === TAG_ID.HTML;
+    }
+    //Element in scope
+    hasInScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === NS.HTML) {
+                return true;
+            }
+            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasNumberedHeaderInScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (isNumberedHeader(tn) && ns === NS.HTML) {
+                return true;
+            }
+            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInListItemScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === NS.HTML) {
+                return true;
+            }
+            if (((tn === TAG_ID.UL || tn === TAG_ID.OL) && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInButtonScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === NS.HTML) {
+                return true;
+            }
+            if ((tn === TAG_ID.BUTTON && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInTableScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== NS.HTML) {
+                continue;
+            }
+            if (tn === tagName) {
+                return true;
+            }
+            if (tn === TAG_ID.TABLE || tn === TAG_ID.TEMPLATE || tn === TAG_ID.HTML) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasTableBodyContextInTableScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== NS.HTML) {
+                continue;
+            }
+            if (tn === TAG_ID.TBODY || tn === TAG_ID.THEAD || tn === TAG_ID.TFOOT) {
+                return true;
+            }
+            if (tn === TAG_ID.TABLE || tn === TAG_ID.HTML) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInSelectScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== NS.HTML) {
+                continue;
+            }
+            if (tn === tagName) {
+                return true;
+            }
+            if (tn !== TAG_ID.OPTION && tn !== TAG_ID.OPTGROUP) {
+                return false;
+            }
+        }
+        return true;
+    }
+    //Implied end tags
+    generateImpliedEndTags() {
+        while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsThoroughly() {
+        while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsWithExclusion(exclusionId) {
+        while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+}
+
+//Const
+const NOAH_ARK_CAPACITY = 3;
+var EntryType;
+(function (EntryType) {
+    EntryType[EntryType["Marker"] = 0] = "Marker";
+    EntryType[EntryType["Element"] = 1] = "Element";
+})(EntryType = EntryType || (EntryType = {}));
+const MARKER = { type: EntryType.Marker };
+//List of formatting elements
+class FormattingElementList {
+    constructor(treeAdapter) {
+        this.treeAdapter = treeAdapter;
+        this.entries = [];
+        this.bookmark = null;
+    }
+    //Noah Ark's condition
+    //OPTIMIZATION: at first we try to find possible candidates for exclusion using
+    //lightweight heuristics without thorough attributes check.
+    _getNoahArkConditionCandidates(newElement, neAttrs) {
+        const candidates = [];
+        const neAttrsLength = neAttrs.length;
+        const neTagName = this.treeAdapter.getTagName(newElement);
+        const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
+        for (let i = 0; i < this.entries.length; i++) {
+            const entry = this.entries[i];
+            if (entry.type === EntryType.Marker) {
+                break;
+            }
+            const { element } = entry;
+            if (this.treeAdapter.getTagName(element) === neTagName &&
+                this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {
+                const elementAttrs = this.treeAdapter.getAttrList(element);
+                if (elementAttrs.length === neAttrsLength) {
+                    candidates.push({ idx: i, attrs: elementAttrs });
+                }
+            }
+        }
+        return candidates;
+    }
+    _ensureNoahArkCondition(newElement) {
+        if (this.entries.length < NOAH_ARK_CAPACITY)
+            return;
+        const neAttrs = this.treeAdapter.getAttrList(newElement);
+        const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);
+        if (candidates.length < NOAH_ARK_CAPACITY)
+            return;
+        //NOTE: build attrs map for the new element, so we can perform fast lookups
+        const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));
+        let validCandidates = 0;
+        //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met
+        for (let i = 0; i < candidates.length; i++) {
+            const candidate = candidates[i];
+            // We know that `candidate.attrs.length === neAttrs.length`
+            if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {
+                validCandidates += 1;
+                if (validCandidates >= NOAH_ARK_CAPACITY) {
+                    this.entries.splice(candidate.idx, 1);
+                }
+            }
+        }
+    }
+    //Mutations
+    insertMarker() {
+        this.entries.unshift(MARKER);
+    }
+    pushElement(element, token) {
+        this._ensureNoahArkCondition(element);
+        this.entries.unshift({
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    insertElementAfterBookmark(element, token) {
+        const bookmarkIdx = this.entries.indexOf(this.bookmark);
+        this.entries.splice(bookmarkIdx, 0, {
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    removeEntry(entry) {
+        const entryIndex = this.entries.indexOf(entry);
+        if (entryIndex >= 0) {
+            this.entries.splice(entryIndex, 1);
+        }
+    }
+    /**
+     * Clears the list of formatting elements up to the last marker.
+     *
+     * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+     */
+    clearToLastMarker() {
+        const markerIdx = this.entries.indexOf(MARKER);
+        if (markerIdx >= 0) {
+            this.entries.splice(0, markerIdx + 1);
+        }
+        else {
+            this.entries.length = 0;
+        }
+    }
+    //Search
+    getElementEntryInScopeWithTagName(tagName) {
+        const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);
+        return entry && entry.type === EntryType.Element ? entry : null;
+    }
+    getElementEntry(element) {
+        return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);
+    }
+}
+
+function createTextNode(value) {
+    return {
+        nodeName: '#text',
+        value,
+        parentNode: null,
+    };
+}
+const defaultTreeAdapter = {
+    //Node construction
+    createDocument() {
+        return {
+            nodeName: '#document',
+            mode: DOCUMENT_MODE.NO_QUIRKS,
+            childNodes: [],
+        };
+    },
+    createDocumentFragment() {
+        return {
+            nodeName: '#document-fragment',
+            childNodes: [],
+        };
+    },
+    createElement(tagName, namespaceURI, attrs) {
+        return {
+            nodeName: tagName,
+            tagName,
+            attrs,
+            namespaceURI,
+            childNodes: [],
+            parentNode: null,
+        };
+    },
+    createCommentNode(data) {
+        return {
+            nodeName: '#comment',
+            data,
+            parentNode: null,
+        };
+    },
+    //Tree mutation
+    appendChild(parentNode, newNode) {
+        parentNode.childNodes.push(newNode);
+        newNode.parentNode = parentNode;
+    },
+    insertBefore(parentNode, newNode, referenceNode) {
+        const insertionIdx = parentNode.childNodes.indexOf(referenceNode);
+        parentNode.childNodes.splice(insertionIdx, 0, newNode);
+        newNode.parentNode = parentNode;
+    },
+    setTemplateContent(templateElement, contentElement) {
+        templateElement.content = contentElement;
+    },
+    getTemplateContent(templateElement) {
+        return templateElement.content;
+    },
+    setDocumentType(document, name, publicId, systemId) {
+        const doctypeNode = document.childNodes.find((node) => node.nodeName === '#documentType');
+        if (doctypeNode) {
+            doctypeNode.name = name;
+            doctypeNode.publicId = publicId;
+            doctypeNode.systemId = systemId;
+        }
+        else {
+            const node = {
+                nodeName: '#documentType',
+                name,
+                publicId,
+                systemId,
+                parentNode: null,
+            };
+            defaultTreeAdapter.appendChild(document, node);
+        }
+    },
+    setDocumentMode(document, mode) {
+        document.mode = mode;
+    },
+    getDocumentMode(document) {
+        return document.mode;
+    },
+    detachNode(node) {
+        if (node.parentNode) {
+            const idx = node.parentNode.childNodes.indexOf(node);
+            node.parentNode.childNodes.splice(idx, 1);
+            node.parentNode = null;
+        }
+    },
+    insertText(parentNode, text) {
+        if (parentNode.childNodes.length > 0) {
+            const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];
+            if (defaultTreeAdapter.isTextNode(prevNode)) {
+                prevNode.value += text;
+                return;
+            }
+        }
+        defaultTreeAdapter.appendChild(parentNode, createTextNode(text));
+    },
+    insertTextBefore(parentNode, text, referenceNode) {
+        const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
+        if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {
+            prevNode.value += text;
+        }
+        else {
+            defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);
+        }
+    },
+    adoptAttributes(recipient, attrs) {
+        const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name));
+        for (let j = 0; j < attrs.length; j++) {
+            if (!recipientAttrsMap.has(attrs[j].name)) {
+                recipient.attrs.push(attrs[j]);
+            }
+        }
+    },
+    //Tree traversing
+    getFirstChild(node) {
+        return node.childNodes[0];
+    },
+    getChildNodes(node) {
+        return node.childNodes;
+    },
+    getParentNode(node) {
+        return node.parentNode;
+    },
+    getAttrList(element) {
+        return element.attrs;
+    },
+    //Node data
+    getTagName(element) {
+        return element.tagName;
+    },
+    getNamespaceURI(element) {
+        return element.namespaceURI;
+    },
+    getTextNodeContent(textNode) {
+        return textNode.value;
+    },
+    getCommentNodeContent(commentNode) {
+        return commentNode.data;
+    },
+    getDocumentTypeNodeName(doctypeNode) {
+        return doctypeNode.name;
+    },
+    getDocumentTypeNodePublicId(doctypeNode) {
+        return doctypeNode.publicId;
+    },
+    getDocumentTypeNodeSystemId(doctypeNode) {
+        return doctypeNode.systemId;
+    },
+    //Node types
+    isTextNode(node) {
+        return node.nodeName === '#text';
+    },
+    isCommentNode(node) {
+        return node.nodeName === '#comment';
+    },
+    isDocumentTypeNode(node) {
+        return node.nodeName === '#documentType';
+    },
+    isElementNode(node) {
+        return Object.prototype.hasOwnProperty.call(node, 'tagName');
+    },
+    // Source code location
+    setNodeSourceCodeLocation(node, location) {
+        node.sourceCodeLocation = location;
+    },
+    getNodeSourceCodeLocation(node) {
+        return node.sourceCodeLocation;
+    },
+    updateNodeSourceCodeLocation(node, endLocation) {
+        node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation };
+    },
+};
+
+//Const
+const VALID_DOCTYPE_NAME = 'html';
+const VALID_SYSTEM_ID = 'about:legacy-compat';
+const QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd';
+const QUIRKS_MODE_PUBLIC_ID_PREFIXES = [
+    '+//silmaril//dtd html pro v0r11 19970101//',
+    '-//as//dtd html 3.0 aswedit + extensions//',
+    '-//advasoft ltd//dtd html 3.0 aswedit + extensions//',
+    '-//ietf//dtd html 2.0 level 1//',
+    '-//ietf//dtd html 2.0 level 2//',
+    '-//ietf//dtd html 2.0 strict level 1//',
+    '-//ietf//dtd html 2.0 strict level 2//',
+    '-//ietf//dtd html 2.0 strict//',
+    '-//ietf//dtd html 2.0//',
+    '-//ietf//dtd html 2.1e//',
+    '-//ietf//dtd html 3.0//',
+    '-//ietf//dtd html 3.2 final//',
+    '-//ietf//dtd html 3.2//',
+    '-//ietf//dtd html 3//',
+    '-//ietf//dtd html level 0//',
+    '-//ietf//dtd html level 1//',
+    '-//ietf//dtd html level 2//',
+    '-//ietf//dtd html level 3//',
+    '-//ietf//dtd html strict level 0//',
+    '-//ietf//dtd html strict level 1//',
+    '-//ietf//dtd html strict level 2//',
+    '-//ietf//dtd html strict level 3//',
+    '-//ietf//dtd html strict//',
+    '-//ietf//dtd html//',
+    '-//metrius//dtd metrius presentational//',
+    '-//microsoft//dtd internet explorer 2.0 html strict//',
+    '-//microsoft//dtd internet explorer 2.0 html//',
+    '-//microsoft//dtd internet explorer 2.0 tables//',
+    '-//microsoft//dtd internet explorer 3.0 html strict//',
+    '-//microsoft//dtd internet explorer 3.0 html//',
+    '-//microsoft//dtd internet explorer 3.0 tables//',
+    '-//netscape comm. corp.//dtd html//',
+    '-//netscape comm. corp.//dtd strict html//',
+    "-//o'reilly and associates//dtd html 2.0//",
+    "-//o'reilly and associates//dtd html extended 1.0//",
+    "-//o'reilly and associates//dtd html extended relaxed 1.0//",
+    '-//sq//dtd html 2.0 hotmetal + extensions//',
+    '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//',
+    '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//',
+    '-//spyglass//dtd html 2.0 extended//',
+    '-//sun microsystems corp.//dtd hotjava html//',
+    '-//sun microsystems corp.//dtd hotjava strict html//',
+    '-//w3c//dtd html 3 1995-03-24//',
+    '-//w3c//dtd html 3.2 draft//',
+    '-//w3c//dtd html 3.2 final//',
+    '-//w3c//dtd html 3.2//',
+    '-//w3c//dtd html 3.2s draft//',
+    '-//w3c//dtd html 4.0 frameset//',
+    '-//w3c//dtd html 4.0 transitional//',
+    '-//w3c//dtd html experimental 19960712//',
+    '-//w3c//dtd html experimental 970421//',
+    '-//w3c//dtd w3 html//',
+    '-//w3o//dtd w3 html 3.0//',
+    '-//webtechs//dtd mozilla html 2.0//',
+    '-//webtechs//dtd mozilla html//',
+];
+const QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [
+    ...QUIRKS_MODE_PUBLIC_ID_PREFIXES,
+    '-//w3c//dtd html 4.01 frameset//',
+    '-//w3c//dtd html 4.01 transitional//',
+];
+const QUIRKS_MODE_PUBLIC_IDS = new Set([
+    '-//w3o//dtd w3 html strict 3.0//en//',
+    '-/w3c/dtd html 4.0 transitional/en',
+    'html',
+]);
+const LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];
+const LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [
+    ...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES,
+    '-//w3c//dtd html 4.01 frameset//',
+    '-//w3c//dtd html 4.01 transitional//',
+];
+//Utils
+function hasPrefix(publicId, prefixes) {
+    return prefixes.some((prefix) => publicId.startsWith(prefix));
+}
+//API
+function isConforming(token) {
+    return (token.name === VALID_DOCTYPE_NAME &&
+        token.publicId === null &&
+        (token.systemId === null || token.systemId === VALID_SYSTEM_ID));
+}
+function getDocumentMode(token) {
+    if (token.name !== VALID_DOCTYPE_NAME) {
+        return DOCUMENT_MODE.QUIRKS;
+    }
+    const { systemId } = token;
+    if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {
+        return DOCUMENT_MODE.QUIRKS;
+    }
+    let { publicId } = token;
+    if (publicId !== null) {
+        publicId = publicId.toLowerCase();
+        if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) {
+            return DOCUMENT_MODE.QUIRKS;
+        }
+        let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;
+        if (hasPrefix(publicId, prefixes)) {
+            return DOCUMENT_MODE.QUIRKS;
+        }
+        prefixes =
+            systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;
+        if (hasPrefix(publicId, prefixes)) {
+            return DOCUMENT_MODE.LIMITED_QUIRKS;
+        }
+    }
+    return DOCUMENT_MODE.NO_QUIRKS;
+}
+
+//MIME types
+const MIME_TYPES = {
+    TEXT_HTML: 'text/html',
+    APPLICATION_XML: 'application/xhtml+xml',
+};
+//Attributes
+const DEFINITION_URL_ATTR = 'definitionurl';
+const ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';
+const SVG_ATTRS_ADJUSTMENT_MAP = new Map([
+    'attributeName',
+    'attributeType',
+    'baseFrequency',
+    'baseProfile',
+    'calcMode',
+    'clipPathUnits',
+    'diffuseConstant',
+    'edgeMode',
+    'filterUnits',
+    'glyphRef',
+    'gradientTransform',
+    'gradientUnits',
+    'kernelMatrix',
+    'kernelUnitLength',
+    'keyPoints',
+    'keySplines',
+    'keyTimes',
+    'lengthAdjust',
+    'limitingConeAngle',
+    'markerHeight',
+    'markerUnits',
+    'markerWidth',
+    'maskContentUnits',
+    'maskUnits',
+    'numOctaves',
+    'pathLength',
+    'patternContentUnits',
+    'patternTransform',
+    'patternUnits',
+    'pointsAtX',
+    'pointsAtY',
+    'pointsAtZ',
+    'preserveAlpha',
+    'preserveAspectRatio',
+    'primitiveUnits',
+    'refX',
+    'refY',
+    'repeatCount',
+    'repeatDur',
+    'requiredExtensions',
+    'requiredFeatures',
+    'specularConstant',
+    'specularExponent',
+    'spreadMethod',
+    'startOffset',
+    'stdDeviation',
+    'stitchTiles',
+    'surfaceScale',
+    'systemLanguage',
+    'tableValues',
+    'targetX',
+    'targetY',
+    'textLength',
+    'viewBox',
+    'viewTarget',
+    'xChannelSelector',
+    'yChannelSelector',
+    'zoomAndPan',
+].map((attr) => [attr.toLowerCase(), attr]));
+const XML_ATTRS_ADJUSTMENT_MAP = new Map([
+    ['xlink:actuate', { prefix: 'xlink', name: 'actuate', namespace: NS.XLINK }],
+    ['xlink:arcrole', { prefix: 'xlink', name: 'arcrole', namespace: NS.XLINK }],
+    ['xlink:href', { prefix: 'xlink', name: 'href', namespace: NS.XLINK }],
+    ['xlink:role', { prefix: 'xlink', name: 'role', namespace: NS.XLINK }],
+    ['xlink:show', { prefix: 'xlink', name: 'show', namespace: NS.XLINK }],
+    ['xlink:title', { prefix: 'xlink', name: 'title', namespace: NS.XLINK }],
+    ['xlink:type', { prefix: 'xlink', name: 'type', namespace: NS.XLINK }],
+    ['xml:base', { prefix: 'xml', name: 'base', namespace: NS.XML }],
+    ['xml:lang', { prefix: 'xml', name: 'lang', namespace: NS.XML }],
+    ['xml:space', { prefix: 'xml', name: 'space', namespace: NS.XML }],
+    ['xmlns', { prefix: '', name: 'xmlns', namespace: NS.XMLNS }],
+    ['xmlns:xlink', { prefix: 'xmlns', name: 'xlink', namespace: NS.XMLNS }],
+]);
+//SVG tag names adjustment map
+const SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map([
+    'altGlyph',
+    'altGlyphDef',
+    'altGlyphItem',
+    'animateColor',
+    'animateMotion',
+    'animateTransform',
+    'clipPath',
+    'feBlend',
+    'feColorMatrix',
+    'feComponentTransfer',
+    'feComposite',
+    'feConvolveMatrix',
+    'feDiffuseLighting',
+    'feDisplacementMap',
+    'feDistantLight',
+    'feFlood',
+    'feFuncA',
+    'feFuncB',
+    'feFuncG',
+    'feFuncR',
+    'feGaussianBlur',
+    'feImage',
+    'feMerge',
+    'feMergeNode',
+    'feMorphology',
+    'feOffset',
+    'fePointLight',
+    'feSpecularLighting',
+    'feSpotLight',
+    'feTile',
+    'feTurbulence',
+    'foreignObject',
+    'glyphRef',
+    'linearGradient',
+    'radialGradient',
+    'textPath',
+].map((tn) => [tn.toLowerCase(), tn]));
+//Tags that causes exit from foreign content
+const EXITS_FOREIGN_CONTENT = new Set([
+    TAG_ID.B,
+    TAG_ID.BIG,
+    TAG_ID.BLOCKQUOTE,
+    TAG_ID.BODY,
+    TAG_ID.BR,
+    TAG_ID.CENTER,
+    TAG_ID.CODE,
+    TAG_ID.DD,
+    TAG_ID.DIV,
+    TAG_ID.DL,
+    TAG_ID.DT,
+    TAG_ID.EM,
+    TAG_ID.EMBED,
+    TAG_ID.H1,
+    TAG_ID.H2,
+    TAG_ID.H3,
+    TAG_ID.H4,
+    TAG_ID.H5,
+    TAG_ID.H6,
+    TAG_ID.HEAD,
+    TAG_ID.HR,
+    TAG_ID.I,
+    TAG_ID.IMG,
+    TAG_ID.LI,
+    TAG_ID.LISTING,
+    TAG_ID.MENU,
+    TAG_ID.META,
+    TAG_ID.NOBR,
+    TAG_ID.OL,
+    TAG_ID.P,
+    TAG_ID.PRE,
+    TAG_ID.RUBY,
+    TAG_ID.S,
+    TAG_ID.SMALL,
+    TAG_ID.SPAN,
+    TAG_ID.STRONG,
+    TAG_ID.STRIKE,
+    TAG_ID.SUB,
+    TAG_ID.SUP,
+    TAG_ID.TABLE,
+    TAG_ID.TT,
+    TAG_ID.U,
+    TAG_ID.UL,
+    TAG_ID.VAR,
+]);
+//Check exit from foreign content
+function causesExit(startTagToken) {
+    const tn = startTagToken.tagID;
+    const isFontWithAttrs = tn === TAG_ID.FONT &&
+        startTagToken.attrs.some(({ name }) => name === ATTRS.COLOR || name === ATTRS.SIZE || name === ATTRS.FACE);
+    return isFontWithAttrs || EXITS_FOREIGN_CONTENT.has(tn);
+}
+//Token adjustments
+function adjustTokenMathMLAttrs(token) {
+    for (let i = 0; i < token.attrs.length; i++) {
+        if (token.attrs[i].name === DEFINITION_URL_ATTR) {
+            token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;
+            break;
+        }
+    }
+}
+function adjustTokenSVGAttrs(token) {
+    for (let i = 0; i < token.attrs.length; i++) {
+        const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);
+        if (adjustedAttrName != null) {
+            token.attrs[i].name = adjustedAttrName;
+        }
+    }
+}
+function adjustTokenXMLAttrs(token) {
+    for (let i = 0; i < token.attrs.length; i++) {
+        const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name);
+        if (adjustedAttrEntry) {
+            token.attrs[i].prefix = adjustedAttrEntry.prefix;
+            token.attrs[i].name = adjustedAttrEntry.name;
+            token.attrs[i].namespace = adjustedAttrEntry.namespace;
+        }
+    }
+}
+function adjustTokenSVGTagName(token) {
+    const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName);
+    if (adjustedTagName != null) {
+        token.tagName = adjustedTagName;
+        token.tagID = getTagID(token.tagName);
+    }
+}
+//Integration points
+function isMathMLTextIntegrationPoint(tn, ns) {
+    return ns === NS.MATHML && (tn === TAG_ID.MI || tn === TAG_ID.MO || tn === TAG_ID.MN || tn === TAG_ID.MS || tn === TAG_ID.MTEXT);
+}
+function isHtmlIntegrationPoint(tn, ns, attrs) {
+    if (ns === NS.MATHML && tn === TAG_ID.ANNOTATION_XML) {
+        for (let i = 0; i < attrs.length; i++) {
+            if (attrs[i].name === ATTRS.ENCODING) {
+                const value = attrs[i].value.toLowerCase();
+                return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;
+            }
+        }
+    }
+    return ns === NS.SVG && (tn === TAG_ID.FOREIGN_OBJECT || tn === TAG_ID.DESC || tn === TAG_ID.TITLE);
+}
+function isIntegrationPoint(tn, ns, attrs, foreignNS) {
+    return (((!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) ||
+        ((!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns)));
+}
+
+//Misc constants
+const HIDDEN_INPUT_TYPE = 'hidden';
+//Adoption agency loops iteration count
+const AA_OUTER_LOOP_ITER = 8;
+const AA_INNER_LOOP_ITER = 3;
+//Insertion modes
+var InsertionMode;
+(function (InsertionMode) {
+    InsertionMode[InsertionMode["INITIAL"] = 0] = "INITIAL";
+    InsertionMode[InsertionMode["BEFORE_HTML"] = 1] = "BEFORE_HTML";
+    InsertionMode[InsertionMode["BEFORE_HEAD"] = 2] = "BEFORE_HEAD";
+    InsertionMode[InsertionMode["IN_HEAD"] = 3] = "IN_HEAD";
+    InsertionMode[InsertionMode["IN_HEAD_NO_SCRIPT"] = 4] = "IN_HEAD_NO_SCRIPT";
+    InsertionMode[InsertionMode["AFTER_HEAD"] = 5] = "AFTER_HEAD";
+    InsertionMode[InsertionMode["IN_BODY"] = 6] = "IN_BODY";
+    InsertionMode[InsertionMode["TEXT"] = 7] = "TEXT";
+    InsertionMode[InsertionMode["IN_TABLE"] = 8] = "IN_TABLE";
+    InsertionMode[InsertionMode["IN_TABLE_TEXT"] = 9] = "IN_TABLE_TEXT";
+    InsertionMode[InsertionMode["IN_CAPTION"] = 10] = "IN_CAPTION";
+    InsertionMode[InsertionMode["IN_COLUMN_GROUP"] = 11] = "IN_COLUMN_GROUP";
+    InsertionMode[InsertionMode["IN_TABLE_BODY"] = 12] = "IN_TABLE_BODY";
+    InsertionMode[InsertionMode["IN_ROW"] = 13] = "IN_ROW";
+    InsertionMode[InsertionMode["IN_CELL"] = 14] = "IN_CELL";
+    InsertionMode[InsertionMode["IN_SELECT"] = 15] = "IN_SELECT";
+    InsertionMode[InsertionMode["IN_SELECT_IN_TABLE"] = 16] = "IN_SELECT_IN_TABLE";
+    InsertionMode[InsertionMode["IN_TEMPLATE"] = 17] = "IN_TEMPLATE";
+    InsertionMode[InsertionMode["AFTER_BODY"] = 18] = "AFTER_BODY";
+    InsertionMode[InsertionMode["IN_FRAMESET"] = 19] = "IN_FRAMESET";
+    InsertionMode[InsertionMode["AFTER_FRAMESET"] = 20] = "AFTER_FRAMESET";
+    InsertionMode[InsertionMode["AFTER_AFTER_BODY"] = 21] = "AFTER_AFTER_BODY";
+    InsertionMode[InsertionMode["AFTER_AFTER_FRAMESET"] = 22] = "AFTER_AFTER_FRAMESET";
+})(InsertionMode || (InsertionMode = {}));
+const BASE_LOC = {
+    startLine: -1,
+    startCol: -1,
+    startOffset: -1,
+    endLine: -1,
+    endCol: -1,
+    endOffset: -1,
+};
+const TABLE_STRUCTURE_TAGS = new Set([TAG_ID.TABLE, TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TR]);
+const defaultParserOptions = {
+    scriptingEnabled: true,
+    sourceCodeLocationInfo: false,
+    treeAdapter: defaultTreeAdapter,
+    onParseError: null,
+};
+//Parser
+class Parser {
+    constructor(options, document, fragmentContext = null, scriptHandler = null) {
+        this.fragmentContext = fragmentContext;
+        this.scriptHandler = scriptHandler;
+        this.currentToken = null;
+        this.stopped = false;
+        this.insertionMode = InsertionMode.INITIAL;
+        this.originalInsertionMode = InsertionMode.INITIAL;
+        this.headElement = null;
+        this.formElement = null;
+        /** Indicates that the current node is not an element in the HTML namespace */
+        this.currentNotInHTML = false;
+        /**
+         * The template insertion mode stack is maintained from the left.
+         * Ie. the topmost element will always have index 0.
+         */
+        this.tmplInsertionModeStack = [];
+        this.pendingCharacterTokens = [];
+        this.hasNonWhitespacePendingCharacterToken = false;
+        this.framesetOk = true;
+        this.skipNextNewLine = false;
+        this.fosterParentingEnabled = false;
+        this.options = {
+            ...defaultParserOptions,
+            ...options,
+        };
+        this.treeAdapter = this.options.treeAdapter;
+        this.onParseError = this.options.onParseError;
+        // Always enable location info if we report parse errors.
+        if (this.onParseError) {
+            this.options.sourceCodeLocationInfo = true;
+        }
+        this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument();
+        this.tokenizer = new Tokenizer(this.options, this);
+        this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
+        this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : TAG_ID.UNKNOWN;
+        this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID);
+        this.openElements = new OpenElementStack(this.document, this.treeAdapter, this);
+    }
+    // API
+    static parse(html, options) {
+        const parser = new this(options);
+        parser.tokenizer.write(html, true);
+        return parser.document;
+    }
+    static getFragmentParser(fragmentContext, options) {
+        const opts = {
+            ...defaultParserOptions,
+            ...options,
+        };
+        //NOTE: use a <template> element as the fragment context if no context element was provided,
+        //so we will parse in a "forgiving" manner
+        fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : (fragmentContext = opts.treeAdapter.createElement(TAG_NAMES.TEMPLATE, NS.HTML, []));
+        //NOTE: create a fake element which will be used as the `document` for fragment parsing.
+        //This is important for jsdom, where a new `document` cannot be created. This led to
+        //fragment parsing messing with the main `document`.
+        const documentMock = opts.treeAdapter.createElement('documentmock', NS.HTML, []);
+        const parser = new this(opts, documentMock, fragmentContext);
+        if (parser.fragmentContextID === TAG_ID.TEMPLATE) {
+            parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
+        }
+        parser._initTokenizerForFragmentParsing();
+        parser._insertFakeRootElement();
+        parser._resetInsertionMode();
+        parser._findFormInFragmentContext();
+        return parser;
+    }
+    getFragment() {
+        const rootElement = this.treeAdapter.getFirstChild(this.document);
+        const fragment = this.treeAdapter.createDocumentFragment();
+        this._adoptNodes(rootElement, fragment);
+        return fragment;
+    }
+    //Errors
+    _err(token, code, beforeToken) {
+        var _a;
+        if (!this.onParseError)
+            return;
+        const loc = (_a = token.location) !== null && _a !== void 0 ? _a : BASE_LOC;
+        const err = {
+            code,
+            startLine: loc.startLine,
+            startCol: loc.startCol,
+            startOffset: loc.startOffset,
+            endLine: beforeToken ? loc.startLine : loc.endLine,
+            endCol: beforeToken ? loc.startCol : loc.endCol,
+            endOffset: beforeToken ? loc.startOffset : loc.endOffset,
+        };
+        this.onParseError(err);
+    }
+    //Stack events
+    onItemPush(node, tid, isTop) {
+        var _a, _b;
+        (_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a, node);
+        if (isTop && this.openElements.stackTop > 0)
+            this._setContextModes(node, tid);
+    }
+    onItemPop(node, isTop) {
+        var _a, _b;
+        if (this.options.sourceCodeLocationInfo) {
+            this._setEndLocation(node, this.currentToken);
+        }
+        (_b = (_a = this.treeAdapter).onItemPop) === null || _b === void 0 ? void 0 : _b.call(_a, node, this.openElements.current);
+        if (isTop) {
+            let current;
+            let currentTagId;
+            if (this.openElements.stackTop === 0 && this.fragmentContext) {
+                current = this.fragmentContext;
+                currentTagId = this.fragmentContextID;
+            }
+            else {
+                ({ current, currentTagId } = this.openElements);
+            }
+            this._setContextModes(current, currentTagId);
+        }
+    }
+    _setContextModes(current, tid) {
+        const isHTML = current === this.document || this.treeAdapter.getNamespaceURI(current) === NS.HTML;
+        this.currentNotInHTML = !isHTML;
+        this.tokenizer.inForeignNode = !isHTML && !this._isIntegrationPoint(tid, current);
+    }
+    _switchToTextParsing(currentToken, nextTokenizerState) {
+        this._insertElement(currentToken, NS.HTML);
+        this.tokenizer.state = nextTokenizerState;
+        this.originalInsertionMode = this.insertionMode;
+        this.insertionMode = InsertionMode.TEXT;
+    }
+    switchToPlaintextParsing() {
+        this.insertionMode = InsertionMode.TEXT;
+        this.originalInsertionMode = InsertionMode.IN_BODY;
+        this.tokenizer.state = TokenizerMode.PLAINTEXT;
+    }
+    //Fragment parsing
+    _getAdjustedCurrentElement() {
+        return this.openElements.stackTop === 0 && this.fragmentContext
+            ? this.fragmentContext
+            : this.openElements.current;
+    }
+    _findFormInFragmentContext() {
+        let node = this.fragmentContext;
+        while (node) {
+            if (this.treeAdapter.getTagName(node) === TAG_NAMES.FORM) {
+                this.formElement = node;
+                break;
+            }
+            node = this.treeAdapter.getParentNode(node);
+        }
+    }
+    _initTokenizerForFragmentParsing() {
+        if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) {
+            return;
+        }
+        switch (this.fragmentContextID) {
+            case TAG_ID.TITLE:
+            case TAG_ID.TEXTAREA: {
+                this.tokenizer.state = TokenizerMode.RCDATA;
+                break;
+            }
+            case TAG_ID.STYLE:
+            case TAG_ID.XMP:
+            case TAG_ID.IFRAME:
+            case TAG_ID.NOEMBED:
+            case TAG_ID.NOFRAMES:
+            case TAG_ID.NOSCRIPT: {
+                this.tokenizer.state = TokenizerMode.RAWTEXT;
+                break;
+            }
+            case TAG_ID.SCRIPT: {
+                this.tokenizer.state = TokenizerMode.SCRIPT_DATA;
+                break;
+            }
+            case TAG_ID.PLAINTEXT: {
+                this.tokenizer.state = TokenizerMode.PLAINTEXT;
+                break;
+            }
+            // Do nothing
+        }
+    }
+    //Tree mutation
+    _setDocumentType(token) {
+        const name = token.name || '';
+        const publicId = token.publicId || '';
+        const systemId = token.systemId || '';
+        this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
+        if (token.location) {
+            const documentChildren = this.treeAdapter.getChildNodes(this.document);
+            const docTypeNode = documentChildren.find((node) => this.treeAdapter.isDocumentTypeNode(node));
+            if (docTypeNode) {
+                this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location);
+            }
+        }
+    }
+    _attachElementToTree(element, location) {
+        if (this.options.sourceCodeLocationInfo) {
+            const loc = location && {
+                ...location,
+                startTag: location,
+            };
+            this.treeAdapter.setNodeSourceCodeLocation(element, loc);
+        }
+        if (this._shouldFosterParentOnInsertion()) {
+            this._fosterParentElement(element);
+        }
+        else {
+            const parent = this.openElements.currentTmplContentOrNode;
+            this.treeAdapter.appendChild(parent, element);
+        }
+    }
+    _appendElement(token, namespaceURI) {
+        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+        this._attachElementToTree(element, token.location);
+    }
+    _insertElement(token, namespaceURI) {
+        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+        this._attachElementToTree(element, token.location);
+        this.openElements.push(element, token.tagID);
+    }
+    _insertFakeElement(tagName, tagID) {
+        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
+        this._attachElementToTree(element, null);
+        this.openElements.push(element, tagID);
+    }
+    _insertTemplate(token) {
+        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
+        const content = this.treeAdapter.createDocumentFragment();
+        this.treeAdapter.setTemplateContent(tmpl, content);
+        this._attachElementToTree(tmpl, token.location);
+        this.openElements.push(tmpl, token.tagID);
+        if (this.options.sourceCodeLocationInfo)
+            this.treeAdapter.setNodeSourceCodeLocation(content, null);
+    }
+    _insertFakeRootElement() {
+        const element = this.treeAdapter.createElement(TAG_NAMES.HTML, NS.HTML, []);
+        if (this.options.sourceCodeLocationInfo)
+            this.treeAdapter.setNodeSourceCodeLocation(element, null);
+        this.treeAdapter.appendChild(this.openElements.current, element);
+        this.openElements.push(element, TAG_ID.HTML);
+    }
+    _appendCommentNode(token, parent) {
+        const commentNode = this.treeAdapter.createCommentNode(token.data);
+        this.treeAdapter.appendChild(parent, commentNode);
+        if (this.options.sourceCodeLocationInfo) {
+            this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
+        }
+    }
+    _insertCharacters(token) {
+        let parent;
+        let beforeElement;
+        if (this._shouldFosterParentOnInsertion()) {
+            ({ parent, beforeElement } = this._findFosterParentingLocation());
+            if (beforeElement) {
+                this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement);
+            }
+            else {
+                this.treeAdapter.insertText(parent, token.chars);
+            }
+        }
+        else {
+            parent = this.openElements.currentTmplContentOrNode;
+            this.treeAdapter.insertText(parent, token.chars);
+        }
+        if (!token.location)
+            return;
+        const siblings = this.treeAdapter.getChildNodes(parent);
+        const textNodeIdx = beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length;
+        const textNode = siblings[textNodeIdx - 1];
+        //NOTE: if we have a location assigned by another token, then just update the end position
+        const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);
+        if (tnLoc) {
+            const { endLine, endCol, endOffset } = token.location;
+            this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });
+        }
+        else if (this.options.sourceCodeLocationInfo) {
+            this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
+        }
+    }
+    _adoptNodes(donor, recipient) {
+        for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
+            this.treeAdapter.detachNode(child);
+            this.treeAdapter.appendChild(recipient, child);
+        }
+    }
+    _setEndLocation(element, closingToken) {
+        if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {
+            const ctLoc = closingToken.location;
+            const tn = this.treeAdapter.getTagName(element);
+            const endLoc = 
+            // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing
+            // tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.
+            closingToken.type === TokenType.END_TAG && tn === closingToken.tagName
+                ? {
+                    endTag: { ...ctLoc },
+                    endLine: ctLoc.endLine,
+                    endCol: ctLoc.endCol,
+                    endOffset: ctLoc.endOffset,
+                }
+                : {
+                    endLine: ctLoc.startLine,
+                    endCol: ctLoc.startCol,
+                    endOffset: ctLoc.startOffset,
+                };
+            this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);
+        }
+    }
+    //Token processing
+    shouldProcessStartTagTokenInForeignContent(token) {
+        // Check that neither current === document, or ns === NS.HTML
+        if (!this.currentNotInHTML)
+            return false;
+        let current;
+        let currentTagId;
+        if (this.openElements.stackTop === 0 && this.fragmentContext) {
+            current = this.fragmentContext;
+            currentTagId = this.fragmentContextID;
+        }
+        else {
+            ({ current, currentTagId } = this.openElements);
+        }
+        if (token.tagID === TAG_ID.SVG &&
+            this.treeAdapter.getTagName(current) === TAG_NAMES.ANNOTATION_XML &&
+            this.treeAdapter.getNamespaceURI(current) === NS.MATHML) {
+            return false;
+        }
+        return (
+        // Check that `current` is not an integration point for HTML or MathML elements.
+        this.tokenizer.inForeignNode ||
+            // If it _is_ an integration point, then we might have to check that it is not an HTML
+            // integration point.
+            ((token.tagID === TAG_ID.MGLYPH || token.tagID === TAG_ID.MALIGNMARK) &&
+                !this._isIntegrationPoint(currentTagId, current, NS.HTML)));
+    }
+    _processToken(token) {
+        switch (token.type) {
+            case TokenType.CHARACTER: {
+                this.onCharacter(token);
+                break;
+            }
+            case TokenType.NULL_CHARACTER: {
+                this.onNullCharacter(token);
+                break;
+            }
+            case TokenType.COMMENT: {
+                this.onComment(token);
+                break;
+            }
+            case TokenType.DOCTYPE: {
+                this.onDoctype(token);
+                break;
+            }
+            case TokenType.START_TAG: {
+                this._processStartTag(token);
+                break;
+            }
+            case TokenType.END_TAG: {
+                this.onEndTag(token);
+                break;
+            }
+            case TokenType.EOF: {
+                this.onEof(token);
+                break;
+            }
+            case TokenType.WHITESPACE_CHARACTER: {
+                this.onWhitespaceCharacter(token);
+                break;
+            }
+        }
+    }
+    //Integration points
+    _isIntegrationPoint(tid, element, foreignNS) {
+        const ns = this.treeAdapter.getNamespaceURI(element);
+        const attrs = this.treeAdapter.getAttrList(element);
+        return isIntegrationPoint(tid, ns, attrs, foreignNS);
+    }
+    //Active formatting elements reconstruction
+    _reconstructActiveFormattingElements() {
+        const listLength = this.activeFormattingElements.entries.length;
+        if (listLength) {
+            const endIndex = this.activeFormattingElements.entries.findIndex((entry) => entry.type === EntryType.Marker || this.openElements.contains(entry.element));
+            const unopenIdx = endIndex < 0 ? listLength - 1 : endIndex - 1;
+            for (let i = unopenIdx; i >= 0; i--) {
+                const entry = this.activeFormattingElements.entries[i];
+                this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
+                entry.element = this.openElements.current;
+            }
+        }
+    }
+    //Close elements
+    _closeTableCell() {
+        this.openElements.generateImpliedEndTags();
+        this.openElements.popUntilTableCellPopped();
+        this.activeFormattingElements.clearToLastMarker();
+        this.insertionMode = InsertionMode.IN_ROW;
+    }
+    _closePElement() {
+        this.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.P);
+        this.openElements.popUntilTagNamePopped(TAG_ID.P);
+    }
+    //Insertion modes
+    _resetInsertionMode() {
+        for (let i = this.openElements.stackTop; i >= 0; i--) {
+            //Insertion mode reset map
+            switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {
+                case TAG_ID.TR: {
+                    this.insertionMode = InsertionMode.IN_ROW;
+                    return;
+                }
+                case TAG_ID.TBODY:
+                case TAG_ID.THEAD:
+                case TAG_ID.TFOOT: {
+                    this.insertionMode = InsertionMode.IN_TABLE_BODY;
+                    return;
+                }
+                case TAG_ID.CAPTION: {
+                    this.insertionMode = InsertionMode.IN_CAPTION;
+                    return;
+                }
+                case TAG_ID.COLGROUP: {
+                    this.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+                    return;
+                }
+                case TAG_ID.TABLE: {
+                    this.insertionMode = InsertionMode.IN_TABLE;
+                    return;
+                }
+                case TAG_ID.BODY: {
+                    this.insertionMode = InsertionMode.IN_BODY;
+                    return;
+                }
+                case TAG_ID.FRAMESET: {
+                    this.insertionMode = InsertionMode.IN_FRAMESET;
+                    return;
+                }
+                case TAG_ID.SELECT: {
+                    this._resetInsertionModeForSelect(i);
+                    return;
+                }
+                case TAG_ID.TEMPLATE: {
+                    this.insertionMode = this.tmplInsertionModeStack[0];
+                    return;
+                }
+                case TAG_ID.HTML: {
+                    this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;
+                    return;
+                }
+                case TAG_ID.TD:
+                case TAG_ID.TH: {
+                    if (i > 0) {
+                        this.insertionMode = InsertionMode.IN_CELL;
+                        return;
+                    }
+                    break;
+                }
+                case TAG_ID.HEAD: {
+                    if (i > 0) {
+                        this.insertionMode = InsertionMode.IN_HEAD;
+                        return;
+                    }
+                    break;
+                }
+            }
+        }
+        this.insertionMode = InsertionMode.IN_BODY;
+    }
+    _resetInsertionModeForSelect(selectIdx) {
+        if (selectIdx > 0) {
+            for (let i = selectIdx - 1; i > 0; i--) {
+                const tn = this.openElements.tagIDs[i];
+                if (tn === TAG_ID.TEMPLATE) {
+                    break;
+                }
+                else if (tn === TAG_ID.TABLE) {
+                    this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE;
+                    return;
+                }
+            }
+        }
+        this.insertionMode = InsertionMode.IN_SELECT;
+    }
+    //Foster parenting
+    _isElementCausesFosterParenting(tn) {
+        return TABLE_STRUCTURE_TAGS.has(tn);
+    }
+    _shouldFosterParentOnInsertion() {
+        return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.currentTagId);
+    }
+    _findFosterParentingLocation() {
+        for (let i = this.openElements.stackTop; i >= 0; i--) {
+            const openElement = this.openElements.items[i];
+            switch (this.openElements.tagIDs[i]) {
+                case TAG_ID.TEMPLATE: {
+                    if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) {
+                        return { parent: this.treeAdapter.getTemplateContent(openElement), beforeElement: null };
+                    }
+                    break;
+                }
+                case TAG_ID.TABLE: {
+                    const parent = this.treeAdapter.getParentNode(openElement);
+                    if (parent) {
+                        return { parent, beforeElement: openElement };
+                    }
+                    return { parent: this.openElements.items[i - 1], beforeElement: null };
+                }
+                // Do nothing
+            }
+        }
+        return { parent: this.openElements.items[0], beforeElement: null };
+    }
+    _fosterParentElement(element) {
+        const location = this._findFosterParentingLocation();
+        if (location.beforeElement) {
+            this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
+        }
+        else {
+            this.treeAdapter.appendChild(location.parent, element);
+        }
+    }
+    //Special elements
+    _isSpecialElement(element, id) {
+        const ns = this.treeAdapter.getNamespaceURI(element);
+        return SPECIAL_ELEMENTS[ns].has(id);
+    }
+    onCharacter(token) {
+        this.skipNextNewLine = false;
+        if (this.tokenizer.inForeignNode) {
+            characterInForeignContent(this, token);
+            return;
+        }
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                tokenInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HTML: {
+                tokenBeforeHtml(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD: {
+                tokenBeforeHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD: {
+                tokenInHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD_NO_SCRIPT: {
+                tokenInHeadNoScript(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_HEAD: {
+                tokenAfterHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_BODY:
+            case InsertionMode.IN_CAPTION:
+            case InsertionMode.IN_CELL:
+            case InsertionMode.IN_TEMPLATE: {
+                characterInBody(this, token);
+                break;
+            }
+            case InsertionMode.TEXT:
+            case InsertionMode.IN_SELECT:
+            case InsertionMode.IN_SELECT_IN_TABLE: {
+                this._insertCharacters(token);
+                break;
+            }
+            case InsertionMode.IN_TABLE:
+            case InsertionMode.IN_TABLE_BODY:
+            case InsertionMode.IN_ROW: {
+                characterInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                characterInTableText(this, token);
+                break;
+            }
+            case InsertionMode.IN_COLUMN_GROUP: {
+                tokenInColumnGroup(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY: {
+                tokenAfterBody(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_BODY: {
+                tokenAfterAfterBody(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onNullCharacter(token) {
+        this.skipNextNewLine = false;
+        if (this.tokenizer.inForeignNode) {
+            nullCharacterInForeignContent(this, token);
+            return;
+        }
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                tokenInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HTML: {
+                tokenBeforeHtml(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD: {
+                tokenBeforeHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD: {
+                tokenInHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD_NO_SCRIPT: {
+                tokenInHeadNoScript(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_HEAD: {
+                tokenAfterHead(this, token);
+                break;
+            }
+            case InsertionMode.TEXT: {
+                this._insertCharacters(token);
+                break;
+            }
+            case InsertionMode.IN_TABLE:
+            case InsertionMode.IN_TABLE_BODY:
+            case InsertionMode.IN_ROW: {
+                characterInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_COLUMN_GROUP: {
+                tokenInColumnGroup(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY: {
+                tokenAfterBody(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_BODY: {
+                tokenAfterAfterBody(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onComment(token) {
+        this.skipNextNewLine = false;
+        if (this.currentNotInHTML) {
+            appendComment(this, token);
+            return;
+        }
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL:
+            case InsertionMode.BEFORE_HTML:
+            case InsertionMode.BEFORE_HEAD:
+            case InsertionMode.IN_HEAD:
+            case InsertionMode.IN_HEAD_NO_SCRIPT:
+            case InsertionMode.AFTER_HEAD:
+            case InsertionMode.IN_BODY:
+            case InsertionMode.IN_TABLE:
+            case InsertionMode.IN_CAPTION:
+            case InsertionMode.IN_COLUMN_GROUP:
+            case InsertionMode.IN_TABLE_BODY:
+            case InsertionMode.IN_ROW:
+            case InsertionMode.IN_CELL:
+            case InsertionMode.IN_SELECT:
+            case InsertionMode.IN_SELECT_IN_TABLE:
+            case InsertionMode.IN_TEMPLATE:
+            case InsertionMode.IN_FRAMESET:
+            case InsertionMode.AFTER_FRAMESET: {
+                appendComment(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                tokenInTableText(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY: {
+                appendCommentToRootHtmlElement(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_BODY:
+            case InsertionMode.AFTER_AFTER_FRAMESET: {
+                appendCommentToDocument(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onDoctype(token) {
+        this.skipNextNewLine = false;
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                doctypeInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD:
+            case InsertionMode.IN_HEAD:
+            case InsertionMode.IN_HEAD_NO_SCRIPT:
+            case InsertionMode.AFTER_HEAD: {
+                this._err(token, ERR.misplacedDoctype);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                tokenInTableText(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onStartTag(token) {
+        this.skipNextNewLine = false;
+        this.currentToken = token;
+        this._processStartTag(token);
+        if (token.selfClosing && !token.ackSelfClosing) {
+            this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
+        }
+    }
+    /**
+     * Processes a given start tag.
+     *
+     * `onStartTag` checks if a self-closing tag was recognized. When a token
+     * is moved inbetween multiple insertion modes, this check for self-closing
+     * could lead to false positives. To avoid this, `_processStartTag` is used
+     * for nested calls.
+     *
+     * @param token The token to process.
+     */
+    _processStartTag(token) {
+        if (this.shouldProcessStartTagTokenInForeignContent(token)) {
+            startTagInForeignContent(this, token);
+        }
+        else {
+            this._startTagOutsideForeignContent(token);
+        }
+    }
+    _startTagOutsideForeignContent(token) {
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                tokenInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HTML: {
+                startTagBeforeHtml(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD: {
+                startTagBeforeHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD: {
+                startTagInHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD_NO_SCRIPT: {
+                startTagInHeadNoScript(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_HEAD: {
+                startTagAfterHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_BODY: {
+                startTagInBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE: {
+                startTagInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                tokenInTableText(this, token);
+                break;
+            }
+            case InsertionMode.IN_CAPTION: {
+                startTagInCaption(this, token);
+                break;
+            }
+            case InsertionMode.IN_COLUMN_GROUP: {
+                startTagInColumnGroup(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_BODY: {
+                startTagInTableBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_ROW: {
+                startTagInRow(this, token);
+                break;
+            }
+            case InsertionMode.IN_CELL: {
+                startTagInCell(this, token);
+                break;
+            }
+            case InsertionMode.IN_SELECT: {
+                startTagInSelect(this, token);
+                break;
+            }
+            case InsertionMode.IN_SELECT_IN_TABLE: {
+                startTagInSelectInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TEMPLATE: {
+                startTagInTemplate(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY: {
+                startTagAfterBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_FRAMESET: {
+                startTagInFrameset(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_FRAMESET: {
+                startTagAfterFrameset(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_BODY: {
+                startTagAfterAfterBody(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_FRAMESET: {
+                startTagAfterAfterFrameset(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onEndTag(token) {
+        this.skipNextNewLine = false;
+        this.currentToken = token;
+        if (this.currentNotInHTML) {
+            endTagInForeignContent(this, token);
+        }
+        else {
+            this._endTagOutsideForeignContent(token);
+        }
+    }
+    _endTagOutsideForeignContent(token) {
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                tokenInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HTML: {
+                endTagBeforeHtml(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD: {
+                endTagBeforeHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD: {
+                endTagInHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD_NO_SCRIPT: {
+                endTagInHeadNoScript(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_HEAD: {
+                endTagAfterHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_BODY: {
+                endTagInBody(this, token);
+                break;
+            }
+            case InsertionMode.TEXT: {
+                endTagInText(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE: {
+                endTagInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                tokenInTableText(this, token);
+                break;
+            }
+            case InsertionMode.IN_CAPTION: {
+                endTagInCaption(this, token);
+                break;
+            }
+            case InsertionMode.IN_COLUMN_GROUP: {
+                endTagInColumnGroup(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_BODY: {
+                endTagInTableBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_ROW: {
+                endTagInRow(this, token);
+                break;
+            }
+            case InsertionMode.IN_CELL: {
+                endTagInCell(this, token);
+                break;
+            }
+            case InsertionMode.IN_SELECT: {
+                endTagInSelect(this, token);
+                break;
+            }
+            case InsertionMode.IN_SELECT_IN_TABLE: {
+                endTagInSelectInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TEMPLATE: {
+                endTagInTemplate(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY: {
+                endTagAfterBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_FRAMESET: {
+                endTagInFrameset(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_FRAMESET: {
+                endTagAfterFrameset(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_AFTER_BODY: {
+                tokenAfterAfterBody(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onEof(token) {
+        switch (this.insertionMode) {
+            case InsertionMode.INITIAL: {
+                tokenInInitialMode(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HTML: {
+                tokenBeforeHtml(this, token);
+                break;
+            }
+            case InsertionMode.BEFORE_HEAD: {
+                tokenBeforeHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD: {
+                tokenInHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_HEAD_NO_SCRIPT: {
+                tokenInHeadNoScript(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_HEAD: {
+                tokenAfterHead(this, token);
+                break;
+            }
+            case InsertionMode.IN_BODY:
+            case InsertionMode.IN_TABLE:
+            case InsertionMode.IN_CAPTION:
+            case InsertionMode.IN_COLUMN_GROUP:
+            case InsertionMode.IN_TABLE_BODY:
+            case InsertionMode.IN_ROW:
+            case InsertionMode.IN_CELL:
+            case InsertionMode.IN_SELECT:
+            case InsertionMode.IN_SELECT_IN_TABLE: {
+                eofInBody(this, token);
+                break;
+            }
+            case InsertionMode.TEXT: {
+                eofInText(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                tokenInTableText(this, token);
+                break;
+            }
+            case InsertionMode.IN_TEMPLATE: {
+                eofInTemplate(this, token);
+                break;
+            }
+            case InsertionMode.AFTER_BODY:
+            case InsertionMode.IN_FRAMESET:
+            case InsertionMode.AFTER_FRAMESET:
+            case InsertionMode.AFTER_AFTER_BODY:
+            case InsertionMode.AFTER_AFTER_FRAMESET: {
+                stopParsing(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+    onWhitespaceCharacter(token) {
+        if (this.skipNextNewLine) {
+            this.skipNextNewLine = false;
+            if (token.chars.charCodeAt(0) === CODE_POINTS.LINE_FEED) {
+                if (token.chars.length === 1) {
+                    return;
+                }
+                token.chars = token.chars.substr(1);
+            }
+        }
+        if (this.tokenizer.inForeignNode) {
+            this._insertCharacters(token);
+            return;
+        }
+        switch (this.insertionMode) {
+            case InsertionMode.IN_HEAD:
+            case InsertionMode.IN_HEAD_NO_SCRIPT:
+            case InsertionMode.AFTER_HEAD:
+            case InsertionMode.TEXT:
+            case InsertionMode.IN_COLUMN_GROUP:
+            case InsertionMode.IN_SELECT:
+            case InsertionMode.IN_SELECT_IN_TABLE:
+            case InsertionMode.IN_FRAMESET:
+            case InsertionMode.AFTER_FRAMESET: {
+                this._insertCharacters(token);
+                break;
+            }
+            case InsertionMode.IN_BODY:
+            case InsertionMode.IN_CAPTION:
+            case InsertionMode.IN_CELL:
+            case InsertionMode.IN_TEMPLATE:
+            case InsertionMode.AFTER_BODY:
+            case InsertionMode.AFTER_AFTER_BODY:
+            case InsertionMode.AFTER_AFTER_FRAMESET: {
+                whitespaceCharacterInBody(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE:
+            case InsertionMode.IN_TABLE_BODY:
+            case InsertionMode.IN_ROW: {
+                characterInTable(this, token);
+                break;
+            }
+            case InsertionMode.IN_TABLE_TEXT: {
+                whitespaceCharacterInTableText(this, token);
+                break;
+            }
+            // Do nothing
+        }
+    }
+}
+//Adoption agency algorithm
+//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)
+//------------------------------------------------------------------
+//Steps 5-8 of the algorithm
+function aaObtainFormattingElementEntry(p, token) {
+    let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);
+    if (formattingElementEntry) {
+        if (!p.openElements.contains(formattingElementEntry.element)) {
+            p.activeFormattingElements.removeEntry(formattingElementEntry);
+            formattingElementEntry = null;
+        }
+        else if (!p.openElements.hasInScope(token.tagID)) {
+            formattingElementEntry = null;
+        }
+    }
+    else {
+        genericEndTagInBody(p, token);
+    }
+    return formattingElementEntry;
+}
+//Steps 9 and 10 of the algorithm
+function aaObtainFurthestBlock(p, formattingElementEntry) {
+    let furthestBlock = null;
+    let idx = p.openElements.stackTop;
+    for (; idx >= 0; idx--) {
+        const element = p.openElements.items[idx];
+        if (element === formattingElementEntry.element) {
+            break;
+        }
+        if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) {
+            furthestBlock = element;
+        }
+    }
+    if (!furthestBlock) {
+        p.openElements.shortenToLength(idx < 0 ? 0 : idx);
+        p.activeFormattingElements.removeEntry(formattingElementEntry);
+    }
+    return furthestBlock;
+}
+//Step 13 of the algorithm
+function aaInnerLoop(p, furthestBlock, formattingElement) {
+    let lastElement = furthestBlock;
+    let nextElement = p.openElements.getCommonAncestor(furthestBlock);
+    for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
+        //NOTE: store the next element for the next loop iteration (it may be deleted from the stack by step 9.5)
+        nextElement = p.openElements.getCommonAncestor(element);
+        const elementEntry = p.activeFormattingElements.getElementEntry(element);
+        const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
+        const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;
+        if (shouldRemoveFromOpenElements) {
+            if (counterOverflow) {
+                p.activeFormattingElements.removeEntry(elementEntry);
+            }
+            p.openElements.remove(element);
+        }
+        else {
+            element = aaRecreateElementFromEntry(p, elementEntry);
+            if (lastElement === furthestBlock) {
+                p.activeFormattingElements.bookmark = elementEntry;
+            }
+            p.treeAdapter.detachNode(lastElement);
+            p.treeAdapter.appendChild(element, lastElement);
+            lastElement = element;
+        }
+    }
+    return lastElement;
+}
+//Step 13.7 of the algorithm
+function aaRecreateElementFromEntry(p, elementEntry) {
+    const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
+    const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
+    p.openElements.replace(elementEntry.element, newElement);
+    elementEntry.element = newElement;
+    return newElement;
+}
+//Step 14 of the algorithm
+function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
+    const tn = p.treeAdapter.getTagName(commonAncestor);
+    const tid = getTagID(tn);
+    if (p._isElementCausesFosterParenting(tid)) {
+        p._fosterParentElement(lastElement);
+    }
+    else {
+        const ns = p.treeAdapter.getNamespaceURI(commonAncestor);
+        if (tid === TAG_ID.TEMPLATE && ns === NS.HTML) {
+            commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
+        }
+        p.treeAdapter.appendChild(commonAncestor, lastElement);
+    }
+}
+//Steps 15-19 of the algorithm
+function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
+    const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
+    const { token } = formattingElementEntry;
+    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
+    p._adoptNodes(furthestBlock, newElement);
+    p.treeAdapter.appendChild(furthestBlock, newElement);
+    p.activeFormattingElements.insertElementAfterBookmark(newElement, token);
+    p.activeFormattingElements.removeEntry(formattingElementEntry);
+    p.openElements.remove(formattingElementEntry.element);
+    p.openElements.insertAfter(furthestBlock, newElement, token.tagID);
+}
+//Algorithm entry point
+function callAdoptionAgency(p, token) {
+    for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
+        const formattingElementEntry = aaObtainFormattingElementEntry(p, token);
+        if (!formattingElementEntry) {
+            break;
+        }
+        const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
+        if (!furthestBlock) {
+            break;
+        }
+        p.activeFormattingElements.bookmark = formattingElementEntry;
+        const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
+        const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
+        p.treeAdapter.detachNode(lastElement);
+        if (commonAncestor)
+            aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
+        aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);
+    }
+}
+//Generic token handlers
+//------------------------------------------------------------------
+function appendComment(p, token) {
+    p._appendCommentNode(token, p.openElements.currentTmplContentOrNode);
+}
+function appendCommentToRootHtmlElement(p, token) {
+    p._appendCommentNode(token, p.openElements.items[0]);
+}
+function appendCommentToDocument(p, token) {
+    p._appendCommentNode(token, p.document);
+}
+function stopParsing(p, token) {
+    p.stopped = true;
+    // NOTE: Set end locations for elements that remain on the open element stack.
+    if (token.location) {
+        // NOTE: If we are not in a fragment, `html` and `body` will stay on the stack.
+        // This is a problem, as we might overwrite their end position here.
+        const target = p.fragmentContext ? 0 : 2;
+        for (let i = p.openElements.stackTop; i >= target; i--) {
+            p._setEndLocation(p.openElements.items[i], token);
+        }
+        // Handle `html` and `body`
+        if (!p.fragmentContext && p.openElements.stackTop >= 0) {
+            const htmlElement = p.openElements.items[0];
+            const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement);
+            if (htmlLocation && !htmlLocation.endTag) {
+                p._setEndLocation(htmlElement, token);
+                if (p.openElements.stackTop >= 1) {
+                    const bodyElement = p.openElements.items[1];
+                    const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement);
+                    if (bodyLocation && !bodyLocation.endTag) {
+                        p._setEndLocation(bodyElement, token);
+                    }
+                }
+            }
+        }
+    }
+}
+// The "initial" insertion mode
+//------------------------------------------------------------------
+function doctypeInInitialMode(p, token) {
+    p._setDocumentType(token);
+    const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : getDocumentMode(token);
+    if (!isConforming(token)) {
+        p._err(token, ERR.nonConformingDoctype);
+    }
+    p.treeAdapter.setDocumentMode(p.document, mode);
+    p.insertionMode = InsertionMode.BEFORE_HTML;
+}
+function tokenInInitialMode(p, token) {
+    p._err(token, ERR.missingDoctype, true);
+    p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS);
+    p.insertionMode = InsertionMode.BEFORE_HTML;
+    p._processToken(token);
+}
+// The "before html" insertion mode
+//------------------------------------------------------------------
+function startTagBeforeHtml(p, token) {
+    if (token.tagID === TAG_ID.HTML) {
+        p._insertElement(token, NS.HTML);
+        p.insertionMode = InsertionMode.BEFORE_HEAD;
+    }
+    else {
+        tokenBeforeHtml(p, token);
+    }
+}
+function endTagBeforeHtml(p, token) {
+    const tn = token.tagID;
+    if (tn === TAG_ID.HTML || tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.BR) {
+        tokenBeforeHtml(p, token);
+    }
+}
+function tokenBeforeHtml(p, token) {
+    p._insertFakeRootElement();
+    p.insertionMode = InsertionMode.BEFORE_HEAD;
+    p._processToken(token);
+}
+// The "before head" insertion mode
+//------------------------------------------------------------------
+function startTagBeforeHead(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.HEAD: {
+            p._insertElement(token, NS.HTML);
+            p.headElement = p.openElements.current;
+            p.insertionMode = InsertionMode.IN_HEAD;
+            break;
+        }
+        default: {
+            tokenBeforeHead(p, token);
+        }
+    }
+}
+function endTagBeforeHead(p, token) {
+    const tn = token.tagID;
+    if (tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.HTML || tn === TAG_ID.BR) {
+        tokenBeforeHead(p, token);
+    }
+    else {
+        p._err(token, ERR.endTagWithoutMatchingOpenElement);
+    }
+}
+function tokenBeforeHead(p, token) {
+    p._insertFakeElement(TAG_NAMES.HEAD, TAG_ID.HEAD);
+    p.headElement = p.openElements.current;
+    p.insertionMode = InsertionMode.IN_HEAD;
+    p._processToken(token);
+}
+// The "in head" insertion mode
+//------------------------------------------------------------------
+function startTagInHead(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BASE:
+        case TAG_ID.BASEFONT:
+        case TAG_ID.BGSOUND:
+        case TAG_ID.LINK:
+        case TAG_ID.META: {
+            p._appendElement(token, NS.HTML);
+            token.ackSelfClosing = true;
+            break;
+        }
+        case TAG_ID.TITLE: {
+            p._switchToTextParsing(token, TokenizerMode.RCDATA);
+            break;
+        }
+        case TAG_ID.NOSCRIPT: {
+            if (p.options.scriptingEnabled) {
+                p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+            }
+            else {
+                p._insertElement(token, NS.HTML);
+                p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;
+            }
+            break;
+        }
+        case TAG_ID.NOFRAMES:
+        case TAG_ID.STYLE: {
+            p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+            break;
+        }
+        case TAG_ID.SCRIPT: {
+            p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            p._insertTemplate(token);
+            p.activeFormattingElements.insertMarker();
+            p.framesetOk = false;
+            p.insertionMode = InsertionMode.IN_TEMPLATE;
+            p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
+            break;
+        }
+        case TAG_ID.HEAD: {
+            p._err(token, ERR.misplacedStartTagForHeadElement);
+            break;
+        }
+        default: {
+            tokenInHead(p, token);
+        }
+    }
+}
+function endTagInHead(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HEAD: {
+            p.openElements.pop();
+            p.insertionMode = InsertionMode.AFTER_HEAD;
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.BR:
+        case TAG_ID.HTML: {
+            tokenInHead(p, token);
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        default: {
+            p._err(token, ERR.endTagWithoutMatchingOpenElement);
+        }
+    }
+}
+function templateEndTagInHead(p, token) {
+    if (p.openElements.tmplCount > 0) {
+        p.openElements.generateImpliedEndTagsThoroughly();
+        if (p.openElements.currentTagId !== TAG_ID.TEMPLATE) {
+            p._err(token, ERR.closingOfElementWithOpenChildElements);
+        }
+        p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE);
+        p.activeFormattingElements.clearToLastMarker();
+        p.tmplInsertionModeStack.shift();
+        p._resetInsertionMode();
+    }
+    else {
+        p._err(token, ERR.endTagWithoutMatchingOpenElement);
+    }
+}
+function tokenInHead(p, token) {
+    p.openElements.pop();
+    p.insertionMode = InsertionMode.AFTER_HEAD;
+    p._processToken(token);
+}
+// The "in head no script" insertion mode
+//------------------------------------------------------------------
+function startTagInHeadNoScript(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BASEFONT:
+        case TAG_ID.BGSOUND:
+        case TAG_ID.HEAD:
+        case TAG_ID.LINK:
+        case TAG_ID.META:
+        case TAG_ID.NOFRAMES:
+        case TAG_ID.STYLE: {
+            startTagInHead(p, token);
+            break;
+        }
+        case TAG_ID.NOSCRIPT: {
+            p._err(token, ERR.nestedNoscriptInHead);
+            break;
+        }
+        default: {
+            tokenInHeadNoScript(p, token);
+        }
+    }
+}
+function endTagInHeadNoScript(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.NOSCRIPT: {
+            p.openElements.pop();
+            p.insertionMode = InsertionMode.IN_HEAD;
+            break;
+        }
+        case TAG_ID.BR: {
+            tokenInHeadNoScript(p, token);
+            break;
+        }
+        default: {
+            p._err(token, ERR.endTagWithoutMatchingOpenElement);
+        }
+    }
+}
+function tokenInHeadNoScript(p, token) {
+    const errCode = token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;
+    p._err(token, errCode);
+    p.openElements.pop();
+    p.insertionMode = InsertionMode.IN_HEAD;
+    p._processToken(token);
+}
+// The "after head" insertion mode
+//------------------------------------------------------------------
+function startTagAfterHead(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BODY: {
+            p._insertElement(token, NS.HTML);
+            p.framesetOk = false;
+            p.insertionMode = InsertionMode.IN_BODY;
+            break;
+        }
+        case TAG_ID.FRAMESET: {
+            p._insertElement(token, NS.HTML);
+            p.insertionMode = InsertionMode.IN_FRAMESET;
+            break;
+        }
+        case TAG_ID.BASE:
+        case TAG_ID.BASEFONT:
+        case TAG_ID.BGSOUND:
+        case TAG_ID.LINK:
+        case TAG_ID.META:
+        case TAG_ID.NOFRAMES:
+        case TAG_ID.SCRIPT:
+        case TAG_ID.STYLE:
+        case TAG_ID.TEMPLATE:
+        case TAG_ID.TITLE: {
+            p._err(token, ERR.abandonedHeadElementChild);
+            p.openElements.push(p.headElement, TAG_ID.HEAD);
+            startTagInHead(p, token);
+            p.openElements.remove(p.headElement);
+            break;
+        }
+        case TAG_ID.HEAD: {
+            p._err(token, ERR.misplacedStartTagForHeadElement);
+            break;
+        }
+        default: {
+            tokenAfterHead(p, token);
+        }
+    }
+}
+function endTagAfterHead(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.BODY:
+        case TAG_ID.HTML:
+        case TAG_ID.BR: {
+            tokenAfterHead(p, token);
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        default: {
+            p._err(token, ERR.endTagWithoutMatchingOpenElement);
+        }
+    }
+}
+function tokenAfterHead(p, token) {
+    p._insertFakeElement(TAG_NAMES.BODY, TAG_ID.BODY);
+    p.insertionMode = InsertionMode.IN_BODY;
+    modeInBody(p, token);
+}
+// The "in body" insertion mode
+//------------------------------------------------------------------
+function modeInBody(p, token) {
+    switch (token.type) {
+        case TokenType.CHARACTER: {
+            characterInBody(p, token);
+            break;
+        }
+        case TokenType.WHITESPACE_CHARACTER: {
+            whitespaceCharacterInBody(p, token);
+            break;
+        }
+        case TokenType.COMMENT: {
+            appendComment(p, token);
+            break;
+        }
+        case TokenType.START_TAG: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TokenType.END_TAG: {
+            endTagInBody(p, token);
+            break;
+        }
+        case TokenType.EOF: {
+            eofInBody(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+function whitespaceCharacterInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertCharacters(token);
+}
+function characterInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertCharacters(token);
+    p.framesetOk = false;
+}
+function htmlStartTagInBody(p, token) {
+    if (p.openElements.tmplCount === 0) {
+        p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
+    }
+}
+function bodyStartTagInBody(p, token) {
+    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+    if (bodyElement && p.openElements.tmplCount === 0) {
+        p.framesetOk = false;
+        p.treeAdapter.adoptAttributes(bodyElement, token.attrs);
+    }
+}
+function framesetStartTagInBody(p, token) {
+    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+    if (p.framesetOk && bodyElement) {
+        p.treeAdapter.detachNode(bodyElement);
+        p.openElements.popAllUpToHtmlElement();
+        p._insertElement(token, NS.HTML);
+        p.insertionMode = InsertionMode.IN_FRAMESET;
+    }
+}
+function addressStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._insertElement(token, NS.HTML);
+}
+function numberedHeaderStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    if (isNumberedHeader(p.openElements.currentTagId)) {
+        p.openElements.pop();
+    }
+    p._insertElement(token, NS.HTML);
+}
+function preStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._insertElement(token, NS.HTML);
+    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
+    //on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)
+    p.skipNextNewLine = true;
+    p.framesetOk = false;
+}
+function formStartTagInBody(p, token) {
+    const inTemplate = p.openElements.tmplCount > 0;
+    if (!p.formElement || inTemplate) {
+        if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+            p._closePElement();
+        }
+        p._insertElement(token, NS.HTML);
+        if (!inTemplate) {
+            p.formElement = p.openElements.current;
+        }
+    }
+}
+function listItemStartTagInBody(p, token) {
+    p.framesetOk = false;
+    const tn = token.tagID;
+    for (let i = p.openElements.stackTop; i >= 0; i--) {
+        const elementId = p.openElements.tagIDs[i];
+        if ((tn === TAG_ID.LI && elementId === TAG_ID.LI) ||
+            ((tn === TAG_ID.DD || tn === TAG_ID.DT) && (elementId === TAG_ID.DD || elementId === TAG_ID.DT))) {
+            p.openElements.generateImpliedEndTagsWithExclusion(elementId);
+            p.openElements.popUntilTagNamePopped(elementId);
+            break;
+        }
+        if (elementId !== TAG_ID.ADDRESS &&
+            elementId !== TAG_ID.DIV &&
+            elementId !== TAG_ID.P &&
+            p._isSpecialElement(p.openElements.items[i], elementId)) {
+            break;
+        }
+    }
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._insertElement(token, NS.HTML);
+}
+function plaintextStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._insertElement(token, NS.HTML);
+    p.tokenizer.state = TokenizerMode.PLAINTEXT;
+}
+function buttonStartTagInBody(p, token) {
+    if (p.openElements.hasInScope(TAG_ID.BUTTON)) {
+        p.openElements.generateImpliedEndTags();
+        p.openElements.popUntilTagNamePopped(TAG_ID.BUTTON);
+    }
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+    p.framesetOk = false;
+}
+function aStartTagInBody(p, token) {
+    const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TAG_NAMES.A);
+    if (activeElementEntry) {
+        callAdoptionAgency(p, token);
+        p.openElements.remove(activeElementEntry.element);
+        p.activeFormattingElements.removeEntry(activeElementEntry);
+    }
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+    p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function bStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+    p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function nobrStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    if (p.openElements.hasInScope(TAG_ID.NOBR)) {
+        callAdoptionAgency(p, token);
+        p._reconstructActiveFormattingElements();
+    }
+    p._insertElement(token, NS.HTML);
+    p.activeFormattingElements.pushElement(p.openElements.current, token);
+}
+function appletStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+    p.activeFormattingElements.insertMarker();
+    p.framesetOk = false;
+}
+function tableStartTagInBody(p, token) {
+    if (p.treeAdapter.getDocumentMode(p.document) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._insertElement(token, NS.HTML);
+    p.framesetOk = false;
+    p.insertionMode = InsertionMode.IN_TABLE;
+}
+function areaStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._appendElement(token, NS.HTML);
+    p.framesetOk = false;
+    token.ackSelfClosing = true;
+}
+function isHiddenInput(token) {
+    const inputType = getTokenAttr(token, ATTRS.TYPE);
+    return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE;
+}
+function inputStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._appendElement(token, NS.HTML);
+    if (!isHiddenInput(token)) {
+        p.framesetOk = false;
+    }
+    token.ackSelfClosing = true;
+}
+function paramStartTagInBody(p, token) {
+    p._appendElement(token, NS.HTML);
+    token.ackSelfClosing = true;
+}
+function hrStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._appendElement(token, NS.HTML);
+    p.framesetOk = false;
+    token.ackSelfClosing = true;
+}
+function imageStartTagInBody(p, token) {
+    token.tagName = TAG_NAMES.IMG;
+    token.tagID = TAG_ID.IMG;
+    areaStartTagInBody(p, token);
+}
+function textareaStartTagInBody(p, token) {
+    p._insertElement(token, NS.HTML);
+    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
+    //on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)
+    p.skipNextNewLine = true;
+    p.tokenizer.state = TokenizerMode.RCDATA;
+    p.originalInsertionMode = p.insertionMode;
+    p.framesetOk = false;
+    p.insertionMode = InsertionMode.TEXT;
+}
+function xmpStartTagInBody(p, token) {
+    if (p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._closePElement();
+    }
+    p._reconstructActiveFormattingElements();
+    p.framesetOk = false;
+    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+function iframeStartTagInBody(p, token) {
+    p.framesetOk = false;
+    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse
+//<noembed> as rawtext.
+function noembedStartTagInBody(p, token) {
+    p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
+}
+function selectStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+    p.framesetOk = false;
+    p.insertionMode =
+        p.insertionMode === InsertionMode.IN_TABLE ||
+            p.insertionMode === InsertionMode.IN_CAPTION ||
+            p.insertionMode === InsertionMode.IN_TABLE_BODY ||
+            p.insertionMode === InsertionMode.IN_ROW ||
+            p.insertionMode === InsertionMode.IN_CELL
+            ? InsertionMode.IN_SELECT_IN_TABLE
+            : InsertionMode.IN_SELECT;
+}
+function optgroupStartTagInBody(p, token) {
+    if (p.openElements.currentTagId === TAG_ID.OPTION) {
+        p.openElements.pop();
+    }
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+}
+function rbStartTagInBody(p, token) {
+    if (p.openElements.hasInScope(TAG_ID.RUBY)) {
+        p.openElements.generateImpliedEndTags();
+    }
+    p._insertElement(token, NS.HTML);
+}
+function rtStartTagInBody(p, token) {
+    if (p.openElements.hasInScope(TAG_ID.RUBY)) {
+        p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.RTC);
+    }
+    p._insertElement(token, NS.HTML);
+}
+function mathStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    adjustTokenMathMLAttrs(token);
+    adjustTokenXMLAttrs(token);
+    if (token.selfClosing) {
+        p._appendElement(token, NS.MATHML);
+    }
+    else {
+        p._insertElement(token, NS.MATHML);
+    }
+    token.ackSelfClosing = true;
+}
+function svgStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    adjustTokenSVGAttrs(token);
+    adjustTokenXMLAttrs(token);
+    if (token.selfClosing) {
+        p._appendElement(token, NS.SVG);
+    }
+    else {
+        p._insertElement(token, NS.SVG);
+    }
+    token.ackSelfClosing = true;
+}
+function genericStartTagInBody(p, token) {
+    p._reconstructActiveFormattingElements();
+    p._insertElement(token, NS.HTML);
+}
+function startTagInBody(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.I:
+        case TAG_ID.S:
+        case TAG_ID.B:
+        case TAG_ID.U:
+        case TAG_ID.EM:
+        case TAG_ID.TT:
+        case TAG_ID.BIG:
+        case TAG_ID.CODE:
+        case TAG_ID.FONT:
+        case TAG_ID.SMALL:
+        case TAG_ID.STRIKE:
+        case TAG_ID.STRONG: {
+            bStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.A: {
+            aStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.H1:
+        case TAG_ID.H2:
+        case TAG_ID.H3:
+        case TAG_ID.H4:
+        case TAG_ID.H5:
+        case TAG_ID.H6: {
+            numberedHeaderStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.P:
+        case TAG_ID.DL:
+        case TAG_ID.OL:
+        case TAG_ID.UL:
+        case TAG_ID.DIV:
+        case TAG_ID.DIR:
+        case TAG_ID.NAV:
+        case TAG_ID.MAIN:
+        case TAG_ID.MENU:
+        case TAG_ID.ASIDE:
+        case TAG_ID.CENTER:
+        case TAG_ID.FIGURE:
+        case TAG_ID.FOOTER:
+        case TAG_ID.HEADER:
+        case TAG_ID.HGROUP:
+        case TAG_ID.DIALOG:
+        case TAG_ID.DETAILS:
+        case TAG_ID.ADDRESS:
+        case TAG_ID.ARTICLE:
+        case TAG_ID.SECTION:
+        case TAG_ID.SUMMARY:
+        case TAG_ID.FIELDSET:
+        case TAG_ID.BLOCKQUOTE:
+        case TAG_ID.FIGCAPTION: {
+            addressStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.LI:
+        case TAG_ID.DD:
+        case TAG_ID.DT: {
+            listItemStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BR:
+        case TAG_ID.IMG:
+        case TAG_ID.WBR:
+        case TAG_ID.AREA:
+        case TAG_ID.EMBED:
+        case TAG_ID.KEYGEN: {
+            areaStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.HR: {
+            hrStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.RB:
+        case TAG_ID.RTC: {
+            rbStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.RT:
+        case TAG_ID.RP: {
+            rtStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.PRE:
+        case TAG_ID.LISTING: {
+            preStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.XMP: {
+            xmpStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.SVG: {
+            svgStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.HTML: {
+            htmlStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BASE:
+        case TAG_ID.LINK:
+        case TAG_ID.META:
+        case TAG_ID.STYLE:
+        case TAG_ID.TITLE:
+        case TAG_ID.SCRIPT:
+        case TAG_ID.BGSOUND:
+        case TAG_ID.BASEFONT:
+        case TAG_ID.TEMPLATE: {
+            startTagInHead(p, token);
+            break;
+        }
+        case TAG_ID.BODY: {
+            bodyStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.FORM: {
+            formStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.NOBR: {
+            nobrStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.MATH: {
+            mathStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.TABLE: {
+            tableStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.INPUT: {
+            inputStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.PARAM:
+        case TAG_ID.TRACK:
+        case TAG_ID.SOURCE: {
+            paramStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.IMAGE: {
+            imageStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.BUTTON: {
+            buttonStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.APPLET:
+        case TAG_ID.OBJECT:
+        case TAG_ID.MARQUEE: {
+            appletStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.IFRAME: {
+            iframeStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.SELECT: {
+            selectStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.OPTION:
+        case TAG_ID.OPTGROUP: {
+            optgroupStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.NOEMBED: {
+            noembedStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.FRAMESET: {
+            framesetStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.TEXTAREA: {
+            textareaStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.NOSCRIPT: {
+            if (p.options.scriptingEnabled) {
+                noembedStartTagInBody(p, token);
+            }
+            else {
+                genericStartTagInBody(p, token);
+            }
+            break;
+        }
+        case TAG_ID.PLAINTEXT: {
+            plaintextStartTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.COL:
+        case TAG_ID.TH:
+        case TAG_ID.TD:
+        case TAG_ID.TR:
+        case TAG_ID.HEAD:
+        case TAG_ID.FRAME:
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD:
+        case TAG_ID.CAPTION:
+        case TAG_ID.COLGROUP: {
+            // Ignore token
+            break;
+        }
+        default: {
+            genericStartTagInBody(p, token);
+        }
+    }
+}
+function bodyEndTagInBody(p, token) {
+    if (p.openElements.hasInScope(TAG_ID.BODY)) {
+        p.insertionMode = InsertionMode.AFTER_BODY;
+        //NOTE: <body> is never popped from the stack, so we need to updated
+        //the end location explicitly.
+        if (p.options.sourceCodeLocationInfo) {
+            const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+            if (bodyElement) {
+                p._setEndLocation(bodyElement, token);
+            }
+        }
+    }
+}
+function htmlEndTagInBody(p, token) {
+    if (p.openElements.hasInScope(TAG_ID.BODY)) {
+        p.insertionMode = InsertionMode.AFTER_BODY;
+        endTagAfterBody(p, token);
+    }
+}
+function addressEndTagInBody(p, token) {
+    const tn = token.tagID;
+    if (p.openElements.hasInScope(tn)) {
+        p.openElements.generateImpliedEndTags();
+        p.openElements.popUntilTagNamePopped(tn);
+    }
+}
+function formEndTagInBody(p) {
+    const inTemplate = p.openElements.tmplCount > 0;
+    const { formElement } = p;
+    if (!inTemplate) {
+        p.formElement = null;
+    }
+    if ((formElement || inTemplate) && p.openElements.hasInScope(TAG_ID.FORM)) {
+        p.openElements.generateImpliedEndTags();
+        if (inTemplate) {
+            p.openElements.popUntilTagNamePopped(TAG_ID.FORM);
+        }
+        else if (formElement) {
+            p.openElements.remove(formElement);
+        }
+    }
+}
+function pEndTagInBody(p) {
+    if (!p.openElements.hasInButtonScope(TAG_ID.P)) {
+        p._insertFakeElement(TAG_NAMES.P, TAG_ID.P);
+    }
+    p._closePElement();
+}
+function liEndTagInBody(p) {
+    if (p.openElements.hasInListItemScope(TAG_ID.LI)) {
+        p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.LI);
+        p.openElements.popUntilTagNamePopped(TAG_ID.LI);
+    }
+}
+function ddEndTagInBody(p, token) {
+    const tn = token.tagID;
+    if (p.openElements.hasInScope(tn)) {
+        p.openElements.generateImpliedEndTagsWithExclusion(tn);
+        p.openElements.popUntilTagNamePopped(tn);
+    }
+}
+function numberedHeaderEndTagInBody(p) {
+    if (p.openElements.hasNumberedHeaderInScope()) {
+        p.openElements.generateImpliedEndTags();
+        p.openElements.popUntilNumberedHeaderPopped();
+    }
+}
+function appletEndTagInBody(p, token) {
+    const tn = token.tagID;
+    if (p.openElements.hasInScope(tn)) {
+        p.openElements.generateImpliedEndTags();
+        p.openElements.popUntilTagNamePopped(tn);
+        p.activeFormattingElements.clearToLastMarker();
+    }
+}
+function brEndTagInBody(p) {
+    p._reconstructActiveFormattingElements();
+    p._insertFakeElement(TAG_NAMES.BR, TAG_ID.BR);
+    p.openElements.pop();
+    p.framesetOk = false;
+}
+function genericEndTagInBody(p, token) {
+    const tn = token.tagName;
+    const tid = token.tagID;
+    for (let i = p.openElements.stackTop; i > 0; i--) {
+        const element = p.openElements.items[i];
+        const elementId = p.openElements.tagIDs[i];
+        // Compare the tag name here, as the tag might not be a known tag with an ID.
+        if (tid === elementId && (tid !== TAG_ID.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {
+            p.openElements.generateImpliedEndTagsWithExclusion(tid);
+            if (p.openElements.stackTop >= i)
+                p.openElements.shortenToLength(i);
+            break;
+        }
+        if (p._isSpecialElement(element, elementId)) {
+            break;
+        }
+    }
+}
+function endTagInBody(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.A:
+        case TAG_ID.B:
+        case TAG_ID.I:
+        case TAG_ID.S:
+        case TAG_ID.U:
+        case TAG_ID.EM:
+        case TAG_ID.TT:
+        case TAG_ID.BIG:
+        case TAG_ID.CODE:
+        case TAG_ID.FONT:
+        case TAG_ID.NOBR:
+        case TAG_ID.SMALL:
+        case TAG_ID.STRIKE:
+        case TAG_ID.STRONG: {
+            callAdoptionAgency(p, token);
+            break;
+        }
+        case TAG_ID.P: {
+            pEndTagInBody(p);
+            break;
+        }
+        case TAG_ID.DL:
+        case TAG_ID.UL:
+        case TAG_ID.OL:
+        case TAG_ID.DIR:
+        case TAG_ID.DIV:
+        case TAG_ID.NAV:
+        case TAG_ID.PRE:
+        case TAG_ID.MAIN:
+        case TAG_ID.MENU:
+        case TAG_ID.ASIDE:
+        case TAG_ID.BUTTON:
+        case TAG_ID.CENTER:
+        case TAG_ID.FIGURE:
+        case TAG_ID.FOOTER:
+        case TAG_ID.HEADER:
+        case TAG_ID.HGROUP:
+        case TAG_ID.DIALOG:
+        case TAG_ID.ADDRESS:
+        case TAG_ID.ARTICLE:
+        case TAG_ID.DETAILS:
+        case TAG_ID.SECTION:
+        case TAG_ID.SUMMARY:
+        case TAG_ID.LISTING:
+        case TAG_ID.FIELDSET:
+        case TAG_ID.BLOCKQUOTE:
+        case TAG_ID.FIGCAPTION: {
+            addressEndTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.LI: {
+            liEndTagInBody(p);
+            break;
+        }
+        case TAG_ID.DD:
+        case TAG_ID.DT: {
+            ddEndTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.H1:
+        case TAG_ID.H2:
+        case TAG_ID.H3:
+        case TAG_ID.H4:
+        case TAG_ID.H5:
+        case TAG_ID.H6: {
+            numberedHeaderEndTagInBody(p);
+            break;
+        }
+        case TAG_ID.BR: {
+            brEndTagInBody(p);
+            break;
+        }
+        case TAG_ID.BODY: {
+            bodyEndTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.HTML: {
+            htmlEndTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.FORM: {
+            formEndTagInBody(p);
+            break;
+        }
+        case TAG_ID.APPLET:
+        case TAG_ID.OBJECT:
+        case TAG_ID.MARQUEE: {
+            appletEndTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        default: {
+            genericEndTagInBody(p, token);
+        }
+    }
+}
+function eofInBody(p, token) {
+    if (p.tmplInsertionModeStack.length > 0) {
+        eofInTemplate(p, token);
+    }
+    else {
+        stopParsing(p, token);
+    }
+}
+// The "text" insertion mode
+//------------------------------------------------------------------
+function endTagInText(p, token) {
+    var _a;
+    if (token.tagID === TAG_ID.SCRIPT) {
+        (_a = p.scriptHandler) === null || _a === void 0 ? void 0 : _a.call(p, p.openElements.current);
+    }
+    p.openElements.pop();
+    p.insertionMode = p.originalInsertionMode;
+}
+function eofInText(p, token) {
+    p._err(token, ERR.eofInElementThatCanContainOnlyText);
+    p.openElements.pop();
+    p.insertionMode = p.originalInsertionMode;
+    p.onEof(token);
+}
+// The "in table" insertion mode
+//------------------------------------------------------------------
+function characterInTable(p, token) {
+    if (TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) {
+        p.pendingCharacterTokens.length = 0;
+        p.hasNonWhitespacePendingCharacterToken = false;
+        p.originalInsertionMode = p.insertionMode;
+        p.insertionMode = InsertionMode.IN_TABLE_TEXT;
+        switch (token.type) {
+            case TokenType.CHARACTER: {
+                characterInTableText(p, token);
+                break;
+            }
+            case TokenType.WHITESPACE_CHARACTER: {
+                whitespaceCharacterInTableText(p, token);
+                break;
+            }
+            // Ignore null
+        }
+    }
+    else {
+        tokenInTable(p, token);
+    }
+}
+function captionStartTagInTable(p, token) {
+    p.openElements.clearBackToTableContext();
+    p.activeFormattingElements.insertMarker();
+    p._insertElement(token, NS.HTML);
+    p.insertionMode = InsertionMode.IN_CAPTION;
+}
+function colgroupStartTagInTable(p, token) {
+    p.openElements.clearBackToTableContext();
+    p._insertElement(token, NS.HTML);
+    p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+}
+function colStartTagInTable(p, token) {
+    p.openElements.clearBackToTableContext();
+    p._insertFakeElement(TAG_NAMES.COLGROUP, TAG_ID.COLGROUP);
+    p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+    startTagInColumnGroup(p, token);
+}
+function tbodyStartTagInTable(p, token) {
+    p.openElements.clearBackToTableContext();
+    p._insertElement(token, NS.HTML);
+    p.insertionMode = InsertionMode.IN_TABLE_BODY;
+}
+function tdStartTagInTable(p, token) {
+    p.openElements.clearBackToTableContext();
+    p._insertFakeElement(TAG_NAMES.TBODY, TAG_ID.TBODY);
+    p.insertionMode = InsertionMode.IN_TABLE_BODY;
+    startTagInTableBody(p, token);
+}
+function tableStartTagInTable(p, token) {
+    if (p.openElements.hasInTableScope(TAG_ID.TABLE)) {
+        p.openElements.popUntilTagNamePopped(TAG_ID.TABLE);
+        p._resetInsertionMode();
+        p._processStartTag(token);
+    }
+}
+function inputStartTagInTable(p, token) {
+    if (isHiddenInput(token)) {
+        p._appendElement(token, NS.HTML);
+    }
+    else {
+        tokenInTable(p, token);
+    }
+    token.ackSelfClosing = true;
+}
+function formStartTagInTable(p, token) {
+    if (!p.formElement && p.openElements.tmplCount === 0) {
+        p._insertElement(token, NS.HTML);
+        p.formElement = p.openElements.current;
+        p.openElements.pop();
+    }
+}
+function startTagInTable(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.TD:
+        case TAG_ID.TH:
+        case TAG_ID.TR: {
+            tdStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.STYLE:
+        case TAG_ID.SCRIPT:
+        case TAG_ID.TEMPLATE: {
+            startTagInHead(p, token);
+            break;
+        }
+        case TAG_ID.COL: {
+            colStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.FORM: {
+            formStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.TABLE: {
+            tableStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD: {
+            tbodyStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.INPUT: {
+            inputStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.CAPTION: {
+            captionStartTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.COLGROUP: {
+            colgroupStartTagInTable(p, token);
+            break;
+        }
+        default: {
+            tokenInTable(p, token);
+        }
+    }
+}
+function endTagInTable(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.TABLE: {
+            if (p.openElements.hasInTableScope(TAG_ID.TABLE)) {
+                p.openElements.popUntilTagNamePopped(TAG_ID.TABLE);
+                p._resetInsertionMode();
+            }
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.HTML:
+        case TAG_ID.TBODY:
+        case TAG_ID.TD:
+        case TAG_ID.TFOOT:
+        case TAG_ID.TH:
+        case TAG_ID.THEAD:
+        case TAG_ID.TR: {
+            // Ignore token
+            break;
+        }
+        default: {
+            tokenInTable(p, token);
+        }
+    }
+}
+function tokenInTable(p, token) {
+    const savedFosterParentingState = p.fosterParentingEnabled;
+    p.fosterParentingEnabled = true;
+    // Process token in `In Body` mode
+    modeInBody(p, token);
+    p.fosterParentingEnabled = savedFosterParentingState;
+}
+// The "in table text" insertion mode
+//------------------------------------------------------------------
+function whitespaceCharacterInTableText(p, token) {
+    p.pendingCharacterTokens.push(token);
+}
+function characterInTableText(p, token) {
+    p.pendingCharacterTokens.push(token);
+    p.hasNonWhitespacePendingCharacterToken = true;
+}
+function tokenInTableText(p, token) {
+    let i = 0;
+    if (p.hasNonWhitespacePendingCharacterToken) {
+        for (; i < p.pendingCharacterTokens.length; i++) {
+            tokenInTable(p, p.pendingCharacterTokens[i]);
+        }
+    }
+    else {
+        for (; i < p.pendingCharacterTokens.length; i++) {
+            p._insertCharacters(p.pendingCharacterTokens[i]);
+        }
+    }
+    p.insertionMode = p.originalInsertionMode;
+    p._processToken(token);
+}
+// The "in caption" insertion mode
+//------------------------------------------------------------------
+const TABLE_VOID_ELEMENTS = new Set([TAG_ID.CAPTION, TAG_ID.COL, TAG_ID.COLGROUP, TAG_ID.TBODY, TAG_ID.TD, TAG_ID.TFOOT, TAG_ID.TH, TAG_ID.THEAD, TAG_ID.TR]);
+function startTagInCaption(p, token) {
+    const tn = token.tagID;
+    if (TABLE_VOID_ELEMENTS.has(tn)) {
+        if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) {
+            p.openElements.generateImpliedEndTags();
+            p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION);
+            p.activeFormattingElements.clearToLastMarker();
+            p.insertionMode = InsertionMode.IN_TABLE;
+            startTagInTable(p, token);
+        }
+    }
+    else {
+        startTagInBody(p, token);
+    }
+}
+function endTagInCaption(p, token) {
+    const tn = token.tagID;
+    switch (tn) {
+        case TAG_ID.CAPTION:
+        case TAG_ID.TABLE: {
+            if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) {
+                p.openElements.generateImpliedEndTags();
+                p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION);
+                p.activeFormattingElements.clearToLastMarker();
+                p.insertionMode = InsertionMode.IN_TABLE;
+                if (tn === TAG_ID.TABLE) {
+                    endTagInTable(p, token);
+                }
+            }
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.HTML:
+        case TAG_ID.TBODY:
+        case TAG_ID.TD:
+        case TAG_ID.TFOOT:
+        case TAG_ID.TH:
+        case TAG_ID.THEAD:
+        case TAG_ID.TR: {
+            // Ignore token
+            break;
+        }
+        default: {
+            endTagInBody(p, token);
+        }
+    }
+}
+// The "in column group" insertion mode
+//------------------------------------------------------------------
+function startTagInColumnGroup(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.COL: {
+            p._appendElement(token, NS.HTML);
+            token.ackSelfClosing = true;
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            startTagInHead(p, token);
+            break;
+        }
+        default: {
+            tokenInColumnGroup(p, token);
+        }
+    }
+}
+function endTagInColumnGroup(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.COLGROUP: {
+            if (p.openElements.currentTagId === TAG_ID.COLGROUP) {
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE;
+            }
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        case TAG_ID.COL: {
+            // Ignore token
+            break;
+        }
+        default: {
+            tokenInColumnGroup(p, token);
+        }
+    }
+}
+function tokenInColumnGroup(p, token) {
+    if (p.openElements.currentTagId === TAG_ID.COLGROUP) {
+        p.openElements.pop();
+        p.insertionMode = InsertionMode.IN_TABLE;
+        p._processToken(token);
+    }
+}
+// The "in table body" insertion mode
+//------------------------------------------------------------------
+function startTagInTableBody(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.TR: {
+            p.openElements.clearBackToTableBodyContext();
+            p._insertElement(token, NS.HTML);
+            p.insertionMode = InsertionMode.IN_ROW;
+            break;
+        }
+        case TAG_ID.TH:
+        case TAG_ID.TD: {
+            p.openElements.clearBackToTableBodyContext();
+            p._insertFakeElement(TAG_NAMES.TR, TAG_ID.TR);
+            p.insertionMode = InsertionMode.IN_ROW;
+            startTagInRow(p, token);
+            break;
+        }
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD: {
+            if (p.openElements.hasTableBodyContextInTableScope()) {
+                p.openElements.clearBackToTableBodyContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE;
+                startTagInTable(p, token);
+            }
+            break;
+        }
+        default: {
+            startTagInTable(p, token);
+        }
+    }
+}
+function endTagInTableBody(p, token) {
+    const tn = token.tagID;
+    switch (token.tagID) {
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD: {
+            if (p.openElements.hasInTableScope(tn)) {
+                p.openElements.clearBackToTableBodyContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE;
+            }
+            break;
+        }
+        case TAG_ID.TABLE: {
+            if (p.openElements.hasTableBodyContextInTableScope()) {
+                p.openElements.clearBackToTableBodyContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE;
+                endTagInTable(p, token);
+            }
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.HTML:
+        case TAG_ID.TD:
+        case TAG_ID.TH:
+        case TAG_ID.TR: {
+            // Ignore token
+            break;
+        }
+        default: {
+            endTagInTable(p, token);
+        }
+    }
+}
+// The "in row" insertion mode
+//------------------------------------------------------------------
+function startTagInRow(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.TH:
+        case TAG_ID.TD: {
+            p.openElements.clearBackToTableRowContext();
+            p._insertElement(token, NS.HTML);
+            p.insertionMode = InsertionMode.IN_CELL;
+            p.activeFormattingElements.insertMarker();
+            break;
+        }
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD:
+        case TAG_ID.TR: {
+            if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+                p.openElements.clearBackToTableRowContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE_BODY;
+                startTagInTableBody(p, token);
+            }
+            break;
+        }
+        default: {
+            startTagInTable(p, token);
+        }
+    }
+}
+function endTagInRow(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.TR: {
+            if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+                p.openElements.clearBackToTableRowContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE_BODY;
+            }
+            break;
+        }
+        case TAG_ID.TABLE: {
+            if (p.openElements.hasInTableScope(TAG_ID.TR)) {
+                p.openElements.clearBackToTableRowContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE_BODY;
+                endTagInTableBody(p, token);
+            }
+            break;
+        }
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD: {
+            if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope(TAG_ID.TR)) {
+                p.openElements.clearBackToTableRowContext();
+                p.openElements.pop();
+                p.insertionMode = InsertionMode.IN_TABLE_BODY;
+                endTagInTableBody(p, token);
+            }
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.HTML:
+        case TAG_ID.TD:
+        case TAG_ID.TH: {
+            // Ignore end tag
+            break;
+        }
+        default: {
+            endTagInTable(p, token);
+        }
+    }
+}
+// The "in cell" insertion mode
+//------------------------------------------------------------------
+function startTagInCell(p, token) {
+    const tn = token.tagID;
+    if (TABLE_VOID_ELEMENTS.has(tn)) {
+        if (p.openElements.hasInTableScope(TAG_ID.TD) || p.openElements.hasInTableScope(TAG_ID.TH)) {
+            p._closeTableCell();
+            startTagInRow(p, token);
+        }
+    }
+    else {
+        startTagInBody(p, token);
+    }
+}
+function endTagInCell(p, token) {
+    const tn = token.tagID;
+    switch (tn) {
+        case TAG_ID.TD:
+        case TAG_ID.TH: {
+            if (p.openElements.hasInTableScope(tn)) {
+                p.openElements.generateImpliedEndTags();
+                p.openElements.popUntilTagNamePopped(tn);
+                p.activeFormattingElements.clearToLastMarker();
+                p.insertionMode = InsertionMode.IN_ROW;
+            }
+            break;
+        }
+        case TAG_ID.TABLE:
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD:
+        case TAG_ID.TR: {
+            if (p.openElements.hasInTableScope(tn)) {
+                p._closeTableCell();
+                endTagInRow(p, token);
+            }
+            break;
+        }
+        case TAG_ID.BODY:
+        case TAG_ID.CAPTION:
+        case TAG_ID.COL:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.HTML: {
+            // Ignore token
+            break;
+        }
+        default: {
+            endTagInBody(p, token);
+        }
+    }
+}
+// The "in select" insertion mode
+//------------------------------------------------------------------
+function startTagInSelect(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.OPTION: {
+            if (p.openElements.currentTagId === TAG_ID.OPTION) {
+                p.openElements.pop();
+            }
+            p._insertElement(token, NS.HTML);
+            break;
+        }
+        case TAG_ID.OPTGROUP: {
+            if (p.openElements.currentTagId === TAG_ID.OPTION) {
+                p.openElements.pop();
+            }
+            if (p.openElements.currentTagId === TAG_ID.OPTGROUP) {
+                p.openElements.pop();
+            }
+            p._insertElement(token, NS.HTML);
+            break;
+        }
+        case TAG_ID.INPUT:
+        case TAG_ID.KEYGEN:
+        case TAG_ID.TEXTAREA:
+        case TAG_ID.SELECT: {
+            if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
+                p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+                p._resetInsertionMode();
+                if (token.tagID !== TAG_ID.SELECT) {
+                    p._processStartTag(token);
+                }
+            }
+            break;
+        }
+        case TAG_ID.SCRIPT:
+        case TAG_ID.TEMPLATE: {
+            startTagInHead(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+function endTagInSelect(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.OPTGROUP: {
+            if (p.openElements.stackTop > 0 &&
+                p.openElements.currentTagId === TAG_ID.OPTION &&
+                p.openElements.tagIDs[p.openElements.stackTop - 1] === TAG_ID.OPTGROUP) {
+                p.openElements.pop();
+            }
+            if (p.openElements.currentTagId === TAG_ID.OPTGROUP) {
+                p.openElements.pop();
+            }
+            break;
+        }
+        case TAG_ID.OPTION: {
+            if (p.openElements.currentTagId === TAG_ID.OPTION) {
+                p.openElements.pop();
+            }
+            break;
+        }
+        case TAG_ID.SELECT: {
+            if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) {
+                p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+                p._resetInsertionMode();
+            }
+            break;
+        }
+        case TAG_ID.TEMPLATE: {
+            templateEndTagInHead(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+// The "in select in table" insertion mode
+//------------------------------------------------------------------
+function startTagInSelectInTable(p, token) {
+    const tn = token.tagID;
+    if (tn === TAG_ID.CAPTION ||
+        tn === TAG_ID.TABLE ||
+        tn === TAG_ID.TBODY ||
+        tn === TAG_ID.TFOOT ||
+        tn === TAG_ID.THEAD ||
+        tn === TAG_ID.TR ||
+        tn === TAG_ID.TD ||
+        tn === TAG_ID.TH) {
+        p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+        p._resetInsertionMode();
+        p._processStartTag(token);
+    }
+    else {
+        startTagInSelect(p, token);
+    }
+}
+function endTagInSelectInTable(p, token) {
+    const tn = token.tagID;
+    if (tn === TAG_ID.CAPTION ||
+        tn === TAG_ID.TABLE ||
+        tn === TAG_ID.TBODY ||
+        tn === TAG_ID.TFOOT ||
+        tn === TAG_ID.THEAD ||
+        tn === TAG_ID.TR ||
+        tn === TAG_ID.TD ||
+        tn === TAG_ID.TH) {
+        if (p.openElements.hasInTableScope(tn)) {
+            p.openElements.popUntilTagNamePopped(TAG_ID.SELECT);
+            p._resetInsertionMode();
+            p.onEndTag(token);
+        }
+    }
+    else {
+        endTagInSelect(p, token);
+    }
+}
+// The "in template" insertion mode
+//------------------------------------------------------------------
+function startTagInTemplate(p, token) {
+    switch (token.tagID) {
+        // First, handle tags that can start without a mode change
+        case TAG_ID.BASE:
+        case TAG_ID.BASEFONT:
+        case TAG_ID.BGSOUND:
+        case TAG_ID.LINK:
+        case TAG_ID.META:
+        case TAG_ID.NOFRAMES:
+        case TAG_ID.SCRIPT:
+        case TAG_ID.STYLE:
+        case TAG_ID.TEMPLATE:
+        case TAG_ID.TITLE: {
+            startTagInHead(p, token);
+            break;
+        }
+        // Re-process the token in the appropriate mode
+        case TAG_ID.CAPTION:
+        case TAG_ID.COLGROUP:
+        case TAG_ID.TBODY:
+        case TAG_ID.TFOOT:
+        case TAG_ID.THEAD: {
+            p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;
+            p.insertionMode = InsertionMode.IN_TABLE;
+            startTagInTable(p, token);
+            break;
+        }
+        case TAG_ID.COL: {
+            p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;
+            p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
+            startTagInColumnGroup(p, token);
+            break;
+        }
+        case TAG_ID.TR: {
+            p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;
+            p.insertionMode = InsertionMode.IN_TABLE_BODY;
+            startTagInTableBody(p, token);
+            break;
+        }
+        case TAG_ID.TD:
+        case TAG_ID.TH: {
+            p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;
+            p.insertionMode = InsertionMode.IN_ROW;
+            startTagInRow(p, token);
+            break;
+        }
+        default: {
+            p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;
+            p.insertionMode = InsertionMode.IN_BODY;
+            startTagInBody(p, token);
+        }
+    }
+}
+function endTagInTemplate(p, token) {
+    if (token.tagID === TAG_ID.TEMPLATE) {
+        templateEndTagInHead(p, token);
+    }
+}
+function eofInTemplate(p, token) {
+    if (p.openElements.tmplCount > 0) {
+        p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE);
+        p.activeFormattingElements.clearToLastMarker();
+        p.tmplInsertionModeStack.shift();
+        p._resetInsertionMode();
+        p.onEof(token);
+    }
+    else {
+        stopParsing(p, token);
+    }
+}
+// The "after body" insertion mode
+//------------------------------------------------------------------
+function startTagAfterBody(p, token) {
+    if (token.tagID === TAG_ID.HTML) {
+        startTagInBody(p, token);
+    }
+    else {
+        tokenAfterBody(p, token);
+    }
+}
+function endTagAfterBody(p, token) {
+    var _a;
+    if (token.tagID === TAG_ID.HTML) {
+        if (!p.fragmentContext) {
+            p.insertionMode = InsertionMode.AFTER_AFTER_BODY;
+        }
+        //NOTE: <html> is never popped from the stack, so we need to updated
+        //the end location explicitly.
+        if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === TAG_ID.HTML) {
+            p._setEndLocation(p.openElements.items[0], token);
+            // Update the body element, if it doesn't have an end tag
+            const bodyElement = p.openElements.items[1];
+            if (bodyElement && !((_a = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a === void 0 ? void 0 : _a.endTag)) {
+                p._setEndLocation(bodyElement, token);
+            }
+        }
+    }
+    else {
+        tokenAfterBody(p, token);
+    }
+}
+function tokenAfterBody(p, token) {
+    p.insertionMode = InsertionMode.IN_BODY;
+    modeInBody(p, token);
+}
+// The "in frameset" insertion mode
+//------------------------------------------------------------------
+function startTagInFrameset(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.FRAMESET: {
+            p._insertElement(token, NS.HTML);
+            break;
+        }
+        case TAG_ID.FRAME: {
+            p._appendElement(token, NS.HTML);
+            token.ackSelfClosing = true;
+            break;
+        }
+        case TAG_ID.NOFRAMES: {
+            startTagInHead(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+function endTagInFrameset(p, token) {
+    if (token.tagID === TAG_ID.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
+        p.openElements.pop();
+        if (!p.fragmentContext && p.openElements.currentTagId !== TAG_ID.FRAMESET) {
+            p.insertionMode = InsertionMode.AFTER_FRAMESET;
+        }
+    }
+}
+// The "after frameset" insertion mode
+//------------------------------------------------------------------
+function startTagAfterFrameset(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.NOFRAMES: {
+            startTagInHead(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+function endTagAfterFrameset(p, token) {
+    if (token.tagID === TAG_ID.HTML) {
+        p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET;
+    }
+}
+// The "after after body" insertion mode
+//------------------------------------------------------------------
+function startTagAfterAfterBody(p, token) {
+    if (token.tagID === TAG_ID.HTML) {
+        startTagInBody(p, token);
+    }
+    else {
+        tokenAfterAfterBody(p, token);
+    }
+}
+function tokenAfterAfterBody(p, token) {
+    p.insertionMode = InsertionMode.IN_BODY;
+    modeInBody(p, token);
+}
+// The "after after frameset" insertion mode
+//------------------------------------------------------------------
+function startTagAfterAfterFrameset(p, token) {
+    switch (token.tagID) {
+        case TAG_ID.HTML: {
+            startTagInBody(p, token);
+            break;
+        }
+        case TAG_ID.NOFRAMES: {
+            startTagInHead(p, token);
+            break;
+        }
+        // Do nothing
+    }
+}
+// The rules for parsing tokens in foreign content
+//------------------------------------------------------------------
+function nullCharacterInForeignContent(p, token) {
+    token.chars = REPLACEMENT_CHARACTER;
+    p._insertCharacters(token);
+}
+function characterInForeignContent(p, token) {
+    p._insertCharacters(token);
+    p.framesetOk = false;
+}
+function popUntilHtmlOrIntegrationPoint(p) {
+    while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&
+        !p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) {
+        p.openElements.pop();
+    }
+}
+function startTagInForeignContent(p, token) {
+    if (causesExit(token)) {
+        popUntilHtmlOrIntegrationPoint(p);
+        p._startTagOutsideForeignContent(token);
+    }
+    else {
+        const current = p._getAdjustedCurrentElement();
+        const currentNs = p.treeAdapter.getNamespaceURI(current);
+        if (currentNs === NS.MATHML) {
+            adjustTokenMathMLAttrs(token);
+        }
+        else if (currentNs === NS.SVG) {
+            adjustTokenSVGTagName(token);
+            adjustTokenSVGAttrs(token);
+        }
+        adjustTokenXMLAttrs(token);
+        if (token.selfClosing) {
+            p._appendElement(token, currentNs);
+        }
+        else {
+            p._insertElement(token, currentNs);
+        }
+        token.ackSelfClosing = true;
+    }
+}
+function endTagInForeignContent(p, token) {
+    if (token.tagID === TAG_ID.P || token.tagID === TAG_ID.BR) {
+        popUntilHtmlOrIntegrationPoint(p);
+        p._endTagOutsideForeignContent(token);
+        return;
+    }
+    for (let i = p.openElements.stackTop; i > 0; i--) {
+        const element = p.openElements.items[i];
+        if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
+            p._endTagOutsideForeignContent(token);
+            break;
+        }
+        const tagName = p.treeAdapter.getTagName(element);
+        if (tagName.toLowerCase() === token.tagName) {
+            //NOTE: update the token tag name for `_setEndLocation`.
+            token.tagName = tagName;
+            p.openElements.shortenToLength(i);
+            break;
+        }
+    }
+}
+
+// Shorthands
+/**
+ * Parses an HTML string.
+ *
+ * @param html Input HTML string.
+ * @param options Parsing options.
+ * @returns Document
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * console.log(document.childNodes[1].tagName); //> 'html'
+ *```
+ */
+function parse(html, options) {
+    return Parser.parse(html, options);
+}
+
+export { ERR as ErrorCodes, Parser, Tokenizer, TokenizerMode, defaultTreeAdapter, parse };
diff --git a/node_modules/vite/dist/node/chunks/dep-IQS-Za7F.js b/node_modules/vite/dist/node/chunks/dep-IQS-Za7F.js
new file mode 100644
index 0000000..b471e60
--- /dev/null
+++ b/node_modules/vite/dist/node/chunks/dep-IQS-Za7F.js
@@ -0,0 +1,561 @@
+import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
+import { dirname as __cjs_dirname } from 'node:path';
+import { createRequire as __cjs_createRequire } from 'node:module';
+
+const __filename = __cjs_fileURLToPath(import.meta.url);
+const __dirname = __cjs_dirname(__filename);
+const require = __cjs_createRequire(import.meta.url);
+const __require = require;
+var openParentheses = "(".charCodeAt(0);
+var closeParentheses = ")".charCodeAt(0);
+var singleQuote = "'".charCodeAt(0);
+var doubleQuote = '"'.charCodeAt(0);
+var backslash = "\\".charCodeAt(0);
+var slash = "/".charCodeAt(0);
+var comma = ",".charCodeAt(0);
+var colon = ":".charCodeAt(0);
+var star = "*".charCodeAt(0);
+var uLower = "u".charCodeAt(0);
+var uUpper = "U".charCodeAt(0);
+var plus = "+".charCodeAt(0);
+var isUnicodeRange = /^[a-f0-9?-]+$/i;
+
+var parse$1 = function(input) {
+  var tokens = [];
+  var value = input;
+
+  var next,
+    quote,
+    prev,
+    token,
+    escape,
+    escapePos,
+    whitespacePos,
+    parenthesesOpenPos;
+  var pos = 0;
+  var code = value.charCodeAt(pos);
+  var max = value.length;
+  var stack = [{ nodes: tokens }];
+  var balanced = 0;
+  var parent;
+
+  var name = "";
+  var before = "";
+  var after = "";
+
+  while (pos < max) {
+    // Whitespaces
+    if (code <= 32) {
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = value.slice(pos, next);
+
+      prev = tokens[tokens.length - 1];
+      if (code === closeParentheses && balanced) {
+        after = token;
+      } else if (prev && prev.type === "div") {
+        prev.after = token;
+        prev.sourceEndIndex += token.length;
+      } else if (
+        code === comma ||
+        code === colon ||
+        (code === slash &&
+          value.charCodeAt(next + 1) !== star &&
+          (!parent ||
+            (parent && parent.type === "function" && parent.value !== "calc")))
+      ) {
+        before = token;
+      } else {
+        tokens.push({
+          type: "space",
+          sourceIndex: pos,
+          sourceEndIndex: next,
+          value: token
+        });
+      }
+
+      pos = next;
+
+      // Quotes
+    } else if (code === singleQuote || code === doubleQuote) {
+      next = pos;
+      quote = code === singleQuote ? "'" : '"';
+      token = {
+        type: "string",
+        sourceIndex: pos,
+        quote: quote
+      };
+      do {
+        escape = false;
+        next = value.indexOf(quote, next + 1);
+        if (~next) {
+          escapePos = next;
+          while (value.charCodeAt(escapePos - 1) === backslash) {
+            escapePos -= 1;
+            escape = !escape;
+          }
+        } else {
+          value += quote;
+          next = value.length - 1;
+          token.unclosed = true;
+        }
+      } while (escape);
+      token.value = value.slice(pos + 1, next);
+      token.sourceEndIndex = token.unclosed ? next : next + 1;
+      tokens.push(token);
+      pos = next + 1;
+      code = value.charCodeAt(pos);
+
+      // Comments
+    } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+      next = value.indexOf("*/", pos);
+
+      token = {
+        type: "comment",
+        sourceIndex: pos,
+        sourceEndIndex: next + 2
+      };
+
+      if (next === -1) {
+        token.unclosed = true;
+        next = value.length;
+        token.sourceEndIndex = next;
+      }
+
+      token.value = value.slice(pos + 2, next);
+      tokens.push(token);
+
+      pos = next + 2;
+      code = value.charCodeAt(pos);
+
+      // Operation within calc
+    } else if (
+      (code === slash || code === star) &&
+      parent &&
+      parent.type === "function" &&
+      parent.value === "calc"
+    ) {
+      token = value[pos];
+      tokens.push({
+        type: "word",
+        sourceIndex: pos - before.length,
+        sourceEndIndex: pos + token.length,
+        value: token
+      });
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      // Dividers
+    } else if (code === slash || code === comma || code === colon) {
+      token = value[pos];
+
+      tokens.push({
+        type: "div",
+        sourceIndex: pos - before.length,
+        sourceEndIndex: pos + token.length,
+        value: token,
+        before: before,
+        after: ""
+      });
+      before = "";
+
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      // Open parentheses
+    } else if (openParentheses === code) {
+      // Whitespaces after open parentheses
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      parenthesesOpenPos = pos;
+      token = {
+        type: "function",
+        sourceIndex: pos - name.length,
+        value: name,
+        before: value.slice(parenthesesOpenPos + 1, next)
+      };
+      pos = next;
+
+      if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+        next -= 1;
+        do {
+          escape = false;
+          next = value.indexOf(")", next + 1);
+          if (~next) {
+            escapePos = next;
+            while (value.charCodeAt(escapePos - 1) === backslash) {
+              escapePos -= 1;
+              escape = !escape;
+            }
+          } else {
+            value += ")";
+            next = value.length - 1;
+            token.unclosed = true;
+          }
+        } while (escape);
+        // Whitespaces before closed
+        whitespacePos = next;
+        do {
+          whitespacePos -= 1;
+          code = value.charCodeAt(whitespacePos);
+        } while (code <= 32);
+        if (parenthesesOpenPos < whitespacePos) {
+          if (pos !== whitespacePos + 1) {
+            token.nodes = [
+              {
+                type: "word",
+                sourceIndex: pos,
+                sourceEndIndex: whitespacePos + 1,
+                value: value.slice(pos, whitespacePos + 1)
+              }
+            ];
+          } else {
+            token.nodes = [];
+          }
+          if (token.unclosed && whitespacePos + 1 !== next) {
+            token.after = "";
+            token.nodes.push({
+              type: "space",
+              sourceIndex: whitespacePos + 1,
+              sourceEndIndex: next,
+              value: value.slice(whitespacePos + 1, next)
+            });
+          } else {
+            token.after = value.slice(whitespacePos + 1, next);
+            token.sourceEndIndex = next;
+          }
+        } else {
+          token.after = "";
+          token.nodes = [];
+        }
+        pos = next + 1;
+        token.sourceEndIndex = token.unclosed ? next : pos;
+        code = value.charCodeAt(pos);
+        tokens.push(token);
+      } else {
+        balanced += 1;
+        token.after = "";
+        token.sourceEndIndex = pos + 1;
+        tokens.push(token);
+        stack.push(token);
+        tokens = token.nodes = [];
+        parent = token;
+      }
+      name = "";
+
+      // Close parentheses
+    } else if (closeParentheses === code && balanced) {
+      pos += 1;
+      code = value.charCodeAt(pos);
+
+      parent.after = after;
+      parent.sourceEndIndex += after.length;
+      after = "";
+      balanced -= 1;
+      stack[stack.length - 1].sourceEndIndex = pos;
+      stack.pop();
+      parent = stack[balanced];
+      tokens = parent.nodes;
+
+      // Words
+    } else {
+      next = pos;
+      do {
+        if (code === backslash) {
+          next += 1;
+        }
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (
+        next < max &&
+        !(
+          code <= 32 ||
+          code === singleQuote ||
+          code === doubleQuote ||
+          code === comma ||
+          code === colon ||
+          code === slash ||
+          code === openParentheses ||
+          (code === star &&
+            parent &&
+            parent.type === "function" &&
+            parent.value === "calc") ||
+          (code === slash &&
+            parent.type === "function" &&
+            parent.value === "calc") ||
+          (code === closeParentheses && balanced)
+        )
+      );
+      token = value.slice(pos, next);
+
+      if (openParentheses === code) {
+        name = token;
+      } else if (
+        (uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) &&
+        plus === token.charCodeAt(1) &&
+        isUnicodeRange.test(token.slice(2))
+      ) {
+        tokens.push({
+          type: "unicode-range",
+          sourceIndex: pos,
+          sourceEndIndex: next,
+          value: token
+        });
+      } else {
+        tokens.push({
+          type: "word",
+          sourceIndex: pos,
+          sourceEndIndex: next,
+          value: token
+        });
+      }
+
+      pos = next;
+    }
+  }
+
+  for (pos = stack.length - 1; pos; pos -= 1) {
+    stack[pos].unclosed = true;
+    stack[pos].sourceEndIndex = value.length;
+  }
+
+  return stack[0].nodes;
+};
+
+var walk$1 = function walk(nodes, cb, bubble) {
+  var i, max, node, result;
+
+  for (i = 0, max = nodes.length; i < max; i += 1) {
+    node = nodes[i];
+    if (!bubble) {
+      result = cb(node, i, nodes);
+    }
+
+    if (
+      result !== false &&
+      node.type === "function" &&
+      Array.isArray(node.nodes)
+    ) {
+      walk(node.nodes, cb, bubble);
+    }
+
+    if (bubble) {
+      cb(node, i, nodes);
+    }
+  }
+};
+
+function stringifyNode(node, custom) {
+  var type = node.type;
+  var value = node.value;
+  var buf;
+  var customResult;
+
+  if (custom && (customResult = custom(node)) !== undefined) {
+    return customResult;
+  } else if (type === "word" || type === "space") {
+    return value;
+  } else if (type === "string") {
+    buf = node.quote || "";
+    return buf + value + (node.unclosed ? "" : buf);
+  } else if (type === "comment") {
+    return "/*" + value + (node.unclosed ? "" : "*/");
+  } else if (type === "div") {
+    return (node.before || "") + value + (node.after || "");
+  } else if (Array.isArray(node.nodes)) {
+    buf = stringify$1(node.nodes, custom);
+    if (type !== "function") {
+      return buf;
+    }
+    return (
+      value +
+      "(" +
+      (node.before || "") +
+      buf +
+      (node.after || "") +
+      (node.unclosed ? "" : ")")
+    );
+  }
+  return value;
+}
+
+function stringify$1(nodes, custom) {
+  var result, i;
+
+  if (Array.isArray(nodes)) {
+    result = "";
+    for (i = nodes.length - 1; ~i; i -= 1) {
+      result = stringifyNode(nodes[i], custom) + result;
+    }
+    return result;
+  }
+  return stringifyNode(nodes, custom);
+}
+
+var stringify_1 = stringify$1;
+
+var unit;
+var hasRequiredUnit;
+
+function requireUnit () {
+	if (hasRequiredUnit) return unit;
+	hasRequiredUnit = 1;
+	var minus = "-".charCodeAt(0);
+	var plus = "+".charCodeAt(0);
+	var dot = ".".charCodeAt(0);
+	var exp = "e".charCodeAt(0);
+	var EXP = "E".charCodeAt(0);
+
+	// Check if three code points would start a number
+	// https://www.w3.org/TR/css-syntax-3/#starts-with-a-number
+	function likeNumber(value) {
+	  var code = value.charCodeAt(0);
+	  var nextCode;
+
+	  if (code === plus || code === minus) {
+	    nextCode = value.charCodeAt(1);
+
+	    if (nextCode >= 48 && nextCode <= 57) {
+	      return true;
+	    }
+
+	    var nextNextCode = value.charCodeAt(2);
+
+	    if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  if (code === dot) {
+	    nextCode = value.charCodeAt(1);
+
+	    if (nextCode >= 48 && nextCode <= 57) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  if (code >= 48 && code <= 57) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	// Consume a number
+	// https://www.w3.org/TR/css-syntax-3/#consume-number
+	unit = function(value) {
+	  var pos = 0;
+	  var length = value.length;
+	  var code;
+	  var nextCode;
+	  var nextNextCode;
+
+	  if (length === 0 || !likeNumber(value)) {
+	    return false;
+	  }
+
+	  code = value.charCodeAt(pos);
+
+	  if (code === plus || code === minus) {
+	    pos++;
+	  }
+
+	  while (pos < length) {
+	    code = value.charCodeAt(pos);
+
+	    if (code < 48 || code > 57) {
+	      break;
+	    }
+
+	    pos += 1;
+	  }
+
+	  code = value.charCodeAt(pos);
+	  nextCode = value.charCodeAt(pos + 1);
+
+	  if (code === dot && nextCode >= 48 && nextCode <= 57) {
+	    pos += 2;
+
+	    while (pos < length) {
+	      code = value.charCodeAt(pos);
+
+	      if (code < 48 || code > 57) {
+	        break;
+	      }
+
+	      pos += 1;
+	    }
+	  }
+
+	  code = value.charCodeAt(pos);
+	  nextCode = value.charCodeAt(pos + 1);
+	  nextNextCode = value.charCodeAt(pos + 2);
+
+	  if (
+	    (code === exp || code === EXP) &&
+	    ((nextCode >= 48 && nextCode <= 57) ||
+	      ((nextCode === plus || nextCode === minus) &&
+	        nextNextCode >= 48 &&
+	        nextNextCode <= 57))
+	  ) {
+	    pos += nextCode === plus || nextCode === minus ? 3 : 2;
+
+	    while (pos < length) {
+	      code = value.charCodeAt(pos);
+
+	      if (code < 48 || code > 57) {
+	        break;
+	      }
+
+	      pos += 1;
+	    }
+	  }
+
+	  return {
+	    number: value.slice(0, pos),
+	    unit: value.slice(pos)
+	  };
+	};
+	return unit;
+}
+
+var parse = parse$1;
+var walk = walk$1;
+var stringify = stringify_1;
+
+function ValueParser(value) {
+  if (this instanceof ValueParser) {
+    this.nodes = parse(value);
+    return this;
+  }
+  return new ValueParser(value);
+}
+
+ValueParser.prototype.toString = function() {
+  return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+};
+
+ValueParser.prototype.walk = function(cb, bubble) {
+  walk(this.nodes, cb, bubble);
+  return this;
+};
+
+ValueParser.unit = requireUnit();
+
+ValueParser.walk = walk;
+
+ValueParser.stringify = stringify;
+
+var lib = ValueParser;
+
+export { lib as l };
diff --git a/node_modules/vite/dist/node/cli.js b/node_modules/vite/dist/node/cli.js
new file mode 100644
index 0000000..656b50c
--- /dev/null
+++ b/node_modules/vite/dist/node/cli.js
@@ -0,0 +1,916 @@
+import path from 'node:path';
+import fs__default from 'node:fs';
+import { performance } from 'node:perf_hooks';
+import { EventEmitter } from 'events';
+import { A as colors, v as createLogger, r as resolveConfig } from './chunks/dep-CDnG8rE7.js';
+import { VERSION } from './constants.js';
+import 'node:fs/promises';
+import 'node:url';
+import 'node:util';
+import 'node:module';
+import 'tty';
+import 'path';
+import 'esbuild';
+import 'fs';
+import 'node:events';
+import 'node:stream';
+import 'node:string_decoder';
+import 'node:child_process';
+import 'node:http';
+import 'node:https';
+import 'util';
+import 'net';
+import 'url';
+import 'http';
+import 'stream';
+import 'os';
+import 'child_process';
+import 'node:os';
+import 'node:crypto';
+import 'node:dns';
+import 'crypto';
+import 'module';
+import 'node:assert';
+import 'node:v8';
+import 'node:worker_threads';
+import 'node:buffer';
+import 'rollup/parseAst';
+import 'querystring';
+import 'node:readline';
+import 'zlib';
+import 'buffer';
+import 'https';
+import 'tls';
+import 'assert';
+import 'node:zlib';
+
+function toArr(any) {
+	return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+
+function toVal(out, key, val, opts) {
+	var x, old=out[key], nxt=(
+		!!~opts.string.indexOf(key) ? (val == null || val === true ? '' : String(val))
+		: typeof val === 'boolean' ? val
+		: !!~opts.boolean.indexOf(key) ? (val === 'false' ? false : val === 'true' || (out._.push((x = +val,x * 0 === 0) ? x : val),!!val))
+		: (x = +val,x * 0 === 0) ? x : val
+	);
+	out[key] = old == null ? nxt : (Array.isArray(old) ? old.concat(nxt) : [old, nxt]);
+}
+
+function mri2 (args, opts) {
+	args = args || [];
+	opts = opts || {};
+
+	var k, arr, arg, name, val, out={ _:[] };
+	var i=0, j=0, idx=0, len=args.length;
+
+	const alibi = opts.alias !== void 0;
+	const strict = opts.unknown !== void 0;
+	const defaults = opts.default !== void 0;
+
+	opts.alias = opts.alias || {};
+	opts.string = toArr(opts.string);
+	opts.boolean = toArr(opts.boolean);
+
+	if (alibi) {
+		for (k in opts.alias) {
+			arr = opts.alias[k] = toArr(opts.alias[k]);
+			for (i=0; i < arr.length; i++) {
+				(opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+			}
+		}
+	}
+
+	for (i=opts.boolean.length; i-- > 0;) {
+		arr = opts.alias[opts.boolean[i]] || [];
+		for (j=arr.length; j-- > 0;) opts.boolean.push(arr[j]);
+	}
+
+	for (i=opts.string.length; i-- > 0;) {
+		arr = opts.alias[opts.string[i]] || [];
+		for (j=arr.length; j-- > 0;) opts.string.push(arr[j]);
+	}
+
+	if (defaults) {
+		for (k in opts.default) {
+			name = typeof opts.default[k];
+			arr = opts.alias[k] = opts.alias[k] || [];
+			if (opts[name] !== void 0) {
+				opts[name].push(k);
+				for (i=0; i < arr.length; i++) {
+					opts[name].push(arr[i]);
+				}
+			}
+		}
+	}
+
+	const keys = strict ? Object.keys(opts.alias) : [];
+
+	for (i=0; i < len; i++) {
+		arg = args[i];
+
+		if (arg === '--') {
+			out._ = out._.concat(args.slice(++i));
+			break;
+		}
+
+		for (j=0; j < arg.length; j++) {
+			if (arg.charCodeAt(j) !== 45) break; // "-"
+		}
+
+		if (j === 0) {
+			out._.push(arg);
+		} else if (arg.substring(j, j + 3) === 'no-') {
+			name = arg.substring(j + 3);
+			if (strict && !~keys.indexOf(name)) {
+				return opts.unknown(arg);
+			}
+			out[name] = false;
+		} else {
+			for (idx=j+1; idx < arg.length; idx++) {
+				if (arg.charCodeAt(idx) === 61) break; // "="
+			}
+
+			name = arg.substring(j, idx);
+			val = arg.substring(++idx) || (i+1 === len || (''+args[i+1]).charCodeAt(0) === 45 || args[++i]);
+			arr = (j === 2 ? [name] : name);
+
+			for (idx=0; idx < arr.length; idx++) {
+				name = arr[idx];
+				if (strict && !~keys.indexOf(name)) return opts.unknown('-'.repeat(j) + name);
+				toVal(out, name, (idx + 1 < arr.length) || val, opts);
+			}
+		}
+	}
+
+	if (defaults) {
+		for (k in opts.default) {
+			if (out[k] === void 0) {
+				out[k] = opts.default[k];
+			}
+		}
+	}
+
+	if (alibi) {
+		for (k in out) {
+			arr = opts.alias[k] || [];
+			while (arr.length > 0) {
+				out[arr.shift()] = out[k];
+			}
+		}
+	}
+
+	return out;
+}
+
+const removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+const findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+const getMriOptions = (options) => {
+  const result = {alias: {}, boolean: []};
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+const findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+const padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+const camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+const setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (; i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+const setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+const getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+const camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+class CACError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+}
+
+class Option {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+}
+
+const processArgs = process.argv;
+const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+
+class Command {
+  constructor(rawName, description, config = {}, cli) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const {name, commands} = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const {name} = this.cli;
+    const {versionNumber} = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const {options, globalCommand} = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const {options: parsedOptions, globalCommand} = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+}
+class GlobalCommand extends Command {
+  constructor(cli) {
+    super("@@global@@", "", {}, cli);
+  }
+}
+
+var __assign = Object.assign;
+class CAC extends EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({args, options}, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = void 0;
+    this.matchedCommandName = void 0;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = {args: this.args, options: this.options};
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, {_: []});
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== void 0) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === void 0) {
+          transforms[cliOption.name] = Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const {args, options, matchedCommand: command} = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+}
+
+const cac = (name = "") => new CAC(name);
+
+const cli = cac("vite");
+let profileSession = global.__vite_profile_session;
+let profileCount = 0;
+const stopProfiler = (log) => {
+  if (!profileSession) return;
+  return new Promise((res, rej) => {
+    profileSession.post("Profiler.stop", (err, { profile }) => {
+      if (!err) {
+        const outPath = path.resolve(
+          `./vite-profile-${profileCount++}.cpuprofile`
+        );
+        fs__default.writeFileSync(outPath, JSON.stringify(profile));
+        log(
+          colors.yellow(
+            `CPU profile written to ${colors.white(colors.dim(outPath))}`
+          )
+        );
+        profileSession = void 0;
+        res();
+      } else {
+        rej(err);
+      }
+    });
+  });
+};
+const filterDuplicateOptions = (options) => {
+  for (const [key, value] of Object.entries(options)) {
+    if (Array.isArray(value)) {
+      options[key] = value[value.length - 1];
+    }
+  }
+};
+function cleanOptions(options) {
+  const ret = { ...options };
+  delete ret["--"];
+  delete ret.c;
+  delete ret.config;
+  delete ret.base;
+  delete ret.l;
+  delete ret.logLevel;
+  delete ret.clearScreen;
+  delete ret.d;
+  delete ret.debug;
+  delete ret.f;
+  delete ret.filter;
+  delete ret.m;
+  delete ret.mode;
+  if ("sourcemap" in ret) {
+    const sourcemap = ret.sourcemap;
+    ret.sourcemap = sourcemap === "true" ? true : sourcemap === "false" ? false : ret.sourcemap;
+  }
+  return ret;
+}
+const convertHost = (v) => {
+  if (typeof v === "number") {
+    return String(v);
+  }
+  return v;
+};
+const convertBase = (v) => {
+  if (v === 0) {
+    return "";
+  }
+  return v;
+};
+cli.option("-c, --config <file>", `[string] use specified config file`).option("--base <path>", `[string] public base path (default: /)`, {
+  type: [convertBase]
+}).option("-l, --logLevel <level>", `[string] info | warn | error | silent`).option("--clearScreen", `[boolean] allow/disable clear screen when logging`).option("-d, --debug [feat]", `[string | boolean] show debug logs`).option("-f, --filter <filter>", `[string] filter debug logs`).option("-m, --mode <mode>", `[string] set env mode`);
+cli.command("[root]", "start dev server").alias("serve").alias("dev").option("--host [host]", `[string] specify hostname`, { type: [convertHost] }).option("--port <port>", `[number] specify port`).option("--open [path]", `[boolean | string] open browser on startup`).option("--cors", `[boolean] enable CORS`).option("--strictPort", `[boolean] exit if specified port is already in use`).option(
+  "--force",
+  `[boolean] force the optimizer to ignore the cache and re-bundle`
+).action(async (root, options) => {
+  filterDuplicateOptions(options);
+  const { createServer } = await import('./chunks/dep-CDnG8rE7.js').then(function (n) { return n.E; });
+  try {
+    const server = await createServer({
+      root,
+      base: options.base,
+      mode: options.mode,
+      configFile: options.config,
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      optimizeDeps: { force: options.force },
+      server: cleanOptions(options)
+    });
+    if (!server.httpServer) {
+      throw new Error("HTTP server not available");
+    }
+    await server.listen();
+    const info = server.config.logger.info;
+    const viteStartTime = global.__vite_start_time ?? false;
+    const startupDurationString = viteStartTime ? colors.dim(
+      `ready in ${colors.reset(
+        colors.bold(Math.ceil(performance.now() - viteStartTime))
+      )} ms`
+    ) : "";
+    const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
+    info(
+      `
+  ${colors.green(
+        `${colors.bold("VITE")} v${VERSION}`
+      )}  ${startupDurationString}
+`,
+      {
+        clear: !hasExistingLogs
+      }
+    );
+    server.printUrls();
+    const customShortcuts = [];
+    if (profileSession) {
+      customShortcuts.push({
+        key: "p",
+        description: "start/stop the profiler",
+        async action(server2) {
+          if (profileSession) {
+            await stopProfiler(server2.config.logger.info);
+          } else {
+            const inspector = await import('node:inspector').then(
+              (r) => r.default
+            );
+            await new Promise((res) => {
+              profileSession = new inspector.Session();
+              profileSession.connect();
+              profileSession.post("Profiler.enable", () => {
+                profileSession.post("Profiler.start", () => {
+                  server2.config.logger.info("Profiler started");
+                  res();
+                });
+              });
+            });
+          }
+        }
+      });
+    }
+    server.bindCLIShortcuts({ print: true, customShortcuts });
+  } catch (e) {
+    const logger = createLogger(options.logLevel);
+    logger.error(colors.red(`error when starting dev server:
+${e.stack}`), {
+      error: e
+    });
+    stopProfiler(logger.info);
+    process.exit(1);
+  }
+});
+cli.command("build [root]", "build for production").option("--target <target>", `[string] transpile target (default: 'modules')`).option("--outDir <dir>", `[string] output directory (default: dist)`).option(
+  "--assetsDir <dir>",
+  `[string] directory under outDir to place assets in (default: assets)`
+).option(
+  "--assetsInlineLimit <number>",
+  `[number] static asset base64 inline threshold in bytes (default: 4096)`
+).option(
+  "--ssr [entry]",
+  `[string] build specified entry for server-side rendering`
+).option(
+  "--sourcemap [output]",
+  `[boolean | "inline" | "hidden"] output source maps for build (default: false)`
+).option(
+  "--minify [minifier]",
+  `[boolean | "terser" | "esbuild"] enable/disable minification, or specify minifier to use (default: esbuild)`
+).option("--manifest [name]", `[boolean | string] emit build manifest json`).option("--ssrManifest [name]", `[boolean | string] emit ssr manifest json`).option(
+  "--emptyOutDir",
+  `[boolean] force empty outDir when it's outside of root`
+).option("-w, --watch", `[boolean] rebuilds when modules have changed on disk`).action(async (root, options) => {
+  filterDuplicateOptions(options);
+  const { build } = await import('./chunks/dep-CDnG8rE7.js').then(function (n) { return n.F; });
+  const buildOptions = cleanOptions(options);
+  try {
+    await build({
+      root,
+      base: options.base,
+      mode: options.mode,
+      configFile: options.config,
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      build: buildOptions
+    });
+  } catch (e) {
+    createLogger(options.logLevel).error(
+      colors.red(`error during build:
+${e.stack}`),
+      { error: e }
+    );
+    process.exit(1);
+  } finally {
+    stopProfiler((message) => createLogger(options.logLevel).info(message));
+  }
+});
+cli.command("optimize [root]", "pre-bundle dependencies").option(
+  "--force",
+  `[boolean] force the optimizer to ignore the cache and re-bundle`
+).action(
+  async (root, options) => {
+    filterDuplicateOptions(options);
+    const { optimizeDeps } = await import('./chunks/dep-CDnG8rE7.js').then(function (n) { return n.D; });
+    try {
+      const config = await resolveConfig(
+        {
+          root,
+          base: options.base,
+          configFile: options.config,
+          logLevel: options.logLevel,
+          mode: options.mode
+        },
+        "serve"
+      );
+      await optimizeDeps(config, options.force, true);
+    } catch (e) {
+      createLogger(options.logLevel).error(
+        colors.red(`error when optimizing deps:
+${e.stack}`),
+        { error: e }
+      );
+      process.exit(1);
+    }
+  }
+);
+cli.command("preview [root]", "locally preview production build").option("--host [host]", `[string] specify hostname`, { type: [convertHost] }).option("--port <port>", `[number] specify port`).option("--strictPort", `[boolean] exit if specified port is already in use`).option("--open [path]", `[boolean | string] open browser on startup`).option("--outDir <dir>", `[string] output directory (default: dist)`).action(
+  async (root, options) => {
+    filterDuplicateOptions(options);
+    const { preview } = await import('./chunks/dep-CDnG8rE7.js').then(function (n) { return n.G; });
+    try {
+      const server = await preview({
+        root,
+        base: options.base,
+        configFile: options.config,
+        logLevel: options.logLevel,
+        mode: options.mode,
+        build: {
+          outDir: options.outDir
+        },
+        preview: {
+          port: options.port,
+          strictPort: options.strictPort,
+          host: options.host,
+          open: options.open
+        }
+      });
+      server.printUrls();
+      server.bindCLIShortcuts({ print: true });
+    } catch (e) {
+      createLogger(options.logLevel).error(
+        colors.red(`error when starting preview server:
+${e.stack}`),
+        { error: e }
+      );
+      process.exit(1);
+    } finally {
+      stopProfiler((message) => createLogger(options.logLevel).info(message));
+    }
+  }
+);
+cli.help();
+cli.version(VERSION);
+cli.parse();
+
+export { stopProfiler };
diff --git a/node_modules/vite/dist/node/constants.js b/node_modules/vite/dist/node/constants.js
new file mode 100644
index 0000000..8fc478d
--- /dev/null
+++ b/node_modules/vite/dist/node/constants.js
@@ -0,0 +1,112 @@
+import path, { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+
+const { version } = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url)).toString()
+);
+const VERSION = version;
+const DEFAULT_MAIN_FIELDS = [
+  "browser",
+  "module",
+  "jsnext:main",
+  // moment still uses this...
+  "jsnext"
+];
+const ESBUILD_MODULES_TARGET = [
+  "es2020",
+  // support import.meta.url
+  "edge88",
+  "firefox78",
+  "chrome87",
+  "safari14"
+];
+const DEFAULT_EXTENSIONS = [
+  ".mjs",
+  ".js",
+  ".mts",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".json"
+];
+const DEFAULT_CONFIG_FILES = [
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.ts",
+  "vite.config.cjs",
+  "vite.config.mts",
+  "vite.config.cts"
+];
+const JS_TYPES_RE = /\.(?:j|t)sx?$|\.mjs$/;
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
+const SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+const FS_PREFIX = `/@fs/`;
+const CLIENT_PUBLIC_PATH = `/@vite/client`;
+const ENV_PUBLIC_PATH = `/@vite/env`;
+const VITE_PACKAGE_DIR = resolve(
+  // import.meta.url is `dist/node/constants.js` after bundle
+  fileURLToPath(import.meta.url),
+  "../../.."
+);
+const CLIENT_ENTRY = resolve(VITE_PACKAGE_DIR, "dist/client/client.mjs");
+const ENV_ENTRY = resolve(VITE_PACKAGE_DIR, "dist/client/env.mjs");
+const CLIENT_DIR = path.dirname(CLIENT_ENTRY);
+const KNOWN_ASSET_TYPES = [
+  // images
+  "apng",
+  "bmp",
+  "png",
+  "jpe?g",
+  "jfif",
+  "pjpeg",
+  "pjp",
+  "gif",
+  "svg",
+  "ico",
+  "webp",
+  "avif",
+  // media
+  "mp4",
+  "webm",
+  "ogg",
+  "mp3",
+  "wav",
+  "flac",
+  "aac",
+  "opus",
+  "mov",
+  "m4a",
+  "vtt",
+  // fonts
+  "woff2?",
+  "eot",
+  "ttf",
+  "otf",
+  // other
+  "webmanifest",
+  "pdf",
+  "txt"
+];
+const DEFAULT_ASSETS_RE = new RegExp(
+  `\\.(` + KNOWN_ASSET_TYPES.join("|") + `)(\\?.*)?$`
+);
+const DEP_VERSION_RE = /[?&](v=[\w.-]+)\b/;
+const loopbackHosts = /* @__PURE__ */ new Set([
+  "localhost",
+  "127.0.0.1",
+  "::1",
+  "0000:0000:0000:0000:0000:0000:0000:0001"
+]);
+const wildcardHosts = /* @__PURE__ */ new Set([
+  "0.0.0.0",
+  "::",
+  "0000:0000:0000:0000:0000:0000:0000:0000"
+]);
+const DEFAULT_DEV_PORT = 5173;
+const DEFAULT_PREVIEW_PORT = 4173;
+const DEFAULT_ASSETS_INLINE_LIMIT = 4096;
+const METADATA_FILENAME = "_metadata.json";
+
+export { CLIENT_DIR, CLIENT_ENTRY, CLIENT_PUBLIC_PATH, CSS_LANGS_RE, DEFAULT_ASSETS_INLINE_LIMIT, DEFAULT_ASSETS_RE, DEFAULT_CONFIG_FILES, DEFAULT_DEV_PORT, DEFAULT_EXTENSIONS, DEFAULT_MAIN_FIELDS, DEFAULT_PREVIEW_PORT, DEP_VERSION_RE, ENV_ENTRY, ENV_PUBLIC_PATH, ESBUILD_MODULES_TARGET, FS_PREFIX, JS_TYPES_RE, KNOWN_ASSET_TYPES, METADATA_FILENAME, OPTIMIZABLE_ENTRY_RE, SPECIAL_QUERY_RE, VERSION, VITE_PACKAGE_DIR, loopbackHosts, wildcardHosts };
diff --git a/node_modules/vite/dist/node/index.d.ts b/node_modules/vite/dist/node/index.d.ts
new file mode 100644
index 0000000..8592398
--- /dev/null
+++ b/node_modules/vite/dist/node/index.d.ts
@@ -0,0 +1,3578 @@
+/// <reference types="node" />
+import { PluginHooks, RollupError, SourceMap, ModuleInfo, PartialResolvedId, MinimalPluginContext, InputOptions, CustomPluginOptions, LoadResult, SourceDescription, RollupOptions, WatcherOptions, InputOption, ModuleFormat, RollupOutput, RollupWatcher, SourceMapInput, ExistingRawSourceMap, OutputBundle, OutputChunk, ObjectHook, PluginContext, ResolveIdResult, TransformPluginContext, GetManualChunk } from 'rollup';
+import * as rollup from 'rollup';
+export { rollup as Rollup };
+export { parseAst, parseAstAsync } from 'rollup/parseAst';
+import * as http from 'node:http';
+import { OutgoingHttpHeaders, ClientRequestArgs, IncomingMessage, ClientRequest, Agent, Server, ServerResponse } from 'node:http';
+import { Http2SecureServer } from 'node:http2';
+import * as fs from 'node:fs';
+import * as events from 'node:events';
+import { EventEmitter } from 'node:events';
+import { ServerOptions as HttpsServerOptions, Server as HttpsServer } from 'node:https';
+import * as net from 'node:net';
+import * as url from 'node:url';
+import { URL } from 'node:url';
+import * as stream from 'node:stream';
+import { Duplex, DuplexOptions } from 'node:stream';
+import { F as FetchResult, H as HMRLogger } from './types.d-aGj9QkWt.js';
+export { a as FetchFunction } from './types.d-aGj9QkWt.js';
+import { SecureContextOptions } from 'node:tls';
+import { ZlibOptions } from 'node:zlib';
+import { HMRPayload, CustomPayload } from '../../types/hmrPayload.js';
+export { ConnectedPayload, CustomPayload, ErrorPayload, FullReloadPayload, HMRPayload, PrunePayload, Update, UpdatePayload } from '../../types/hmrPayload.js';
+import { InferCustomEventPayload } from '../../types/customEvent.js';
+export { CustomEventMap, InferCustomEventPayload, InvalidatePayload } from '../../types/customEvent.js';
+import { TransformOptions as esbuild_TransformOptions, TransformResult as esbuild_TransformResult, BuildOptions as esbuild_BuildOptions } from 'esbuild';
+export { TransformOptions as EsbuildTransformOptions, version as esbuildVersion } from 'esbuild';
+import * as PostCSS from 'postcss';
+import { ViteRuntimeOptions, ViteModuleRunner, ViteRuntime, HMRRuntimeConnection } from 'vite/runtime';
+export { GeneralImportGlobOptions, ImportGlobFunction, ImportGlobOptions, KnownAsTypeMap } from '../../types/importGlob.js';
+export { ChunkMetadata } from '../../types/metadata.js';
+import '../../types/hot.js';
+
+interface Alias {
+  find: string | RegExp
+  replacement: string
+  /**
+   * Instructs the plugin to use an alternative resolving algorithm,
+   * rather than the Rollup's resolver.
+   * @default null
+   */
+  customResolver?: ResolverFunction | ResolverObject | null
+}
+
+type MapToFunction<T> = T extends Function ? T : never
+
+type ResolverFunction = MapToFunction<PluginHooks['resolveId']>
+
+interface ResolverObject {
+  buildStart?: PluginHooks['buildStart']
+  resolveId: ResolverFunction
+}
+
+/**
+ * Specifies an `Object`, or an `Array` of `Object`,
+ * which defines aliases used to replace values in `import` or `require` statements.
+ * With either format, the order of the entries is important,
+ * in that the first defined rules are applied first.
+ *
+ * This is passed to \@rollup/plugin-alias as the "entries" field
+ * https://github.com/rollup/plugins/tree/master/packages/alias#entries
+ */
+type AliasOptions = readonly Alias[] | { [find: string]: string }
+
+type AnymatchFn = (testString: string) => boolean
+type AnymatchPattern = string | RegExp | AnymatchFn
+type AnymatchMatcher = AnymatchPattern | AnymatchPattern[]
+
+// Inlined to avoid extra dependency (chokidar is bundled in the published build)
+
+declare class FSWatcher extends EventEmitter implements fs.FSWatcher {
+  options: WatchOptions
+
+  /**
+   * Constructs a new FSWatcher instance with optional WatchOptions parameter.
+   */
+  constructor(options?: WatchOptions)
+
+  /**
+   * When called, requests that the Node.js event loop not exit so long as the fs.FSWatcher is active.
+   * Calling watcher.ref() multiple times will have no effect.
+   */
+  ref(): this
+
+  /**
+   * When called, the active fs.FSWatcher object will not require the Node.js event loop to remain active.
+   * If there is no other activity keeping the event loop running, the process may exit before the fs.FSWatcher object's callback is invoked.
+   * Calling watcher.unref() multiple times will have no effect.
+   */
+  unref(): this
+
+  /**
+   * Add files, directories, or glob patterns for tracking. Takes an array of strings or just one
+   * string.
+   */
+  add(paths: string | ReadonlyArray<string>): this
+
+  /**
+   * Stop watching files, directories, or glob patterns. Takes an array of strings or just one
+   * string.
+   */
+  unwatch(paths: string | ReadonlyArray<string>): this
+
+  /**
+   * Returns an object representing all the paths on the file system being watched by this
+   * `FSWatcher` instance. The object's keys are all the directories (using absolute paths unless
+   * the `cwd` option was used), and the values are arrays of the names of the items contained in
+   * each directory.
+   */
+  getWatched(): {
+    [directory: string]: string[]
+  }
+
+  /**
+   * Removes all listeners from watched files.
+   */
+  close(): Promise<void>
+
+  on(
+    event: 'add' | 'addDir' | 'change',
+    listener: (path: string, stats?: fs.Stats) => void,
+  ): this
+
+  on(
+    event: 'all',
+    listener: (
+      eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
+      path: string,
+      stats?: fs.Stats,
+    ) => void,
+  ): this
+
+  /**
+   * Error occurred
+   */
+  on(event: 'error', listener: (error: Error) => void): this
+
+  /**
+   * Exposes the native Node `fs.FSWatcher events`
+   */
+  on(
+    event: 'raw',
+    listener: (eventName: string, path: string, details: any) => void,
+  ): this
+
+  /**
+   * Fires when the initial scan is complete
+   */
+  on(event: 'ready', listener: () => void): this
+
+  on(event: 'unlink' | 'unlinkDir', listener: (path: string) => void): this
+
+  on(event: string, listener: (...args: any[]) => void): this
+}
+
+interface WatchOptions {
+  /**
+   * Indicates whether the process should continue to run as long as files are being watched. If
+   * set to `false` when using `fsevents` to watch, no more events will be emitted after `ready`,
+   * even if the process continues to run.
+   */
+  persistent?: boolean
+
+  /**
+   * ([anymatch](https://github.com/micromatch/anymatch)-compatible definition) Defines files/paths to
+   * be ignored. The whole relative or absolute path is tested, not just filename. If a function
+   * with two arguments is provided, it gets called twice per path - once with a single argument
+   * (the path), second time with two arguments (the path and the
+   * [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object of that path).
+   */
+  ignored?: AnymatchMatcher
+
+  /**
+   * If set to `false` then `add`/`addDir` events are also emitted for matching paths while
+   * instantiating the watching as chokidar discovers these file paths (before the `ready` event).
+   */
+  ignoreInitial?: boolean
+
+  /**
+   * When `false`, only the symlinks themselves will be watched for changes instead of following
+   * the link references and bubbling events through the link's path.
+   */
+  followSymlinks?: boolean
+
+  /**
+   * The base directory from which watch `paths` are to be derived. Paths emitted with events will
+   * be relative to this.
+   */
+  cwd?: string
+
+  /**
+   * If set to true then the strings passed to .watch() and .add() are treated as literal path
+   * names, even if they look like globs.
+   *
+   * @default false
+   */
+  disableGlobbing?: boolean
+
+  /**
+   * Whether to use fs.watchFile (backed by polling), or fs.watch. If polling leads to high CPU
+   * utilization, consider setting this to `false`. It is typically necessary to **set this to
+   * `true` to successfully watch files over a network**, and it may be necessary to successfully
+   * watch files in other non-standard situations. Setting to `true` explicitly on OS X overrides
+   * the `useFsEvents` default.
+   */
+  usePolling?: boolean
+
+  /**
+   * Whether to use the `fsevents` watching interface if available. When set to `true` explicitly
+   * and `fsevents` is available this supersedes the `usePolling` setting. When set to `false` on
+   * OS X, `usePolling: true` becomes the default.
+   */
+  useFsEvents?: boolean
+
+  /**
+   * If relying upon the [`fs.Stats`](https://nodejs.org/api/fs.html#fs_class_fs_stats) object that
+   * may get passed with `add`, `addDir`, and `change` events, set this to `true` to ensure it is
+   * provided even in cases where it wasn't already available from the underlying watch events.
+   */
+  alwaysStat?: boolean
+
+  /**
+   * If set, limits how many levels of subdirectories will be traversed.
+   */
+  depth?: number
+
+  /**
+   * Interval of file system polling.
+   */
+  interval?: number
+
+  /**
+   * Interval of file system polling for binary files. ([see list of binary extensions](https://gi
+   * thub.com/sindresorhus/binary-extensions/blob/master/binary-extensions.json))
+   */
+  binaryInterval?: number
+
+  /**
+   *  Indicates whether to watch files that don't have read permissions if possible. If watching
+   *  fails due to `EPERM` or `EACCES` with this set to `true`, the errors will be suppressed
+   *  silently.
+   */
+  ignorePermissionErrors?: boolean
+
+  /**
+   * `true` if `useFsEvents` and `usePolling` are `false`. Automatically filters out artifacts
+   * that occur when using editors that use "atomic writes" instead of writing directly to the
+   * source file. If a file is re-added within 100 ms of being deleted, Chokidar emits a `change`
+   * event rather than `unlink` then `add`. If the default of 100 ms does not work well for you,
+   * you can override it by setting `atomic` to a custom value, in milliseconds.
+   */
+  atomic?: boolean | number
+
+  /**
+   * can be set to an object in order to adjust timing params:
+   */
+  awaitWriteFinish?: AwaitWriteFinishOptions | boolean
+}
+
+interface AwaitWriteFinishOptions {
+  /**
+   * Amount of time in milliseconds for a file size to remain constant before emitting its event.
+   */
+  stabilityThreshold?: number
+
+  /**
+   * File size polling interval.
+   */
+  pollInterval?: number
+}
+
+// Inlined to avoid extra dependency
+// MIT Licensed https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/LICENSE
+
+declare namespace Connect {
+  export type ServerHandle = HandleFunction | http.Server
+
+  export class IncomingMessage extends http.IncomingMessage {
+    originalUrl?: http.IncomingMessage['url'] | undefined
+  }
+
+  export type NextFunction = (err?: any) => void
+
+  export type SimpleHandleFunction = (
+    req: IncomingMessage,
+    res: http.ServerResponse,
+  ) => void
+  export type NextHandleFunction = (
+    req: IncomingMessage,
+    res: http.ServerResponse,
+    next: NextFunction,
+  ) => void
+  export type ErrorHandleFunction = (
+    err: any,
+    req: IncomingMessage,
+    res: http.ServerResponse,
+    next: NextFunction,
+  ) => void
+  export type HandleFunction =
+    | SimpleHandleFunction
+    | NextHandleFunction
+    | ErrorHandleFunction
+
+  export interface ServerStackItem {
+    route: string
+    handle: ServerHandle
+  }
+
+  export interface Server extends NodeJS.EventEmitter {
+    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void
+
+    route: string
+    stack: ServerStackItem[]
+
+    /**
+     * Utilize the given middleware `handle` to the given `route`,
+     * defaulting to _/_. This "route" is the mount-point for the
+     * middleware, when given a value other than _/_ the middleware
+     * is only effective when that segment is present in the request's
+     * pathname.
+     *
+     * For example if we were to mount a function at _/admin_, it would
+     * be invoked on _/admin_, and _/admin/settings_, however it would
+     * not be invoked for _/_, or _/posts_.
+     */
+    use(fn: NextHandleFunction): Server
+    use(fn: HandleFunction): Server
+    use(route: string, fn: NextHandleFunction): Server
+    use(route: string, fn: HandleFunction): Server
+
+    /**
+     * Handle server requests, punting them down
+     * the middleware stack.
+     */
+    handle(
+      req: http.IncomingMessage,
+      res: http.ServerResponse,
+      next: Function,
+    ): void
+
+    /**
+     * Listen for connections.
+     *
+     * This method takes the same arguments
+     * as node's `http.Server#listen()`.
+     *
+     * HTTP and HTTPS:
+     *
+     * If you run your application both as HTTP
+     * and HTTPS you may wrap them individually,
+     * since your Connect "server" is really just
+     * a JavaScript `Function`.
+     *
+     *      var connect = require('connect')
+     *        , http = require('http')
+     *        , https = require('https');
+     *
+     *      var app = connect();
+     *
+     *      http.createServer(app).listen(80);
+     *      https.createServer(options, app).listen(443);
+     */
+    listen(
+      port: number,
+      hostname?: string,
+      backlog?: number,
+      callback?: Function,
+    ): http.Server
+    listen(port: number, hostname?: string, callback?: Function): http.Server
+    listen(path: string, callback?: Function): http.Server
+    listen(handle: any, listeningListener?: Function): http.Server
+  }
+}
+
+// Inlined to avoid extra dependency
+// MIT Licensed https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/LICENSE
+
+declare namespace HttpProxy {
+  export type ProxyTarget = ProxyTargetUrl | ProxyTargetDetailed
+
+  export type ProxyTargetUrl = string | Partial<url.Url>
+
+  export interface ProxyTargetDetailed {
+    host: string
+    port: number
+    protocol?: string | undefined
+    hostname?: string | undefined
+    socketPath?: string | undefined
+    key?: string | undefined
+    passphrase?: string | undefined
+    pfx?: Buffer | string | undefined
+    cert?: string | undefined
+    ca?: string | undefined
+    ciphers?: string | undefined
+    secureProtocol?: string | undefined
+  }
+
+  export type ErrorCallback = (
+    err: Error,
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    target?: ProxyTargetUrl,
+  ) => void
+
+  export class Server extends events.EventEmitter {
+    /**
+     * Creates the proxy server with specified options.
+     * @param options - Config object passed to the proxy
+     */
+    constructor(options?: ServerOptions)
+
+    /**
+     * Used for proxying regular HTTP(S) requests
+     * @param req - Client request.
+     * @param res - Client response.
+     * @param options - Additional options.
+     * @param callback - Error callback.
+     */
+    web(
+      req: http.IncomingMessage,
+      res: http.ServerResponse,
+      options?: ServerOptions,
+      callback?: ErrorCallback,
+    ): void
+
+    /**
+     * Used for proxying regular HTTP(S) requests
+     * @param req - Client request.
+     * @param socket - Client socket.
+     * @param head - Client head.
+     * @param options - Additional options.
+     * @param callback - Error callback.
+     */
+    ws(
+      req: http.IncomingMessage,
+      socket: unknown,
+      head: unknown,
+      options?: ServerOptions,
+      callback?: ErrorCallback,
+    ): void
+
+    /**
+     * A function that wraps the object in a webserver, for your convenience
+     * @param port - Port to listen on
+     */
+    listen(port: number): Server
+
+    /**
+     * A function that closes the inner webserver and stops listening on given port
+     */
+    close(callback?: () => void): void
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options - Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    static createProxyServer(options?: ServerOptions): Server
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options - Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    static createServer(options?: ServerOptions): Server
+
+    /**
+     * Creates the proxy server with specified options.
+     * @param options - Config object passed to the proxy
+     * @returns Proxy object with handlers for `ws` and `web` requests
+     */
+    static createProxy(options?: ServerOptions): Server
+
+    addListener(event: string, listener: () => void): this
+    on(event: string, listener: () => void): this
+    on(event: 'error', listener: ErrorCallback): this
+    on(
+      event: 'start',
+      listener: (
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        target: ProxyTargetUrl,
+      ) => void,
+    ): this
+    on(
+      event: 'proxyReq',
+      listener: (
+        proxyReq: http.ClientRequest,
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        options: ServerOptions,
+      ) => void,
+    ): this
+    on(
+      event: 'proxyRes',
+      listener: (
+        proxyRes: http.IncomingMessage,
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+      ) => void,
+    ): this
+    on(
+      event: 'proxyReqWs',
+      listener: (
+        proxyReq: http.ClientRequest,
+        req: http.IncomingMessage,
+        socket: net.Socket,
+        options: ServerOptions,
+        head: any,
+      ) => void,
+    ): this
+    on(
+      event: 'econnreset',
+      listener: (
+        err: Error,
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        target: ProxyTargetUrl,
+      ) => void,
+    ): this
+    on(
+      event: 'end',
+      listener: (
+        req: http.IncomingMessage,
+        res: http.ServerResponse,
+        proxyRes: http.IncomingMessage,
+      ) => void,
+    ): this
+    on(
+      event: 'close',
+      listener: (
+        proxyRes: http.IncomingMessage,
+        proxySocket: net.Socket,
+        proxyHead: any,
+      ) => void,
+    ): this
+
+    once(event: string, listener: () => void): this
+    removeListener(event: string, listener: () => void): this
+    removeAllListeners(event?: string): this
+    getMaxListeners(): number
+    setMaxListeners(n: number): this
+    listeners(event: string): Array<() => void>
+    emit(event: string, ...args: any[]): boolean
+    listenerCount(type: string): number
+  }
+
+  export interface ServerOptions {
+    /** URL string to be parsed with the url module. */
+    target?: ProxyTarget | undefined
+    /** URL string to be parsed with the url module. */
+    forward?: ProxyTargetUrl | undefined
+    /** Object to be passed to http(s).request. */
+    agent?: any
+    /** Object to be passed to https.createServer(). */
+    ssl?: any
+    /** If you want to proxy websockets. */
+    ws?: boolean | undefined
+    /** Adds x- forward headers. */
+    xfwd?: boolean | undefined
+    /** Verify SSL certificate. */
+    secure?: boolean | undefined
+    /** Explicitly specify if we are proxying to another proxy. */
+    toProxy?: boolean | undefined
+    /** Specify whether you want to prepend the target's path to the proxy path. */
+    prependPath?: boolean | undefined
+    /** Specify whether you want to ignore the proxy path of the incoming request. */
+    ignorePath?: boolean | undefined
+    /** Local interface string to bind for outgoing connections. */
+    localAddress?: string | undefined
+    /** Changes the origin of the host header to the target URL. */
+    changeOrigin?: boolean | undefined
+    /** specify whether you want to keep letter case of response header key */
+    preserveHeaderKeyCase?: boolean | undefined
+    /** Basic authentication i.e. 'user:password' to compute an Authorization header. */
+    auth?: string | undefined
+    /** Rewrites the location hostname on (301 / 302 / 307 / 308) redirects, Default: null. */
+    hostRewrite?: string | undefined
+    /** Rewrites the location host/ port on (301 / 302 / 307 / 308) redirects based on requested host/ port.Default: false. */
+    autoRewrite?: boolean | undefined
+    /** Rewrites the location protocol on (301 / 302 / 307 / 308) redirects to 'http' or 'https'.Default: null. */
+    protocolRewrite?: string | undefined
+    /** rewrites domain of set-cookie headers. */
+    cookieDomainRewrite?:
+      | false
+      | string
+      | { [oldDomain: string]: string }
+      | undefined
+    /** rewrites path of set-cookie headers. Default: false */
+    cookiePathRewrite?:
+      | false
+      | string
+      | { [oldPath: string]: string }
+      | undefined
+    /** object with extra headers to be added to target requests. */
+    headers?: { [header: string]: string } | undefined
+    /** Timeout (in milliseconds) when proxy receives no response from target. Default: 120000 (2 minutes) */
+    proxyTimeout?: number | undefined
+    /** Timeout (in milliseconds) for incoming requests */
+    timeout?: number | undefined
+    /** Specify whether you want to follow redirects. Default: false */
+    followRedirects?: boolean | undefined
+    /** If set to true, none of the webOutgoing passes are called and it's your responsibility to appropriately return the response by listening and acting on the proxyRes event */
+    selfHandleResponse?: boolean | undefined
+    /** Buffer */
+    buffer?: stream.Stream | undefined
+  }
+}
+
+interface ProxyOptions extends HttpProxy.ServerOptions {
+    /**
+     * rewrite path
+     */
+    rewrite?: (path: string) => string;
+    /**
+     * configure the proxy server (e.g. listen to events)
+     */
+    configure?: (proxy: HttpProxy.Server, options: ProxyOptions) => void;
+    /**
+     * webpack-dev-server style bypass function
+     */
+    bypass?: (req: http.IncomingMessage, res: http.ServerResponse, options: ProxyOptions) => void | null | undefined | false | string;
+    /**
+     * rewrite the Origin header of a WebSocket request to match the the target
+     *
+     * **Exercise caution as rewriting the Origin can leave the proxying open to [CSRF attacks](https://owasp.org/www-community/attacks/csrf).**
+     */
+    rewriteWsOrigin?: boolean | undefined;
+}
+
+type LogType = 'error' | 'warn' | 'info';
+type LogLevel = LogType | 'silent';
+interface Logger {
+    info(msg: string, options?: LogOptions): void;
+    warn(msg: string, options?: LogOptions): void;
+    warnOnce(msg: string, options?: LogOptions): void;
+    error(msg: string, options?: LogErrorOptions): void;
+    clearScreen(type: LogType): void;
+    hasErrorLogged(error: Error | RollupError): boolean;
+    hasWarned: boolean;
+}
+interface LogOptions {
+    clear?: boolean;
+    timestamp?: boolean;
+}
+interface LogErrorOptions extends LogOptions {
+    error?: Error | RollupError | null;
+}
+interface LoggerOptions {
+    prefix?: string;
+    allowClearScreen?: boolean;
+    customLogger?: Logger;
+}
+declare function createLogger(level?: LogLevel, options?: LoggerOptions): Logger;
+
+interface CommonServerOptions {
+    /**
+     * Specify server port. Note if the port is already being used, Vite will
+     * automatically try the next available port so this may not be the actual
+     * port the server ends up listening on.
+     */
+    port?: number;
+    /**
+     * If enabled, vite will exit if specified port is already in use
+     */
+    strictPort?: boolean;
+    /**
+     * Specify which IP addresses the server should listen on.
+     * Set to 0.0.0.0 to listen on all addresses, including LAN and public addresses.
+     */
+    host?: string | boolean;
+    /**
+     * Enable TLS + HTTP/2.
+     * Note: this downgrades to TLS only when the proxy option is also used.
+     */
+    https?: HttpsServerOptions;
+    /**
+     * Open browser window on startup
+     */
+    open?: boolean | string;
+    /**
+     * Configure custom proxy rules for the dev server. Expects an object
+     * of `{ key: options }` pairs.
+     * Uses [`http-proxy`](https://github.com/http-party/node-http-proxy).
+     * Full options [here](https://github.com/http-party/node-http-proxy#options).
+     *
+     * Example `vite.config.js`:
+     * ``` js
+     * module.exports = {
+     *   proxy: {
+     *     // string shorthand: /foo -> http://localhost:4567/foo
+     *     '/foo': 'http://localhost:4567',
+     *     // with options
+     *     '/api': {
+     *       target: 'http://jsonplaceholder.typicode.com',
+     *       changeOrigin: true,
+     *       rewrite: path => path.replace(/^\/api/, '')
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    proxy?: Record<string, string | ProxyOptions>;
+    /**
+     * Configure CORS for the dev server.
+     * Uses https://github.com/expressjs/cors.
+     * Set to `true` to allow all methods from any origin, or configure separately
+     * using an object.
+     */
+    cors?: CorsOptions | boolean;
+    /**
+     * Specify server response headers.
+     */
+    headers?: OutgoingHttpHeaders;
+}
+/**
+ * https://github.com/expressjs/cors#configuration-options
+ */
+interface CorsOptions {
+    origin?: CorsOrigin | ((origin: string | undefined, cb: (err: Error, origins: CorsOrigin) => void) => void);
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}
+type CorsOrigin = boolean | string | RegExp | (string | RegExp)[];
+
+interface PreviewOptions extends CommonServerOptions {
+}
+interface ResolvedPreviewOptions extends PreviewOptions {
+}
+interface PreviewServer {
+    /**
+     * The resolved vite config object
+     */
+    config: ResolvedConfig;
+    /**
+     * Stop the server.
+     */
+    close(): Promise<void>;
+    /**
+     * A connect app instance.
+     * - Can be used to attach custom middlewares to the preview server.
+     * - Can also be used as the handler function of a custom http server
+     *   or as a middleware in any connect-style Node.js frameworks
+     *
+     * https://github.com/senchalabs/connect#use-middleware
+     */
+    middlewares: Connect.Server;
+    /**
+     * native Node http server instance
+     */
+    httpServer: HttpServer;
+    /**
+     * The resolved urls Vite prints on the CLI.
+     * null before server is listening.
+     */
+    resolvedUrls: ResolvedServerUrls | null;
+    /**
+     * Print server urls
+     */
+    printUrls(): void;
+    /**
+     * Bind CLI shortcuts
+     */
+    bindCLIShortcuts(options?: BindCLIShortcutsOptions<PreviewServer>): void;
+}
+type PreviewServerHook = (this: void, server: PreviewServer) => (() => void) | void | Promise<(() => void) | void>;
+/**
+ * Starts the Vite server in preview mode, to simulate a production deployment
+ */
+declare function preview(inlineConfig?: InlineConfig): Promise<PreviewServer>;
+
+type BindCLIShortcutsOptions<Server = ViteDevServer | PreviewServer> = {
+    /**
+     * Print a one-line shortcuts "help" hint to the terminal
+     */
+    print?: boolean;
+    /**
+     * Custom shortcuts to run when a key is pressed. These shortcuts take priority
+     * over the default shortcuts if they have the same keys (except the `h` key).
+     * To disable a default shortcut, define the same key but with `action: undefined`.
+     */
+    customShortcuts?: CLIShortcut<Server>[];
+};
+type CLIShortcut<Server = ViteDevServer | PreviewServer> = {
+    key: string;
+    description: string;
+    action?(server: Server): void | Promise<void>;
+};
+
+interface TransformResult {
+    code: string;
+    map: SourceMap | {
+        mappings: '';
+    } | null;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
+}
+interface TransformOptions {
+    ssr?: boolean;
+    html?: boolean;
+}
+
+declare class ModuleNode {
+    /**
+     * Public served url path, starts with /
+     */
+    url: string;
+    /**
+     * Resolved file system path + query
+     */
+    id: string | null;
+    file: string | null;
+    type: 'js' | 'css';
+    info?: ModuleInfo;
+    meta?: Record<string, any>;
+    importers: Set<ModuleNode>;
+    clientImportedModules: Set<ModuleNode>;
+    ssrImportedModules: Set<ModuleNode>;
+    acceptedHmrDeps: Set<ModuleNode>;
+    acceptedHmrExports: Set<string> | null;
+    importedBindings: Map<string, Set<string>> | null;
+    isSelfAccepting?: boolean;
+    transformResult: TransformResult | null;
+    ssrTransformResult: TransformResult | null;
+    ssrModule: Record<string, any> | null;
+    ssrError: Error | null;
+    lastHMRTimestamp: number;
+    lastInvalidationTimestamp: number;
+    /**
+     * @param setIsSelfAccepting - set `false` to set `isSelfAccepting` later. e.g. #7870
+     */
+    constructor(url: string, setIsSelfAccepting?: boolean);
+    get importedModules(): Set<ModuleNode>;
+}
+type ResolvedUrl = [
+    url: string,
+    resolvedId: string,
+    meta: object | null | undefined
+];
+declare class ModuleGraph {
+    private resolveId;
+    urlToModuleMap: Map<string, ModuleNode>;
+    idToModuleMap: Map<string, ModuleNode>;
+    etagToModuleMap: Map<string, ModuleNode>;
+    fileToModulesMap: Map<string, Set<ModuleNode>>;
+    safeModulesPath: Set<string>;
+    constructor(resolveId: (url: string, ssr: boolean) => Promise<PartialResolvedId | null>);
+    getModuleByUrl(rawUrl: string, ssr?: boolean): Promise<ModuleNode | undefined>;
+    getModuleById(id: string): ModuleNode | undefined;
+    getModulesByFile(file: string): Set<ModuleNode> | undefined;
+    onFileChange(file: string): void;
+    onFileDelete(file: string): void;
+    invalidateModule(mod: ModuleNode, seen?: Set<ModuleNode>, timestamp?: number, isHmr?: boolean, 
+    ): void;
+    invalidateAll(): void;
+    /**
+     * Update the module graph based on a module's updated imports information
+     * If there are dependencies that no longer have any importers, they are
+     * returned as a Set.
+     *
+     * @param staticImportedUrls Subset of `importedModules` where they're statically imported in code.
+     *   This is only used for soft invalidations so `undefined` is fine but may cause more runtime processing.
+     */
+    updateModuleInfo(mod: ModuleNode, importedModules: Set<string | ModuleNode>, importedBindings: Map<string, Set<string>> | null, acceptedModules: Set<string | ModuleNode>, acceptedExports: Set<string> | null, isSelfAccepting: boolean, ssr?: boolean, 
+    ): Promise<Set<ModuleNode> | undefined>;
+    ensureEntryFromUrl(rawUrl: string, ssr?: boolean, setIsSelfAccepting?: boolean): Promise<ModuleNode>;
+    createFileOnlyEntry(file: string): ModuleNode;
+    resolveUrl(url: string, ssr?: boolean): Promise<ResolvedUrl>;
+    updateModuleTransformResult(mod: ModuleNode, result: TransformResult | null, ssr: boolean): void;
+    getModuleByEtag(etag: string): ModuleNode | undefined;
+}
+
+/**
+ * This file is refactored into TypeScript based on
+ * https://github.com/preactjs/wmr/blob/main/packages/wmr/src/lib/rollup-plugin-container.js
+ */
+
+declare class PluginContainer {
+    config: ResolvedConfig;
+    moduleGraph?: ModuleGraph | undefined;
+    watcher?: FSWatcher | undefined;
+    plugins: readonly Plugin<any>[];
+    private _pluginContextMap;
+    private _pluginContextMapSsr;
+    private _resolvedRollupOptions?;
+    private _processesing;
+    private _seenResolves;
+    private _closed;
+    private _moduleNodeToLoadAddedImports;
+    getSortedPluginHooks: PluginHookUtils['getSortedPluginHooks'];
+    getSortedPlugins: PluginHookUtils['getSortedPlugins'];
+    watchFiles: Set<string>;
+    minimalContext: MinimalPluginContext;
+    private _updateModuleLoadAddedImports;
+    private _getAddedImports;
+    getModuleInfo(id: string): ModuleInfo | null;
+    private handleHookPromise;
+    get options(): InputOptions;
+    resolveRollupOptions(): Promise<InputOptions>;
+    private _getPluginContext;
+    private hookParallel;
+    buildStart(_options?: InputOptions): Promise<void>;
+    resolveId(rawId: string, importer?: string | undefined, options?: {
+        attributes?: Record<string, string>;
+        custom?: CustomPluginOptions;
+        skip?: Set<Plugin>;
+        ssr?: boolean;
+        isEntry?: boolean;
+    }): Promise<PartialResolvedId | null>;
+    load(id: string, options?: {
+        ssr?: boolean;
+    }): Promise<LoadResult | null>;
+    transform(code: string, id: string, options?: {
+        ssr?: boolean;
+        inMap?: SourceDescription['map'];
+    }): Promise<{
+        code: string;
+        map: SourceMap | {
+            mappings: '';
+        } | null;
+    }>;
+    watchChange(id: string, change: {
+        event: 'create' | 'update' | 'delete';
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+
+// Modified and inlined to avoid extra dependency
+// Source: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/ws/index.d.ts
+
+declare const WebSocketAlias: typeof WebSocket
+interface WebSocketAlias extends WebSocket {}
+
+// WebSocket socket.
+declare class WebSocket extends EventEmitter {
+  /** The connection is not yet open. */
+  static readonly CONNECTING: 0
+  /** The connection is open and ready to communicate. */
+  static readonly OPEN: 1
+  /** The connection is in the process of closing. */
+  static readonly CLOSING: 2
+  /** The connection is closed. */
+  static readonly CLOSED: 3
+
+  binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments'
+  readonly bufferedAmount: number
+  readonly extensions: string
+  /** Indicates whether the websocket is paused */
+  readonly isPaused: boolean
+  readonly protocol: string
+  /** The current state of the connection */
+  readonly readyState:
+    | typeof WebSocket.CONNECTING
+    | typeof WebSocket.OPEN
+    | typeof WebSocket.CLOSING
+    | typeof WebSocket.CLOSED
+  readonly url: string
+
+  /** The connection is not yet open. */
+  readonly CONNECTING: 0
+  /** The connection is open and ready to communicate. */
+  readonly OPEN: 1
+  /** The connection is in the process of closing. */
+  readonly CLOSING: 2
+  /** The connection is closed. */
+  readonly CLOSED: 3
+
+  onopen: ((event: WebSocket.Event) => void) | null
+  onerror: ((event: WebSocket.ErrorEvent) => void) | null
+  onclose: ((event: WebSocket.CloseEvent) => void) | null
+  onmessage: ((event: WebSocket.MessageEvent) => void) | null
+
+  constructor(address: null)
+  constructor(
+    address: string | URL,
+    options?: WebSocket.ClientOptions | ClientRequestArgs,
+  )
+  constructor(
+    address: string | URL,
+    protocols?: string | string[],
+    options?: WebSocket.ClientOptions | ClientRequestArgs,
+  )
+
+  close(code?: number, data?: string | Buffer): void
+  ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+  pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void
+  send(data: any, cb?: (err?: Error) => void): void
+  send(
+    data: any,
+    options: {
+      mask?: boolean | undefined
+      binary?: boolean | undefined
+      compress?: boolean | undefined
+      fin?: boolean | undefined
+    },
+    cb?: (err?: Error) => void,
+  ): void
+  terminate(): void
+
+  /**
+   * Pause the websocket causing it to stop emitting events. Some events can still be
+   * emitted after this is called, until all buffered data is consumed. This method
+   * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+   */
+  pause(): void
+  /**
+   * Make a paused socket resume emitting events. This method is a noop if the ready
+   * state is `CONNECTING` or `CLOSED`.
+   */
+  resume(): void
+
+  // HTML5 WebSocket events
+  addEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+  addEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void,
+    options?: WebSocket.EventListenerOptions,
+  ): void
+
+  removeEventListener(
+    method: 'message',
+    cb: (event: WebSocket.MessageEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'close',
+    cb: (event: WebSocket.CloseEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'error',
+    cb: (event: WebSocket.ErrorEvent) => void,
+  ): void
+  removeEventListener(
+    method: 'open',
+    cb: (event: WebSocket.Event) => void,
+  ): void
+
+  // Events
+  on(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  on(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  on(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  on(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  on(event: 'open', listener: (this: WebSocket) => void): this
+  on(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  on(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  on(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
+
+  once(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  once(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  once(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  once(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  once(event: 'open', listener: (this: WebSocket) => void): this
+  once(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  once(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  once(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
+
+  off(
+    event: 'close',
+    listener: (this: WebSocket, code: number, reason: Buffer) => void,
+  ): this
+  off(event: 'error', listener: (this: WebSocket, err: Error) => void): this
+  off(
+    event: 'upgrade',
+    listener: (this: WebSocket, request: IncomingMessage) => void,
+  ): this
+  off(
+    event: 'message',
+    listener: (
+      this: WebSocket,
+      data: WebSocket.RawData,
+      isBinary: boolean,
+    ) => void,
+  ): this
+  off(event: 'open', listener: (this: WebSocket) => void): this
+  off(
+    event: 'ping' | 'pong',
+    listener: (this: WebSocket, data: Buffer) => void,
+  ): this
+  off(
+    event: 'unexpected-response',
+    listener: (
+      this: WebSocket,
+      request: ClientRequest,
+      response: IncomingMessage,
+    ) => void,
+  ): this
+  off(
+    event: string | symbol,
+    listener: (this: WebSocket, ...args: any[]) => void,
+  ): this
+
+  addListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void,
+  ): this
+  addListener(event: 'error', listener: (err: Error) => void): this
+  addListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void,
+  ): this
+  addListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
+  ): this
+  addListener(event: 'open', listener: () => void): this
+  addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+  addListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void,
+  ): this
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this
+
+  removeListener(
+    event: 'close',
+    listener: (code: number, reason: Buffer) => void,
+  ): this
+  removeListener(event: 'error', listener: (err: Error) => void): this
+  removeListener(
+    event: 'upgrade',
+    listener: (request: IncomingMessage) => void,
+  ): this
+  removeListener(
+    event: 'message',
+    listener: (data: WebSocket.RawData, isBinary: boolean) => void,
+  ): this
+  removeListener(event: 'open', listener: () => void): this
+  removeListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this
+  removeListener(
+    event: 'unexpected-response',
+    listener: (request: ClientRequest, response: IncomingMessage) => void,
+  ): this
+  removeListener(
+    event: string | symbol,
+    listener: (...args: any[]) => void,
+  ): this
+}
+
+declare namespace WebSocket {
+  /**
+   * Data represents the raw message payload received over the WebSocket.
+   */
+  type RawData = Buffer | ArrayBuffer | Buffer[]
+
+  /**
+   * Data represents the message payload received over the WebSocket.
+   */
+  type Data = string | Buffer | ArrayBuffer | Buffer[]
+
+  /**
+   * CertMeta represents the accepted types for certificate & key data.
+   */
+  type CertMeta = string | string[] | Buffer | Buffer[]
+
+  /**
+   * VerifyClientCallbackSync is a synchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
+   */
+  type VerifyClientCallbackSync = (info: {
+    origin: string
+    secure: boolean
+    req: IncomingMessage
+  }) => boolean
+
+  /**
+   * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+   * incoming message. The return value (boolean) of the function determines
+   * whether or not to accept the handshake.
+   */
+  type VerifyClientCallbackAsync = (
+    info: { origin: string; secure: boolean; req: IncomingMessage },
+    callback: (
+      res: boolean,
+      code?: number,
+      message?: string,
+      headers?: OutgoingHttpHeaders,
+    ) => void,
+  ) => void
+
+  interface ClientOptions extends SecureContextOptions {
+    protocol?: string | undefined
+    followRedirects?: boolean | undefined
+    generateMask?(mask: Buffer): void
+    handshakeTimeout?: number | undefined
+    maxRedirects?: number | undefined
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+    localAddress?: string | undefined
+    protocolVersion?: number | undefined
+    headers?: { [key: string]: string } | undefined
+    origin?: string | undefined
+    agent?: Agent | undefined
+    host?: string | undefined
+    family?: number | undefined
+    checkServerIdentity?(servername: string, cert: CertMeta): boolean
+    rejectUnauthorized?: boolean | undefined
+    maxPayload?: number | undefined
+    skipUTF8Validation?: boolean | undefined
+  }
+
+  interface PerMessageDeflateOptions {
+    serverNoContextTakeover?: boolean | undefined
+    clientNoContextTakeover?: boolean | undefined
+    serverMaxWindowBits?: number | undefined
+    clientMaxWindowBits?: number | undefined
+    zlibDeflateOptions?:
+      | {
+          flush?: number | undefined
+          finishFlush?: number | undefined
+          chunkSize?: number | undefined
+          windowBits?: number | undefined
+          level?: number | undefined
+          memLevel?: number | undefined
+          strategy?: number | undefined
+          dictionary?: Buffer | Buffer[] | DataView | undefined
+          info?: boolean | undefined
+        }
+      | undefined
+    zlibInflateOptions?: ZlibOptions | undefined
+    threshold?: number | undefined
+    concurrencyLimit?: number | undefined
+  }
+
+  interface Event {
+    type: string
+    target: WebSocket
+  }
+
+  interface ErrorEvent {
+    error: any
+    message: string
+    type: string
+    target: WebSocket
+  }
+
+  interface CloseEvent {
+    wasClean: boolean
+    code: number
+    reason: string
+    type: string
+    target: WebSocket
+  }
+
+  interface MessageEvent {
+    data: Data
+    type: string
+    target: WebSocket
+  }
+
+  interface EventListenerOptions {
+    once?: boolean | undefined
+  }
+
+  interface ServerOptions {
+    host?: string | undefined
+    port?: number | undefined
+    backlog?: number | undefined
+    server?: Server | HttpsServer | undefined
+    verifyClient?:
+      | VerifyClientCallbackAsync
+      | VerifyClientCallbackSync
+      | undefined
+    handleProtocols?: (
+      protocols: Set<string>,
+      request: IncomingMessage,
+    ) => string | false
+    path?: string | undefined
+    noServer?: boolean | undefined
+    clientTracking?: boolean | undefined
+    perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined
+    maxPayload?: number | undefined
+    skipUTF8Validation?: boolean | undefined
+    WebSocket?: typeof WebSocket.WebSocket | undefined
+  }
+
+  interface AddressInfo {
+    address: string
+    family: string
+    port: number
+  }
+
+  // WebSocket Server
+  class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+    options: ServerOptions
+    path: string
+    clients: Set<T>
+
+    constructor(options?: ServerOptions, callback?: () => void)
+
+    address(): AddressInfo | string
+    close(cb?: (err?: Error) => void): void
+    handleUpgrade(
+      request: IncomingMessage,
+      socket: Duplex,
+      upgradeHead: Buffer,
+      callback: (client: T, request: IncomingMessage) => void,
+    ): void
+    shouldHandle(request: IncomingMessage): boolean | Promise<boolean>
+
+    // Events
+    on(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    on(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    on(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    on(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    once(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    once(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    once(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    once(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    off(
+      event: 'connection',
+      cb: (this: Server<T>, socket: T, request: IncomingMessage) => void,
+    ): this
+    off(event: 'error', cb: (this: Server<T>, error: Error) => void): this
+    off(
+      event: 'headers',
+      cb: (
+        this: Server<T>,
+        headers: string[],
+        request: IncomingMessage,
+      ) => void,
+    ): this
+    off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this
+    off(
+      event: string | symbol,
+      listener: (this: Server<T>, ...args: any[]) => void,
+    ): this
+
+    addListener(
+      event: 'connection',
+      cb: (client: T, request: IncomingMessage) => void,
+    ): this
+    addListener(event: 'error', cb: (err: Error) => void): this
+    addListener(
+      event: 'headers',
+      cb: (headers: string[], request: IncomingMessage) => void,
+    ): this
+    addListener(event: 'close' | 'listening', cb: () => void): this
+    addListener(
+      event: string | symbol,
+      listener: (...args: any[]) => void,
+    ): this
+
+    removeListener(event: 'connection', cb: (client: T) => void): this
+    removeListener(event: 'error', cb: (err: Error) => void): this
+    removeListener(
+      event: 'headers',
+      cb: (headers: string[], request: IncomingMessage) => void,
+    ): this
+    removeListener(event: 'close' | 'listening', cb: () => void): this
+    removeListener(
+      event: string | symbol,
+      listener: (...args: any[]) => void,
+    ): this
+  }
+
+  const WebSocketServer: typeof Server
+  interface WebSocketServer extends Server {}
+  const WebSocket: typeof WebSocketAlias
+  interface WebSocket extends WebSocketAlias {}
+
+  // WebSocket stream
+  function createWebSocketStream(
+    websocket: WebSocket,
+    options?: DuplexOptions,
+  ): Duplex
+}
+
+interface HmrOptions {
+    protocol?: string;
+    host?: string;
+    port?: number;
+    clientPort?: number;
+    path?: string;
+    timeout?: number;
+    overlay?: boolean;
+    server?: HttpServer;
+}
+interface HmrContext {
+    file: string;
+    timestamp: number;
+    modules: Array<ModuleNode>;
+    read: () => string | Promise<string>;
+    server: ViteDevServer;
+}
+interface HMRBroadcasterClient {
+    /**
+     * Send event to the client
+     */
+    send(payload: HMRPayload): void;
+    /**
+     * Send custom event
+     */
+    send(event: string, payload?: CustomPayload['data']): void;
+}
+interface HMRChannel {
+    /**
+     * Unique channel name
+     */
+    name: string;
+    /**
+     * Broadcast events to all clients
+     */
+    send(payload: HMRPayload): void;
+    /**
+     * Send custom event
+     */
+    send<T extends string>(event: T, payload?: InferCustomEventPayload<T>): void;
+    /**
+     * Handle custom event emitted by `import.meta.hot.send`
+     */
+    on<T extends string>(event: T, listener: (data: InferCustomEventPayload<T>, client: HMRBroadcasterClient, ...args: any[]) => void): void;
+    on(event: 'connection', listener: () => void): void;
+    /**
+     * Unregister event listener
+     */
+    off(event: string, listener: Function): void;
+    /**
+     * Start listening for messages
+     */
+    listen(): void;
+    /**
+     * Disconnect all clients, called when server is closed or restarted.
+     */
+    close(): void;
+}
+interface HMRBroadcaster extends Omit<HMRChannel, 'close' | 'name'> {
+    /**
+     * All registered channels. Always has websocket channel.
+     */
+    readonly channels: HMRChannel[];
+    /**
+     * Add a new third-party channel.
+     */
+    addChannel(connection: HMRChannel): HMRBroadcaster;
+    close(): Promise<unknown[]>;
+}
+interface ServerHMRChannel extends HMRChannel {
+    api: {
+        innerEmitter: EventEmitter;
+        outsideEmitter: EventEmitter;
+    };
+}
+
+type WebSocketCustomListener<T> = (data: T, client: WebSocketClient) => void;
+interface WebSocketServer extends HMRChannel {
+    /**
+     * Listen on port and host
+     */
+    listen(): void;
+    /**
+     * Get all connected clients.
+     */
+    clients: Set<WebSocketClient>;
+    /**
+     * Disconnect all clients and terminate the server.
+     */
+    close(): Promise<void>;
+    /**
+     * Handle custom event emitted by `import.meta.hot.send`
+     */
+    on: WebSocket.Server['on'] & {
+        <T extends string>(event: T, listener: WebSocketCustomListener<InferCustomEventPayload<T>>): void;
+    };
+    /**
+     * Unregister event listener.
+     */
+    off: WebSocket.Server['off'] & {
+        (event: string, listener: Function): void;
+    };
+}
+interface WebSocketClient {
+    /**
+     * Send event to the client
+     */
+    send(payload: HMRPayload): void;
+    /**
+     * Send custom event
+     */
+    send(event: string, payload?: CustomPayload['data']): void;
+    /**
+     * The raw WebSocket instance
+     * @advanced
+     */
+    socket: WebSocket;
+}
+
+interface ServerOptions extends CommonServerOptions {
+    /**
+     * Configure HMR-specific options (port, host, path & protocol)
+     */
+    hmr?: HmrOptions | boolean;
+    /**
+     * Do not start the websocket connection.
+     * @experimental
+     */
+    ws?: false;
+    /**
+     * Warm-up files to transform and cache the results in advance. This improves the
+     * initial page load during server starts and prevents transform waterfalls.
+     */
+    warmup?: {
+        /**
+         * The files to be transformed and used on the client-side. Supports glob patterns.
+         */
+        clientFiles?: string[];
+        /**
+         * The files to be transformed and used in SSR. Supports glob patterns.
+         */
+        ssrFiles?: string[];
+    };
+    /**
+     * chokidar watch options or null to disable FS watching
+     * https://github.com/paulmillr/chokidar#api
+     */
+    watch?: WatchOptions | null;
+    /**
+     * Create Vite dev server to be used as a middleware in an existing server
+     * @default false
+     */
+    middlewareMode?: boolean | {
+        /**
+         * Parent server instance to attach to
+         *
+         * This is needed to proxy WebSocket connections to the parent server.
+         */
+        server: HttpServer;
+    };
+    /**
+     * Options for files served via '/\@fs/'.
+     */
+    fs?: FileSystemServeOptions;
+    /**
+     * Origin for the generated asset URLs.
+     *
+     * @example `http://127.0.0.1:8080`
+     */
+    origin?: string;
+    /**
+     * Pre-transform known direct imports
+     * @default true
+     */
+    preTransformRequests?: boolean;
+    /**
+     * Whether or not to ignore-list source files in the dev server sourcemap, used to populate
+     * the [`x_google_ignoreList` source map extension](https://developer.chrome.com/blog/devtools-better-angular-debugging/#the-x_google_ignorelist-source-map-extension).
+     *
+     * By default, it excludes all paths containing `node_modules`. You can pass `false` to
+     * disable this behavior, or, for full control, a function that takes the source path and
+     * sourcemap path and returns whether to ignore the source path.
+     */
+    sourcemapIgnoreList?: false | ((sourcePath: string, sourcemapPath: string) => boolean);
+}
+interface ResolvedServerOptions extends Omit<ServerOptions, 'fs' | 'middlewareMode' | 'sourcemapIgnoreList'> {
+    fs: Required<FileSystemServeOptions>;
+    middlewareMode: NonNullable<ServerOptions['middlewareMode']>;
+    sourcemapIgnoreList: Exclude<ServerOptions['sourcemapIgnoreList'], false | undefined>;
+}
+interface FileSystemServeOptions {
+    /**
+     * Strictly restrict file accessing outside of allowing paths.
+     *
+     * Set to `false` to disable the warning
+     *
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * Restrict accessing files outside the allowed directories.
+     *
+     * Accepts absolute path or a path relative to project root.
+     * Will try to search up for workspace root by default.
+     */
+    allow?: string[];
+    /**
+     * Restrict accessing files that matches the patterns.
+     *
+     * This will have higher priority than `allow`.
+     * picomatch patterns are supported.
+     *
+     * @default ['.env', '.env.*', '*.crt', '*.pem']
+     */
+    deny?: string[];
+    /**
+     * Enable caching of fs calls. It is enabled by default if no custom watch ignored patterns are provided.
+     *
+     * @experimental
+     * @default undefined
+     */
+    cachedChecks?: boolean;
+}
+type ServerHook = (this: void, server: ViteDevServer) => (() => void) | void | Promise<(() => void) | void>;
+type HttpServer = http.Server | Http2SecureServer;
+interface ViteDevServer {
+    /**
+     * The resolved vite config object
+     */
+    config: ResolvedConfig;
+    /**
+     * A connect app instance.
+     * - Can be used to attach custom middlewares to the dev server.
+     * - Can also be used as the handler function of a custom http server
+     *   or as a middleware in any connect-style Node.js frameworks
+     *
+     * https://github.com/senchalabs/connect#use-middleware
+     */
+    middlewares: Connect.Server;
+    /**
+     * native Node http server instance
+     * will be null in middleware mode
+     */
+    httpServer: HttpServer | null;
+    /**
+     * chokidar watcher instance
+     * https://github.com/paulmillr/chokidar#api
+     */
+    watcher: FSWatcher;
+    /**
+     * web socket server with `send(payload)` method
+     */
+    ws: WebSocketServer;
+    /**
+     * HMR broadcaster that can be used to send custom HMR messages to the client
+     *
+     * Always sends a message to at least a WebSocket client. Any third party can
+     * add a channel to the broadcaster to process messages
+     * @deprecated will be replaced with the environment api in v6.
+     */
+    hot: HMRBroadcaster;
+    /**
+     * Rollup plugin container that can run plugin hooks on a given file
+     */
+    pluginContainer: PluginContainer;
+    /**
+     * Module graph that tracks the import relationships, url to file mapping
+     * and hmr state.
+     */
+    moduleGraph: ModuleGraph;
+    /**
+     * The resolved urls Vite prints on the CLI. null in middleware mode or
+     * before `server.listen` is called.
+     */
+    resolvedUrls: ResolvedServerUrls | null;
+    /**
+     * Programmatically resolve, load and transform a URL and get the result
+     * without going through the http request pipeline.
+     */
+    transformRequest(url: string, options?: TransformOptions): Promise<TransformResult | null>;
+    /**
+     * Same as `transformRequest` but only warm up the URLs so the next request
+     * will already be cached. The function will never throw as it handles and
+     * reports errors internally.
+     */
+    warmupRequest(url: string, options?: TransformOptions): Promise<void>;
+    /**
+     * Apply vite built-in HTML transforms and any plugin HTML transforms.
+     */
+    transformIndexHtml(url: string, html: string, originalUrl?: string): Promise<string>;
+    /**
+     * Transform module code into SSR format.
+     */
+    ssrTransform(code: string, inMap: SourceMap | {
+        mappings: '';
+    } | null, url: string, originalCode?: string): Promise<TransformResult | null>;
+    /**
+     * Load a given URL as an instantiated module for SSR.
+     */
+    ssrLoadModule(url: string, opts?: {
+        fixStacktrace?: boolean;
+    }): Promise<Record<string, any>>;
+    /**
+     * Fetch information about the module for Vite SSR runtime.
+     * @experimental
+     */
+    ssrFetchModule(id: string, importer?: string): Promise<FetchResult>;
+    /**
+     * Returns a fixed version of the given stack
+     */
+    ssrRewriteStacktrace(stack: string): string;
+    /**
+     * Mutates the given SSR error by rewriting the stacktrace
+     */
+    ssrFixStacktrace(e: Error): void;
+    /**
+     * Triggers HMR for a module in the module graph. You can use the `server.moduleGraph`
+     * API to retrieve the module to be reloaded. If `hmr` is false, this is a no-op.
+     */
+    reloadModule(module: ModuleNode): Promise<void>;
+    /**
+     * Start the server.
+     */
+    listen(port?: number, isRestart?: boolean): Promise<ViteDevServer>;
+    /**
+     * Stop the server.
+     */
+    close(): Promise<void>;
+    /**
+     * Print server urls
+     */
+    printUrls(): void;
+    /**
+     * Bind CLI shortcuts
+     */
+    bindCLIShortcuts(options?: BindCLIShortcutsOptions<ViteDevServer>): void;
+    /**
+     * Restart the server.
+     *
+     * @param forceOptimize - force the optimizer to re-bundle, same as --force cli flag
+     */
+    restart(forceOptimize?: boolean): Promise<void>;
+    /**
+     * Open browser
+     */
+    openBrowser(): void;
+    /**
+     * Calling `await server.waitForRequestsIdle(id)` will wait until all static imports
+     * are processed. If called from a load or transform plugin hook, the id needs to be
+     * passed as a parameter to avoid deadlocks. Calling this function after the first
+     * static imports section of the module graph has been processed will resolve immediately.
+     * @experimental
+     */
+    waitForRequestsIdle: (ignoredId?: string) => Promise<void>;
+}
+interface ResolvedServerUrls {
+    local: string[];
+    network: string[];
+}
+declare function createServer(inlineConfig?: InlineConfig): Promise<ViteDevServer>;
+
+/** Cache for package.json resolution and package.json contents */
+type PackageCache = Map<string, PackageData>;
+interface PackageData {
+    dir: string;
+    hasSideEffects: (id: string) => boolean | 'no-treeshake' | null;
+    webResolvedImports: Record<string, string | undefined>;
+    nodeResolvedImports: Record<string, string | undefined>;
+    setResolvedCache: (key: string, entry: string, targetWeb: boolean) => void;
+    getResolvedCache: (key: string, targetWeb: boolean) => string | undefined;
+    data: {
+        [field: string]: any;
+        name: string;
+        type: string;
+        version: string;
+        main: string;
+        module: string;
+        browser: string | Record<string, string | false>;
+        exports: string | Record<string, any> | string[];
+        imports: Record<string, any>;
+        dependencies: Record<string, string>;
+    };
+}
+
+interface RollupCommonJSOptions {
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can
+   * narrow this list by only including specific files. These files will be
+   * analyzed and transpiled if either the analysis does not find ES module
+   * specific statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: string | RegExp | readonly (string | RegExp)[]
+  /**
+   * A minimatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: string | RegExp | readonly (string | RegExp)[]
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean
+  /**
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
+   */
+  sourceMap?: boolean
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: boolean
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a minimatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * minimatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | string | RegExp | readonly (string | RegExp)[]
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean)
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is
+   * hoisted to the top of the file, outside the `try-catch` clause.
+   *
+   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the
+   *   `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  ignoreTryCatch?:
+    | boolean
+    | 'remove'
+    | ReadonlyArray<string>
+    | ((id: string) => boolean | 'remove')
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugin assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine whether it is
+   * an ES module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean)
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However, there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?:
+    | boolean
+    | 'auto'
+    | 'preferred'
+    | 'namespace'
+    | ((id: string) => boolean | 'auto' | 'preferred' | 'namespace')
+
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?: boolean | 'auto' | ((id: string) => boolean | 'auto')
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like) environment for them with support for dynamic
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -\> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string
+}
+
+interface RollupDynamicImportVarsOptions {
+  /**
+   * Files to include in this plugin (default all).
+   * @default []
+   */
+  include?: string | RegExp | (string | RegExp)[]
+  /**
+   * Files to exclude in this plugin (default none).
+   * @default []
+   */
+  exclude?: string | RegExp | (string | RegExp)[]
+  /**
+   * By default, the plugin quits the build process when it encounters an error. If you set this option to true, it will throw a warning instead and leave the code untouched.
+   * @default false
+   */
+  warnOnError?: boolean
+}
+
+// Modified and inlined to avoid extra dependency
+// Source: https://github.com/terser/terser/blob/master/tools/terser.d.ts
+// BSD Licensed https://github.com/terser/terser/blob/master/LICENSE
+
+declare namespace Terser {
+  export type ECMA = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020
+
+  export type ConsoleProperty = keyof typeof console
+  type DropConsoleOption = boolean | ConsoleProperty[]
+
+  export interface ParseOptions {
+    bare_returns?: boolean
+    /** @deprecated legacy option. Currently, all supported EcmaScript is valid to parse. */
+    ecma?: ECMA
+    html5_comments?: boolean
+    shebang?: boolean
+  }
+
+  export interface CompressOptions {
+    arguments?: boolean
+    arrows?: boolean
+    booleans_as_integers?: boolean
+    booleans?: boolean
+    collapse_vars?: boolean
+    comparisons?: boolean
+    computed_props?: boolean
+    conditionals?: boolean
+    dead_code?: boolean
+    defaults?: boolean
+    directives?: boolean
+    drop_console?: DropConsoleOption
+    drop_debugger?: boolean
+    ecma?: ECMA
+    evaluate?: boolean
+    expression?: boolean
+    global_defs?: object
+    hoist_funs?: boolean
+    hoist_props?: boolean
+    hoist_vars?: boolean
+    ie8?: boolean
+    if_return?: boolean
+    inline?: boolean | InlineFunctions
+    join_vars?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fargs?: boolean
+    keep_fnames?: boolean | RegExp
+    keep_infinity?: boolean
+    loops?: boolean
+    module?: boolean
+    negate_iife?: boolean
+    passes?: number
+    properties?: boolean
+    pure_funcs?: string[]
+    pure_new?: boolean
+    pure_getters?: boolean | 'strict'
+    reduce_funcs?: boolean
+    reduce_vars?: boolean
+    sequences?: boolean | number
+    side_effects?: boolean
+    switches?: boolean
+    toplevel?: boolean
+    top_retain?: null | string | string[] | RegExp
+    typeofs?: boolean
+    unsafe_arrows?: boolean
+    unsafe?: boolean
+    unsafe_comps?: boolean
+    unsafe_Function?: boolean
+    unsafe_math?: boolean
+    unsafe_symbols?: boolean
+    unsafe_methods?: boolean
+    unsafe_proto?: boolean
+    unsafe_regexp?: boolean
+    unsafe_undefined?: boolean
+    unused?: boolean
+  }
+
+  export enum InlineFunctions {
+    Disabled = 0,
+    SimpleFunctions = 1,
+    WithArguments = 2,
+    WithArgumentsAndVariables = 3,
+  }
+
+  export interface MangleOptions {
+    eval?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fnames?: boolean | RegExp
+    module?: boolean
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
+    properties?: boolean | ManglePropertiesOptions
+    reserved?: string[]
+    safari10?: boolean
+    toplevel?: boolean
+  }
+
+  /**
+   * An identifier mangler for which the output is invariant with respect to the source code.
+   */
+  export interface SimpleIdentifierMangler {
+    /**
+     * Obtains the nth most favored (usually shortest) identifier to rename a variable to.
+     * The mangler will increment n and retry until the return value is not in use in scope, and is not a reserved word.
+     * This function is expected to be stable; Evaluating get(n) === get(n) should always return true.
+     * @param n The ordinal of the identifier.
+     */
+    get(n: number): string
+  }
+
+  /**
+   * An identifier mangler that leverages character frequency analysis to determine identifier precedence.
+   */
+  export interface WeightedIdentifierMangler extends SimpleIdentifierMangler {
+    /**
+     * Modifies the internal weighting of the input characters by the specified delta.
+     * Will be invoked on the entire printed AST, and then deduct mangleable identifiers.
+     * @param chars The characters to modify the weighting of.
+     * @param delta The numeric weight to add to the characters.
+     */
+    consider(chars: string, delta: number): number
+    /**
+     * Resets character weights.
+     */
+    reset(): void
+    /**
+     * Sorts identifiers by character frequency, in preparation for calls to get(n).
+     */
+    sort(): void
+  }
+
+  export interface ManglePropertiesOptions {
+    builtins?: boolean
+    debug?: boolean
+    keep_quoted?: boolean | 'strict'
+    nth_identifier?: SimpleIdentifierMangler | WeightedIdentifierMangler
+    regex?: RegExp | string
+    reserved?: string[]
+  }
+
+  export interface FormatOptions {
+    ascii_only?: boolean
+    /** @deprecated Not implemented anymore */
+    beautify?: boolean
+    braces?: boolean
+    comments?:
+      | boolean
+      | 'all'
+      | 'some'
+      | RegExp
+      | ((
+          node: any,
+          comment: {
+            value: string
+            type: 'comment1' | 'comment2' | 'comment3' | 'comment4'
+            pos: number
+            line: number
+            col: number
+          },
+        ) => boolean)
+    ecma?: ECMA
+    ie8?: boolean
+    keep_numbers?: boolean
+    indent_level?: number
+    indent_start?: number
+    inline_script?: boolean
+    keep_quoted_props?: boolean
+    max_line_len?: number | false
+    preamble?: string
+    preserve_annotations?: boolean
+    quote_keys?: boolean
+    quote_style?: OutputQuoteStyle
+    safari10?: boolean
+    semicolons?: boolean
+    shebang?: boolean
+    shorthand?: boolean
+    source_map?: SourceMapOptions
+    webkit?: boolean
+    width?: number
+    wrap_iife?: boolean
+    wrap_func_args?: boolean
+  }
+
+  export enum OutputQuoteStyle {
+    PreferDouble = 0,
+    AlwaysSingle = 1,
+    AlwaysDouble = 2,
+    AlwaysOriginal = 3,
+  }
+
+  export interface MinifyOptions {
+    compress?: boolean | CompressOptions
+    ecma?: ECMA
+    enclose?: boolean | string
+    ie8?: boolean
+    keep_classnames?: boolean | RegExp
+    keep_fnames?: boolean | RegExp
+    mangle?: boolean | MangleOptions
+    module?: boolean
+    nameCache?: object
+    format?: FormatOptions
+    /** @deprecated */
+    output?: FormatOptions
+    parse?: ParseOptions
+    safari10?: boolean
+    sourceMap?: boolean | SourceMapOptions
+    toplevel?: boolean
+  }
+
+  export interface MinifyOutput {
+    code?: string
+    map?: object | string
+    decoded_map?: object | null
+  }
+
+  export interface SourceMapOptions {
+    /** Source map object, 'inline' or source map file content */
+    content?: object | string
+    includeSources?: boolean
+    filename?: string
+    root?: string
+    asObject?: boolean
+    url?: string | 'inline'
+  }
+}
+
+interface TerserOptions extends Terser.MinifyOptions {
+    /**
+     * Vite-specific option to specify the max number of workers to spawn
+     * when minifying files with terser.
+     *
+     * @default number of CPUs minus 1
+     */
+    maxWorkers?: number;
+}
+
+interface BuildOptions {
+    /**
+     * Compatibility transform target. The transform is performed with esbuild
+     * and the lowest supported target is es2015/es6. Note this only handles
+     * syntax transformation and does not cover polyfills (except for dynamic
+     * import)
+     *
+     * Default: 'modules' - Similar to `@babel/preset-env`'s targets.esmodules,
+     * transpile targeting browsers that natively support dynamic es module imports.
+     * https://caniuse.com/es6-module-dynamic-import
+     *
+     * Another special value is 'esnext' - which only performs minimal transpiling
+     * (for minification compat) and assumes native dynamic imports support.
+     *
+     * For custom targets, see https://esbuild.github.io/api/#target and
+     * https://esbuild.github.io/content-types/#javascript for more details.
+     * @default 'modules'
+     */
+    target?: 'modules' | esbuild_TransformOptions['target'] | false;
+    /**
+     * whether to inject module preload polyfill.
+     * Note: does not apply to library mode.
+     * @default true
+     * @deprecated use `modulePreload.polyfill` instead
+     */
+    polyfillModulePreload?: boolean;
+    /**
+     * Configure module preload
+     * Note: does not apply to library mode.
+     * @default true
+     */
+    modulePreload?: boolean | ModulePreloadOptions;
+    /**
+     * Directory relative from `root` where build output will be placed. If the
+     * directory exists, it will be removed before the build.
+     * @default 'dist'
+     */
+    outDir?: string;
+    /**
+     * Directory relative from `outDir` where the built js/css/image assets will
+     * be placed.
+     * @default 'assets'
+     */
+    assetsDir?: string;
+    /**
+     * Static asset files smaller than this number (in bytes) will be inlined as
+     * base64 strings. Default limit is `4096` (4 KiB). Set to `0` to disable.
+     * @default 4096
+     */
+    assetsInlineLimit?: number | ((filePath: string, content: Buffer) => boolean | undefined);
+    /**
+     * Whether to code-split CSS. When enabled, CSS in async chunks will be
+     * inlined as strings in the chunk and inserted via dynamically created
+     * style tags when the chunk is loaded.
+     * @default true
+     */
+    cssCodeSplit?: boolean;
+    /**
+     * An optional separate target for CSS minification.
+     * As esbuild only supports configuring targets to mainstream
+     * browsers, users may need this option when they are targeting
+     * a niche browser that comes with most modern JavaScript features
+     * but has poor CSS support, e.g. Android WeChat WebView, which
+     * doesn't support the #RGBA syntax.
+     * @default target
+     */
+    cssTarget?: esbuild_TransformOptions['target'] | false;
+    /**
+     * Override CSS minification specifically instead of defaulting to `build.minify`,
+     * so you can configure minification for JS and CSS separately.
+     * @default 'esbuild'
+     */
+    cssMinify?: boolean | 'esbuild' | 'lightningcss';
+    /**
+     * If `true`, a separate sourcemap file will be created. If 'inline', the
+     * sourcemap will be appended to the resulting output file as data URI.
+     * 'hidden' works like `true` except that the corresponding sourcemap
+     * comments in the bundled files are suppressed.
+     * @default false
+     */
+    sourcemap?: boolean | 'inline' | 'hidden';
+    /**
+     * Set to `false` to disable minification, or specify the minifier to use.
+     * Available options are 'terser' or 'esbuild'.
+     * @default 'esbuild'
+     */
+    minify?: boolean | 'terser' | 'esbuild';
+    /**
+     * Options for terser
+     * https://terser.org/docs/api-reference#minify-options
+     *
+     * In addition, you can also pass a `maxWorkers: number` option to specify the
+     * max number of workers to spawn. Defaults to the number of CPUs minus 1.
+     */
+    terserOptions?: TerserOptions;
+    /**
+     * Will be merged with internal rollup options.
+     * https://rollupjs.org/configuration-options/
+     */
+    rollupOptions?: RollupOptions;
+    /**
+     * Options to pass on to `@rollup/plugin-commonjs`
+     */
+    commonjsOptions?: RollupCommonJSOptions;
+    /**
+     * Options to pass on to `@rollup/plugin-dynamic-import-vars`
+     */
+    dynamicImportVarsOptions?: RollupDynamicImportVarsOptions;
+    /**
+     * Whether to write bundle to disk
+     * @default true
+     */
+    write?: boolean;
+    /**
+     * Empty outDir on write.
+     * @default true when outDir is a sub directory of project root
+     */
+    emptyOutDir?: boolean | null;
+    /**
+     * Copy the public directory to outDir on write.
+     * @default true
+     */
+    copyPublicDir?: boolean;
+    /**
+     * Whether to emit a .vite/manifest.json under assets dir to map hash-less filenames
+     * to their hashed versions. Useful when you want to generate your own HTML
+     * instead of using the one generated by Vite.
+     *
+     * Example:
+     *
+     * ```json
+     * {
+     *   "main.js": {
+     *     "file": "main.68fe3fad.js",
+     *     "css": "main.e6b63442.css",
+     *     "imports": [...],
+     *     "dynamicImports": [...]
+     *   }
+     * }
+     * ```
+     * @default false
+     */
+    manifest?: boolean | string;
+    /**
+     * Build in library mode. The value should be the global name of the lib in
+     * UMD mode. This will produce esm + cjs + umd bundle formats with default
+     * configurations that are suitable for distributing libraries.
+     * @default false
+     */
+    lib?: LibraryOptions | false;
+    /**
+     * Produce SSR oriented build. Note this requires specifying SSR entry via
+     * `rollupOptions.input`.
+     * @default false
+     */
+    ssr?: boolean | string;
+    /**
+     * Generate SSR manifest for determining style links and asset preload
+     * directives in production.
+     * @default false
+     */
+    ssrManifest?: boolean | string;
+    /**
+     * Emit assets during SSR.
+     * @default false
+     */
+    ssrEmitAssets?: boolean;
+    /**
+     * Set to false to disable reporting compressed chunk sizes.
+     * Can slightly improve build speed.
+     * @default true
+     */
+    reportCompressedSize?: boolean;
+    /**
+     * Adjust chunk size warning limit (in kB).
+     * @default 500
+     */
+    chunkSizeWarningLimit?: number;
+    /**
+     * Rollup watch options
+     * https://rollupjs.org/configuration-options/#watch
+     * @default null
+     */
+    watch?: WatcherOptions | null;
+}
+interface LibraryOptions {
+    /**
+     * Path of library entry
+     */
+    entry: InputOption;
+    /**
+     * The name of the exposed global variable. Required when the `formats` option includes
+     * `umd` or `iife`
+     */
+    name?: string;
+    /**
+     * Output bundle formats
+     * @default ['es', 'umd']
+     */
+    formats?: LibraryFormats[];
+    /**
+     * The name of the package file output. The default file name is the name option
+     * of the project package.json. It can also be defined as a function taking the
+     * format as an argument.
+     */
+    fileName?: string | ((format: ModuleFormat, entryName: string) => string);
+}
+type LibraryFormats = 'es' | 'cjs' | 'umd' | 'iife' | 'system';
+interface ModulePreloadOptions {
+    /**
+     * Whether to inject a module preload polyfill.
+     * Note: does not apply to library mode.
+     * @default true
+     */
+    polyfill?: boolean;
+    /**
+     * Resolve the list of dependencies to preload for a given dynamic import
+     * @experimental
+     */
+    resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+interface ResolvedModulePreloadOptions {
+    polyfill: boolean;
+    resolveDependencies?: ResolveModulePreloadDependenciesFn;
+}
+type ResolveModulePreloadDependenciesFn = (filename: string, deps: string[], context: {
+    hostId: string;
+    hostType: 'html' | 'js';
+}) => string[];
+interface ResolvedBuildOptions extends Required<Omit<BuildOptions, 'polyfillModulePreload'>> {
+    modulePreload: false | ResolvedModulePreloadOptions;
+}
+/**
+ * Bundles the app for production.
+ * Returns a Promise containing the build result.
+ */
+declare function build(inlineConfig?: InlineConfig): Promise<RollupOutput | RollupOutput[] | RollupWatcher>;
+type RenderBuiltAssetUrl = (filename: string, type: {
+    type: 'asset' | 'public';
+    hostId: string;
+    hostType: 'js' | 'css' | 'html';
+    ssr: boolean;
+}) => string | {
+    relative?: boolean;
+    runtime?: string;
+} | undefined;
+
+interface ESBuildOptions extends esbuild_TransformOptions {
+    include?: string | RegExp | string[] | RegExp[];
+    exclude?: string | RegExp | string[] | RegExp[];
+    jsxInject?: string;
+    /**
+     * This option is not respected. Use `build.minify` instead.
+     */
+    minify?: never;
+}
+type ESBuildTransformResult = Omit<esbuild_TransformResult, 'map'> & {
+    map: SourceMap;
+};
+declare function transformWithEsbuild(code: string, filename: string, options?: esbuild_TransformOptions, inMap?: object): Promise<ESBuildTransformResult>;
+
+type ExportsData = {
+    hasModuleSyntax: boolean;
+    exports: readonly string[];
+    jsxLoader?: boolean;
+};
+interface DepsOptimizer {
+    metadata: DepOptimizationMetadata;
+    scanProcessing?: Promise<void>;
+    registerMissingImport: (id: string, resolved: string) => OptimizedDepInfo;
+    run: () => void;
+    isOptimizedDepFile: (id: string) => boolean;
+    isOptimizedDepUrl: (url: string) => boolean;
+    getOptimizedDepId: (depInfo: OptimizedDepInfo) => string;
+    close: () => Promise<void>;
+    options: DepOptimizationOptions;
+}
+interface DepOptimizationConfig {
+    /**
+     * Force optimize listed dependencies (must be resolvable import paths,
+     * cannot be globs).
+     */
+    include?: string[];
+    /**
+     * Do not optimize these dependencies (must be resolvable import paths,
+     * cannot be globs).
+     */
+    exclude?: string[];
+    /**
+     * Forces ESM interop when importing these dependencies. Some legacy
+     * packages advertise themselves as ESM but use `require` internally
+     * @experimental
+     */
+    needsInterop?: string[];
+    /**
+     * Options to pass to esbuild during the dep scanning and optimization
+     *
+     * Certain options are omitted since changing them would not be compatible
+     * with Vite's dep optimization.
+     *
+     * - `external` is also omitted, use Vite's `optimizeDeps.exclude` option
+     * - `plugins` are merged with Vite's dep plugin
+     *
+     * https://esbuild.github.io/api
+     */
+    esbuildOptions?: Omit<esbuild_BuildOptions, 'bundle' | 'entryPoints' | 'external' | 'write' | 'watch' | 'outdir' | 'outfile' | 'outbase' | 'outExtension' | 'metafile'>;
+    /**
+     * List of file extensions that can be optimized. A corresponding esbuild
+     * plugin must exist to handle the specific extension.
+     *
+     * By default, Vite can optimize `.mjs`, `.js`, `.ts`, and `.mts` files. This option
+     * allows specifying additional extensions.
+     *
+     * @experimental
+     */
+    extensions?: string[];
+    /**
+     * Deps optimization during build was removed in Vite 5.1. This option is
+     * now redundant and will be removed in a future version. Switch to using
+     * `optimizeDeps.noDiscovery` and an empty or undefined `optimizeDeps.include`.
+     * true or 'dev' disables the optimizer, false or 'build' leaves it enabled.
+     * @default 'build'
+     * @deprecated
+     * @experimental
+     */
+    disabled?: boolean | 'build' | 'dev';
+    /**
+     * Automatic dependency discovery. When `noDiscovery` is true, only dependencies
+     * listed in `include` will be optimized. The scanner isn't run for cold start
+     * in this case. CJS-only dependencies must be present in `include` during dev.
+     * @default false
+     * @experimental
+     */
+    noDiscovery?: boolean;
+    /**
+     * When enabled, it will hold the first optimized deps results until all static
+     * imports are crawled on cold start. This avoids the need for full-page reloads
+     * when new dependencies are discovered and they trigger the generation of new
+     * common chunks. If all dependencies are found by the scanner plus the explicitly
+     * defined ones in `include`, it is better to disable this option to let the
+     * browser process more requests in parallel.
+     * @default true
+     * @experimental
+     */
+    holdUntilCrawlEnd?: boolean;
+}
+type DepOptimizationOptions = DepOptimizationConfig & {
+    /**
+     * By default, Vite will crawl your `index.html` to detect dependencies that
+     * need to be pre-bundled. If `build.rollupOptions.input` is specified, Vite
+     * will crawl those entry points instead.
+     *
+     * If neither of these fit your needs, you can specify custom entries using
+     * this option - the value should be a fast-glob pattern or array of patterns
+     * (https://github.com/mrmlnc/fast-glob#basic-syntax) that are relative from
+     * vite project root. This will overwrite default entries inference.
+     */
+    entries?: string | string[];
+    /**
+     * Force dep pre-optimization regardless of whether deps have changed.
+     * @experimental
+     */
+    force?: boolean;
+};
+interface OptimizedDepInfo {
+    id: string;
+    file: string;
+    src?: string;
+    needsInterop?: boolean;
+    browserHash?: string;
+    fileHash?: string;
+    /**
+     * During optimization, ids can still be resolved to their final location
+     * but the bundles may not yet be saved to disk
+     */
+    processing?: Promise<void>;
+    /**
+     * ExportData cache, discovered deps will parse the src entry to get exports
+     * data used both to define if interop is needed and when pre-bundling
+     */
+    exportsData?: Promise<ExportsData>;
+}
+interface DepOptimizationMetadata {
+    /**
+     * The main hash is determined by user config and dependency lockfiles.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    hash: string;
+    /**
+     * This hash is determined by dependency lockfiles.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    lockfileHash: string;
+    /**
+     * This hash is determined by user config.
+     * This is checked on server startup to avoid unnecessary re-bundles.
+     */
+    configHash: string;
+    /**
+     * The browser hash is determined by the main hash plus additional dependencies
+     * discovered at runtime. This is used to invalidate browser requests to
+     * optimized deps.
+     */
+    browserHash: string;
+    /**
+     * Metadata for each already optimized dependency
+     */
+    optimized: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for non-entry optimized chunks and dynamic imports
+     */
+    chunks: Record<string, OptimizedDepInfo>;
+    /**
+     * Metadata for each newly discovered dependency after processing
+     */
+    discovered: Record<string, OptimizedDepInfo>;
+    /**
+     * OptimizedDepInfo list
+     */
+    depInfoList: OptimizedDepInfo[];
+}
+/**
+ * Scan and optimize dependencies within a project.
+ * Used by Vite CLI when running `vite optimize`.
+ */
+declare function optimizeDeps(config: ResolvedConfig, force?: boolean | undefined, asCommand?: boolean): Promise<DepOptimizationMetadata>;
+
+type SSRTarget = 'node' | 'webworker';
+type SsrDepOptimizationOptions = DepOptimizationConfig;
+interface SSROptions {
+    noExternal?: string | RegExp | (string | RegExp)[] | true;
+    external?: string[] | true;
+    /**
+     * Define the target for the ssr build. The browser field in package.json
+     * is ignored for node but used if webworker is the target
+     * @default 'node'
+     */
+    target?: SSRTarget;
+    /**
+     * Control over which dependencies are optimized during SSR and esbuild options
+     * During build:
+     *   no external CJS dependencies are optimized by default
+     * During dev:
+     *   explicit no external CJS dependencies are optimized by default
+     * @experimental
+     */
+    optimizeDeps?: SsrDepOptimizationOptions;
+    resolve?: {
+        /**
+         * Conditions that are used in the plugin pipeline. The default value is the root config's `resolve.conditions`.
+         *
+         * Use this to override the default ssr conditions for the ssr build.
+         *
+         * @default rootConfig.resolve.conditions
+         */
+        conditions?: string[];
+        /**
+         * Conditions that are used during ssr import (including `ssrLoadModule`) of externalized dependencies.
+         *
+         * @default []
+         */
+        externalConditions?: string[];
+    };
+}
+interface ResolvedSSROptions extends SSROptions {
+    target: SSRTarget;
+    optimizeDeps: SsrDepOptimizationOptions;
+}
+
+interface FsUtils {
+    existsSync: (path: string) => boolean;
+    isDirectory: (path: string) => boolean;
+    tryResolveRealFile: (path: string, preserveSymlinks?: boolean) => string | undefined;
+    tryResolveRealFileWithExtensions: (path: string, extensions: string[], preserveSymlinks?: boolean) => string | undefined;
+    tryResolveRealFileOrType: (path: string, preserveSymlinks?: boolean) => {
+        path?: string;
+        type: 'directory' | 'file';
+    } | undefined;
+    initWatcher?: (watcher: FSWatcher) => void;
+}
+
+interface ResolveOptions {
+    /**
+     * @default ['browser', 'module', 'jsnext:main', 'jsnext']
+     */
+    mainFields?: string[];
+    conditions?: string[];
+    /**
+     * @default ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json']
+     */
+    extensions?: string[];
+    dedupe?: string[];
+    /**
+     * @default false
+     */
+    preserveSymlinks?: boolean;
+}
+interface InternalResolveOptions extends Required<ResolveOptions> {
+    root: string;
+    isBuild: boolean;
+    isProduction: boolean;
+    ssrConfig?: SSROptions;
+    packageCache?: PackageCache;
+    fsUtils?: FsUtils;
+    /**
+     * src code mode also attempts the following:
+     * - resolving /xxx as URLs
+     * - resolving bare imports from optimized deps
+     */
+    asSrc?: boolean;
+    tryIndex?: boolean;
+    tryPrefix?: string;
+    preferRelative?: boolean;
+    isRequire?: boolean;
+    isFromTsImporter?: boolean;
+    tryEsmOnly?: boolean;
+    scan?: boolean;
+    ssrOptimizeCheck?: boolean;
+    getDepsOptimizer?: (ssr: boolean) => DepsOptimizer | undefined;
+    shouldExternalize?: (id: string, importer?: string) => boolean | undefined;
+}
+
+// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
+
+interface Targets {
+  android?: number,
+  chrome?: number,
+  edge?: number,
+  firefox?: number,
+  ie?: number,
+  ios_saf?: number,
+  opera?: number,
+  safari?: number,
+  samsung?: number
+}
+
+interface Drafts {
+  /** Whether to enable @custom-media rules. */
+  customMedia?: boolean
+}
+
+interface NonStandard {
+  /** Whether to enable the non-standard >>> and /deep/ selector combinators used by Angular and Vue. */
+  deepSelectorCombinator?: boolean
+}
+
+interface PseudoClasses {
+  hover?: string,
+  active?: string,
+  focus?: string,
+  focusVisible?: string,
+  focusWithin?: string
+}
+
+interface CSSModulesConfig {
+  /** The pattern to use when renaming class names and other identifiers. Default is `[hash]_[local]`. */
+  pattern?: string,
+  /** Whether to rename dashed identifiers, e.g. custom properties. */
+  dashedIdents?: boolean
+}
+
+/**
+ * Options are spread, so you can also use options that are not typed here like
+ * visitor (not exposed because it would impact too much the bundle size)
+ */
+type LightningCSSOptions = {
+  targets?: Targets
+  include?: number
+  exclude?: number
+  drafts?: Drafts
+  nonStandard?: NonStandard
+  pseudoClasses?: PseudoClasses
+  unusedSymbols?: string[]
+  cssModules?: CSSModulesConfig
+  errorRecovery?: boolean
+}
+
+interface CSSOptions {
+    /**
+     * Using lightningcss is an experimental option to handle CSS modules,
+     * assets and imports via Lightning CSS. It requires to install it as a
+     * peer dependency. This is incompatible with the use of preprocessors.
+     *
+     * @default 'postcss'
+     * @experimental
+     */
+    transformer?: 'postcss' | 'lightningcss';
+    /**
+     * https://github.com/css-modules/postcss-modules
+     */
+    modules?: CSSModulesOptions | false;
+    /**
+     * Options for preprocessors.
+     *
+     * In addition to options specific to each processors, Vite supports `additionalData` option.
+     * The `additionalData` option can be used to inject extra code for each style content.
+     */
+    preprocessorOptions?: Record<string, any>;
+    /**
+     * If this option is set, preprocessors will run in workers when possible.
+     * `true` means the number of CPUs minus 1.
+     *
+     * @default 0
+     * @experimental
+     */
+    preprocessorMaxWorkers?: number | true;
+    postcss?: string | (PostCSS.ProcessOptions & {
+        plugins?: PostCSS.AcceptedPlugin[];
+    });
+    /**
+     * Enables css sourcemaps during dev
+     * @default false
+     * @experimental
+     */
+    devSourcemap?: boolean;
+    /**
+     * @experimental
+     */
+    lightningcss?: LightningCSSOptions;
+}
+interface CSSModulesOptions {
+    getJSON?: (cssFileName: string, json: Record<string, string>, outputFileName: string) => void;
+    scopeBehaviour?: 'global' | 'local';
+    globalModulePaths?: RegExp[];
+    exportGlobals?: boolean;
+    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+    hashPrefix?: string;
+    /**
+     * default: undefined
+     */
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly' | ((originalClassName: string, generatedClassName: string, inputFile: string) => string);
+}
+type ResolvedCSSOptions = Omit<CSSOptions, 'lightningcss'> & {
+    lightningcss?: LightningCSSOptions & {
+        targets: LightningCSSOptions['targets'];
+    };
+};
+interface PreprocessCSSResult {
+    code: string;
+    map?: SourceMapInput;
+    modules?: Record<string, string>;
+    deps?: Set<string>;
+}
+/**
+ * @experimental
+ */
+declare function preprocessCSS(code: string, filename: string, config: ResolvedConfig): Promise<PreprocessCSSResult>;
+declare function formatPostcssSourceMap(rawMap: ExistingRawSourceMap, file: string): Promise<ExistingRawSourceMap>;
+
+interface HtmlTagDescriptor {
+    tag: string;
+    attrs?: Record<string, string | boolean | undefined>;
+    children?: string | HtmlTagDescriptor[];
+    /**
+     * default: 'head-prepend'
+     */
+    injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
+}
+type IndexHtmlTransformResult = string | HtmlTagDescriptor[] | {
+    html: string;
+    tags: HtmlTagDescriptor[];
+};
+interface IndexHtmlTransformContext {
+    /**
+     * public path when served
+     */
+    path: string;
+    /**
+     * filename on disk
+     */
+    filename: string;
+    server?: ViteDevServer;
+    bundle?: OutputBundle;
+    chunk?: OutputChunk;
+    originalUrl?: string;
+}
+type IndexHtmlTransformHook = (this: void, html: string, ctx: IndexHtmlTransformContext) => IndexHtmlTransformResult | void | Promise<IndexHtmlTransformResult | void>;
+type IndexHtmlTransform = IndexHtmlTransformHook | {
+    order?: 'pre' | 'post' | null;
+    /**
+     * @deprecated renamed to `order`
+     */
+    enforce?: 'pre' | 'post';
+    /**
+     * @deprecated renamed to `handler`
+     */
+    transform: IndexHtmlTransformHook;
+} | {
+    order?: 'pre' | 'post' | null;
+    /**
+     * @deprecated renamed to `order`
+     */
+    enforce?: 'pre' | 'post';
+    handler: IndexHtmlTransformHook;
+};
+
+/**
+ * Vite plugins extends the Rollup plugin interface with a few extra
+ * vite-specific options. A valid vite plugin is also a valid Rollup plugin.
+ * On the contrary, a Rollup plugin may or may NOT be a valid vite universal
+ * plugin, since some Rollup features do not make sense in an unbundled
+ * dev server context. That said, as long as a rollup plugin doesn't have strong
+ * coupling between its bundle phase and output phase hooks then it should
+ * just work (that means, most of them).
+ *
+ * By default, the plugins are run during both serve and build. When a plugin
+ * is applied during serve, it will only run **non output plugin hooks** (see
+ * rollup type definition of {@link rollup#PluginHooks}). You can think of the
+ * dev server as only running `const bundle = rollup.rollup()` but never calling
+ * `bundle.generate()`.
+ *
+ * A plugin that expects to have different behavior depending on serve/build can
+ * export a factory function that receives the command being run via options.
+ *
+ * If a plugin should be applied only for server or build, a function format
+ * config file can be used to conditional determine the plugins to use.
+ */
+interface Plugin<A = any> extends rollup.Plugin<A> {
+    /**
+     * Enforce plugin invocation tier similar to webpack loaders. Hooks ordering
+     * is still subject to the `order` property in the hook object.
+     *
+     * Plugin invocation order:
+     * - alias resolution
+     * - `enforce: 'pre'` plugins
+     * - vite core plugins
+     * - normal plugins
+     * - vite build plugins
+     * - `enforce: 'post'` plugins
+     * - vite build post plugins
+     */
+    enforce?: 'pre' | 'post';
+    /**
+     * Apply the plugin only for serve or build, or on certain conditions.
+     */
+    apply?: 'serve' | 'build' | ((this: void, config: UserConfig, env: ConfigEnv) => boolean);
+    /**
+     * Modify vite config before it's resolved. The hook can either mutate the
+     * passed-in config directly, or return a partial config object that will be
+     * deeply merged into existing config.
+     *
+     * Note: User plugins are resolved before running this hook so injecting other
+     * plugins inside  the `config` hook will have no effect.
+     */
+    config?: ObjectHook<(this: void, config: UserConfig, env: ConfigEnv) => Omit<UserConfig, 'plugins'> | null | void | Promise<Omit<UserConfig, 'plugins'> | null | void>>;
+    /**
+     * Use this hook to read and store the final resolved vite config.
+     */
+    configResolved?: ObjectHook<(this: void, config: ResolvedConfig) => void | Promise<void>>;
+    /**
+     * Configure the vite server. The hook receives the {@link ViteDevServer}
+     * instance. This can also be used to store a reference to the server
+     * for use in other hooks.
+     *
+     * The hooks will be called before internal middlewares are applied. A hook
+     * can return a post hook that will be called after internal middlewares
+     * are applied. Hook can be async functions and will be called in series.
+     */
+    configureServer?: ObjectHook<ServerHook>;
+    /**
+     * Configure the preview server. The hook receives the {@link PreviewServer}
+     * instance. This can also be used to store a reference to the server
+     * for use in other hooks.
+     *
+     * The hooks are called before other middlewares are applied. A hook can
+     * return a post hook that will be called after other middlewares are
+     * applied. Hooks can be async functions and will be called in series.
+     */
+    configurePreviewServer?: ObjectHook<PreviewServerHook>;
+    /**
+     * Transform index.html.
+     * The hook receives the following arguments:
+     *
+     * - html: string
+     * - ctx?: vite.ServerContext (only present during serve)
+     * - bundle?: rollup.OutputBundle (only present during build)
+     *
+     * It can either return a transformed string, or a list of html tag
+     * descriptors that will be injected into the `<head>` or `<body>`.
+     *
+     * By default the transform is applied **after** vite's internal html
+     * transform. If you need to apply the transform before vite, use an object:
+     * `{ order: 'pre', handler: hook }`
+     */
+    transformIndexHtml?: IndexHtmlTransform;
+    /**
+     * Perform custom handling of HMR updates.
+     * The handler receives a context containing changed filename, timestamp, a
+     * list of modules affected by the file change, and the dev server instance.
+     *
+     * - The hook can return a filtered list of modules to narrow down the update.
+     *   e.g. for a Vue SFC, we can narrow down the part to update by comparing
+     *   the descriptors.
+     *
+     * - The hook can also return an empty array and then perform custom updates
+     *   by sending a custom hmr payload via server.ws.send().
+     *
+     * - If the hook doesn't return a value, the hmr update will be performed as
+     *   normal.
+     */
+    handleHotUpdate?: ObjectHook<(this: void, ctx: HmrContext) => Array<ModuleNode> | void | Promise<Array<ModuleNode> | void>>;
+    /**
+     * extend hooks with ssr flag
+     */
+    resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
+        attributes: Record<string, string>;
+        custom?: CustomPluginOptions;
+        ssr?: boolean;
+        isEntry: boolean;
+    }) => Promise<ResolveIdResult> | ResolveIdResult>;
+    load?: ObjectHook<(this: PluginContext, id: string, options?: {
+        ssr?: boolean;
+    }) => Promise<LoadResult> | LoadResult>;
+    transform?: ObjectHook<(this: TransformPluginContext, code: string, id: string, options?: {
+        ssr?: boolean;
+    }) => Promise<rollup.TransformResult> | rollup.TransformResult>;
+}
+type HookHandler<T> = T extends ObjectHook<infer H> ? H : T;
+type PluginWithRequiredHook<K extends keyof Plugin> = Plugin & {
+    [P in K]: NonNullable<Plugin[P]>;
+};
+
+interface JsonOptions {
+    /**
+     * Generate a named export for every property of the JSON object
+     * @default true
+     */
+    namedExports?: boolean;
+    /**
+     * Generate performant output as JSON.parse("stringified").
+     * Enabling this will disable namedExports.
+     * @default false
+     */
+    stringify?: boolean;
+}
+
+interface ConfigEnv {
+    /**
+     * 'serve': during dev (`vite` command)
+     * 'build': when building for production (`vite build` command)
+     */
+    command: 'build' | 'serve';
+    mode: string;
+    isSsrBuild?: boolean;
+    isPreview?: boolean;
+}
+/**
+ * spa: include SPA fallback middleware and configure sirv with `single: true` in preview
+ *
+ * mpa: only include non-SPA HTML middlewares
+ *
+ * custom: don't include HTML middlewares
+ */
+type AppType = 'spa' | 'mpa' | 'custom';
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+/**
+ * Type helper to make it easier to use vite.config.ts
+ * accepts a direct {@link UserConfig} object, or a function that returns it.
+ * The function receives a {@link ConfigEnv} object.
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+type PluginOption = Plugin | false | null | undefined | PluginOption[] | Promise<Plugin | false | null | undefined | PluginOption[]>;
+interface UserConfig {
+    /**
+     * Project root directory. Can be an absolute path, or a path relative from
+     * the location of the config file itself.
+     * @default process.cwd()
+     */
+    root?: string;
+    /**
+     * Base public path when served in development or production.
+     * @default '/'
+     */
+    base?: string;
+    /**
+     * Directory to serve as plain static assets. Files in this directory are
+     * served and copied to build dist dir as-is without transform. The value
+     * can be either an absolute file system path or a path relative to project root.
+     *
+     * Set to `false` or an empty string to disable copied static assets to build dist dir.
+     * @default 'public'
+     */
+    publicDir?: string | false;
+    /**
+     * Directory to save cache files. Files in this directory are pre-bundled
+     * deps or some other cache files that generated by vite, which can improve
+     * the performance. You can use `--force` flag or manually delete the directory
+     * to regenerate the cache files. The value can be either an absolute file
+     * system path or a path relative to project root.
+     * Default to `.vite` when no `package.json` is detected.
+     * @default 'node_modules/.vite'
+     */
+    cacheDir?: string;
+    /**
+     * Explicitly set a mode to run in. This will override the default mode for
+     * each command, and can be overridden by the command line --mode option.
+     */
+    mode?: string;
+    /**
+     * Define global variable replacements.
+     * Entries will be defined on `window` during dev and replaced during build.
+     */
+    define?: Record<string, any>;
+    /**
+     * Array of vite plugins to use.
+     */
+    plugins?: PluginOption[];
+    /**
+     * Configure resolver
+     */
+    resolve?: ResolveOptions & {
+        alias?: AliasOptions;
+    };
+    /**
+     * HTML related options
+     */
+    html?: HTMLOptions;
+    /**
+     * CSS related options (preprocessors and CSS modules)
+     */
+    css?: CSSOptions;
+    /**
+     * JSON loading options
+     */
+    json?: JsonOptions;
+    /**
+     * Transform options to pass to esbuild.
+     * Or set to `false` to disable esbuild.
+     */
+    esbuild?: ESBuildOptions | false;
+    /**
+     * Specify additional picomatch patterns to be treated as static assets.
+     */
+    assetsInclude?: string | RegExp | (string | RegExp)[];
+    /**
+     * Server specific options, e.g. host, port, https...
+     */
+    server?: ServerOptions;
+    /**
+     * Build specific options
+     */
+    build?: BuildOptions;
+    /**
+     * Preview specific options, e.g. host, port, https...
+     */
+    preview?: PreviewOptions;
+    /**
+     * Dep optimization options
+     */
+    optimizeDeps?: DepOptimizationOptions;
+    /**
+     * SSR specific options
+     */
+    ssr?: SSROptions;
+    /**
+     * Experimental features
+     *
+     * Features under this field could change in the future and might NOT follow semver.
+     * Please be careful and always pin Vite's version when using them.
+     * @experimental
+     */
+    experimental?: ExperimentalOptions;
+    /**
+     * Legacy options
+     *
+     * Features under this field only follow semver for patches, they could be removed in a
+     * future minor version. Please always pin Vite's version to a minor when using them.
+     */
+    legacy?: LegacyOptions;
+    /**
+     * Log level.
+     * @default 'info'
+     */
+    logLevel?: LogLevel;
+    /**
+     * Custom logger.
+     */
+    customLogger?: Logger;
+    /**
+     * @default true
+     */
+    clearScreen?: boolean;
+    /**
+     * Environment files directory. Can be an absolute path, or a path relative from
+     * root.
+     * @default root
+     */
+    envDir?: string;
+    /**
+     * Env variables starts with `envPrefix` will be exposed to your client source code via import.meta.env.
+     * @default 'VITE_'
+     */
+    envPrefix?: string | string[];
+    /**
+     * Worker bundle options
+     */
+    worker?: {
+        /**
+         * Output format for worker bundle
+         * @default 'iife'
+         */
+        format?: 'es' | 'iife';
+        /**
+         * Vite plugins that apply to worker bundle. The plugins returned by this function
+         * should be new instances every time it is called, because they are used for each
+         * rollup worker bundling process.
+         */
+        plugins?: () => PluginOption[];
+        /**
+         * Rollup options to build worker bundle
+         */
+        rollupOptions?: Omit<RollupOptions, 'plugins' | 'input' | 'onwarn' | 'preserveEntrySignatures'>;
+    };
+    /**
+     * Whether your application is a Single Page Application (SPA),
+     * a Multi-Page Application (MPA), or Custom Application (SSR
+     * and frameworks with custom HTML handling)
+     * @default 'spa'
+     */
+    appType?: AppType;
+}
+interface HTMLOptions {
+    /**
+     * A nonce value placeholder that will be used when generating script/style tags.
+     *
+     * Make sure that this placeholder will be replaced with a unique value for each request by the server.
+     */
+    cspNonce?: string;
+}
+interface ExperimentalOptions {
+    /**
+     * Append fake `&lang.(ext)` when queries are specified, to preserve the file extension for following plugins to process.
+     *
+     * @experimental
+     * @default false
+     */
+    importGlobRestoreExtension?: boolean;
+    /**
+     * Allow finegrain control over assets and public files paths
+     *
+     * @experimental
+     */
+    renderBuiltUrl?: RenderBuiltAssetUrl;
+    /**
+     * Enables support of HMR partial accept via `import.meta.hot.acceptExports`.
+     *
+     * @experimental
+     * @default false
+     */
+    hmrPartialAccept?: boolean;
+    /**
+     * Skips SSR transform to make it easier to use Vite with Node ESM loaders.
+     * @warning Enabling this will break normal operation of Vite's SSR in development mode.
+     *
+     * @experimental
+     * @default false
+     */
+    skipSsrTransform?: boolean;
+}
+interface LegacyOptions {
+    /**
+     * In Vite 4, SSR-externalized modules (modules not bundled and loaded by Node.js at runtime)
+     * are implicitly proxied in dev to automatically handle `default` and `__esModule` access.
+     * However, this does not correctly reflect how it works in the Node.js runtime, causing
+     * inconsistencies between dev and prod.
+     *
+     * In Vite 5, the proxy is removed so dev and prod are consistent, but if you still require
+     * the old behaviour, you can enable this option. If so, please leave your feedback at
+     * https://github.com/vitejs/vite/discussions/14697.
+     */
+    proxySsrExternalModules?: boolean;
+}
+interface ResolvedWorkerOptions {
+    format: 'es' | 'iife';
+    plugins: (bundleChain: string[]) => Promise<Plugin[]>;
+    rollupOptions: RollupOptions;
+}
+interface InlineConfig extends UserConfig {
+    configFile?: string | false;
+    envFile?: false;
+}
+type ResolvedConfig = Readonly<Omit<UserConfig, 'plugins' | 'css' | 'assetsInclude' | 'optimizeDeps' | 'worker' | 'build'> & {
+    configFile: string | undefined;
+    configFileDependencies: string[];
+    inlineConfig: InlineConfig;
+    root: string;
+    base: string;
+    publicDir: string;
+    cacheDir: string;
+    command: 'build' | 'serve';
+    mode: string;
+    isWorker: boolean;
+    isProduction: boolean;
+    envDir: string;
+    env: Record<string, any>;
+    resolve: Required<ResolveOptions> & {
+        alias: Alias[];
+    };
+    plugins: readonly Plugin[];
+    css: ResolvedCSSOptions;
+    esbuild: ESBuildOptions | false;
+    server: ResolvedServerOptions;
+    build: ResolvedBuildOptions;
+    preview: ResolvedPreviewOptions;
+    ssr: ResolvedSSROptions;
+    assetsInclude: (file: string) => boolean;
+    logger: Logger;
+    createResolver: (options?: Partial<InternalResolveOptions>) => ResolveFn;
+    optimizeDeps: DepOptimizationOptions;
+    worker: ResolvedWorkerOptions;
+    appType: AppType;
+    experimental: ExperimentalOptions;
+} & PluginHookUtils>;
+interface PluginHookUtils {
+    getSortedPlugins: <K extends keyof Plugin>(hookName: K) => PluginWithRequiredHook<K>[];
+    getSortedPluginHooks: <K extends keyof Plugin>(hookName: K) => NonNullable<HookHandler<Plugin[K]>>[];
+}
+type ResolveFn = (id: string, importer?: string, aliasOnly?: boolean, ssr?: boolean) => Promise<string | undefined>;
+declare function resolveConfig(inlineConfig: InlineConfig, command: 'build' | 'serve', defaultMode?: string, defaultNodeEnv?: string, isPreview?: boolean): Promise<ResolvedConfig>;
+declare function sortUserPlugins(plugins: (Plugin | Plugin[])[] | undefined): [Plugin[], Plugin[], Plugin[]];
+declare function loadConfigFromFile(configEnv: ConfigEnv, configFile?: string, configRoot?: string, logLevel?: LogLevel, customLogger?: Logger): Promise<{
+    path: string;
+    config: UserConfig;
+    dependencies: string[];
+} | null>;
+
+declare function buildErrorMessage(err: RollupError, args?: string[], includeStack?: boolean): string;
+
+interface FetchModuleOptions {
+    inlineSourceMap?: boolean;
+    processSourceMap?<T extends NonNullable<TransformResult['map']>>(map: T): T;
+}
+/**
+ * Fetch module information for Vite runtime.
+ * @experimental
+ */
+declare function fetchModule(server: ViteDevServer, url: string, importer?: string, options?: FetchModuleOptions): Promise<FetchResult>;
+
+declare const VERSION: string;
+
+declare const isCSSRequest: (request: string) => boolean;
+/**
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
+ */
+declare class SplitVendorChunkCache {
+    cache: Map<string, boolean>;
+    constructor();
+    reset(): void;
+}
+/**
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
+ */
+declare function splitVendorChunk(options?: {
+    cache?: SplitVendorChunkCache;
+}): GetManualChunk;
+/**
+ * @deprecated use build.rollupOptions.output.manualChunks or framework specific configuration
+ */
+declare function splitVendorChunkPlugin(): Plugin;
+
+/**
+ * Inlined to keep `@rollup/pluginutils` in devDependencies
+ */
+type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+declare const createFilter: (include?: FilterPattern, exclude?: FilterPattern, options?: {
+    resolve?: string | false | null;
+}) => (id: string | unknown) => boolean;
+declare const rollupVersion: string;
+declare function normalizePath(id: string): string;
+declare function mergeConfig<D extends Record<string, any>, O extends Record<string, any>>(defaults: D extends Function ? never : D, overrides: O extends Function ? never : O, isRoot?: boolean): Record<string, any>;
+declare function mergeAlias(a?: AliasOptions, b?: AliasOptions): AliasOptions | undefined;
+
+interface SendOptions {
+    etag?: string;
+    cacheControl?: string;
+    headers?: OutgoingHttpHeaders;
+    map?: SourceMap | {
+        mappings: '';
+    } | null;
+}
+declare function send(req: IncomingMessage, res: ServerResponse, content: string | Buffer, type: string, options: SendOptions): void;
+
+/**
+ * Search up for the nearest workspace root
+ */
+declare function searchForWorkspaceRoot(current: string, root?: string): string;
+
+/**
+ * Check if the url is allowed to be served, via the `server.fs` config.
+ */
+declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
+
+declare function loadEnv(mode: string, envDir: string, prefixes?: string | string[]): Record<string, string>;
+declare function resolveEnvPrefix({ envPrefix, }: UserConfig): string[];
+
+type Manifest = Record<string, ManifestChunk>;
+interface ManifestChunk {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    name?: string;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+}
+
+/**
+ * @experimental
+ */
+interface MainThreadRuntimeOptions extends Omit<ViteRuntimeOptions, 'root' | 'fetchModule' | 'hmr'> {
+    /**
+     * Disable HMR or configure HMR logger.
+     */
+    hmr?: false | {
+        logger?: false | HMRLogger;
+    };
+    /**
+     * Provide a custom module runner. This controls how the code is executed.
+     */
+    runner?: ViteModuleRunner;
+}
+/**
+ * Create an instance of the Vite SSR runtime that support HMR.
+ * @experimental
+ */
+declare function createViteRuntime(server: ViteDevServer, options?: MainThreadRuntimeOptions): Promise<ViteRuntime>;
+
+/**
+ * The connector class to establish HMR communication between the server and the Vite runtime.
+ * @experimental
+ */
+declare class ServerHMRConnector implements HMRRuntimeConnection {
+    private handlers;
+    private hmrChannel;
+    private hmrClient;
+    private connected;
+    constructor(server: ViteDevServer);
+    isReady(): boolean;
+    send(message: string): void;
+    onUpdate(handler: (payload: HMRPayload) => void): void;
+}
+
+export { type Alias, type AliasOptions, type AnymatchFn, type AnymatchPattern, type AppType, type AwaitWriteFinishOptions, type BindCLIShortcutsOptions, type BuildOptions, type CLIShortcut, type CSSModulesOptions, type CSSOptions, type CommonServerOptions, type ConfigEnv, Connect, type CorsOptions, type CorsOrigin, type DepOptimizationConfig, type DepOptimizationMetadata, type DepOptimizationOptions, type ESBuildOptions, type ESBuildTransformResult, type ExperimentalOptions, type ExportsData, FSWatcher, type FetchModuleOptions, type FileSystemServeOptions, type FilterPattern, type HMRBroadcaster, type HMRBroadcasterClient, type HMRChannel, type HTMLOptions, type HmrContext, type HmrOptions, type HookHandler, type HtmlTagDescriptor, HttpProxy, type HttpServer, type IndexHtmlTransform, type IndexHtmlTransformContext, type IndexHtmlTransformHook, type IndexHtmlTransformResult, type InlineConfig, type InternalResolveOptions, type JsonOptions, type LegacyOptions, type LibraryFormats, type LibraryOptions, type LightningCSSOptions, type LogErrorOptions, type LogLevel, type LogOptions, type LogType, type Logger, type LoggerOptions, type MainThreadRuntimeOptions, type Manifest, type ManifestChunk, type MapToFunction, type AnymatchMatcher as Matcher, ModuleGraph, ModuleNode, type ModulePreloadOptions, type OptimizedDepInfo, type Plugin, PluginContainer, type PluginHookUtils, type PluginOption, type PreprocessCSSResult, type PreviewOptions, type PreviewServer, type PreviewServerHook, type ProxyOptions, type RenderBuiltAssetUrl, type ResolveFn, type ResolveModulePreloadDependenciesFn, type ResolveOptions, type ResolvedBuildOptions, type ResolvedCSSOptions, type ResolvedConfig, type ResolvedModulePreloadOptions, type ResolvedPreviewOptions, type ResolvedSSROptions, type ResolvedServerOptions, type ResolvedServerUrls, type ResolvedUrl, type ResolvedWorkerOptions, type ResolverFunction, type ResolverObject, type RollupCommonJSOptions, type RollupDynamicImportVarsOptions, type SSROptions, type SSRTarget, type SendOptions, type ServerHMRChannel, ServerHMRConnector, type ServerHook, type ServerOptions, SplitVendorChunkCache, type SsrDepOptimizationOptions, Terser, type TerserOptions, type TransformOptions, type TransformResult, type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type ViteDevServer, type WatchOptions, WebSocket, WebSocketAlias, type WebSocketClient, type WebSocketCustomListener, WebSocketServer, build, buildErrorMessage, createFilter, createLogger, createServer, createViteRuntime, defineConfig, fetchModule, formatPostcssSourceMap, isCSSRequest, isFileServingAllowed, loadConfigFromFile, loadEnv, mergeAlias, mergeConfig, normalizePath, optimizeDeps, preprocessCSS, preview, resolveConfig, resolveEnvPrefix, rollupVersion, searchForWorkspaceRoot, send, sortUserPlugins, splitVendorChunk, splitVendorChunkPlugin, transformWithEsbuild, VERSION as version };
diff --git a/node_modules/vite/dist/node/index.js b/node_modules/vite/dist/node/index.js
new file mode 100644
index 0000000..00070a8
--- /dev/null
+++ b/node_modules/vite/dist/node/index.js
@@ -0,0 +1,260 @@
+export { parseAst, parseAstAsync } from 'rollup/parseAst';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-CDnG8rE7.js';
+export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-CDnG8rE7.js';
+export { VERSION as version } from './constants.js';
+export { version as esbuildVersion } from 'esbuild';
+import { existsSync, readFileSync } from 'node:fs';
+import { ViteRuntime, ESModulesRunner } from 'vite/runtime';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:url';
+import 'node:util';
+import 'node:perf_hooks';
+import 'node:module';
+import 'tty';
+import 'path';
+import 'fs';
+import 'node:events';
+import 'node:stream';
+import 'node:string_decoder';
+import 'node:child_process';
+import 'node:http';
+import 'node:https';
+import 'util';
+import 'net';
+import 'events';
+import 'url';
+import 'http';
+import 'stream';
+import 'os';
+import 'child_process';
+import 'node:os';
+import 'node:crypto';
+import 'node:dns';
+import 'crypto';
+import 'module';
+import 'node:assert';
+import 'node:v8';
+import 'node:worker_threads';
+import 'node:buffer';
+import 'querystring';
+import 'node:readline';
+import 'zlib';
+import 'buffer';
+import 'https';
+import 'tls';
+import 'assert';
+import 'node:zlib';
+
+const CSS_LANGS_RE = (
+  // eslint-disable-next-line regexp/no-unused-capturing-group
+  /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/
+);
+const isCSSRequest = (request) => CSS_LANGS_RE.test(request);
+class SplitVendorChunkCache {
+  cache;
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+}
+function splitVendorChunk(options = {}) {
+  const cache = options.cache ?? new SplitVendorChunkCache();
+  return (id, { getModuleInfo }) => {
+    if (isInNodeModules(id) && !isCSSRequest(id) && staticImportedByEntry(id, getModuleInfo, cache.cache)) {
+      return "vendor";
+    }
+  };
+}
+function staticImportedByEntry(id, getModuleInfo, cache, importStack = []) {
+  if (cache.has(id)) {
+    return cache.get(id);
+  }
+  if (importStack.includes(id)) {
+    cache.set(id, false);
+    return false;
+  }
+  const mod = getModuleInfo(id);
+  if (!mod) {
+    cache.set(id, false);
+    return false;
+  }
+  if (mod.isEntry) {
+    cache.set(id, true);
+    return true;
+  }
+  const someImporterIs = mod.importers.some(
+    (importer) => staticImportedByEntry(
+      importer,
+      getModuleInfo,
+      cache,
+      importStack.concat(id)
+    )
+  );
+  cache.set(id, someImporterIs);
+  return someImporterIs;
+}
+function splitVendorChunkPlugin() {
+  const caches = [];
+  function createSplitVendorChunk(output, config) {
+    const cache = new SplitVendorChunkCache();
+    caches.push(cache);
+    const build = config.build ?? {};
+    const format = output?.format;
+    if (!build.ssr && !build.lib && format !== "umd" && format !== "iife") {
+      return splitVendorChunk({ cache });
+    }
+  }
+  return {
+    name: "vite:split-vendor-chunk",
+    config(config) {
+      let outputs = config?.build?.rollupOptions?.output;
+      if (outputs) {
+        outputs = arraify(outputs);
+        for (const output of outputs) {
+          const viteManualChunks = createSplitVendorChunk(output, config);
+          if (viteManualChunks) {
+            if (output.manualChunks) {
+              if (typeof output.manualChunks === "function") {
+                const userManualChunks = output.manualChunks;
+                output.manualChunks = (id, api) => {
+                  return userManualChunks(id, api) ?? viteManualChunks(id, api);
+                };
+              } else {
+                console.warn(
+                  "(!) the `splitVendorChunk` plugin doesn't have any effect when using the object form of `build.rollupOptions.output.manualChunks`. Consider using the function form instead."
+                );
+              }
+            } else {
+              output.manualChunks = viteManualChunks;
+            }
+          }
+        }
+      } else {
+        return {
+          build: {
+            rollupOptions: {
+              output: {
+                manualChunks: createSplitVendorChunk({}, config)
+              }
+            }
+          }
+        };
+      }
+    },
+    buildStart() {
+      caches.forEach((cache) => cache.reset());
+    }
+  };
+}
+
+class ServerHMRBroadcasterClient {
+  constructor(hmrChannel) {
+    this.hmrChannel = hmrChannel;
+  }
+  send(...args) {
+    let payload;
+    if (typeof args[0] === "string") {
+      payload = {
+        type: "custom",
+        event: args[0],
+        data: args[1]
+      };
+    } else {
+      payload = args[0];
+    }
+    if (payload.type !== "custom") {
+      throw new Error(
+        "Cannot send non-custom events from the client to the server."
+      );
+    }
+    this.hmrChannel.send(payload);
+  }
+}
+class ServerHMRConnector {
+  handlers = [];
+  hmrChannel;
+  hmrClient;
+  connected = false;
+  constructor(server) {
+    const hmrChannel = server.hot?.channels.find(
+      (c) => c.name === "ssr"
+    );
+    if (!hmrChannel) {
+      throw new Error(
+        "Your version of Vite doesn't support HMR during SSR. Please, use Vite 5.1 or higher."
+      );
+    }
+    this.hmrClient = new ServerHMRBroadcasterClient(hmrChannel);
+    hmrChannel.api.outsideEmitter.on("send", (payload) => {
+      this.handlers.forEach((listener) => listener(payload));
+    });
+    this.hmrChannel = hmrChannel;
+  }
+  isReady() {
+    return this.connected;
+  }
+  send(message) {
+    const payload = JSON.parse(message);
+    this.hmrChannel.api.innerEmitter.emit(
+      payload.event,
+      payload.data,
+      this.hmrClient
+    );
+  }
+  onUpdate(handler) {
+    this.handlers.push(handler);
+    handler({ type: "connected" });
+    this.connected = true;
+  }
+}
+
+function createHMROptions(server, options) {
+  if (server.config.server.hmr === false || options.hmr === false) {
+    return false;
+  }
+  const connection = new ServerHMRConnector(server);
+  return {
+    connection,
+    logger: options.hmr?.logger
+  };
+}
+const prepareStackTrace = {
+  retrieveFile(id) {
+    if (existsSync(id)) {
+      return readFileSync(id, "utf-8");
+    }
+  }
+};
+function resolveSourceMapOptions(options) {
+  if (options.sourcemapInterceptor != null) {
+    if (options.sourcemapInterceptor === "prepareStackTrace") {
+      return prepareStackTrace;
+    }
+    if (typeof options.sourcemapInterceptor === "object") {
+      return { ...prepareStackTrace, ...options.sourcemapInterceptor };
+    }
+    return options.sourcemapInterceptor;
+  }
+  if (typeof process !== "undefined" && "setSourceMapsEnabled" in process) {
+    return "node";
+  }
+  return prepareStackTrace;
+}
+async function createViteRuntime(server, options = {}) {
+  const hmr = createHMROptions(server, options);
+  return new ViteRuntime(
+    {
+      ...options,
+      root: server.config.root,
+      fetchModule: server.ssrFetchModule,
+      hmr,
+      sourcemapInterceptor: resolveSourceMapOptions(options)
+    },
+    options.runner || new ESModulesRunner()
+  );
+}
+
+export { ServerHMRConnector, createViteRuntime, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
diff --git a/node_modules/vite/dist/node/runtime.d.ts b/node_modules/vite/dist/node/runtime.d.ts
new file mode 100644
index 0000000..040e138
--- /dev/null
+++ b/node_modules/vite/dist/node/runtime.d.ts
@@ -0,0 +1,63 @@
+import { V as ViteRuntimeOptions, b as ViteModuleRunner, M as ModuleCacheMap, c as HMRClient, R as ResolvedResult, d as ViteRuntimeModuleContext } from './types.d-aGj9QkWt.js';
+export { a as FetchFunction, F as FetchResult, e as HMRConnection, H as HMRLogger, g as HMRRuntimeConnection, f as ModuleCache, S as SSRImportMetadata, h as ViteRuntimeImportMeta, s as ssrDynamicImportKey, i as ssrExportAllKey, j as ssrImportKey, k as ssrImportMetaKey, l as ssrModuleExportsKey } from './types.d-aGj9QkWt.js';
+import '../../types/hot.js';
+import '../../types/hmrPayload.js';
+import '../../types/customEvent.js';
+
+interface ViteRuntimeDebugger {
+    (formatter: unknown, ...args: unknown[]): void;
+}
+declare class ViteRuntime {
+    options: ViteRuntimeOptions;
+    runner: ViteModuleRunner;
+    private debug?;
+    /**
+     * Holds the cache of modules
+     * Keys of the map are ids
+     */
+    moduleCache: ModuleCacheMap;
+    hmrClient?: HMRClient;
+    entrypoints: Set<string>;
+    private idToUrlMap;
+    private fileToIdMap;
+    private envProxy;
+    private _destroyed;
+    private _resetSourceMapSupport?;
+    constructor(options: ViteRuntimeOptions, runner: ViteModuleRunner, debug?: ViteRuntimeDebugger | undefined);
+    /**
+     * URL to execute. Accepts file path, server path or id relative to the root.
+     */
+    executeUrl<T = any>(url: string): Promise<T>;
+    /**
+     * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
+     * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
+     * If this method is called multiple times, all entrypoints will be reloaded one at a time.
+     */
+    executeEntrypoint<T = any>(url: string): Promise<T>;
+    /**
+     * Clear all caches including HMR listeners.
+     */
+    clearCache(): void;
+    /**
+     * Clears all caches, removes all HMR listeners, and resets source map support.
+     * This method doesn't stop the HMR connection.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+     */
+    isDestroyed(): boolean;
+    private invalidateFiles;
+    private normalizeEntryUrl;
+    private processImport;
+    private cachedRequest;
+    private cachedModule;
+    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
+}
+
+declare class ESModulesRunner implements ViteModuleRunner {
+    runViteModule(context: ViteRuntimeModuleContext, code: string): Promise<any>;
+    runExternalModule(filepath: string): Promise<any>;
+}
+
+export { ESModulesRunner, ModuleCacheMap, ResolvedResult, ViteModuleRunner, ViteRuntime, ViteRuntimeModuleContext, ViteRuntimeOptions };
diff --git a/node_modules/vite/dist/node/runtime.js b/node_modules/vite/dist/node/runtime.js
new file mode 100644
index 0000000..455b969
--- /dev/null
+++ b/node_modules/vite/dist/node/runtime.js
@@ -0,0 +1,1066 @@
+const VALID_ID_PREFIX = "/@id/", NULL_BYTE_PLACEHOLDER = "__x00__";
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+const isWindows = typeof process < "u" && process.platform === "win32";
+function wrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function isPrimitive(value) {
+  return !value || typeof value != "object" && typeof value != "function";
+}
+function withTrailingSlash(path) {
+  return path[path.length - 1] !== "/" ? `${path}/` : path;
+}
+const AsyncFunction = async function() {
+}.constructor, _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+function cwd() {
+  return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "", resolvedAbsolute = !1;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    !path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+  }
+  return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length)
+      char = path[index];
+    else {
+      if (char === "/")
+        break;
+      char = "/";
+    }
+    if (char === "/") {
+      if (!(lastSlash === index - 1 || dots === 1)) if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index, dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+            continue;
+          }
+        }
+        allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+      } else
+        res.length > 0 ? res += `/${path.slice(lastSlash + 1, index)}` : res = path.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+      lastSlash = index, dots = 0;
+    } else char === "." && dots !== -1 ? ++dots : dots = -1;
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
+}, decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8"), CHAR_FORWARD_SLASH = 47, CHAR_BACKWARD_SLASH = 92, percentRegEx = /%/g, backslashRegEx = /\\/g, newlineRegEx = /\n/g, carriageReturnRegEx = /\r/g, tabRegEx = /\t/g, questionRegex = /\?/g, hashRegex = /#/g;
+function encodePathChars(filepath) {
+  return filepath.indexOf("%") !== -1 && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.indexOf("\\") !== -1 && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.indexOf(`
+`) !== -1 && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.indexOf("\r") !== -1 && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.indexOf("	") !== -1 && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
+}
+const posixDirname = dirname, posixResolve = resolve;
+function posixPathToFileHref(posixPath) {
+  let resolved = posixResolve(posixPath);
+  const filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+  return (filePathLast === CHAR_FORWARD_SLASH || isWindows && filePathLast === CHAR_BACKWARD_SLASH) && resolved[resolved.length - 1] !== "/" && (resolved += "/"), resolved = encodePathChars(resolved), resolved.indexOf("?") !== -1 && (resolved = resolved.replace(questionRegex, "%3F")), resolved.indexOf("#") !== -1 && (resolved = resolved.replace(hashRegex, "%23")), new URL(`file://${resolved}`).href;
+}
+function toWindowsPath(path) {
+  return path.replace(/\//g, "\\");
+}
+const comma = 44, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c, charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0, shift = 0, integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c], value |= (integer & 31) << shift, shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+}
+function hasMoreVlq(reader, max) {
+  return reader.pos >= max ? !1 : reader.peek() !== comma;
+}
+class StringReader {
+  constructor(buffer) {
+    this.pos = 0, this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+}
+function decode(mappings) {
+  const { length } = mappings, reader = new StringReader(mappings), decoded = [];
+  let genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";"), line = [];
+    let sorted = !0, lastCol = 0;
+    for (genColumn = 0; reader.pos < semi; ) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]) : seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]) : seg = [genColumn], line.push(seg), reader.pos++;
+    }
+    sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+const COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4;
+let found = !1;
+function binarySearch(haystack, needle, low, high) {
+  for (; low <= high; ) {
+    const mid = low + (high - low >> 1), cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0)
+      return found = !0, mid;
+    cmp < 0 ? low = mid + 1 : high = mid - 1;
+  }
+  return found = !1, low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++)
+    ;
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--)
+    ;
+  return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0, high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle)
+      return found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle, lastIndex;
+    needle >= lastNeedle ? low = lastIndex === -1 ? 0 : lastIndex : high = lastIndex;
+  }
+  return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+const LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)", LEAST_UPPER_BOUND = -1, GREATEST_LOWER_BOUND = 1;
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = map)._decoded || (_a._decoded = decode(map._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  if (line--, line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  return found ? index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index) : bias === LEAST_UPPER_BOUND && index++, index === -1 || index === segments.length ? -1 : index;
+}
+class DecodedMap {
+  constructor(map, from) {
+    this.map = map;
+    const { mappings, names, sources } = map;
+    this.version = map.version, this.names = names || [], this._encoded = mappings || "", this._decodedMemo = memoizedState(), this.url = from, this.resolvedSources = (sources || []).map(
+      (s) => posixResolve(s || "", from)
+    );
+  }
+  _encoded;
+  _decoded;
+  _decodedMemo;
+  url;
+  version;
+  names = [];
+  resolvedSources;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function getOriginalPosition(map, needle) {
+  const result = originalPositionFor(map, needle);
+  return result.column == null ? null : result;
+}
+const VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(
+  `//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`
+);
+class ModuleCacheMap extends Map {
+  root;
+  constructor(root, entries) {
+    super(entries), this.root = withTrailingSlash(root);
+  }
+  normalize(fsPath) {
+    return normalizeModuleId(fsPath, this.root);
+  }
+  /**
+   * Assign partial data to the map
+   */
+  update(fsPath, mod) {
+    return fsPath = this.normalize(fsPath), super.has(fsPath) ? Object.assign(super.get(fsPath), mod) : this.setByModuleId(fsPath, mod), this;
+  }
+  setByModuleId(modulePath, mod) {
+    return super.set(modulePath, mod);
+  }
+  set(fsPath, mod) {
+    return this.setByModuleId(this.normalize(fsPath), mod);
+  }
+  getByModuleId(modulePath) {
+    super.has(modulePath) || this.setByModuleId(modulePath, {});
+    const mod = super.get(modulePath);
+    return mod.imports || Object.assign(mod, {
+      imports: /* @__PURE__ */ new Set(),
+      importers: /* @__PURE__ */ new Set()
+    }), mod;
+  }
+  get(fsPath) {
+    return this.getByModuleId(this.normalize(fsPath));
+  }
+  deleteByModuleId(modulePath) {
+    return super.delete(modulePath);
+  }
+  delete(fsPath) {
+    return this.deleteByModuleId(this.normalize(fsPath));
+  }
+  invalidate(id) {
+    const module = this.get(id);
+    module.evaluated = !1, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
+  }
+  isImported({
+    importedId,
+    importedBy
+  }, seen = /* @__PURE__ */ new Set()) {
+    if (importedId = this.normalize(importedId), importedBy = this.normalize(importedBy), importedBy === importedId) return !0;
+    if (seen.has(importedId)) return !1;
+    seen.add(importedId);
+    const importers = this.getByModuleId(importedId)?.importers;
+    if (!importers) return !1;
+    if (importers.has(importedBy)) return !0;
+    for (const importer of importers)
+      if (this.isImported({
+        importedBy,
+        importedId: importer
+      }))
+        return !0;
+    return !1;
+  }
+  /**
+   * Invalidate modules that dependent on the given modules, up to the main entry
+   */
+  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id)) continue;
+      invalidated.add(id);
+      const mod = super.get(id);
+      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), super.delete(id);
+    }
+    return invalidated;
+  }
+  /**
+   * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+   */
+  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id)) continue;
+      invalidated.add(id);
+      const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
+      subIds.length && this.invalidateSubDepTree(subIds, invalidated), super.delete(id);
+    }
+    return invalidated;
+  }
+  getSourceMap(moduleId) {
+    const mod = this.get(moduleId);
+    if (mod.map) return mod.map;
+    if (!mod.meta || !("code" in mod.meta)) return null;
+    const mapString = VITE_RUNTIME_SOURCEMAPPING_REGEXP.exec(mod.meta.code)?.[1];
+    if (!mapString) return null;
+    const baseFile = mod.meta.file || moduleId.split("?")[0];
+    return mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), baseFile), mod.map;
+  }
+}
+const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test"]);
+function normalizeModuleId(file, root) {
+  if (prefixedBuiltins.has(file)) return file;
+  let unixFile = slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+  return unixFile.startsWith(root) && (unixFile = unixFile.slice(root.length - 1)), unixFile.replace(/^file:\//, "/");
+}
+class HMRContext {
+  constructor(hmrClient, ownerPath) {
+    this.hmrClient = hmrClient, this.ownerPath = ownerPath, hmrClient.dataMap.has(ownerPath) || hmrClient.dataMap.set(ownerPath, {});
+    const mod = hmrClient.hotModulesMap.get(ownerPath);
+    mod && (mod.callbacks = []);
+    const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+    if (staleListeners)
+      for (const [event, staleFns] of staleListeners) {
+        const listeners = hmrClient.customListenersMap.get(event);
+        listeners && hmrClient.customListenersMap.set(
+          event,
+          listeners.filter((l) => !staleFns.includes(l))
+        );
+      }
+    this.newListeners = /* @__PURE__ */ new Map(), hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+  }
+  newListeners;
+  get data() {
+    return this.hmrClient.dataMap.get(this.ownerPath);
+  }
+  accept(deps, callback) {
+    if (typeof deps == "function" || !deps)
+      this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+    else if (typeof deps == "string")
+      this.acceptDeps([deps], ([mod]) => callback?.(mod));
+    else if (Array.isArray(deps))
+      this.acceptDeps(deps, callback);
+    else
+      throw new Error("invalid hot.accept() usage.");
+  }
+  // export names (first arg) are irrelevant on the client side, they're
+  // extracted in the server for propagation
+  acceptExports(_, callback) {
+    this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+  }
+  dispose(cb) {
+    this.hmrClient.disposeMap.set(this.ownerPath, cb);
+  }
+  prune(cb) {
+    this.hmrClient.pruneMap.set(this.ownerPath, cb);
+  }
+  // Kept for backward compatibility (#11036)
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  decline() {
+  }
+  invalidate(message) {
+    this.hmrClient.notifyListeners("vite:invalidate", {
+      path: this.ownerPath,
+      message
+    }), this.send("vite:invalidate", { path: this.ownerPath, message }), this.hmrClient.logger.debug(
+      `[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`
+    );
+  }
+  on(event, cb) {
+    const addToMap = (map) => {
+      const existing = map.get(event) || [];
+      existing.push(cb), map.set(event, existing);
+    };
+    addToMap(this.hmrClient.customListenersMap), addToMap(this.newListeners);
+  }
+  off(event, cb) {
+    const removeFromMap = (map) => {
+      const existing = map.get(event);
+      if (existing === void 0)
+        return;
+      const pruned = existing.filter((l) => l !== cb);
+      if (pruned.length === 0) {
+        map.delete(event);
+        return;
+      }
+      map.set(event, pruned);
+    };
+    removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
+  }
+  send(event, data) {
+    this.hmrClient.messenger.send(
+      JSON.stringify({ type: "custom", event, data })
+    );
+  }
+  acceptDeps(deps, callback = () => {
+  }) {
+    const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+      id: this.ownerPath,
+      callbacks: []
+    };
+    mod.callbacks.push({
+      deps,
+      fn: callback
+    }), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+  }
+}
+class HMRMessenger {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  queue = [];
+  send(message) {
+    this.queue.push(message), this.flush();
+  }
+  flush() {
+    this.connection.isReady() && (this.queue.forEach((msg) => this.connection.send(msg)), this.queue = []);
+  }
+}
+class HMRClient {
+  constructor(logger, connection, importUpdatedModule) {
+    this.logger = logger, this.importUpdatedModule = importUpdatedModule, this.messenger = new HMRMessenger(connection);
+  }
+  hotModulesMap = /* @__PURE__ */ new Map();
+  disposeMap = /* @__PURE__ */ new Map();
+  pruneMap = /* @__PURE__ */ new Map();
+  dataMap = /* @__PURE__ */ new Map();
+  customListenersMap = /* @__PURE__ */ new Map();
+  ctxToListenersMap = /* @__PURE__ */ new Map();
+  messenger;
+  async notifyListeners(event, data) {
+    const cbs = this.customListenersMap.get(event);
+    cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
+  }
+  clear() {
+    this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
+  }
+  // After an HMR update, some modules are no longer imported on the page
+  // but they may have left behind side effects that need to be cleaned up
+  // (.e.g style injections)
+  async prunePaths(paths) {
+    await Promise.all(
+      paths.map((path) => {
+        const disposer = this.disposeMap.get(path);
+        if (disposer) return disposer(this.dataMap.get(path));
+      })
+    ), paths.forEach((path) => {
+      const fn = this.pruneMap.get(path);
+      fn && fn(this.dataMap.get(path));
+    });
+  }
+  warnFailedUpdate(err, path) {
+    err.message.includes("fetch") || this.logger.error(err), this.logger.error(
+      `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+    );
+  }
+  updateQueue = [];
+  pendingUpdateQueue = !1;
+  /**
+   * buffer multiple hot updates triggered by the same src change
+   * so that they are invoked in the same order they were sent.
+   * (otherwise the order may be inconsistent because of the http request round trip)
+   */
+  async queueUpdate(payload) {
+    if (this.updateQueue.push(this.fetchUpdate(payload)), !this.pendingUpdateQueue) {
+      this.pendingUpdateQueue = !0, await Promise.resolve(), this.pendingUpdateQueue = !1;
+      const loading = [...this.updateQueue];
+      this.updateQueue = [], (await Promise.all(loading)).forEach((fn) => fn && fn());
+    }
+  }
+  async fetchUpdate(update) {
+    const { path, acceptedPath } = update, mod = this.hotModulesMap.get(path);
+    if (!mod)
+      return;
+    let fetchedModule;
+    const isSelfUpdate = path === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(
+      ({ deps }) => deps.includes(acceptedPath)
+    );
+    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+      const disposer = this.disposeMap.get(acceptedPath);
+      disposer && await disposer(this.dataMap.get(acceptedPath));
+      try {
+        fetchedModule = await this.importUpdatedModule(update);
+      } catch (e) {
+        this.warnFailedUpdate(e, acceptedPath);
+      }
+    }
+    return () => {
+      for (const { deps, fn } of qualifiedCallbacks)
+        fn(
+          deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0)
+        );
+      const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+    };
+  }
+}
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+  if (!metadata?.isDynamicImport && metadata?.importedNames?.length) {
+    const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+    if (missingBindings.length) {
+      const lastBinding = missingBindings[missingBindings.length - 1];
+      throw moduleType === "module" ? new SyntaxError(
+        `[vite] The requested module '${rawId}' does not provide an export named '${lastBinding}'`
+      ) : new SyntaxError(`[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(", ")}} = pkg;
+`);
+    }
+  }
+}
+const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {
+}, silentConsole = {
+  debug: noop,
+  error: noop
+};
+function createHMRHandler(runtime) {
+  const queue = new Queue();
+  return (payload) => queue.enqueue(() => handleHMRPayload(runtime, payload));
+}
+async function handleHMRPayload(runtime, payload) {
+  const hmrClient = runtime.hmrClient;
+  if (!(!hmrClient || runtime.isDestroyed()))
+    switch (payload.type) {
+      case "connected":
+        hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
+        break;
+      case "update":
+        await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
+          payload.updates.map(async (update) => {
+            if (update.type === "js-update")
+              return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
+            hmrClient.logger.error(
+              "[vite] css hmr is not supported in runtime mode."
+            );
+          })
+        ), await hmrClient.notifyListeners("vite:afterUpdate", payload);
+        break;
+      case "custom": {
+        await hmrClient.notifyListeners(payload.event, payload.data);
+        break;
+      }
+      case "full-reload": {
+        const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? [...runtime.entrypoints].filter(
+          (entrypoint) => runtime.moduleCache.isImported({
+            importedId: triggeredBy,
+            importedBy: entrypoint
+          })
+        ) : [...runtime.entrypoints];
+        if (!clearEntrypoints.length) break;
+        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runtime.moduleCache.clear();
+        for (const id of clearEntrypoints)
+          await runtime.executeUrl(id);
+        break;
+      }
+      case "prune":
+        await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
+        break;
+      case "error": {
+        await hmrClient.notifyListeners("vite:error", payload);
+        const err = payload.err;
+        hmrClient.logger.error(
+          `[vite] Internal Server Error
+${err.message}
+${err.stack}`
+        );
+        break;
+      }
+      default:
+        return payload;
+    }
+}
+class Queue {
+  queue = [];
+  pending = !1;
+  enqueue(promise) {
+    return new Promise((resolve2, reject) => {
+      this.queue.push({
+        promise,
+        resolve: resolve2,
+        reject
+      }), this.dequeue();
+    });
+  }
+  dequeue() {
+    if (this.pending)
+      return !1;
+    const item = this.queue.shift();
+    return item ? (this.pending = !0, item.promise().then(item.resolve).catch(item.reject).finally(() => {
+      this.pending = !1, this.dequeue();
+    }), !0) : !1;
+  }
+}
+const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => (...args) => {
+  for (const handler of handlers) {
+    const result = handler(...args);
+    if (result) return result;
+  }
+  return null;
+}, retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers), retrieveSourceMapFromHandlers = createExecHandlers(
+  retrieveSourceMapHandlers
+);
+let overridden = !1;
+const originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runtime, options) {
+  moduleGraphs.delete(runtime.moduleCache), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), moduleGraphs.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = !1);
+}
+function interceptStackTrace(runtime, options = {}) {
+  return overridden || (Error.prepareStackTrace = prepareStackTrace, overridden = !0), moduleGraphs.add(runtime.moduleCache), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runtime, options);
+}
+function supportRelativeURL(file, url) {
+  if (!file) return url;
+  const dir = posixDirname(slash(file)), match = /^\w+:\/\/[^/]*/.exec(dir);
+  let protocol = match ? match[0] : "";
+  const startPath = dir.slice(protocol.length);
+  return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
+}
+function getRuntimeSourceMap(position) {
+  for (const moduleCache of moduleGraphs) {
+    const sourceMap = moduleCache.getSourceMap(position.source);
+    if (sourceMap)
+      return {
+        url: position.source,
+        map: sourceMap,
+        vite: !0
+      };
+  }
+  return null;
+}
+function retrieveFile(path) {
+  if (path in fileContentsCache) return fileContentsCache[path];
+  const content = retrieveFileFromHandlers(path);
+  return typeof content == "string" ? (fileContentsCache[path] = content, content) : null;
+}
+function retrieveSourceMapURL(source) {
+  const fileData = retrieveFile(source);
+  if (!fileData) return null;
+  const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+  let lastMatch, match;
+  for (; match = re.exec(fileData); ) lastMatch = match;
+  return lastMatch ? lastMatch[1] : null;
+}
+const reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+  const urlAndMap = retrieveSourceMapFromHandlers(source);
+  if (urlAndMap) return urlAndMap;
+  let sourceMappingURL = retrieveSourceMapURL(source);
+  if (!sourceMappingURL) return null;
+  let sourceMapData;
+  if (reSourceMap.test(sourceMappingURL)) {
+    const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+    sourceMapData = Buffer.from(rawData, "base64").toString(), sourceMappingURL = source;
+  } else
+    sourceMappingURL = supportRelativeURL(source, sourceMappingURL), sourceMapData = retrieveFile(sourceMappingURL);
+  return sourceMapData ? {
+    url: sourceMappingURL,
+    map: sourceMapData
+  } : null;
+}
+function mapSourcePosition(position) {
+  if (!position.source) return position;
+  let sourceMap = getRuntimeSourceMap(position);
+  if (sourceMap || (sourceMap = sourceMapCache[position.source]), !sourceMap) {
+    const urlAndMap = retrieveSourceMap(position.source);
+    if (urlAndMap && urlAndMap.map) {
+      const url = urlAndMap.url;
+      sourceMap = sourceMapCache[position.source] = {
+        url,
+        map: new DecodedMap(
+          typeof urlAndMap.map == "string" ? JSON.parse(urlAndMap.map) : urlAndMap.map,
+          url
+        )
+      };
+      const contents = sourceMap.map?.map.sourcesContent;
+      sourceMap.map && contents && sourceMap.map.resolvedSources.forEach((source, i) => {
+        const content = contents[i];
+        if (content && source && url) {
+          const contentUrl = supportRelativeURL(url, source);
+          fileContentsCache[contentUrl] = content;
+        }
+      });
+    } else
+      sourceMap = sourceMapCache[position.source] = {
+        url: null,
+        map: null
+      };
+  }
+  if (sourceMap && sourceMap.map && sourceMap.url) {
+    const originalPosition = getOriginalPosition(sourceMap.map, position);
+    if (originalPosition && originalPosition.source != null)
+      return originalPosition.source = supportRelativeURL(
+        sourceMap.url,
+        originalPosition.source
+      ), sourceMap.vite && (originalPosition._vite = !0), originalPosition;
+  }
+  return position;
+}
+function mapEvalOrigin(origin) {
+  let match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+  if (match) {
+    const position = mapSourcePosition({
+      name: null,
+      source: match[2],
+      line: +match[3],
+      column: +match[4] - 1
+    });
+    return `eval at ${match[1]} (${position.source}:${position.line}:${position.column + 1})`;
+  }
+  return match = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match ? `eval at ${match[1]} (${mapEvalOrigin(match[2])})` : origin;
+}
+function CallSiteToString() {
+  let fileName, fileLocation = "";
+  if (this.isNative())
+    fileLocation = "native";
+  else {
+    fileName = this.getScriptNameOrSourceURL(), !fileName && this.isEval() && (fileLocation = this.getEvalOrigin(), fileLocation += ", "), fileName ? fileLocation += fileName : fileLocation += "<anonymous>";
+    const lineNumber = this.getLineNumber();
+    if (lineNumber != null) {
+      fileLocation += `:${lineNumber}`;
+      const columnNumber = this.getColumnNumber();
+      columnNumber && (fileLocation += `:${columnNumber}`);
+    }
+  }
+  let line = "";
+  const functionName = this.getFunctionName();
+  let addSuffix = !0;
+  const isConstructor = this.isConstructor();
+  if (this.isToplevel() || isConstructor)
+    isConstructor ? line += `new ${functionName || "<anonymous>"}` : functionName ? line += functionName : (line += fileLocation, addSuffix = !1);
+  else {
+    let typeName = this.getTypeName();
+    typeName === "[object Object]" && (typeName = "null");
+    const methodName = this.getMethodName();
+    functionName ? (typeName && functionName.indexOf(typeName) !== 0 && (line += `${typeName}.`), line += functionName, methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1 && (line += ` [as ${methodName}]`)) : line += `${typeName}.${methodName || "<anonymous>"}`;
+  }
+  return addSuffix && (line += ` (${fileLocation})`), line;
+}
+function cloneCallSite(frame) {
+  const object = {};
+  return Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+    const key = name;
+    object[key] = /^(?:is|get)/.test(name) ? function() {
+      return frame[key].call(frame);
+    } : frame[key];
+  }), object.toString = CallSiteToString, object;
+}
+function wrapCallSite(frame, state) {
+  if (state === void 0 && (state = { nextPosition: null, curPosition: null }), frame.isNative())
+    return state.curPosition = null, frame;
+  const source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+  if (source) {
+    const line = frame.getLineNumber();
+    let column = frame.getColumnNumber() - 1;
+    const headerLength = 62;
+    line === 1 && column > headerLength && !frame.isEval() && (column -= headerLength);
+    const position = mapSourcePosition({
+      name: null,
+      source,
+      line,
+      column
+    });
+    state.curPosition = position, frame = cloneCallSite(frame);
+    const originalFunctionName = frame.getFunctionName;
+    return frame.getFunctionName = function() {
+      const name = state.nextPosition == null ? originalFunctionName() : state.nextPosition.name || originalFunctionName();
+      return name === "eval" && "_vite" in position ? null : name;
+    }, frame.getFileName = function() {
+      return position.source ?? void 0;
+    }, frame.getLineNumber = function() {
+      return position.line;
+    }, frame.getColumnNumber = function() {
+      return position.column + 1;
+    }, frame.getScriptNameOrSourceURL = function() {
+      return position.source;
+    }, frame;
+  }
+  let origin = frame.isEval() && frame.getEvalOrigin();
+  return origin && (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
+    return origin || void 0;
+  }), frame;
+}
+function prepareStackTrace(error, stack) {
+  const name = error.name || "Error", message = error.message || "", errorString = `${name}: ${message}`, state = { nextPosition: null, curPosition: null }, processedStack = [];
+  for (let i = stack.length - 1; i >= 0; i--)
+    processedStack.push(`
+    at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
+  return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
+}
+function enableSourceMapSupport(runtime) {
+  if (runtime.options.sourcemapInterceptor === "node") {
+    if (typeof process > "u")
+      throw new TypeError(
+        `Cannot use "sourcemapInterceptor: 'node'" because global "process" variable is not available.`
+      );
+    if (typeof process.setSourceMapsEnabled != "function")
+      throw new TypeError(
+        `Cannot use "sourcemapInterceptor: 'node'" because "process.setSourceMapsEnabled" function is not available. Please use Node >= 16.6.0.`
+      );
+    const isEnabledAlready = process.sourceMapsEnabled ?? !1;
+    return process.setSourceMapsEnabled(!0), () => !isEnabledAlready && process.setSourceMapsEnabled(!1);
+  }
+  return interceptStackTrace(
+    runtime,
+    typeof runtime.options.sourcemapInterceptor == "object" ? runtime.options.sourcemapInterceptor : void 0
+  );
+}
+class ViteRuntime {
+  constructor(options, runner, debug) {
+    this.options = options, this.runner = runner, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
+      options.hmr.logger === !1 ? silentConsole : options.hmr.logger || console,
+      options.hmr.connection,
+      ({ acceptedPath, ssrInvalidates }) => (this.moduleCache.invalidate(acceptedPath), ssrInvalidates && this.invalidateFiles(ssrInvalidates), this.executeUrl(acceptedPath))
+    ), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this._resetSourceMapSupport = enableSourceMapSupport(this));
+  }
+  /**
+   * Holds the cache of modules
+   * Keys of the map are ids
+   */
+  moduleCache;
+  hmrClient;
+  entrypoints = /* @__PURE__ */ new Set();
+  idToUrlMap = /* @__PURE__ */ new Map();
+  fileToIdMap = /* @__PURE__ */ new Map();
+  envProxy = new Proxy({}, {
+    get(_, p) {
+      throw new Error(
+        `[vite-runtime] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`
+      );
+    }
+  });
+  _destroyed = !1;
+  _resetSourceMapSupport;
+  /**
+   * URL to execute. Accepts file path, server path or id relative to the root.
+   */
+  async executeUrl(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule);
+  }
+  /**
+   * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
+   * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
+   * If this method is called multiple times, all entrypoints will be reloaded one at a time.
+   */
+  async executeEntrypoint(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule, [], {
+      entrypoint: !0
+    });
+  }
+  /**
+   * Clear all caches including HMR listeners.
+   */
+  clearCache() {
+    this.moduleCache.clear(), this.idToUrlMap.clear(), this.entrypoints.clear(), this.hmrClient?.clear();
+  }
+  /**
+   * Clears all caches, removes all HMR listeners, and resets source map support.
+   * This method doesn't stop the HMR connection.
+   */
+  async destroy() {
+    this._resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this._destroyed = !0;
+  }
+  /**
+   * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+   */
+  isDestroyed() {
+    return this._destroyed;
+  }
+  invalidateFiles(files) {
+    files.forEach((file) => {
+      const ids = this.fileToIdMap.get(file);
+      ids && ids.forEach((id) => this.moduleCache.invalidate(id));
+    });
+  }
+  // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
+  // this URL is something that user passes down manually, and is later resolved by fetchModule
+  // moduleCache.normalize is used on resolved "file" property
+  normalizeEntryUrl(url) {
+    if (url[0] === ".")
+      return url;
+    url.startsWith("file://") && (url = url.slice(isWindows ? 8 : 7)), url = slash(url);
+    const _root = this.options.root, root = _root[_root.length - 1] === "/" ? _root : `${_root}/`;
+    return url.startsWith(root) ? url.slice(root.length - 1) : url[0] === "/" ? url : wrapId(url);
+  }
+  processImport(exports, fetchResult, metadata) {
+    if (!("externalize" in fetchResult))
+      return exports;
+    const { id, type } = fetchResult;
+    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, id, type, metadata), exports;
+  }
+  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
+    const moduleId = fetchedModule.id;
+    metadata?.entrypoint && this.entrypoints.add(moduleId);
+    const mod = this.moduleCache.getByModuleId(moduleId), { imports, importers } = mod, importee = callstack[callstack.length - 1];
+    if (importee && importers.add(importee), (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) && mod.exports)
+      return this.processImport(mod.exports, fetchedModule, metadata);
+    let debugTimer;
+    this.debug && (debugTimer = setTimeout(() => {
+      const getStack = () => `stack:
+${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
+`)}`;
+      this.debug(
+        `[vite-runtime] module ${moduleId} takes over 2s to load.
+${getStack()}`
+      );
+    }, 2e3));
+    try {
+      if (mod.promise)
+        return this.processImport(await mod.promise, fetchedModule, metadata);
+      const promise = this.directRequest(id, fetchedModule, callstack);
+      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, fetchedModule, metadata);
+    } finally {
+      mod.evaluated = !0, debugTimer && clearTimeout(debugTimer);
+    }
+  }
+  async cachedModule(id, importer) {
+    if (this._destroyed)
+      throw new Error("[vite] Vite runtime has been destroyed.");
+    const normalized = this.idToUrlMap.get(id);
+    if (normalized) {
+      const mod2 = this.moduleCache.getByModuleId(normalized);
+      if (mod2.meta)
+        return mod2.meta;
+    }
+    this.debug?.("[vite-runtime] fetching", id);
+    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.options.fetchModule(id, importer), idQuery = id.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fullFile = file ? `${file}${query}` : id, moduleId = this.moduleCache.normalize(fullFile), mod = this.moduleCache.getByModuleId(moduleId);
+    if (fetchedModule.id = moduleId, mod.meta = fetchedModule, file) {
+      const fileModules = this.fileToIdMap.get(file) || [];
+      fileModules.push(moduleId), this.fileToIdMap.set(file, fileModules);
+    }
+    return this.idToUrlMap.set(id, moduleId), this.idToUrlMap.set(unwrapId(id), moduleId), fetchedModule;
+  }
+  // override is allowed, consider this a public API
+  async directRequest(id, fetchResult, _callstack) {
+    const moduleId = fetchResult.id, callstack = [..._callstack, moduleId], mod = this.moduleCache.getByModuleId(moduleId), request = async (dep, metadata) => {
+      const fetchedModule = await this.cachedModule(dep, moduleId);
+      return this.moduleCache.getByModuleId(fetchedModule.id).importers.add(moduleId), mod.imports.add(fetchedModule.id), this.cachedRequest(dep, fetchedModule, callstack, metadata);
+    }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), dep)), request(dep, { isDynamicImport: !0 }));
+    if ("externalize" in fetchResult) {
+      const { externalize } = fetchResult;
+      this.debug?.("[vite-runtime] externalizing", externalize);
+      const exports2 = await this.runner.runExternalModule(externalize);
+      return mod.exports = exports2, exports2;
+    }
+    const { code, file } = fetchResult;
+    if (code == null) {
+      const importer = callstack[callstack.length - 2];
+      throw new Error(
+        `[vite-runtime] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`
+      );
+    }
+    const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
+      filename: isWindows ? toWindowsPath(filename) : filename,
+      dirname: isWindows ? toWindowsPath(dirname2) : dirname2,
+      url: href,
+      env: this.envProxy,
+      resolve(id2, parent) {
+        throw new Error(
+          '[vite-runtime] "import.meta.resolve" is not supported.'
+        );
+      },
+      // should be replaced during transformation
+      glob() {
+        throw new Error('[vite-runtime] "import.meta.glob" is not supported.');
+      }
+    }, exports = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(exports, Symbol.toStringTag, {
+      value: "Module",
+      enumerable: !1,
+      configurable: !1
+    }), mod.exports = exports;
+    let hotContext;
+    this.hmrClient && Object.defineProperty(meta, "hot", {
+      enumerable: !0,
+      get: () => {
+        if (!this.hmrClient)
+          throw new Error("[vite-runtime] HMR client was destroyed.");
+        return this.debug?.("[vite-runtime] creating hmr context for", moduleId), hotContext ||= new HMRContext(this.hmrClient, moduleId), hotContext;
+      },
+      set: (value) => {
+        hotContext = value;
+      }
+    });
+    const context = {
+      [ssrImportKey]: request,
+      [ssrDynamicImportKey]: dynamicRequest,
+      [ssrModuleExportsKey]: exports,
+      [ssrExportAllKey]: (obj) => exportAll(exports, obj),
+      [ssrImportMetaKey]: meta
+    };
+    return this.debug?.("[vite-runtime] executing", href), await this.runner.runViteModule(context, code, id), exports;
+  }
+}
+function exportAll(exports, sourceModule) {
+  if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+    for (const key in sourceModule)
+      if (key !== "default" && key !== "__esModule")
+        try {
+          Object.defineProperty(exports, key, {
+            enumerable: !0,
+            configurable: !0,
+            get: () => sourceModule[key]
+          });
+        } catch {
+        }
+  }
+}
+class ESModulesRunner {
+  async runViteModule(context, code) {
+    await new AsyncFunction(
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      // source map should already be inlined by Vite
+      '"use strict";' + code
+    )(
+      context[ssrModuleExportsKey],
+      context[ssrImportMetaKey],
+      context[ssrImportKey],
+      context[ssrDynamicImportKey],
+      context[ssrExportAllKey]
+    ), Object.seal(context[ssrModuleExportsKey]);
+  }
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
+export {
+  ESModulesRunner,
+  ModuleCacheMap,
+  ViteRuntime,
+  ssrDynamicImportKey,
+  ssrExportAllKey,
+  ssrImportKey,
+  ssrImportMetaKey,
+  ssrModuleExportsKey
+};
diff --git a/node_modules/vite/dist/node/types.d-aGj9QkWt.d.ts b/node_modules/vite/dist/node/types.d-aGj9QkWt.d.ts
new file mode 100644
index 0000000..5208d31
--- /dev/null
+++ b/node_modules/vite/dist/node/types.d-aGj9QkWt.d.ts
@@ -0,0 +1,281 @@
+import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
+import { Update, HMRPayload } from '../../types/hmrPayload.js';
+import { InferCustomEventPayload } from '../../types/customEvent.js';
+
+type CustomListenersMap = Map<string, ((data: any) => void)[]>;
+interface HotModule {
+    id: string;
+    callbacks: HotCallback[];
+}
+interface HotCallback {
+    deps: string[];
+    fn: (modules: Array<ModuleNamespace | undefined>) => void;
+}
+interface HMRLogger {
+    error(msg: string | Error): void;
+    debug(...msg: unknown[]): void;
+}
+interface HMRConnection {
+    /**
+     * Checked before sending messages to the client.
+     */
+    isReady(): boolean;
+    /**
+     * Send message to the client.
+     */
+    send(messages: string): void;
+}
+declare class HMRMessenger {
+    private connection;
+    constructor(connection: HMRConnection);
+    private queue;
+    send(message: string): void;
+    flush(): void;
+}
+declare class HMRClient {
+    logger: HMRLogger;
+    private importUpdatedModule;
+    hotModulesMap: Map<string, HotModule>;
+    disposeMap: Map<string, (data: any) => void | Promise<void>>;
+    pruneMap: Map<string, (data: any) => void | Promise<void>>;
+    dataMap: Map<string, any>;
+    customListenersMap: CustomListenersMap;
+    ctxToListenersMap: Map<string, CustomListenersMap>;
+    messenger: HMRMessenger;
+    constructor(logger: HMRLogger, connection: HMRConnection, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
+    notifyListeners<T extends string>(event: T, data: InferCustomEventPayload<T>): Promise<void>;
+    clear(): void;
+    prunePaths(paths: string[]): Promise<void>;
+    protected warnFailedUpdate(err: Error, path: string | string[]): void;
+    private updateQueue;
+    private pendingUpdateQueue;
+    /**
+     * buffer multiple hot updates triggered by the same src change
+     * so that they are invoked in the same order they were sent.
+     * (otherwise the order may be inconsistent because of the http request round trip)
+     */
+    queueUpdate(payload: Update): Promise<void>;
+    private fetchUpdate;
+}
+
+interface DefineImportMetadata {
+    /**
+     * Imported names before being transformed to `ssrImportKey`
+     *
+     * import foo, { bar as baz, qux } from 'hello'
+     * => ['default', 'bar', 'qux']
+     *
+     * import * as namespace from 'world
+     * => undefined
+     */
+    importedNames?: string[];
+}
+interface SSRImportBaseMetadata extends DefineImportMetadata {
+    isDynamicImport?: boolean;
+}
+
+interface SourceMapLike {
+    version: number;
+    mappings?: string;
+    names?: string[];
+    sources?: string[];
+    sourcesContent?: string[];
+}
+declare class DecodedMap {
+    map: SourceMapLike;
+    _encoded: string;
+    _decoded: undefined | number[][][];
+    _decodedMemo: Stats;
+    url: string;
+    version: number;
+    names: string[];
+    resolvedSources: string[];
+    constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+    lastKey: number;
+    lastNeedle: number;
+    lastIndex: number;
+}
+
+declare class ModuleCacheMap extends Map<string, ModuleCache> {
+    private root;
+    constructor(root: string, entries?: [string, ModuleCache][]);
+    normalize(fsPath: string): string;
+    /**
+     * Assign partial data to the map
+     */
+    update(fsPath: string, mod: ModuleCache): this;
+    setByModuleId(modulePath: string, mod: ModuleCache): this;
+    set(fsPath: string, mod: ModuleCache): this;
+    getByModuleId(modulePath: string): ModuleCache;
+    get(fsPath: string): ModuleCache;
+    deleteByModuleId(modulePath: string): boolean;
+    delete(fsPath: string): boolean;
+    invalidate(id: string): void;
+    isImported({ importedId, importedBy, }: {
+        importedId: string;
+        importedBy: string;
+    }, seen?: Set<string>): boolean;
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    /**
+     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     */
+    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    getSourceMap(moduleId: string): null | DecodedMap;
+}
+
+declare const ssrModuleExportsKey = "__vite_ssr_exports__";
+declare const ssrImportKey = "__vite_ssr_import__";
+declare const ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
+declare const ssrExportAllKey = "__vite_ssr_exportAll__";
+declare const ssrImportMetaKey = "__vite_ssr_import_meta__";
+
+interface RetrieveFileHandler {
+    (path: string): string | null | undefined | false;
+}
+interface RetrieveSourceMapHandler {
+    (path: string): null | {
+        url: string;
+        map: any;
+    };
+}
+interface InterceptorOptions {
+    retrieveFile?: RetrieveFileHandler;
+    retrieveSourceMap?: RetrieveSourceMapHandler;
+}
+
+interface SSRImportMetadata extends SSRImportBaseMetadata {
+    entrypoint?: boolean;
+}
+interface HMRRuntimeConnection extends HMRConnection {
+    /**
+     * Configure how HMR is handled when this connection triggers an update.
+     * This method expects that connection will start listening for HMR updates and call this callback when it's received.
+     */
+    onUpdate(callback: (payload: HMRPayload) => void): void;
+}
+interface ViteRuntimeImportMeta extends ImportMeta {
+    url: string;
+    env: ImportMetaEnv;
+    hot?: ViteHotContext;
+    [key: string]: any;
+}
+interface ViteRuntimeModuleContext {
+    [ssrModuleExportsKey]: Record<string, any>;
+    [ssrImportKey]: (id: string, metadata?: DefineImportMetadata) => Promise<any>;
+    [ssrDynamicImportKey]: (id: string, options?: ImportCallOptions) => Promise<any>;
+    [ssrExportAllKey]: (obj: any) => void;
+    [ssrImportMetaKey]: ViteRuntimeImportMeta;
+}
+interface ViteModuleRunner {
+    /**
+     * Run code that was transformed by Vite.
+     * @param context Function context
+     * @param code Transformed code
+     * @param id ID that was used to fetch the module
+     */
+    runViteModule(context: ViteRuntimeModuleContext, code: string, id: string): Promise<any>;
+    /**
+     * Run externalized module.
+     * @param file File URL to the external module
+     */
+    runExternalModule(file: string): Promise<any>;
+}
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    evaluated?: boolean;
+    map?: DecodedMap;
+    meta?: FetchResult;
+    /**
+     * Module ids that imports this module
+     */
+    importers?: Set<string>;
+    imports?: Set<string>;
+}
+type FetchResult = ExternalFetchResult | ViteFetchResult;
+interface ExternalFetchResult {
+    /**
+     * The path to the externalized module starting with file://,
+     * by default this will be imported via a dynamic "import"
+     * instead of being transformed by vite and loaded with vite runtime
+     */
+    externalize: string;
+    /**
+     * Type of the module. Will be used to determine if import statement is correct.
+     * For example, if Vite needs to throw an error if variable is not actually exported
+     */
+    type?: 'module' | 'commonjs' | 'builtin' | 'network';
+}
+interface ViteFetchResult {
+    /**
+     * Code that will be evaluated by vite runtime
+     * by default this will be wrapped in an async function
+     */
+    code: string;
+    /**
+     * File path of the module on disk.
+     * This will be resolved as import.meta.url/filename
+     */
+    file: string | null;
+}
+type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
+    id: string;
+};
+/**
+ * @experimental
+ */
+type FetchFunction = (id: string, importer?: string) => Promise<FetchResult>;
+interface ViteRuntimeOptions {
+    /**
+     * Root of the project
+     */
+    root: string;
+    /**
+     * A method to get the information about the module.
+     * For SSR, Vite exposes `server.ssrFetchModule` function that you can use here.
+     * For other runtime use cases, Vite also exposes `fetchModule` from its main entry point.
+     */
+    fetchModule: FetchFunction;
+    /**
+     * Custom environment variables available on `import.meta.env`. This doesn't modify the actual `process.env`.
+     */
+    environmentVariables?: Record<string, any>;
+    /**
+     * Configure how source maps are resolved. Prefers `node` if `process.setSourceMapsEnabled` is available.
+     * Otherwise it will use `prepareStackTrace` by default which overrides `Error.prepareStackTrace` method.
+     * You can provide an object to configure how file contents and source maps are resolved for files that were not processed by Vite.
+     */
+    sourcemapInterceptor?: false | 'node' | 'prepareStackTrace' | InterceptorOptions;
+    /**
+     * Disable HMR or configure HMR options.
+     */
+    hmr?: false | {
+        /**
+         * Configure how HMR communicates between the client and the server.
+         */
+        connection: HMRRuntimeConnection;
+        /**
+         * Configure HMR logger.
+         */
+        logger?: false | HMRLogger;
+    };
+    /**
+     * Custom module cache. If not provided, creates a separate module cache for each ViteRuntime instance.
+     */
+    moduleCache?: ModuleCacheMap;
+}
+interface ImportMetaEnv {
+    [key: string]: any;
+    BASE_URL: string;
+    MODE: string;
+    DEV: boolean;
+    PROD: boolean;
+    SSR: boolean;
+}
+
+export { type FetchResult as F, type HMRLogger as H, ModuleCacheMap as M, type ResolvedResult as R, type SSRImportMetadata as S, type ViteRuntimeOptions as V, type FetchFunction as a, type ViteModuleRunner as b, HMRClient as c, type ViteRuntimeModuleContext as d, type HMRConnection as e, type ModuleCache as f, type HMRRuntimeConnection as g, type ViteRuntimeImportMeta as h, ssrExportAllKey as i, ssrImportKey as j, ssrImportMetaKey as k, ssrModuleExportsKey as l, ssrDynamicImportKey as s };
diff --git a/node_modules/vite/index.cjs b/node_modules/vite/index.cjs
new file mode 100644
index 0000000..39f2771
--- /dev/null
+++ b/node_modules/vite/index.cjs
@@ -0,0 +1,60 @@
+warnCjsUsage()
+
+// type utils
+module.exports.defineConfig = (config) => config
+
+// proxy cjs utils (sync functions)
+Object.assign(module.exports, require('./dist/node-cjs/publicUtils.cjs'))
+
+// async functions, can be redirect from ESM build
+const asyncFunctions = [
+  'build',
+  'createServer',
+  'preview',
+  'transformWithEsbuild',
+  'resolveConfig',
+  'optimizeDeps',
+  'formatPostcssSourceMap',
+  'loadConfigFromFile',
+  'preprocessCSS',
+]
+asyncFunctions.forEach((name) => {
+  module.exports[name] = (...args) =>
+    import('./dist/node/index.js').then((i) => i[name](...args))
+})
+
+function warnCjsUsage() {
+  if (process.env.VITE_CJS_IGNORE_WARNING) return
+  const logLevelIndex = process.argv.findIndex((arg) =>
+    /^(?:-l|--logLevel)/.test(arg),
+  )
+  if (logLevelIndex > 0) {
+    const logLevelValue = process.argv[logLevelIndex + 1]
+    if (logLevelValue === 'silent' || logLevelValue === 'error') {
+      return
+    }
+    if (/silent|error/.test(process.argv[logLevelIndex])) {
+      return
+    }
+  }
+  const yellow = (str) => `\u001b[33m${str}\u001b[39m`
+  console.warn(
+    yellow(
+      `The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.`,
+    ),
+  )
+  if (process.env.VITE_CJS_TRACE) {
+    const e = {}
+    const stackTraceLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = 100
+    Error.captureStackTrace(e)
+    Error.stackTraceLimit = stackTraceLimit
+    console.log(
+      e.stack
+        .split('\n')
+        .slice(1)
+        .filter((line) => !line.includes('(node:'))
+        .join('\n'),
+    )
+  }
+}
diff --git a/node_modules/vite/index.d.cts b/node_modules/vite/index.d.cts
new file mode 100644
index 0000000..146c8bc
--- /dev/null
+++ b/node_modules/vite/index.d.cts
@@ -0,0 +1,6 @@
+/**
+ * @deprecated The CJS build of Vite's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
+ */
+declare const module: any
+
+export = module
diff --git a/node_modules/vite/node_modules/.bin/esbuild b/node_modules/vite/node_modules/.bin/esbuild
new file mode 120000
index 0000000..f83b9ce
--- /dev/null
+++ b/node_modules/vite/node_modules/.bin/esbuild
@@ -0,0 +1 @@
+../../../esbuild/bin/esbuild
\ No newline at end of file
diff --git a/node_modules/vite/node_modules/.bin/rollup b/node_modules/vite/node_modules/.bin/rollup
new file mode 120000
index 0000000..de0b20f
--- /dev/null
+++ b/node_modules/vite/node_modules/.bin/rollup
@@ -0,0 +1 @@
+../../../rollup/dist/bin/rollup
\ No newline at end of file
diff --git a/node_modules/vite/package.json b/node_modules/vite/package.json
new file mode 100644
index 0000000..f92b391
--- /dev/null
+++ b/node_modules/vite/package.json
@@ -0,0 +1,191 @@
+{
+  "name": "vite",
+  "version": "5.4.8",
+  "type": "module",
+  "license": "MIT",
+  "author": "Evan You",
+  "description": "Native-ESM powered web dev build tool",
+  "bin": {
+    "vite": "bin/vite.js"
+  },
+  "keywords": [
+    "frontend",
+    "framework",
+    "hmr",
+    "dev-server",
+    "build-tool",
+    "vite"
+  ],
+  "main": "./dist/node/index.js",
+  "types": "./dist/node/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/node/index.d.ts",
+        "default": "./dist/node/index.js"
+      },
+      "require": {
+        "types": "./index.d.cts",
+        "default": "./index.cjs"
+      }
+    },
+    "./client": {
+      "types": "./client.d.ts"
+    },
+    "./runtime": {
+      "types": "./dist/node/runtime.d.ts",
+      "import": "./dist/node/runtime.js"
+    },
+    "./dist/client/*": "./dist/client/*",
+    "./types/*": {
+      "types": "./types/*"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "runtime": [
+        "dist/node/runtime.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "bin",
+    "dist",
+    "client.d.ts",
+    "index.cjs",
+    "index.d.cts",
+    "types"
+  ],
+  "engines": {
+    "node": "^18.0.0 || >=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitejs/vite.git",
+    "directory": "packages/vite"
+  },
+  "bugs": {
+    "url": "https://github.com/vitejs/vite/issues"
+  },
+  "homepage": "https://vitejs.dev",
+  "funding": "https://github.com/vitejs/vite?sponsor=1",
+  "//": "READ CONTRIBUTING.md to understand what to put under deps vs. devDeps!",
+  "dependencies": {
+    "esbuild": "^0.21.3",
+    "postcss": "^8.4.43",
+    "rollup": "^4.20.0"
+  },
+  "optionalDependencies": {
+    "fsevents": "~2.3.3"
+  },
+  "devDependencies": {
+    "@ampproject/remapping": "^2.3.0",
+    "@babel/parser": "^7.25.6",
+    "@jridgewell/trace-mapping": "^0.3.25",
+    "@polka/compression": "^1.0.0-next.25",
+    "@rollup/plugin-alias": "^5.1.0",
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-dynamic-import-vars": "^2.1.2",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "15.2.3",
+    "@rollup/pluginutils": "^5.1.0",
+    "@types/escape-html": "^1.0.4",
+    "@types/pnpapi": "^0.0.5",
+    "artichokie": "^0.2.1",
+    "cac": "^6.7.14",
+    "chokidar": "^3.6.0",
+    "connect": "^3.7.0",
+    "convert-source-map": "^2.0.0",
+    "cors": "^2.8.5",
+    "cross-spawn": "^7.0.3",
+    "debug": "^4.3.6",
+    "dep-types": "link:./src/types",
+    "dotenv": "^16.4.5",
+    "dotenv-expand": "^11.0.6",
+    "es-module-lexer": "^1.5.4",
+    "escape-html": "^1.0.3",
+    "estree-walker": "^3.0.3",
+    "etag": "^1.8.1",
+    "fast-glob": "^3.3.2",
+    "http-proxy": "^1.18.1",
+    "launch-editor-middleware": "^2.8.1",
+    "lightningcss": "^1.26.0",
+    "magic-string": "^0.30.11",
+    "micromatch": "^4.0.8",
+    "mlly": "^1.7.1",
+    "mrmime": "^2.0.0",
+    "open": "^8.4.2",
+    "parse5": "^7.1.2",
+    "pathe": "^1.1.2",
+    "periscopic": "^4.0.2",
+    "picocolors": "^1.0.1",
+    "picomatch": "^2.3.1",
+    "postcss-import": "^16.1.0",
+    "postcss-load-config": "^4.0.2",
+    "postcss-modules": "^6.0.0",
+    "resolve.exports": "^2.0.2",
+    "rollup-plugin-dts": "^6.1.1",
+    "rollup-plugin-esbuild": "^6.1.1",
+    "rollup-plugin-license": "^3.5.2",
+    "sass": "^1.77.8",
+    "sass-embedded": "^1.77.8",
+    "sirv": "^2.0.4",
+    "source-map-support": "^0.5.21",
+    "strip-ansi": "^7.1.0",
+    "strip-literal": "^2.1.0",
+    "tsconfck": "^3.1.3",
+    "tslib": "^2.7.0",
+    "types": "link:./types",
+    "ufo": "^1.5.4",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "@types/node": "^18.0.0 || >=20.0.0",
+    "less": "*",
+    "lightningcss": "^1.21.0",
+    "sass": "*",
+    "sass-embedded": "*",
+    "stylus": "*",
+    "sugarss": "*",
+    "terser": "^5.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    },
+    "sass": {
+      "optional": true
+    },
+    "sass-embedded": {
+      "optional": true
+    },
+    "stylus": {
+      "optional": true
+    },
+    "less": {
+      "optional": true
+    },
+    "sugarss": {
+      "optional": true
+    },
+    "lightningcss": {
+      "optional": true
+    },
+    "terser": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "dev": "tsx scripts/dev.ts",
+    "build": "rimraf dist && run-s build-bundle build-types",
+    "build-bundle": "rollup --config rollup.config.ts --configPlugin esbuild",
+    "build-types": "run-s build-types-temp build-types-roll build-types-check",
+    "build-types-temp": "tsc --emitDeclarationOnly --outDir temp -p src/node",
+    "build-types-roll": "rollup --config rollup.dts.config.ts --configPlugin esbuild && rimraf temp",
+    "build-types-check": "tsc --project tsconfig.check.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint --cache --ext .ts src/**",
+    "format": "prettier --write --cache --parser typescript \"src/**/*.ts\""
+  }
+}
\ No newline at end of file
diff --git a/node_modules/vite/types/customEvent.d.ts b/node_modules/vite/types/customEvent.d.ts
new file mode 100644
index 0000000..9202738
--- /dev/null
+++ b/node_modules/vite/types/customEvent.d.ts
@@ -0,0 +1,39 @@
+import type {
+  ErrorPayload,
+  FullReloadPayload,
+  PrunePayload,
+  UpdatePayload,
+} from './hmrPayload'
+
+export interface CustomEventMap {
+  'vite:beforeUpdate': UpdatePayload
+  'vite:afterUpdate': UpdatePayload
+  'vite:beforePrune': PrunePayload
+  'vite:beforeFullReload': FullReloadPayload
+  'vite:error': ErrorPayload
+  'vite:invalidate': InvalidatePayload
+  'vite:ws:connect': WebSocketConnectionPayload
+  'vite:ws:disconnect': WebSocketConnectionPayload
+}
+
+export interface WebSocketConnectionPayload {
+  /**
+   * @experimental
+   * We expose this instance experimentally to see potential usage.
+   * This might be removed in the future if we didn't find reasonable use cases.
+   * If you find this useful, please open an issue with details so we can discuss and make it stable API.
+   */
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  webSocket: WebSocket
+}
+
+export interface InvalidatePayload {
+  path: string
+  message: string | undefined
+}
+
+/**
+ * provides types for built-in Vite events
+ */
+export type InferCustomEventPayload<T extends string> =
+  T extends keyof CustomEventMap ? CustomEventMap[T] : any
diff --git a/node_modules/vite/types/hmrPayload.d.ts b/node_modules/vite/types/hmrPayload.d.ts
new file mode 100644
index 0000000..79dc349
--- /dev/null
+++ b/node_modules/vite/types/hmrPayload.d.ts
@@ -0,0 +1,65 @@
+export type HMRPayload =
+  | ConnectedPayload
+  | UpdatePayload
+  | FullReloadPayload
+  | CustomPayload
+  | ErrorPayload
+  | PrunePayload
+
+export interface ConnectedPayload {
+  type: 'connected'
+}
+
+export interface UpdatePayload {
+  type: 'update'
+  updates: Update[]
+}
+
+export interface Update {
+  type: 'js-update' | 'css-update'
+  path: string
+  acceptedPath: string
+  timestamp: number
+  /** @internal */
+  explicitImportRequired?: boolean
+  /** @internal */
+  isWithinCircularImport?: boolean
+  /** @internal */
+  ssrInvalidates?: string[]
+}
+
+export interface PrunePayload {
+  type: 'prune'
+  paths: string[]
+}
+
+export interface FullReloadPayload {
+  type: 'full-reload'
+  path?: string
+  /** @internal */
+  triggeredBy?: string
+}
+
+export interface CustomPayload {
+  type: 'custom'
+  event: string
+  data?: any
+}
+
+export interface ErrorPayload {
+  type: 'error'
+  err: {
+    [name: string]: any
+    message: string
+    stack: string
+    id?: string
+    frame?: string
+    plugin?: string
+    pluginCode?: string
+    loc?: {
+      file?: string
+      line: number
+      column: number
+    }
+  }
+}
diff --git a/node_modules/vite/types/hot.d.ts b/node_modules/vite/types/hot.d.ts
new file mode 100644
index 0000000..8ef92cd
--- /dev/null
+++ b/node_modules/vite/types/hot.d.ts
@@ -0,0 +1,36 @@
+import type { InferCustomEventPayload } from './customEvent'
+
+export type ModuleNamespace = Record<string, any> & {
+  [Symbol.toStringTag]: 'Module'
+}
+
+export interface ViteHotContext {
+  readonly data: any
+
+  accept(): void
+  accept(cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(
+    deps: readonly string[],
+    cb: (mods: Array<ModuleNamespace | undefined>) => void,
+  ): void
+
+  acceptExports(
+    exportNames: string | readonly string[],
+    cb?: (mod: ModuleNamespace | undefined) => void,
+  ): void
+
+  dispose(cb: (data: any) => void): void
+  prune(cb: (data: any) => void): void
+  invalidate(message?: string): void
+
+  on<T extends string>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  off<T extends string>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
+}
diff --git a/node_modules/vite/types/import-meta.d.ts b/node_modules/vite/types/import-meta.d.ts
new file mode 100644
index 0000000..ee00ff5
--- /dev/null
+++ b/node_modules/vite/types/import-meta.d.ts
@@ -0,0 +1,5 @@
+/// <reference path="./importMeta.d.ts" />
+
+// https://github.com/microsoft/TypeScript/issues/45096
+// TypeScript has a bug that makes <reference types="vite/types/importMeta" />
+// not possible in userland. This file provides a workaround for now.
diff --git a/node_modules/vite/types/importGlob.d.ts b/node_modules/vite/types/importGlob.d.ts
new file mode 100644
index 0000000..e016753
--- /dev/null
+++ b/node_modules/vite/types/importGlob.d.ts
@@ -0,0 +1,75 @@
+export interface ImportGlobOptions<
+  Eager extends boolean,
+  AsType extends string,
+> {
+  /**
+   * Import type for the import url.
+   *
+   * @deprecated Use `query` instead, e.g. `as: 'url'` -> `query: '?url', import: 'default'`
+   */
+  as?: AsType
+  /**
+   * Import as static or dynamic
+   *
+   * @default false
+   */
+  eager?: Eager
+  /**
+   * Import only the specific named export. Set to `default` to import the default export.
+   */
+  import?: string
+  /**
+   * Custom queries
+   */
+  query?: string | Record<string, string | number | boolean>
+  /**
+   * Search files also inside `node_modules/` and hidden directories (e.g. `.git/`). This might have impact on performance.
+   *
+   * @default false
+   */
+  exhaustive?: boolean
+}
+
+export type GeneralImportGlobOptions = ImportGlobOptions<boolean, string>
+
+export interface KnownAsTypeMap {
+  raw: string
+  url: string
+  worker: Worker
+}
+
+export interface ImportGlobFunction {
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 1: No generic provided, infer the type from `eager` and `as`
+   */
+  <
+    Eager extends boolean,
+    As extends string,
+    T = As extends keyof KnownAsTypeMap ? KnownAsTypeMap[As] : unknown,
+  >(
+    glob: string | string[],
+    options?: ImportGlobOptions<Eager, As>,
+  ): (Eager extends true ? true : false) extends true
+    ? Record<string, T>
+    : Record<string, () => Promise<T>>
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 2: Module generic provided, infer the type from `eager: false`
+   */
+  <M>(
+    glob: string | string[],
+    options?: ImportGlobOptions<false, string>,
+  ): Record<string, () => Promise<M>>
+  /**
+   * Import a list of files with a glob pattern.
+   *
+   * Overload 3: Module generic provided, infer the type from `eager: true`
+   */
+  <M>(
+    glob: string | string[],
+    options: ImportGlobOptions<true, string>,
+  ): Record<string, M>
+}
diff --git a/node_modules/vite/types/importMeta.d.ts b/node_modules/vite/types/importMeta.d.ts
new file mode 100644
index 0000000..bd44183
--- /dev/null
+++ b/node_modules/vite/types/importMeta.d.ts
@@ -0,0 +1,22 @@
+// This file is an augmentation to the built-in ImportMeta interface
+// Thus cannot contain any top-level imports
+// <https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation>
+
+interface ImportMetaEnv {
+  [key: string]: any
+  BASE_URL: string
+  MODE: string
+  DEV: boolean
+  PROD: boolean
+  SSR: boolean
+}
+
+interface ImportMeta {
+  url: string
+
+  readonly hot?: import('./hot').ViteHotContext
+
+  readonly env: ImportMetaEnv
+
+  glob: import('./importGlob').ImportGlobFunction
+}
diff --git a/node_modules/vite/types/metadata.d.ts b/node_modules/vite/types/metadata.d.ts
new file mode 100644
index 0000000..d6925c5
--- /dev/null
+++ b/node_modules/vite/types/metadata.d.ts
@@ -0,0 +1,10 @@
+export interface ChunkMetadata {
+  importedAssets: Set<string>
+  importedCss: Set<string>
+}
+
+declare module 'rollup' {
+  export interface RenderedChunk {
+    viteMetadata?: ChunkMetadata
+  }
+}
diff --git a/node_modules/vite/types/package.json b/node_modules/vite/types/package.json
new file mode 100644
index 0000000..00efc39
--- /dev/null
+++ b/node_modules/vite/types/package.json
@@ -0,0 +1,4 @@
+{
+  "//": "this file is here to make typescript happy when moduleResolution=node16+",
+  "version": "0.0.0"
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..09b8568
--- /dev/null
+++ b/package.json
@@ -0,0 +1,13 @@
+{
+  "dependencies": {
+    "@ffmpeg/ffmpeg": "^0.12.10",
+    "@ffmpeg/util": "^0.12.1"
+  },
+  "name": "libwebp",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "vite": "^5.4.8"
+  }
+}
diff --git a/stb_image.c b/stb_image.c
new file mode 100644
index 0000000..21ec010
--- /dev/null
+++ b/stb_image.c
@@ -0,0 +1,4678 @@
+/* stb_image - v1.35 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c
+   when you control the images you're loading
+                                     no warranty implied; use at your own risk
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline (no JPEG progressive)
+      PNG 8-bit-per-channel only
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - overridable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD)
+
+   Latest revisions:
+      1.35 (2014-05-27) warnings, bugfixes, TGA optimization, etc
+      1.34 (unknown   ) warning fix
+      1.33 (2011-07-14) minor fixes suggested by Dave Moore
+      1.32 (2011-07-13) info support for all filetypes (SpartanJ)
+      1.31 (2011-06-19) a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30 (2011-06-11) added ability to load files via io callbacks (Ben Wenger)
+      1.29 (2010-08-16) various warning fixes from Aurelien Pocheville 
+      1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ)
+
+   See end of file for full revision history.
+
+   TODO:
+      stbi_info support for BMP,PSD,HDR,PIC
+
+
+ ============================    Contributors    =========================
+              
+ Image formats                                Bug fixes & warning fixes
+    Sean Barrett (jpeg, png, bmp)                Marc LeBlanc
+    Nicolas Schulz (hdr, psd)                    Christpher Lloyd
+    Jonathan Dummer (tga)                        Dave Moore
+    Jean-Marc Lienher (gif)                      Won Chun
+    Tom Seddon (pic)                             the Horde3D community
+    Thatcher Ulrich (psd)                        Janez Zemva
+                                                 Jonathan Blow
+                                                 Laurent Gomila
+ Extensions, features                            Aruelien Pocheville
+    Jetro Lauha (stbi_info)                      Ryamond Barbiero
+    James "moose2000" Brown (iPhone PNG)         David Woo
+    Ben "Disch" Wenger (io callbacks)            Roy Eltham
+    Martin "SpartanJ" Golini                     Luke Graham
+                                                 Thomas Ruf
+                                                 John Bartholomew
+ Optimizations & bugfixes                        Ken Hamada
+    Fabian "ryg" Giesen                          Cort Stratton
+    Arseny Kapoulkine                            Blazej Dariusz Roszkowski
+                                                 Thibault Reuille
+ If your name should be here but                 Paul Du Bois
+ isn't let Sean know.                            Guillaume George
+
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// To get a header file for this, either cut and paste the header,
+// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and
+// then include stb_image.c from it.
+
+////   begin header file  ////////////////////////////////////////////////////
+//
+// Limitations:
+//    - no jpeg progressive support
+//    - non-HDR formats support 8-bit samples only (jpeg, png)
+//    - no delayed line count (jpeg) -- IJG doesn't support either
+//    - no 1-bit BMP
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ... 
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data)
+//
+// Standard parameters:
+//    int *x       -- outputs image width in pixels
+//    int *y       -- outputs image height in pixels
+//    int *comp    -- outputs # of image components in image file
+//    int req_comp -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
+// If req_comp is non-zero, *comp has the number of components that _would_
+// have been output otherwise. E.g. if you set req_comp to 4, you will always
+// get RGBA output, but you can check *comp to easily see if it's opaque.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
+// can be queried for an extremely brief, end-user unfriendly explanation
+// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
+// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// By default we convert iphone-formatted PNGs back to RGB; nominally they
+// would silently load as BGR, except the existing code should have just
+// failed on such iPhone PNGs. But you can disable this conversion by
+// by calling stbi_convert_iphone_png_to_rgb(0), in which case
+// you will always just get the native iphone "format" through.
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image now supports loading HDR images in general, and currently
+// the Radiance .HDR file format, although the support is provided
+// generically. You can still load any file through the existing interface;
+// if you attempt to load an HDR file, it will be automatically remapped to
+// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+// 
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead. 
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#define _CRT_SECURE_NO_WARNINGS // suppress warnings about fopen()
+#pragma warning(push)
+#pragma warning(disable:4996)   // suppress even more warnings about fopen()
+#endif
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for req_comp
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+typedef unsigned char stbi_uc;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_STDIO
+extern stbi_uc *stbi_load            (char const *filename,     int *x, int *y, int *comp, int req_comp);
+extern stbi_uc *stbi_load_from_file  (FILE *f,                  int *x, int *y, int *comp, int req_comp);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read 
+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+extern stbi_uc *stbi_load_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+#ifndef STBI_NO_HDR
+   extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
+
+   #ifndef STBI_NO_STDIO
+   extern float *stbi_loadf            (char const *filename,   int *x, int *y, int *comp, int req_comp);
+   extern float *stbi_loadf_from_file  (FILE *f,                int *x, int *y, int *comp, int req_comp);
+   #endif
+   
+   extern float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
+
+   extern void   stbi_hdr_to_ldr_gamma(float gamma);
+   extern void   stbi_hdr_to_ldr_scale(float scale);
+
+   extern void   stbi_ldr_to_hdr_gamma(float gamma);
+   extern void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_HDR
+
+// stbi_is_hdr is always defined
+extern int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+extern int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+extern int      stbi_is_hdr          (char const *filename);
+extern int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// NOT THREADSAFE
+extern const char *stbi_failure_reason  (void); 
+
+// free the loaded image -- this is just free()
+extern void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+extern int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+extern int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+
+#ifndef STBI_NO_STDIO
+extern int      stbi_info            (char const *filename,     int *x, int *y, int *comp);
+extern int      stbi_info_from_file  (FILE *f,                  int *x, int *y, int *comp);
+
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+
+// ZLIB client - used by PNG, available for other purposes
+
+extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+extern char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+extern int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+// define faster low-level operations (typically SIMD support)
+#ifdef STBI_SIMD
+typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
+// compute an integer IDCT on "input"
+//     input[x] = data[x] * dequantize[x]
+//     write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
+//                             CLAMP results to 0..255
+typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const  *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
+// compute a conversion from YCbCr to RGB
+//     'count' pixels
+//     write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
+//     y: Y input channel
+//     cb: Cb input channel; scale/biased to be 0..255
+//     cr: Cr input channel; scale/biased to be 0..255
+
+extern void stbi_install_idct(stbi_idct_8x8 func);
+extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
+#endif // STBI_SIMD
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifndef STBI_HEADER_FILE_ONLY
+
+#ifndef STBI_NO_HDR
+#include <math.h>  // ldexp
+#include <string.h> // strcmp, strtok
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+#include <stdlib.h>
+#include <memory.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+
+#ifdef _MSC_VER
+typedef unsigned char  stbi__uint8;
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint8_t  stbi__uint8;
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (32 - (y))))
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi struct and start_xxx functions
+
+// stbi structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__uint32 img_x, img_y;
+   int img_n, img_out_n;
+   
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   stbi__uint8 buffer_start[128];
+
+   stbi__uint8 *img_buffer, *img_buffer_end;
+   stbi__uint8 *img_buffer_original;
+} stbi;
+
+
+static void refill_buffer(stbi *s);
+
+// initialize a memory-decode context
+static void start_mem(stbi *s, stbi__uint8 const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->img_buffer = s->img_buffer_original = (stbi__uint8 *) buffer;
+   s->img_buffer_end = (stbi__uint8 *) buffer+len;
+}
+
+// initialize a callback-based context
+static void start_callbacks(stbi *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->img_buffer_original = s->buffer_start;
+   refill_buffer(s);
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stdio_skip(void *user, int n)
+{
+   fseek((FILE*) user, n, SEEK_CUR);
+}
+
+static int stdio_eof(void *user)
+{
+   return feof((FILE*) user);
+}
+
+static stbi_io_callbacks stbi_stdio_callbacks =
+{
+   stdio_read,
+   stdio_skip,
+   stdio_eof,
+};
+
+static void start_file(stbi *s, FILE *f)
+{
+   start_callbacks(s, &stbi_stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi_rewind(stbi *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+}
+
+static int      stbi_jpeg_test(stbi *s);
+static stbi_uc *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_jpeg_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_png_test(stbi *s);
+static stbi_uc *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_png_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_bmp_test(stbi *s);
+static stbi_uc *stbi_bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_tga_test(stbi *s);
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_tga_info(stbi *s, int *x, int *y, int *comp);
+static int      stbi_psd_test(stbi *s);
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+#ifndef STBI_NO_HDR
+static int      stbi_hdr_test(stbi *s);
+static float   *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+#endif
+static int      stbi_pic_test(stbi *s);
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_gif_test(stbi *s);
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp);
+static int      stbi_gif_info(stbi *s, int *x, int *y, int *comp);
+
+
+// this is not threadsafe
+static const char *failure_reason;
+
+const char *stbi_failure_reason(void)
+{
+   return failure_reason;
+}
+
+static int e(const char *str)
+{
+   failure_reason = str;
+   return 0;
+}
+
+// e - error
+// epf - error returning pointer to float
+// epuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define e(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define e(x,y)  e(y)
+#else
+   #define e(x,y)  e(x)
+#endif
+
+#define epf(x,y)   ((float *) (e(x,y)?NULL:NULL))
+#define epuc(x,y)  ((unsigned char *) (e(x,y)?NULL:NULL))
+
+void stbi_image_free(void *retval_from_stbi_load)
+{
+   free(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_HDR
+static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static unsigned char *stbi_load_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi_jpeg_test(s)) return stbi_jpeg_load(s,x,y,comp,req_comp);
+   if (stbi_png_test(s))  return stbi_png_load(s,x,y,comp,req_comp);
+   if (stbi_bmp_test(s))  return stbi_bmp_load(s,x,y,comp,req_comp);
+   if (stbi_gif_test(s))  return stbi_gif_load(s,x,y,comp,req_comp);
+   if (stbi_psd_test(s))  return stbi_psd_load(s,x,y,comp,req_comp);
+   if (stbi_pic_test(s))  return stbi_pic_load(s,x,y,comp,req_comp);
+
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_test(s)) {
+      float *hdr = stbi_hdr_load(s, x,y,comp,req_comp);
+      return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   // test tga last because it's a crappy test!
+   if (stbi_tga_test(s))
+      return stbi_tga_load(s,x,y,comp,req_comp);
+   return epuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return epuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi s;
+   start_file(&s,f);
+   result = stbi_load_main(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+#endif //!STBI_NO_STDIO
+
+unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+unsigned char *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_load_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_HDR
+
+float *stbi_loadf_main(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_test(s))
+      return stbi_hdr_load(s,x,y,comp,req_comp);
+   #endif
+   data = stbi_load_main(s, x, y, comp, req_comp);
+   if (data)
+      return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return epf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = fopen(filename, "rb");
+   float *result;
+   if (!f) return epf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi s;
+   start_file(&s,f);
+   return stbi_loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_HDR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is
+// defined, for API simplicity; if STBI_NO_HDR is defined, it always
+// reports false!
+
+int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+extern int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+extern int      stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_file(&s,f);
+   return stbi_hdr_test(&s);
+   #else
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+extern int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi_hdr_test(&s);
+   #else
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_HDR
+static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f;
+static float l2h_gamma=2.2f, l2h_scale=1.0f;
+
+void   stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; }
+void   stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; }
+
+void   stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; }
+void   stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; }
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   SCAN_load=0,
+   SCAN_type,
+   SCAN_header
+};
+
+static void refill_buffer(stbi *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static int get8(stbi *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+stbi_inline static int at_eof(stbi *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;   
+}
+
+stbi_inline static stbi__uint8 get8u(stbi *s)
+{
+   return (stbi__uint8) get8(s);
+}
+
+static void skip(stbi *s, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+
+static int getn(stbi *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+         
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+
+static int get16(stbi *s)
+{
+   int z = get8(s);
+   return (z << 8) + get8(s);
+}
+
+static stbi__uint32 get32(stbi *s)
+{
+   stbi__uint32 z = get16(s);
+   return (z << 16) + get16(s);
+}
+
+static int get16le(stbi *s)
+{
+   int z = get8(s);
+   return z + (get8(s) << 8);
+}
+
+static stbi__uint32 get32le(stbi *s)
+{
+   stbi__uint32 z = get16le(s);
+   return z + (get16le(s) << 16);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi__uint8 compute_y(int r, int g, int b)
+{
+   return (stbi__uint8) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+
+static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   assert(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) malloc(req_comp * x * y);
+   if (good == NULL) {
+      free(data);
+      return epuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define COMBO(a,b)  ((a)*8+(b))
+      #define CASE(a,b)   case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (COMBO(img_n, req_comp)) {
+         CASE(1,2) dest[0]=src[0], dest[1]=255; break;
+         CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+         CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break;
+         CASE(2,1) dest[0]=src[0]; break;
+         CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break;
+         CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break;
+         CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break;
+         CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+         CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break;
+         CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break;
+         CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break;
+         CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break;
+         default: assert(0);
+      }
+      #undef CASE
+   }
+
+   free(data);
+   return good;
+}
+
+#ifndef STBI_NO_HDR
+static float   *ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output = (float *) malloc(x * y * comp * sizeof(float));
+   if (output == NULL) { free(data); return epf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale;
+      }
+      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
+   }
+   free(data);
+   return output;
+}
+
+#define float2int(x)   ((int) (x))
+static stbi_uc *hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output = (stbi_uc *) malloc(x * y * comp);
+   if (output == NULL) { free(data); return epuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi__uint8) float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi__uint8) float2int(z);
+      }
+   }
+   free(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder (not actually fully baseline implementation)
+//
+//    simple implementation
+//      - channel subsampling of at most 2 in each dimension
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - uses a lot of intermediate memory, could cache poorly
+//      - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4
+//          stb_jpeg:   1.34 seconds (MSVC6, default release build)
+//          stb_jpeg:   1.06 seconds (MSVC6, processor = Pentium Pro)
+//          IJL11.dll:  1.08 seconds (compiled by intel)
+//          IJG 1998:   0.98 seconds (MSVC6, makefile provided by IJG)
+//          IJG 1998:   0.95 seconds (MSVC6, makefile + proc=PPro)
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi__uint8  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi__uint8  values[256];
+   stbi__uint8  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} huffman;
+
+typedef struct
+{
+   #ifdef STBI_SIMD
+   unsigned short dequant2[4][64];
+   #endif
+   stbi *s;
+   huffman huff_dc[4];
+   huffman huff_ac[4];
+   stbi__uint8 dequant[4][64];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      stbi__uint8 *data;
+      void *raw_data;
+      stbi__uint8 *linebuf;
+   } img_comp[4];
+
+   stbi__uint32         code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+} jpeg;
+
+static int build_huffman(huffman *h, int *count)
+{
+   int i,j,k=0,code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i)
+      for (j=0; j < count[i]; ++j)
+         h->size[k++] = (stbi__uint8) (i+1);
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (stbi__uint16) (code++);
+         if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (stbi__uint8) i;
+         }
+      }
+   }
+   return 1;
+}
+
+static void grow_buffer_unsafe(jpeg *j)
+{
+   do {
+      int b = j->nomore ? 0 : get8(j->s);
+      if (b == 0xff) {
+         int c = get8(j->s);
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static stbi__uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int decode(jpeg *j, huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k];
+   assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int extend_receive(jpeg *j, int n)
+{
+   unsigned int m = 1 << (n-1);
+   unsigned int k;
+   if (j->code_bits < n) grow_buffer_unsafe(j);
+
+   #if 1
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~bmask[n];
+   k &= bmask[n];
+   j->code_bits -= n;
+   #else
+   k = (j->code_buffer >> (32 - n)) & bmask[n];
+   j->code_bits -= n;
+   j->code_buffer <<= n;
+   #endif
+   // the following test is probably a random branch that won't
+   // predict well. I tried to table accelerate it but failed.
+   // maybe it's compiling as a conditional move?
+   if (k < m)
+      return (-1 << n) + k + 1;
+   else
+      return k;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static stbi__uint8 dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b)
+{
+   int diff,dc,k;
+   int t = decode(j, hdc);
+   if (t < 0) return e("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? extend_receive(j, t) : 0;
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   data[0] = (short) dc;
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      int r,s;
+      int rs = decode(j, hac);
+      if (rs < 0) return e("bad huffman code","Corrupt JPEG");
+      s = rs & 15;
+      r = rs >> 4;
+      if (s == 0) {
+         if (rs != 0xf0) break; // end block
+         k += 16;
+      } else {
+         k += r;
+         // decode into unzigzag'd location
+         data[dezigzag[k++]] = (short) extend_receive(j,s);
+      }
+   } while (k < 64);
+   return 1;
+}
+
+// take a -128..127 value and clamp it and convert to 0..255
+stbi_inline static stbi__uint8 clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (stbi__uint8) x;
+}
+
+#define f2f(x)  (int) (((x) * 4096 + 0.5))
+#define fsh(x)  ((x) << 12)
+
+// derived from jidctint -- DCT_ISLOW
+#define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7)       \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * f2f(0.5411961f);             \
+   t2 = p1 + p3*f2f(-1.847759065f);            \
+   t3 = p1 + p2*f2f( 0.765366865f);            \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = fsh(p2+p3);                            \
+   t1 = fsh(p2-p3);                            \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*f2f( 1.175875602f);            \
+   t0 = t0*f2f( 0.298631336f);                 \
+   t1 = t1*f2f( 2.053119869f);                 \
+   t2 = t2*f2f( 3.072711026f);                 \
+   t3 = t3*f2f( 1.501321110f);                 \
+   p1 = p5 + p1*f2f(-0.899976223f);            \
+   p2 = p5 + p2*f2f(-2.562915447f);            \
+   p3 = p3*f2f(-1.961570560f);                 \
+   p4 = p4*f2f(-0.390180644f);                 \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+#ifdef STBI_SIMD
+typedef unsigned short stbi_dequantize_t;
+#else
+typedef stbi__uint8 stbi_dequantize_t;
+#endif
+
+// .344 seconds on 3*anemones.jpg
+static void idct_block(stbi__uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize)
+{
+   int i,val[64],*v=val;
+   stbi_dequantize_t *dq = dequantize;
+   stbi__uint8 *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d,++dq, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0] * dq[0] << 2;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24],
+                 d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = clamp((x0+t3) >> 17);
+      o[7] = clamp((x0-t3) >> 17);
+      o[1] = clamp((x1+t2) >> 17);
+      o[6] = clamp((x1-t2) >> 17);
+      o[2] = clamp((x2+t1) >> 17);
+      o[5] = clamp((x2-t1) >> 17);
+      o[3] = clamp((x3+t0) >> 17);
+      o[4] = clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SIMD
+static stbi_idct_8x8 stbi_idct_installed = idct_block;
+
+void stbi_install_idct(stbi_idct_8x8 func)
+{
+   stbi_idct_installed = func;
+}
+#endif
+
+#define MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi__uint8 get_marker(jpeg *j)
+{
+   stbi__uint8 x;
+   if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; }
+   x = get8u(j->s);
+   if (x != 0xff) return MARKER_none;
+   while (x == 0xff)
+      x = get8u(j->s);
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, reset the entropy decoder and
+// the dc prediction
+static void reset(jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0;
+   j->marker = MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int parse_entropy_coded_data(jpeg *z)
+{
+   reset(z);
+   if (z->scan_n == 1) {
+      int i,j;
+      #ifdef STBI_SIMD
+      __declspec(align(16))
+      #endif
+      short data[64];
+      int n = z->order[0];
+      // non-interleaved data, we just need to process one block at a time,
+      // in trivial scanline order
+      // number of blocks to do just depends on how many actual "pixels" this
+      // component has, independent of interleaved MCU blocking and such
+      int w = (z->img_comp[n].x+7) >> 3;
+      int h = (z->img_comp[n].y+7) >> 3;
+      for (j=0; j < h; ++j) {
+         for (i=0; i < w; ++i) {
+            if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+            #ifdef STBI_SIMD
+            stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+            #else
+            idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+            #endif
+            // every data block is an MCU, so countdown the restart interval
+            if (--z->todo <= 0) {
+               if (z->code_bits < 24) grow_buffer_unsafe(z);
+               // if it's NOT a restart, then just bail, so we get corrupt data
+               // rather than no data
+               if (!RESTART(z->marker)) return 1;
+               reset(z);
+            }
+         }
+      }
+   } else { // interleaved!
+      int i,j,k,x,y;
+      short data[64];
+      for (j=0; j < z->img_mcu_y; ++j) {
+         for (i=0; i < z->img_mcu_x; ++i) {
+            // scan an interleaved mcu... process scan_n components in order
+            for (k=0; k < z->scan_n; ++k) {
+               int n = z->order[k];
+               // scan out an mcu's worth of this component; that's just determined
+               // by the basic H and V specified for the component
+               for (y=0; y < z->img_comp[n].v; ++y) {
+                  for (x=0; x < z->img_comp[n].h; ++x) {
+                     int x2 = (i*z->img_comp[n].h + x)*8;
+                     int y2 = (j*z->img_comp[n].v + y)*8;
+                     if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0;
+                     #ifdef STBI_SIMD
+                     stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]);
+                     #else
+                     idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]);
+                     #endif
+                  }
+               }
+            }
+            // after all interleaved components, that's an interleaved MCU,
+            // so now count down the restart interval
+            if (--z->todo <= 0) {
+               if (z->code_bits < 24) grow_buffer_unsafe(z);
+               // if it's NOT a restart, then just bail, so we get corrupt data
+               // rather than no data
+               if (!RESTART(z->marker)) return 1;
+               reset(z);
+            }
+         }
+      }
+   }
+   return 1;
+}
+
+static int process_marker(jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case MARKER_none: // no marker found
+         return e("expected marker","Corrupt JPEG");
+
+      case 0xC2: // SOF - progressive
+         return e("progressive jpeg","JPEG format not supported (progressive)");
+
+      case 0xDD: // DRI - specify restart interval
+         if (get16(z->s) != 4) return e("bad DRI len","Corrupt JPEG");
+         z->restart_interval = get16(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = get16(z->s)-2;
+         while (L > 0) {
+            int q = get8(z->s);
+            int p = q >> 4;
+            int t = q & 15,i;
+            if (p != 0) return e("bad DQT type","Corrupt JPEG");
+            if (t > 3) return e("bad DQT table","Corrupt JPEG");
+            for (i=0; i < 64; ++i)
+               z->dequant[t][dezigzag[i]] = get8u(z->s);
+            #ifdef STBI_SIMD
+            for (i=0; i < 64; ++i)
+               z->dequant2[t][i] = z->dequant[t][i];
+            #endif
+            L -= 65;
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = get16(z->s)-2;
+         while (L > 0) {
+            stbi__uint8 *v;
+            int sizes[16],i,n=0;
+            int q = get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = get8(z->s);
+               n += sizes[i];
+            }
+            L -= 17;
+            if (tc == 0) {
+               if (!build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = get8u(z->s);
+            L -= n;
+         }
+         return L==0;
+   }
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      skip(z->s, get16(z->s)-2);
+      return 1;
+   }
+   return 0;
+}
+
+// after we see SOS
+static int process_scan_header(jpeg *z)
+{
+   int i;
+   int Ls = get16(z->s);
+   z->scan_n = get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return e("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = get8(z->s), which;
+      int q = get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0;
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+   if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+   get8(z->s); // should be 63, but might be 0
+   if (get8(z->s) != 0) return e("bad SOS","Corrupt JPEG");
+
+   return 1;
+}
+
+static int process_frame_header(jpeg *z, int scan)
+{
+   stbi *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = get16(s);         if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = get8(s);          if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = get16(s);   if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = get16(s);   if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires
+   c = get8(s);
+   if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG");    // JFIF requires
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return e("bad SOF len","Corrupt JPEG");
+
+   for (i=0; i < s->img_n; ++i) {
+      z->img_comp[i].id = get8(s);
+      if (z->img_comp[i].id != i+1)   // JFIF requires
+         if (z->img_comp[i].id != i)  // some version of jpegtran outputs non-JFIF-compliant files!
+            return e("bad component ID","Corrupt JPEG");
+      q = get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = get8(s);  if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != SCAN_load) return 1;
+
+   if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15);
+      if (z->img_comp[i].raw_data == NULL) {
+         for(--i; i >= 0; --i) {
+            free(z->img_comp[i].raw_data);
+            z->img_comp[i].data = NULL;
+         }
+         return e("outofmem", "Out of memory");
+      }
+      // align blocks for installable-idct using mmx/sse
+      z->img_comp[i].data = (stbi__uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define DNL(x)         ((x) == 0xdc)
+#define SOI(x)         ((x) == 0xd8)
+#define EOI(x)         ((x) == 0xd9)
+#define SOF(x)         ((x) == 0xc0 || (x) == 0xc1)
+#define SOS(x)         ((x) == 0xda)
+
+static int decode_jpeg_header(jpeg *z, int scan)
+{
+   int m;
+   z->marker = MARKER_none; // initialize cached marker to empty
+   m = get_marker(z);
+   if (!SOI(m)) return e("no SOI","Corrupt JPEG");
+   if (scan == SCAN_type) return 1;
+   m = get_marker(z);
+   while (!SOF(m)) {
+      if (!process_marker(z,m)) return 0;
+      m = get_marker(z);
+      while (m == MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (at_eof(z->s)) return e("no SOF", "Corrupt JPEG");
+         m = get_marker(z);
+      }
+   }
+   if (!process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+static int decode_jpeg_image(jpeg *j)
+{
+   int m;
+   j->restart_interval = 0;
+   if (!decode_jpeg_header(j, SCAN_load)) return 0;
+   m = get_marker(j);
+   while (!EOI(m)) {
+      if (SOS(m)) {
+         if (!process_scan_header(j)) return 0;
+         if (!parse_entropy_coded_data(j)) return 0;
+         if (j->marker == MARKER_none ) {
+            // handle 0s at the end of image data from IP Kamera 9060
+            while (!at_eof(j->s)) {
+               int x = get8(j->s);
+               if (x == 255) {
+                  j->marker = get8u(j->s);
+                  break;
+               } else if (x != 0) {
+                  return 0;
+               }
+            }
+            // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0
+         }
+      } else {
+         if (!process_marker(j, m)) return 0;
+      }
+      m = get_marker(j);
+   }
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi__uint8 *(*resample_row_func)(stbi__uint8 *out, stbi__uint8 *in0, stbi__uint8 *in1,
+                                    int w, int hs);
+
+#define div4(x) ((stbi__uint8) ((x) >> 2))
+
+static stbi__uint8 *resample_row_1(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi__uint8* resample_row_v_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi__uint8*  resample_row_h_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi__uint8 *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = div4(n+input[i-1]);
+      out[i*2+1] = div4(n+input[i+1]);
+   }
+   out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define div16(x) ((stbi__uint8) ((x) >> 4))
+
+static stbi__uint8 *resample_row_hv_2(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = div16(3*t0 + t1 + 8);
+      out[i*2  ] = div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+static stbi__uint8 *resample_row_generic(stbi__uint8 *out, stbi__uint8 *in_near, stbi__uint8 *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+#define float2fixed(x)  ((int) ((x) * 65536 + 0.5))
+
+// 0.38 seconds on 3*anemones.jpg   (0.25 with processor = Pro)
+// VC6 without processor=Pro is generating multiple LEAs per multiply!
+static void YCbCr_to_RGB_row(stbi__uint8 *out, const stbi__uint8 *y, const stbi__uint8 *pcb, const stbi__uint8 *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 16) + 32768; // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr*float2fixed(1.40200f);
+      g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f);
+      b = y_fixed                            + cb*float2fixed(1.77200f);
+      r >>= 16;
+      g >>= 16;
+      b >>= 16;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi__uint8)r;
+      out[1] = (stbi__uint8)g;
+      out[2] = (stbi__uint8)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#ifdef STBI_SIMD
+static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row;
+
+void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func)
+{
+   stbi_YCbCr_installed = func;
+}
+#endif
+
+
+// clean up the temporary component buffers
+static void cleanup_jpeg(jpeg *j)
+{
+   int i;
+   for (i=0; i < j->s->img_n; ++i) {
+      if (j->img_comp[i].data) {
+         free(j->img_comp[i].raw_data);
+         j->img_comp[i].data = NULL;
+      }
+      if (j->img_comp[i].linebuf) {
+         free(j->img_comp[i].linebuf);
+         j->img_comp[i].linebuf = NULL;
+      }
+   }
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi__uint8 *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion 
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi_resample;
+
+static stbi__uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n;
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+   z->s->img_n = 0;
+
+   // load a jpeg image from whichever source
+   if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n;
+
+   if (z->s->img_n == 3 && n < 3)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi__uint8 *output;
+      stbi__uint8 *coutput[4];
+
+      stbi_resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi_resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (stbi__uint8 *) malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2;
+         else                               r->resample = resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi__uint8 *) malloc(n * z->s->img_x * z->s->img_y + 1);
+      if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi__uint8 *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi_resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            stbi__uint8 *y = coutput[0];
+            if (z->s->img_n == 3) {
+               #ifdef STBI_SIMD
+               stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               #else
+               YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               #endif
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            stbi__uint8 *y = coutput[0];
+            if (n == 1)
+               for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+            else
+               for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255;
+         }
+      }
+      cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp  = z->s->img_n; // report original components, not output
+      return output;
+   }
+}
+
+static unsigned char *stbi_jpeg_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   jpeg j;
+   j.s = s;
+   return load_jpeg_image(&j, x,y,comp,req_comp);
+}
+
+static int stbi_jpeg_test(stbi *s)
+{
+   int r;
+   jpeg j;
+   j.s = s;
+   r = decode_jpeg_header(&j, SCAN_type);
+   stbi_rewind(s);
+   return r;
+}
+
+static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp)
+{
+   if (!decode_jpeg_header(j, SCAN_header)) {
+      stbi_rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n;
+   return 1;
+}
+
+static int stbi_jpeg_info(stbi *s, int *x, int *y, int *comp)
+{
+   jpeg j;
+   j.s = s;
+   return stbi_jpeg_info_raw(&j, x, y, comp);
+}
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define ZFAST_BITS  9 // accelerate all cases in default tables
+#define ZFAST_MASK  ((1 << ZFAST_BITS) - 1)
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi__uint8  size[288];
+   stbi__uint16 value[288]; 
+} zhuffman;
+
+stbi_inline static int bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int bit_reverse(int v, int bits)
+{
+   assert(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return bitreverse16(v) >> (16-bits);
+}
+
+static int zbuild_huffman(zhuffman *z, stbi__uint8 *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 255, sizeof(z->fast));
+   for (i=0; i < num; ++i) 
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      assert(sizes[i] <= (1 << i));
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         z->size[c] = (stbi__uint8)s;
+         z->value[c] = (stbi__uint16)i;
+         if (s <= ZFAST_BITS) {
+            int k = bit_reverse(next_code[s],s);
+            while (k < (1 << ZFAST_BITS)) {
+               z->fast[k] = (stbi__uint16) c;
+               k += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   stbi__uint8 *zbuffer, *zbuffer_end;
+   int num_bits;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   zhuffman z_length, z_distance;
+} zbuf;
+
+stbi_inline static int zget8(zbuf *z)
+{
+   if (z->zbuffer >= z->zbuffer_end) return 0;
+   return *z->zbuffer++;
+}
+
+static void fill_bits(zbuf *z)
+{
+   do {
+      assert(z->code_buffer < (1U << z->num_bits));
+      z->code_buffer |= zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int zreceive(zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;   
+}
+
+stbi_inline static int zhuffman_decode(zbuf *a, zhuffman *z)
+{
+   int b,s,k;
+   if (a->num_bits < 16) fill_bits(a);
+   b = z->fast[a->code_buffer & ZFAST_MASK];
+   if (b < 0xffff) {
+      s = z->size[b];
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return z->value[b];
+   }
+
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = bit_reverse(a->code_buffer, 16);
+   for (s=ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s == 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   assert(z->size[b] == s);
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+static int expand(zbuf *z, int n)  // need to make room for n bytes
+{
+   char *q;
+   int cur, limit;
+   if (!z->z_expandable) return e("output buffer limit","Corrupt PNG");
+   cur   = (int) (z->zout     - z->zout_start);
+   limit = (int) (z->zout_end - z->zout_start);
+   while (cur + n > limit)
+      limit *= 2;
+   q = (char *) realloc(z->zout_start, limit);
+   if (q == NULL) return e("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static int length_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static int length_extra[31]= 
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static int dist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int parse_huffman_block(zbuf *a)
+{
+   for(;;) {
+      int z = zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0;
+         *a->zout++ = (char) z;
+      } else {
+         stbi__uint8 *p;
+         int len,dist;
+         if (z == 256) return 1;
+         z -= 257;
+         len = length_base[z];
+         if (length_extra[z]) len += zreceive(a, length_extra[z]);
+         z = zhuffman_decode(a, &a->z_distance);
+         if (z < 0) return e("bad huffman code","Corrupt PNG");
+         dist = dist_base[z];
+         if (dist_extra[z]) dist += zreceive(a, dist_extra[z]);
+         if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG");
+         if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0;
+         p = (stbi__uint8 *) (a->zout - dist);
+         while (len--)
+            *a->zout++ = *p++;
+      }
+   }
+}
+
+static int compute_huffman_codes(zbuf *a)
+{
+   static stbi__uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   zhuffman z_codelength;
+   stbi__uint8 lencodes[286+32+137];//padding for maximum single op
+   stbi__uint8 codelength_sizes[19];
+   int i,n;
+
+   int hlit  = zreceive(a,5) + 257;
+   int hdist = zreceive(a,5) + 1;
+   int hclen = zreceive(a,4) + 4;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi__uint8) s;
+   }
+   if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < hlit + hdist) {
+      int c = zhuffman_decode(a, &z_codelength);
+      assert(c >= 0 && c < 19);
+      if (c < 16)
+         lencodes[n++] = (stbi__uint8) c;
+      else if (c == 16) {
+         c = zreceive(a,2)+3;
+         memset(lencodes+n, lencodes[n-1], c);
+         n += c;
+      } else if (c == 17) {
+         c = zreceive(a,3)+3;
+         memset(lencodes+n, 0, c);
+         n += c;
+      } else {
+         assert(c == 18);
+         c = zreceive(a,7)+11;
+         memset(lencodes+n, 0, c);
+         n += c;
+      }
+   }
+   if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG");
+   if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int parse_uncompressed_block(zbuf *a)
+{
+   stbi__uint8 header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi__uint8) (a->code_buffer & 255); // wtf this warns?
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   assert(a->num_bits == 0);
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = (stbi__uint8) zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!expand(a, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int parse_zlib_header(zbuf *a)
+{
+   int cmf   = zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = zget8(a);
+   if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+// @TODO: should statically initialize these for optimal thread safety
+static stbi__uint8 default_length[288], default_distance[32];
+static void init_defaults(void)
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     default_length[i]   = 8;
+   for (   ; i <= 255; ++i)     default_length[i]   = 9;
+   for (   ; i <= 279; ++i)     default_length[i]   = 7;
+   for (   ; i <= 287; ++i)     default_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     default_distance[i] = 5;
+}
+
+int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead
+static int parse_zlib(zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   do {
+      final = zreceive(a,1);
+      type = zreceive(a,2);
+      if (type == 0) {
+         if (!parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!default_distance[31]) init_defaults();
+            if (!zbuild_huffman(&a->z_length  , default_length  , 288)) return 0;
+            if (!zbuild_huffman(&a->z_distance, default_distance,  32)) return 0;
+         } else {
+            if (!compute_huffman_codes(a)) return 0;
+         }
+         if (!parse_huffman_block(a)) return 0;
+      }
+      if (stbi_png_partial && a->zout - a->zout_start > 65536)
+         break;
+   } while (!final);
+   return 1;
+}
+
+static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return parse_zlib(a, parse_header);
+}
+
+char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   zbuf a;
+   char *p = (char *) malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi__uint8 *) buffer;
+   a.zbuffer_end = (stbi__uint8 *) buffer + len;
+   if (do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   zbuf a;
+   char *p = (char *) malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi__uint8 *) buffer;
+   a.zbuffer_end = (stbi__uint8 *) buffer + len;
+   if (do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   zbuf a;
+   a.zbuffer = (stbi__uint8 *) ibuffer;
+   a.zbuffer_end = (stbi__uint8 *) ibuffer + ilen;
+   if (do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   zbuf a;
+   char *p = (char *) malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi__uint8 *) buffer;
+   a.zbuffer_end = (stbi__uint8 *) buffer+len;
+   if (do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      free(a.zout_start);
+      return NULL;
+   }
+}
+
+int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   zbuf a;
+   a.zbuffer = (stbi__uint8 *) ibuffer;
+   a.zbuffer_end = (stbi__uint8 *) ibuffer + ilen;
+   if (do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} chunk;
+
+#define PNG_TYPE(a,b,c,d)  (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+
+static chunk get_chunk_header(stbi *s)
+{
+   chunk c;
+   c.length = get32(s);
+   c.type   = get32(s);
+   return c;
+}
+
+static int check_png_header(stbi *s)
+{
+   static stbi__uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (get8u(s) != png_sig[i]) return e("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi *s;
+   stbi__uint8 *idata, *expanded, *out;
+} png;
+
+
+enum {
+   F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4,
+   F_avg_first, F_paeth_first
+};
+
+static stbi__uint8 first_row_filter[5] =
+{
+   F_none, F_sub, F_none, F_avg_first, F_paeth_first
+};
+
+static int paeth(int a, int b, int c)
+{
+   int p = a + b - c;
+   int pa = abs(p-a);
+   int pb = abs(p-b);
+   int pc = abs(p-c);
+   if (pa <= pb && pa <= pc) return a;
+   if (pb <= pc) return b;
+   return c;
+}
+
+// create the png data from post-deflated data
+static int create_png_image_raw(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y)
+{
+   stbi *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+   assert(out_n == s->img_n || out_n == s->img_n+1);
+   if (stbi_png_partial) y = 1;
+   a->out = (stbi__uint8 *) malloc(x * y * out_n);
+   if (!a->out) return e("outofmem", "Out of memory");
+   if (!stbi_png_partial) {
+      if (s->img_x == x && s->img_y == y) {
+         if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+      } else { // interlaced:
+         if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG");
+      }
+   }
+   for (j=0; j < y; ++j) {
+      stbi__uint8 *cur = a->out + stride*j;
+      stbi__uint8 *prior = cur - stride;
+      int filter = *raw++;
+      if (filter > 4) return e("invalid filter","Corrupt PNG");
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+      // handle first pixel explicitly
+      for (k=0; k < img_n; ++k) {
+         switch (filter) {
+            case F_none       : cur[k] = raw[k]; break;
+            case F_sub        : cur[k] = raw[k]; break;
+            case F_up         : cur[k] = raw[k] + prior[k]; break;
+            case F_avg        : cur[k] = raw[k] + (prior[k]>>1); break;
+            case F_paeth      : cur[k] = (stbi__uint8) (raw[k] + paeth(0,prior[k],0)); break;
+            case F_avg_first  : cur[k] = raw[k]; break;
+            case F_paeth_first: cur[k] = raw[k]; break;
+         }
+      }
+      if (img_n != out_n) cur[img_n] = 255;
+      raw += img_n;
+      cur += out_n;
+      prior += out_n;
+      // this is a little gross, so that we don't switch per-pixel or per-component
+      if (img_n == out_n) {
+         #define CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \
+                   for (k=0; k < img_n; ++k)
+         switch (filter) {
+            CASE(F_none)  cur[k] = raw[k]; break;
+            CASE(F_sub)   cur[k] = raw[k] + cur[k-img_n]; break;
+            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
+            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break;
+            CASE(F_paeth)  cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break;
+            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-img_n] >> 1); break;
+            CASE(F_paeth_first)  cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break;
+         }
+         #undef CASE
+      } else {
+         assert(img_n+1 == out_n);
+         #define CASE(f) \
+             case f:     \
+                for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \
+                   for (k=0; k < img_n; ++k)
+         switch (filter) {
+            CASE(F_none)  cur[k] = raw[k]; break;
+            CASE(F_sub)   cur[k] = raw[k] + cur[k-out_n]; break;
+            CASE(F_up)    cur[k] = raw[k] + prior[k]; break;
+            CASE(F_avg)   cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break;
+            CASE(F_paeth)  cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break;
+            CASE(F_avg_first)    cur[k] = raw[k] + (cur[k-out_n] >> 1); break;
+            CASE(F_paeth_first)  cur[k] = (stbi__uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break;
+         }
+         #undef CASE
+      }
+   }
+   return 1;
+}
+
+static int create_png_image(png *a, stbi__uint8 *raw, stbi__uint32 raw_len, int out_n, int interlaced)
+{
+   stbi__uint8 *final;
+   int p;
+   int save;
+   if (!interlaced)
+      return create_png_image_raw(a, raw, raw_len, out_n, a->s->img_x, a->s->img_y);
+   save = stbi_png_partial;
+   stbi_png_partial = 0;
+
+   // de-interlacing
+   final = (stbi__uint8 *) malloc(a->s->img_x * a->s->img_y * out_n);
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) {
+            free(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j)
+            for (i=0; i < x; ++i)
+               memcpy(final + (j*yspc[p]+yorig[p])*a->s->img_x*out_n + (i*xspc[p]+xorig[p])*out_n,
+                      a->out + (j*x+i)*out_n, out_n);
+         free(a->out);
+         raw += (x*out_n+1)*y;
+         raw_len -= (x*out_n+1)*y;
+      }
+   }
+   a->out = final;
+
+   stbi_png_partial = save;
+   return 1;
+}
+
+static int compute_transparency(png *z, stbi__uint8 tc[3], int out_n)
+{
+   stbi *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint8 *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   assert(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int expand_palette(png *a, stbi__uint8 *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi__uint8 *p, *temp_out, *orig = a->out;
+
+   p = (stbi__uint8 *) malloc(pixel_count * pal_img_n);
+   if (p == NULL) return e("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   free(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi_unpremultiply_on_load = 0;
+static int stbi_de_iphone_flag = 0;
+
+void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply;
+}
+void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi_de_iphone_flag = flag_true_if_should_convert;
+}
+
+static void stbi_de_iphone(png *z)
+{
+   stbi *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint8 *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi__uint8 t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      assert(s->img_out_n == 4);
+      if (stbi_unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi__uint8 a = p[3];
+            stbi__uint8 t = p[0];
+            if (a) {
+               p[0] = p[2] * 255 / a;
+               p[1] = p[1] * 255 / a;
+               p[2] =  t   * 255 / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            } 
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi__uint8 t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+static int parse_png_file(png *z, int scan, int req_comp)
+{
+   stbi__uint8 palette[1024], pal_img_n=0;
+   stbi__uint8 has_trans=0, tc[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, iphone=0;
+   stbi *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!check_png_header(s)) return 0;
+
+   if (scan == SCAN_type) return 1;
+
+   for (;;) {
+      chunk c = get_chunk_header(s);
+      switch (c.type) {
+         case PNG_TYPE('C','g','B','I'):
+            iphone = stbi_de_iphone_flag;
+            skip(s, c.length);
+            break;
+         case PNG_TYPE('I','H','D','R'): {
+            int depth,color,comp,filter;
+            if (!first) return e("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return e("bad IHDR len","Corrupt PNG");
+            s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)");
+            s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)");
+            depth = get8(s);  if (depth != 8)        return e("8bit only","PNG not supported: 8-bit only");
+            color = get8(s);  if (color > 6)         return e("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG");
+            comp  = get8(s);  if (comp) return e("bad comp method","Corrupt PNG");
+            filter= get8(s);  if (filter) return e("bad filter method","Corrupt PNG");
+            interlace = get8(s); if (interlace>1) return e("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return e("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode");
+               if (scan == SCAN_header) return 1;
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return e("too large","Corrupt PNG");
+               // if SCAN_header, have to scan to see if we have a tRNS
+            }
+            break;
+         }
+
+         case PNG_TYPE('P','L','T','E'):  {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = get8u(s);
+               palette[i*4+1] = get8u(s);
+               palette[i*4+2] = get8u(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case PNG_TYPE('t','R','N','S'): {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (z->idata) return e("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = get8u(s);
+            } else {
+               if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               for (k=0; k < s->img_n; ++k)
+                  tc[k] = (stbi__uint8) get16(s); // non 8-bit images will be larger
+            }
+            break;
+         }
+
+         case PNG_TYPE('I','D','A','T'): {
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG");
+            if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; }
+            if (ioff + c.length > idata_limit) {
+               stbi__uint8 *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               p = (stbi__uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len;
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if (scan != SCAN_load) return 1;
+            if (z->idata == NULL) return e("no IDAT","Corrupt PNG");
+            z->expanded = (stbi__uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            free(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0;
+            if (has_trans)
+               if (!compute_transparency(z, tc, s->img_out_n)) return 0;
+            if (iphone && s->img_out_n > 2)
+               stbi_de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!expand_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            }
+            free(z->expanded); z->expanded = NULL;
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return e("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX chunk not known";
+               invalid_chunk[0] = (stbi__uint8) (c.type >> 24);
+               invalid_chunk[1] = (stbi__uint8) (c.type >> 16);
+               invalid_chunk[2] = (stbi__uint8) (c.type >>  8);
+               invalid_chunk[3] = (stbi__uint8) (c.type >>  0);
+               #endif
+               return e(invalid_chunk, "PNG not supported: unknown chunk type");
+            }
+            skip(s, c.length);
+            break;
+      }
+      // end of chunk, read and skip CRC
+      get32(s);
+   }
+}
+
+static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp)
+{
+   unsigned char *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error");
+   if (parse_png_file(p, SCAN_load, req_comp)) {
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         result = convert_format(result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   free(p->out);      p->out      = NULL;
+   free(p->expanded); p->expanded = NULL;
+   free(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static unsigned char *stbi_png_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   png p;
+   p.s = s;
+   return do_png(&p, x,y,comp,req_comp);
+}
+
+static int stbi_png_test(stbi *s)
+{
+   int r;
+   r = check_png_header(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static int stbi_png_info_raw(png *p, int *x, int *y, int *comp)
+{
+   if (!parse_png_file(p, SCAN_header, 0)) {
+      stbi_rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int      stbi_png_info(stbi *s, int *x, int *y, int *comp)
+{
+   png p;
+   p.s = s;
+   return stbi_png_info_raw(&p, x, y, comp);
+}
+
+// Microsoft/Windows BMP image
+
+static int bmp_test(stbi *s)
+{
+   int sz;
+   if (get8(s) != 'B') return 0;
+   if (get8(s) != 'M') return 0;
+   get32le(s); // discard filesize
+   get16le(s); // discard reserved
+   get16le(s); // discard reserved
+   get32le(s); // discard data offset
+   sz = get32le(s);
+   if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1;
+   return 0;
+}
+
+static int stbi_bmp_test(stbi *s)
+{
+   int r = bmp_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) n += 16, z >>= 16;
+   if (z >= 0x00100) n +=  8, z >>=  8;
+   if (z >= 0x00010) n +=  4, z >>=  4;
+   if (z >= 0x00004) n +=  2, z >>=  2;
+   if (z >= 0x00002) n +=  1, z >>=  1;
+   return n;
+}
+
+static int bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+static int shiftsigned(int v, int shift, int bits)
+{
+   int result;
+   int z=0;
+
+   if (shift < 0) v <<= -shift;
+   else v >>= shift;
+   result = v;
+
+   z = bits;
+   while (z < 8) {
+      result += v >> z;
+      z += bits;
+   }
+   return result;
+}
+
+static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint8 *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,compress=0,width;
+   int bpp, flip_vertically, pad, target, offset, hsz;
+   if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP");
+   get32le(s); // discard filesize
+   get16le(s); // discard reserved
+   get16le(s); // discard reserved
+   offset = get32le(s);
+   hsz = get32le(s);
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = get16le(s);
+      s->img_y = get16le(s);
+   } else {
+      s->img_x = get32le(s);
+      s->img_y = get32le(s);
+   }
+   if (get16le(s) != 1) return epuc("bad BMP", "bad BMP");
+   bpp = get16le(s);
+   if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit");
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+   if (hsz == 12) {
+      if (bpp < 24)
+         psize = (offset - 14 - 24) / 3;
+   } else {
+      compress = get32le(s);
+      if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE");
+      get32le(s); // discard sizeof
+      get32le(s); // discard hres
+      get32le(s); // discard vres
+      get32le(s); // discard colorsused
+      get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            get32le(s);
+            get32le(s);
+            get32le(s);
+            get32le(s);
+         }
+         if (bpp == 16 || bpp == 32) {
+            mr = mg = mb = 0;
+            if (compress == 0) {
+               if (bpp == 32) {
+                  mr = 0xffu << 16;
+                  mg = 0xffu <<  8;
+                  mb = 0xffu <<  0;
+                  ma = 0xffu << 24;
+                  fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255
+                  STBI_NOTUSED(fake_a);
+               } else {
+                  mr = 31u << 10;
+                  mg = 31u <<  5;
+                  mb = 31u <<  0;
+               }
+            } else if (compress == 3) {
+               mr = get32le(s);
+               mg = get32le(s);
+               mb = get32le(s);
+               // not documented, but generated by photoshop and handled by mspaint
+               if (mr == mg && mg == mb) {
+                  // ?!?!?
+                  return epuc("bad BMP", "bad BMP");
+               }
+            } else
+               return epuc("bad BMP", "bad BMP");
+         }
+      } else {
+         assert(hsz == 108);
+         mr = get32le(s);
+         mg = get32le(s);
+         mb = get32le(s);
+         ma = get32le(s);
+         get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            get32le(s); // discard color space parameters
+      }
+      if (bpp < 16)
+         psize = (offset - 14 - hsz) >> 2;
+   }
+   s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+   out = (stbi_uc *) malloc(target * s->img_x * s->img_y);
+   if (!out) return epuc("outofmem", "Out of memory");
+   if (bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = get8u(s);
+         pal[i][1] = get8u(s);
+         pal[i][0] = get8u(s);
+         if (hsz != 12) get8(s);
+         pal[i][3] = 255;
+      }
+      skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4));
+      if (bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (bpp == 8) width = s->img_x;
+      else { free(out); return epuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      for (j=0; j < (int) s->img_y; ++j) {
+         for (i=0; i < (int) s->img_x; i += 2) {
+            int v=get8(s),v2=0;
+            if (bpp == 4) {
+               v2 = v & 15;
+               v >>= 4;
+            }
+            out[z++] = pal[v][0];
+            out[z++] = pal[v][1];
+            out[z++] = pal[v][2];
+            if (target == 4) out[z++] = 255;
+            if (i+1 == (int) s->img_x) break;
+            v = (bpp == 8) ? get8(s) : v2;
+            out[z++] = pal[v][0];
+            out[z++] = pal[v][1];
+            out[z++] = pal[v][2];
+            if (target == 4) out[z++] = 255;
+         }
+         skip(s, pad);
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      skip(s, offset - 14 - hsz);
+      if (bpp == 24) width = 3 * s->img_x;
+      else if (bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (bpp == 24) {
+         easy = 1;
+      } else if (bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { free(out); return epuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = high_bit(mr)-7; rcount = bitcount(mr);
+         gshift = high_bit(mg)-7; gcount = bitcount(mg);
+         bshift = high_bit(mb)-7; bcount = bitcount(mb);
+         ashift = high_bit(ma)-7; acount = bitcount(ma);
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               int a;
+               out[z+2] = get8u(s);
+               out[z+1] = get8u(s);
+               out[z+0] = get8u(s);
+               z += 3;
+               a = (easy == 2 ? get8(s) : 255);
+               if (target == 4) out[z++] = (stbi__uint8) a;
+            }
+         } else {
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (stbi__uint32) (bpp == 16 ? get16le(s) : get32le(s));
+               int a;
+               out[z++] = (stbi__uint8) shiftsigned(v & mr, rshift, rcount);
+               out[z++] = (stbi__uint8) shiftsigned(v & mg, gshift, gcount);
+               out[z++] = (stbi__uint8) shiftsigned(v & mb, bshift, bcount);
+               a = (ma ? shiftsigned(v & ma, ashift, acount) : 255);
+               if (target == 4) out[z++] = (stbi__uint8) a; 
+            }
+         }
+         skip(s, pad);
+      }
+   }
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i], p1[i] = p2[i], p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+
+static stbi_uc *stbi_bmp_load(stbi *s,int *x, int *y, int *comp, int req_comp)
+{
+   return bmp_load(s, x,y,comp,req_comp);
+}
+
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+
+static int tga_info(stbi *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp;
+    int sz;
+    get8u(s);                   // discard Offset
+    sz = get8u(s);              // color type
+    if( sz > 1 ) {
+        stbi_rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    sz = get8u(s);              // image type
+    // only RGB or grey allowed, +/- RLE
+    if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0;
+    skip(s,9);
+    tga_w = get16le(s);
+    if( tga_w < 1 ) {
+        stbi_rewind(s);
+        return 0;   // test width
+    }
+    tga_h = get16le(s);
+    if( tga_h < 1 ) {
+        stbi_rewind(s);
+        return 0;   // test height
+    }
+    sz = get8(s);               // bits per pixel
+    // only RGB or RGBA or grey allowed
+    if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) {
+        stbi_rewind(s);
+        return 0;
+    }
+    tga_comp = sz;
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp / 8;
+    return 1;                   // seems to have passed everything
+}
+
+int stbi_tga_info(stbi *s, int *x, int *y, int *comp)
+{
+    return tga_info(s, x, y, comp);
+}
+
+static int tga_test(stbi *s)
+{
+   int sz;
+   get8u(s);      //   discard Offset
+   sz = get8u(s);   //   color type
+   if ( sz > 1 ) return 0;   //   only RGB or indexed allowed
+   sz = get8u(s);   //   image type
+   if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0;   //   only RGB or grey allowed, +/- RLE
+   get16(s);      //   discard palette start
+   get16(s);      //   discard palette length
+   get8(s);         //   discard bits per palette color entry
+   get16(s);      //   discard x origin
+   get16(s);      //   discard y origin
+   if ( get16(s) < 1 ) return 0;      //   test width
+   if ( get16(s) < 1 ) return 0;      //   test height
+   sz = get8(s);   //   bits per pixel
+   if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0;   //   only RGB or RGBA or grey allowed
+   return 1;      //   seems to have passed everything
+}
+
+static int stbi_tga_test(stbi *s)
+{
+   int res = tga_test(s);
+   stbi_rewind(s);
+   return res;
+}
+
+static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   //   read in the TGA header stuff
+   int tga_offset = get8u(s);
+   int tga_indexed = get8u(s);
+   int tga_image_type = get8u(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = get16le(s);
+   int tga_palette_len = get16le(s);
+   int tga_palette_bits = get8u(s);
+   int tga_x_origin = get16le(s);
+   int tga_y_origin = get16le(s);
+   int tga_width = get16le(s);
+   int tga_height = get16le(s);
+   int tga_bits_per_pixel = get8u(s);
+   int tga_comp = tga_bits_per_pixel / 8;
+   int tga_inverted = get8u(s);
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4];
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   /* int tga_alpha_bits = tga_inverted & 15; */
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   error check
+   if ( //(tga_indexed) ||
+      (tga_width < 1) || (tga_height < 1) ||
+      (tga_image_type < 1) || (tga_image_type > 3) ||
+      ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
+      (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
+      )
+   {
+      return NULL; // we don't report this as a bad TGA because we don't even know if it's TGA
+   }
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed )
+   {
+      tga_comp = tga_palette_bits / 8;
+   }
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp );
+   if (!tga_data) return epuc("outofmem", "Out of memory");
+
+   //   skip to the data's starting position (offset usually = 0)
+   skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE) {
+      for (i=0; i < tga_height; ++i) {
+         int y = tga_inverted ? tga_height -i - 1 : i;
+         stbi__uint8 *tga_row = tga_data + y*tga_width*tga_comp;
+         getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         //   any data to skip? (offset usually = 0)
+         skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
+         if (!tga_palette) {
+            free(tga_data);
+            return epuc("outofmem", "Out of memory");
+         }
+         if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
+            free(tga_data);
+            free(tga_palette);
+            return epuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE chunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = get8u(s);
+               RLE_count = 1 + (RLE_cmd & 127);
+               RLE_repeating = RLE_cmd >> 7;
+               read_next_pixel = 1;
+            } else if ( !RLE_repeating )
+            {
+               read_next_pixel = 1;
+            }
+         } else
+         {
+            read_next_pixel = 1;
+         }
+         //   OK, if I need to read a pixel, do it now
+         if ( read_next_pixel )
+         {
+            //   load however much data we did have
+            if ( tga_indexed )
+            {
+               //   read in 1 byte, then perform the lookup
+               int pal_idx = get8u(s);
+               if ( pal_idx >= tga_palette_len )
+               {
+                  //   invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_bits_per_pixel / 8;
+               for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+               {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else
+            {
+               //   read in the data raw
+               for (j = 0; j*8 < tga_bits_per_pixel; ++j)
+               {
+                  raw_data[j] = get8u(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   in case we're in RLE mode, keep counting down
+         --RLE_count;
+      }
+      //   do I need to invert the image?
+      if ( tga_inverted )
+      {
+         for (j = 0; j*2 < tga_height; ++j)
+         {
+            int index1 = j * tga_width * req_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * req_comp;
+            for (i = tga_width * req_comp; i > 0; --i)
+            {
+               unsigned char temp = tga_data[index1];
+               tga_data[index1] = tga_data[index2];
+               tga_data[index2] = temp;
+               ++index1;
+               ++index2;
+            }
+         }
+      }
+      //   clear my palette, if I had one
+      if ( tga_palette != NULL )
+      {
+         free( tga_palette );
+      }
+   }
+
+   // swap RGB
+   if (tga_comp >= 3)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   //   OK, done
+   return tga_data;
+}
+
+static stbi_uc *stbi_tga_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return tga_load(s,x,y,comp,req_comp);
+}
+
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+static int psd_test(stbi *s)
+{
+   if (get32(s) != 0x38425053) return 0;   // "8BPS"
+   else return 1;
+}
+
+static int stbi_psd_test(stbi *s)
+{
+   int r = psd_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   int   pixelCount;
+   int channelCount, compression;
+   int channel, i, count, len;
+   int w,h;
+   stbi__uint8 *out;
+
+   // Check identifier
+   if (get32(s) != 0x38425053)   // "8BPS"
+      return epuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (get16(s) != 1)
+      return epuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = get16(s);
+   if (channelCount < 0 || channelCount > 16)
+      return epuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = get32(s);
+   w = get32(s);
+   
+   // Make sure the depth is 8 bits.
+   if (get16(s) != 8)
+      return epuc("unsupported bit depth", "PSD bit depth is not 8 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (get16(s) != 3)
+      return epuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   skip(s,get32(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   skip(s, get32(s) );
+
+   // Skip the reserved data.
+   skip(s, get32(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = get16(s);
+   if (compression > 1)
+      return epuc("bad compression", "PSD has an unknown compression format");
+
+   // Create the destination image.
+   out = (stbi_uc *) malloc(4 * w*h);
+   if (!out) return epuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+   
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi__uint8 *p;
+         
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4;
+         } else {
+            // Read the RLE data.
+            count = 0;
+            while (count < pixelCount) {
+               len = get8(s);
+               if (len == 128) {
+                  // No-op.
+               } else if (len < 128) {
+                  // Copy next len+1 bytes literally.
+                  len++;
+                  count += len;
+                  while (len) {
+                     *p = get8u(s);
+                     p += 4;
+                     len--;
+                  }
+               } else if (len > 128) {
+                  stbi__uint8   val;
+                  // Next -len+1 bytes in the dest are replicated from next source byte.
+                  // (Interpret len as a negative 8-bit int.)
+                  len ^= 0x0FF;
+                  len += 2;
+                  val = get8u(s);
+                  count += len;
+                  while (len) {
+                     *p = val;
+                     p += 4;
+                     len--;
+                  }
+               }
+            }
+         }
+      }
+      
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit value for each pixel in the image.
+      
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi__uint8 *p;
+         
+         p = out + channel;
+         if (channel > channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4;
+         } else {
+            // Read the data.
+            for (i = 0; i < pixelCount; i++)
+               *p = get8u(s), p += 4;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != 4) {
+      out = convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // convert_format frees input on failure
+   }
+
+   if (comp) *comp = channelCount;
+   *y = h;
+   *x = w;
+   
+   return out;
+}
+
+static stbi_uc *stbi_psd_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return psd_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+static int pic_is4(stbi *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int pic_test(stbi *s)
+{
+   int i;
+
+   if (!pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      get8(s);
+
+   if (!pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} pic_packet_t;
+
+static stbi_uc *pic_readval(stbi *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (at_eof(s)) return epuc("bad file","PIC file too short");
+         dest[i]=get8u(s);
+      }
+   }
+
+   return dest;
+}
+
+static void pic_copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   pic_packet_t packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      pic_packet_t *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return epuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = get8(s);
+      packet->size    = get8u(s);
+      packet->type    = get8u(s);
+      packet->channel = get8u(s);
+
+      act_comp |= packet->channel;
+
+      if (at_eof(s))          return epuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return epuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         pic_packet_t *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return epuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!pic_readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=get8u(s);
+                     if (at_eof(s))   return epuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi__uint8) left;
+
+                     if (!pic_readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        pic_copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = get8(s), i;
+                  if (at_eof(s))  return epuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+                     int i;
+
+                     if (count==128)
+                        count = get16(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return epuc("bad file","scanline overrun");
+
+                     if (!pic_readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        pic_copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return epuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!pic_readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static stbi_uc *pic_load(stbi *s,int *px,int *py,int *comp,int req_comp)
+{
+   stbi_uc *result;
+   int i, x,y;
+
+   for (i=0; i<92; ++i)
+      get8(s);
+
+   x = get16(s);
+   y = get16(s);
+   if (at_eof(s))  return epuc("bad file","file too short (pic header)");
+   if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode");
+
+   get32(s); //skip `ratio'
+   get16(s); //skip `fields'
+   get16(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) malloc(x*y*4);
+   memset(result, 0xff, x*y*4);
+
+   if (!pic_load2(s,x,y,comp, result)) {
+      free(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi_pic_test(stbi *s)
+{
+   int r = pic_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static stbi_uc *stbi_pic_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return pic_load(s,x,y,comp,req_comp);
+}
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+typedef struct stbi_gif_lzw_struct {
+   stbi__int16 prefix;
+   stbi__uint8 first;
+   stbi__uint8 suffix;
+} stbi_gif_lzw;
+
+typedef struct stbi_gif_struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi__uint8  pal[256][4];
+   stbi__uint8 lpal[256][4];
+   stbi_gif_lzw codes[4096];
+   stbi__uint8 *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+} stbi_gif;
+
+static int gif_test(stbi *s)
+{
+   int sz;
+   if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return 0;
+   sz = get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi_gif_test(stbi *s)
+{
+   int r = gif_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+static void stbi_gif_parse_colortable(stbi *s, stbi__uint8 pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = get8u(s);
+      pal[i][1] = get8u(s);
+      pal[i][0] = get8u(s);
+      pal[i][3] = transp ? 0 : 255;
+   }   
+}
+
+static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info)
+{
+   stbi__uint8 version;
+   if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8')
+      return e("not GIF", "Corrupt GIF");
+
+   version = get8u(s);
+   if (version != '7' && version != '9')    return e("not GIF", "Corrupt GIF");
+   if (get8(s) != 'a')                      return e("not GIF", "Corrupt GIF");
+ 
+   failure_reason = "";
+   g->w = get16le(s);
+   g->h = get16le(s);
+   g->flags = get8(s);
+   g->bgindex = get8(s);
+   g->ratio = get8(s);
+   g->transparent = -1;
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi_gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp)
+{
+   stbi_gif g;   
+   if (!stbi_gif_header(s, &g, comp, 1)) {
+      stbi_rewind( s );
+      return 0;
+   }
+   if (x) *x = g.w;
+   if (y) *y = g.h;
+   return 1;
+}
+
+static void stbi_out_gif_code(stbi_gif *g, stbi__uint16 code)
+{
+   stbi__uint8 *p, *c;
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi_out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+  
+   p = &g->out[g->cur_x + g->cur_y];
+   c = &g->color_table[g->codes[code].suffix * 4];
+
+   if (c[3] >= 128) {
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static stbi__uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g)
+{
+   stbi__uint8 lzw_cs;
+   stbi__int32 len, code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi_gif_lzw *p;
+
+   lzw_cs = get8u(s);
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (code = 0; code < clear; code++) {
+      g->codes[code].prefix = -1;
+      g->codes[code].first = (stbi__uint8) code;
+      g->codes[code].suffix = (stbi__uint8) code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = get8(s); // start new block
+            if (len == 0) 
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            skip(s, len);
+            while ((len = get8(s)) > 0)
+               skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) return epuc("no clear code", "Corrupt GIF");
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 4096)        return epuc("too many codes", "Corrupt GIF");
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return epuc("illegal code in raster", "Corrupt GIF");
+
+            stbi_out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return epuc("illegal code in raster", "Corrupt GIF");
+         }
+      } 
+   }
+}
+
+static void stbi_fill_gif_background(stbi_gif *g)
+{
+   int i;
+   stbi__uint8 *c = g->pal[g->bgindex];
+   // @OPTIMIZE: write a dword at a time
+   for (i = 0; i < g->w * g->h * 4; i += 4) {
+      stbi__uint8 *p  = &g->out[i];
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+static stbi__uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp)
+{
+   int i;
+   stbi__uint8 *old_out = 0;
+
+   if (g->out == 0) {
+      if (!stbi_gif_header(s, g, comp,0))     return 0; // failure_reason set by stbi_gif_header
+      g->out = (stbi__uint8 *) malloc(4 * g->w * g->h);
+      if (g->out == 0)                      return epuc("outofmem", "Out of memory");
+      stbi_fill_gif_background(g);
+   } else {
+      // animated-gif-only path
+      if (((g->eflags & 0x1C) >> 2) == 3) {
+         old_out = g->out;
+         g->out = (stbi__uint8 *) malloc(4 * g->w * g->h);
+         if (g->out == 0)                   return epuc("outofmem", "Out of memory");
+         memcpy(g->out, old_out, g->w*g->h*4);
+      }
+   }
+    
+   for (;;) {
+      switch (get8(s)) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi__uint8 *o;
+
+            x = get16le(s);
+            y = get16le(s);
+            w = get16le(s);
+            h = get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return epuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            g->lflags = get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (stbi__uint8 *) g->lpal;       
+            } else if (g->flags & 0x80) {
+               for (i=0; i < 256; ++i)  // @OPTIMIZE: reset only the previous transparent
+                  g->pal[i][3] = 255; 
+               if (g->transparent >= 0 && (g->eflags & 0x01))
+                  g->pal[g->transparent][3] = 0;
+               g->color_table = (stbi__uint8 *) g->pal;
+            } else
+               return epuc("missing color table", "Corrupt GIF");
+   
+            o = stbi_process_gif_raster(s, g);
+            if (o == NULL) return NULL;
+
+            if (req_comp && req_comp != 4)
+               o = convert_format(o, 4, req_comp, g->w, g->h);
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            if (get8(s) == 0xF9) { // Graphic Control Extension.
+               len = get8(s);
+               if (len == 4) {
+                  g->eflags = get8(s);
+                  get16le(s); // delay
+                  g->transparent = get8(s);
+               } else {
+                  skip(s, len);
+                  break;
+               }
+            }
+            while ((len = get8(s)) != 0)
+               skip(s, len);
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi__uint8 *) 1;
+
+         default:
+            return epuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static stbi_uc *stbi_gif_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint8 *u = 0;
+   stbi_gif g={0};
+
+   u = stbi_gif_load_next(s, &g, comp, req_comp);
+   if (u == (void *) 1) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+   }
+
+   return u;
+}
+
+static int stbi_gif_info(stbi *s, int *x, int *y, int *comp)
+{
+   return stbi_gif_info_raw(s,x,y,comp);
+}
+
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int hdr_test(stbi *s)
+{
+   const char *signature = "#?RADIANCE\n";
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (get8(s) != signature[i])
+         return 0;
+   return 1;
+}
+
+static int stbi_hdr_test(stbi* s)
+{
+   int r = hdr_test(s);
+   stbi_rewind(s);
+   return r;
+}
+
+#define HDR_BUFLEN  1024
+static char *hdr_gettoken(stbi *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) get8(z);
+
+   while (!at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!at_eof(z) && get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   char buffer[HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+
+
+   // Check identifier
+   if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0)
+      return epf("not HDR", "Corrupt HDR image");
+   
+   // Parse header
+   for(;;) {
+      token = hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return epf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return epf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   *x = width;
+   *y = height;
+
+   *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   // Read data
+   hdr_data = (float *) malloc(height * width * req_comp * sizeof(float));
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            getn(s, rgbe, 4);
+            hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = get8(s);
+         c2 = get8(s);
+         len = get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            stbi__uint8 rgbe[4];
+            rgbe[0] = (stbi__uint8) c1;
+            rgbe[1] = (stbi__uint8) c2;
+            rgbe[2] = (stbi__uint8) len;
+            rgbe[3] = (stbi__uint8) get8u(s);
+            hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            free(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= get8(s);
+         if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4);
+            
+         for (k = 0; k < 4; ++k) {
+            i = 0;
+            while (i < width) {
+               count = get8u(s);
+               if (count > 128) {
+                  // Run
+                  value = get8u(s);
+                  count -= 128;
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = get8u(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      free(scanline);
+   }
+
+   return hdr_data;
+}
+
+static float *stbi_hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp)
+{
+   return hdr_load(s,x,y,comp,req_comp);
+}
+
+static int stbi_hdr_info(stbi *s, int *x, int *y, int *comp)
+{
+   char buffer[HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+
+   if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) {
+       stbi_rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token = hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi_rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+static int stbi_bmp_info(stbi *s, int *x, int *y, int *comp)
+{
+   int hsz;
+   if (get8(s) != 'B' || get8(s) != 'M') {
+       stbi_rewind( s );
+       return 0;
+   }
+   skip(s,12);
+   hsz = get32le(s);
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (hsz == 12) {
+      *x = get16le(s);
+      *y = get16le(s);
+   } else {
+      *x = get32le(s);
+      *y = get32le(s);
+   }
+   if (get16le(s) != 1) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *comp = get16le(s) / 8;
+   return 1;
+}
+
+static int stbi_psd_info(stbi *s, int *x, int *y, int *comp)
+{
+   int channelCount;
+   if (get32(s) != 0x38425053) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (get16(s) != 1) {
+       stbi_rewind( s );
+       return 0;
+   }
+   skip(s, 6);
+   channelCount = get16(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *y = get32(s);
+   *x = get32(s);
+   if (get16(s) != 8) {
+       stbi_rewind( s );
+       return 0;
+   }
+   if (get16(s) != 3) {
+       stbi_rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi_pic_info(stbi *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained;
+   pic_packet_t packets[10];
+
+   skip(s, 92);
+
+   *x = get16(s);
+   *y = get16(s);
+   if (at_eof(s))  return 0;
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+       stbi_rewind( s );
+       return 0;
+   }
+
+   skip(s, 8);
+
+   do {
+      pic_packet_t *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = get8(s);
+      packet->size    = get8u(s);
+      packet->type    = get8u(s);
+      packet->channel = get8u(s);
+      act_comp |= packet->channel;
+
+      if (at_eof(s)) {
+          stbi_rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi_rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+
+static int stbi_info_main(stbi *s, int *x, int *y, int *comp)
+{
+   if (stbi_jpeg_info(s, x, y, comp))
+       return 1;
+   if (stbi_png_info(s, x, y, comp))
+       return 1;
+   if (stbi_gif_info(s, x, y, comp))
+       return 1;
+   if (stbi_bmp_info(s, x, y, comp))
+       return 1;
+   if (stbi_psd_info(s, x, y, comp))
+       return 1;
+   if (stbi_pic_info(s, x, y, comp))
+       return 1;
+   #ifndef STBI_NO_HDR
+   if (stbi_hdr_info(s, x, y, comp))
+       return 1;
+   #endif
+   // test tga last because it's a crappy test!
+   if (stbi_tga_info(s, x, y, comp))
+       return 1;
+   return e("unknown image type", "Image not of any known type, or corrupt");
+}
+
+#ifndef STBI_NO_STDIO
+int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = fopen(filename, "rb");
+    int result;
+    if (!f) return e("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi s;
+   long pos = ftell(f);
+   start_file(&s, f);
+   r = stbi_info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi s;
+   start_mem(&s,buffer,len);
+   return stbi_info_main(&s,x,y,comp);
+}
+
+int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi s;
+   start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi_info_main(&s,x,y,comp);
+}
+
+#endif // STBI_HEADER_FILE_ONLY
+
+#if !defined(STBI_NO_STDIO) && defined(_MSC_VER) && _MSC_VER >= 1400
+#pragma warning(pop)
+#endif
+
+
+/*
+   revision history:
+      1.35 (2014-05-27)
+             various warnings
+             fix broken STBI_SIMD path
+             fix bug where stbi_load_from_file no longer left file pointer in correct place
+             fix broken non-easy path for 32-bit BMP (possibly never used)
+             TGA optimization by Arseny Kapoulkine
+      1.34 (unknown)
+             use STBI_NOTUSED in resample_row_generic(), fix one more leak in tga failure case
+      1.33 (2011-07-14)
+             make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32 (2011-07-13)
+             support for "info" function for all supported filetypes (SpartanJ)
+      1.31 (2011-06-20)
+             a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30 (2011-06-11)
+             added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+             removed deprecated format-specific test/load functions
+             removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+             error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+             fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29 (2010-08-16)
+             various warning fixes from Aurelien Pocheville 
+      1.28 (2010-08-01)
+             fix bug in GIF palette transparency (SpartanJ)
+      1.27 (2010-08-01)
+             cast-to-stbi__uint8 to fix warnings
+      1.26 (2010-07-24)
+             fix bug in file buffering for PNG reported by SpartanJ
+      1.25 (2010-07-17)
+             refix trans_data warning (Won Chun)
+      1.24 (2010-07-12)
+             perf improvements reading from files on platforms with lock-heavy fgetc()
+             minor perf improvements for jpeg
+             deprecated type-specific functions so we'll get feedback if they're needed
+             attempt to fix trans_data warning (Won Chun)
+      1.23   fixed bug in iPhone support
+      1.22 (2010-07-10)
+             removed image *writing* support
+             stbi_info support from Jetro Lauha
+             GIF support from Jean-Marc Lienher
+             iPhone PNG-extensions from James Brown
+             warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva)
+      1.21   fix use of 'stbi__uint8' in header (reported by jon blow)
+      1.20   added support for Softimage PIC, by Tom Seddon
+      1.19   bug in interlaced PNG corruption check (found by ryg)
+      1.18 2008-08-02
+             fix a threading bug (local mutable static)
+      1.17   support interlaced PNG
+      1.16   major bugfix - convert_format converted one too many pixels
+      1.15   initialize some fields for thread safety
+      1.14   fix threadsafe conversion bug
+             header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13   threadsafe
+      1.12   const qualifiers in the API
+      1.11   Support installable IDCT, colorspace conversion routines
+      1.10   Fixes for 64-bit (don't use "unsigned long")
+             optimized upsampling by Fabian "ryg" Giesen
+      1.09   Fix format-conversion for PSD code (bad global variables!)
+      1.08   Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07   attempt to fix C++ warning/errors again
+      1.06   attempt to fix C++ warning/errors again
+      1.05   fix TGA loading to return correct *comp and use good luminance calc
+      1.04   default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03   bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02   support for (subset of) HDR files, float interface for preferred access to them
+      1.01   fix bug: possible bug in handling right-side up bmps... not sure
+             fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all
+      1.00   interface to zlib that skips zlib header
+      0.99   correct handling of alpha in palette
+      0.98   TGA loader by lonesock; dynamically add loaders (untested)
+      0.97   jpeg errors on too large a file; also catch another malloc failure
+      0.96   fix detection of invalid v value - particleman@mollyrocket forum
+      0.95   during header scan, seek to markers in case of padding
+      0.94   STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93   handle jpegtran output; verbose errors
+      0.92   read 4,8,16,24,32-bit BMP files of several formats
+      0.91   output 24-bit Windows 3.0 BMP files
+      0.90   fix a few more warnings; bump version number to approach 1.0
+      0.61   bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60   fix compiling as c++
+      0.59   fix warnings: merge Dave Moore's -Wall fixes
+      0.58   fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57   fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56   fix bug: zlib uncompressed mode len vs. nlen
+      0.55   fix bug: restart_interval not initialized to 0
+      0.54   allow NULL for 'int *comp'
+      0.53   fix bug in png 3->4; speedup png decoding
+      0.52   png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51   obey req_comp requests, 1-component jpegs return as 1-component,
+             on 'test' only check type, not whether we support this variant
+      0.50   first released version
+*/
\ No newline at end of file
diff --git a/stb_image.h b/stb_image.h
new file mode 100644
index 0000000..d4b5c87
--- /dev/null
+++ b/stb_image.h
@@ -0,0 +1,7988 @@
+/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
+                                  no warranty implied; use at your own risk
+
+   Do this:
+      #define STB_IMAGE_IMPLEMENTATION
+   before you include this file in *one* C or C++ file to create the implementation.
+
+   // i.e. it should look like this:
+   #include ...
+   #include ...
+   #include ...
+   #define STB_IMAGE_IMPLEMENTATION
+   #include "stb_image.h"
+
+   You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.
+   And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free
+
+
+   QUICK NOTES:
+      Primarily of interest to game developers and other people who can
+          avoid problematic images and only need the trivial interface
+
+      JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)
+      PNG 1/2/4/8/16-bit-per-channel
+
+      TGA (not sure what subset, if a subset)
+      BMP non-1bpp, non-RLE
+      PSD (composited view only, no extra channels, 8/16 bit-per-channel)
+
+      GIF (*comp always reports as 4-channel)
+      HDR (radiance rgbE format)
+      PIC (Softimage PIC)
+      PNM (PPM and PGM binary only)
+
+      Animated GIF still needs a proper API, but here's one way to do it:
+          http://gist.github.com/urraka/685d9a6340b26b830d49
+
+      - decode from memory or through FILE (define STBI_NO_STDIO to remove code)
+      - decode from arbitrary I/O callbacks
+      - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)
+
+   Full documentation under "DOCUMENTATION" below.
+
+
+LICENSE
+
+  See end of file for license information.
+
+RECENT REVISION HISTORY:
+
+      2.30  (2024-05-31) avoid erroneous gcc warning
+      2.29  (2023-05-xx) optimizations
+      2.28  (2023-01-29) many error fixes, security errors, just tons of stuff
+      2.27  (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes
+      2.26  (2020-07-13) many minor fixes
+      2.25  (2020-02-02) fix warnings
+      2.24  (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically
+      2.23  (2019-08-11) fix clang static analysis warning
+      2.22  (2019-03-04) gif fixes, fix warnings
+      2.21  (2019-02-25) fix typo in comment
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings
+      2.16  (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes
+      2.15  (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-12-04) experimental 16-bit API, only for PNG so far; fixes
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64
+                         RGB-format JPEG; remove white matting in PSD;
+                         allocate large structures on the stack;
+                         correct channel count for PNG & BMP
+      2.10  (2016-01-22) avoid warning introduced in 2.09
+      2.09  (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED
+
+   See end of file for full revision history.
+
+
+ ============================    Contributors    =========================
+
+ Image formats                          Extensions, features
+    Sean Barrett (jpeg, png, bmp)          Jetro Lauha (stbi_info)
+    Nicolas Schulz (hdr, psd)              Martin "SpartanJ" Golini (stbi_info)
+    Jonathan Dummer (tga)                  James "moose2000" Brown (iPhone PNG)
+    Jean-Marc Lienher (gif)                Ben "Disch" Wenger (io callbacks)
+    Tom Seddon (pic)                       Omar Cornut (1/2/4-bit PNG)
+    Thatcher Ulrich (psd)                  Nicolas Guillemot (vertical flip)
+    Ken Miller (pgm, ppm)                  Richard Mitton (16-bit PSD)
+    github:urraka (animated gif)           Junggon Kim (PNM comments)
+    Christopher Forseth (animated gif)     Daniel Gibson (16-bit TGA)
+                                           socks-the-fox (16-bit PNG)
+                                           Jeremy Sawicki (handle all ImageNet JPGs)
+ Optimizations & bugfixes                  Mikhail Morozov (1-bit BMP)
+    Fabian "ryg" Giesen                    Anael Seghezzi (is-16-bit query)
+    Arseny Kapoulkine                      Simon Breuss (16-bit PNM)
+    John-Mark Allen
+    Carmelo J Fdez-Aguera
+
+ Bug & warning fixes
+    Marc LeBlanc            David Woo          Guillaume George     Martins Mozeiko
+    Christpher Lloyd        Jerry Jansson      Joseph Thomson       Blazej Dariusz Roszkowski
+    Phil Jordan                                Dave Moore           Roy Eltham
+    Hayaki Saito            Nathan Reed        Won Chun
+    Luke Graham             Johan Duparc       Nick Verigakis       the Horde3D community
+    Thomas Ruf              Ronny Chevalier                         github:rlyeh
+    Janez Zemva             John Bartholomew   Michal Cichon        github:romigrou
+    Jonathan Blow           Ken Hamada         Tero Hanninen        github:svdijk
+    Eugene Golushkov        Laurent Gomila     Cort Stratton        github:snagar
+    Aruelien Pocheville     Sergio Gonzalez    Thibault Reuille     github:Zelex
+    Cass Everitt            Ryamond Barbiero                        github:grim210
+    Paul Du Bois            Engin Manap        Aldo Culquicondor    github:sammyhw
+    Philipp Wiesemann       Dale Weiler        Oriol Ferrer Mesia   github:phprus
+    Josh Tobin              Neil Bickford      Matthew Gregan       github:poppolopoppo
+    Julian Raschke          Gregory Mullen     Christian Floisand   github:darealshinji
+    Baldur Karlsson         Kevin Schmidt      JR Smith             github:Michaelangel007
+                            Brad Weinberger    Matvey Cherevko      github:mosra
+    Luca Sas                Alexander Veselov  Zack Middleton       [reserved]
+    Ryan C. Gordon          [reserved]                              [reserved]
+                     DO NOT ADD YOUR NAME HERE
+
+                     Jacko Dirks
+
+  To add your name to the credits, pick a random blank space in the middle and fill it.
+  80% of merge conflicts on stb PRs are due to people adding their name at the end
+  of the credits.
+*/
+
+#ifndef STBI_INCLUDE_STB_IMAGE_H
+#define STBI_INCLUDE_STB_IMAGE_H
+
+// DOCUMENTATION
+//
+// Limitations:
+//    - no 12-bit-per-channel JPEG
+//    - no JPEGs with arithmetic coding
+//    - GIF always returns *comp=4
+//
+// Basic usage (see HDR discussion below for HDR usage):
+//    int x,y,n;
+//    unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
+//    // ... process data if not NULL ...
+//    // ... x = width, y = height, n = # 8-bit components per pixel ...
+//    // ... replace '0' with '1'..'4' to force that many components per pixel
+//    // ... but 'n' will always be the number that it would have been if you said 0
+//    stbi_image_free(data);
+//
+// Standard parameters:
+//    int *x                 -- outputs image width in pixels
+//    int *y                 -- outputs image height in pixels
+//    int *channels_in_file  -- outputs # of image components in image file
+//    int desired_channels   -- if non-zero, # of image components requested in result
+//
+// The return value from an image loader is an 'unsigned char *' which points
+// to the pixel data, or NULL on an allocation failure or if the image is
+// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,
+// with each pixel consisting of N interleaved 8-bit components; the first
+// pixel pointed to is top-left-most in the image. There is no padding between
+// image scanlines or between pixels, regardless of format. The number of
+// components N is 'desired_channels' if desired_channels is non-zero, or
+// *channels_in_file otherwise. If desired_channels is non-zero,
+// *channels_in_file has the number of components that _would_ have been
+// output otherwise. E.g. if you set desired_channels to 4, you will always
+// get RGBA output, but you can check *channels_in_file to see if it's trivially
+// opaque because e.g. there were only 3 channels in the source image.
+//
+// An output image with N components has the following components interleaved
+// in this order in each pixel:
+//
+//     N=#comp     components
+//       1           grey
+//       2           grey, alpha
+//       3           red, green, blue
+//       4           red, green, blue, alpha
+//
+// If image loading fails for any reason, the return value will be NULL,
+// and *x, *y, *channels_in_file will be unchanged. The function
+// stbi_failure_reason() can be queried for an extremely brief, end-user
+// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS
+// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
+// more user-friendly ones.
+//
+// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
+//
+// To query the width, height and component count of an image without having to
+// decode the full file, you can use the stbi_info family of functions:
+//
+//   int x,y,n,ok;
+//   ok = stbi_info(filename, &x, &y, &n);
+//   // returns ok=1 and sets x, y, n if image is a supported format,
+//   // 0 otherwise.
+//
+// Note that stb_image pervasively uses ints in its public API for sizes,
+// including sizes of memory buffers. This is now part of the API and thus
+// hard to change without causing breakage. As a result, the various image
+// loaders all have certain limits on image size; these differ somewhat
+// by format but generally boil down to either just under 2GB or just under
+// 1GB. When the decoded image would be larger than this, stb_image decoding
+// will fail.
+//
+// Additionally, stb_image will reject image files that have any of their
+// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,
+// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,
+// the only way to have an image with such dimensions load correctly
+// is for it to have a rather extreme aspect ratio. Either way, the
+// assumption here is that such larger images are likely to be malformed
+// or malicious. If you do need to load an image with individual dimensions
+// larger than that, and it still fits in the overall size limit, you can
+// #define STBI_MAX_DIMENSIONS on your own to be something larger.
+//
+// ===========================================================================
+//
+// UNICODE:
+//
+//   If compiling for Windows and you wish to use Unicode filenames, compile
+//   with
+//       #define STBI_WINDOWS_UTF8
+//   and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert
+//   Windows wchar_t filenames to utf8.
+//
+// ===========================================================================
+//
+// Philosophy
+//
+// stb libraries are designed with the following priorities:
+//
+//    1. easy to use
+//    2. easy to maintain
+//    3. good performance
+//
+// Sometimes I let "good performance" creep up in priority over "easy to maintain",
+// and for best performance I may provide less-easy-to-use APIs that give higher
+// performance, in addition to the easy-to-use ones. Nevertheless, it's important
+// to keep in mind that from the standpoint of you, a client of this library,
+// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.
+//
+// Some secondary priorities arise directly from the first two, some of which
+// provide more explicit reasons why performance can't be emphasized.
+//
+//    - Portable ("ease of use")
+//    - Small source code footprint ("easy to maintain")
+//    - No dependencies ("ease of use")
+//
+// ===========================================================================
+//
+// I/O callbacks
+//
+// I/O callbacks allow you to read from arbitrary sources, like packaged
+// files or some other source. Data read from callbacks are processed
+// through a small internal buffer (currently 128 bytes) to try to reduce
+// overhead.
+//
+// The three functions you must define are "read" (reads some bytes of data),
+// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
+//
+// ===========================================================================
+//
+// SIMD support
+//
+// The JPEG decoder will try to automatically use SIMD kernels on x86 when
+// supported by the compiler. For ARM Neon support, you must explicitly
+// request it.
+//
+// (The old do-it-yourself SIMD API is no longer supported in the current
+// code.)
+//
+// On x86, SSE2 will automatically be used when available based on a run-time
+// test; if not, the generic C versions are used as a fall-back. On ARM targets,
+// the typical path is to have separate builds for NEON and non-NEON devices
+// (at least this is true for iOS and Android). Therefore, the NEON support is
+// toggled by a build flag: define STBI_NEON to get NEON loops.
+//
+// If for some reason you do not want to use any of SIMD code, or if
+// you have issues compiling it, you can disable it entirely by
+// defining STBI_NO_SIMD.
+//
+// ===========================================================================
+//
+// HDR image support   (disable by defining STBI_NO_HDR)
+//
+// stb_image supports loading HDR images in general, and currently the Radiance
+// .HDR file format specifically. You can still load any file through the existing
+// interface; if you attempt to load an HDR file, it will be automatically remapped
+// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
+// both of these constants can be reconfigured through this interface:
+//
+//     stbi_hdr_to_ldr_gamma(2.2f);
+//     stbi_hdr_to_ldr_scale(1.0f);
+//
+// (note, do not use _inverse_ constants; stbi_image will invert them
+// appropriately).
+//
+// Additionally, there is a new, parallel interface for loading files as
+// (linear) floats to preserve the full dynamic range:
+//
+//    float *data = stbi_loadf(filename, &x, &y, &n, 0);
+//
+// If you load LDR images through this interface, those images will
+// be promoted to floating point values, run through the inverse of
+// constants corresponding to the above:
+//
+//     stbi_ldr_to_hdr_scale(1.0f);
+//     stbi_ldr_to_hdr_gamma(2.2f);
+//
+// Finally, given a filename (or an open file or memory block--see header
+// file for details) containing image data, you can query for the "most
+// appropriate" interface to use (that is, whether the image is HDR or
+// not), using:
+//
+//     stbi_is_hdr(char *filename);
+//
+// ===========================================================================
+//
+// iPhone PNG support:
+//
+// We optionally support converting iPhone-formatted PNGs (which store
+// premultiplied BGRA) back to RGB, even though they're internally encoded
+// differently. To enable this conversion, call
+// stbi_convert_iphone_png_to_rgb(1).
+//
+// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
+// pixel to remove any premultiplied alpha *only* if the image file explicitly
+// says there's premultiplied data (currently only happens in iPhone images,
+// and only if iPhone convert-to-rgb processing is on).
+//
+// ===========================================================================
+//
+// ADDITIONAL CONFIGURATION
+//
+//  - You can suppress implementation of any of the decoders to reduce
+//    your code footprint by #defining one or more of the following
+//    symbols before creating the implementation.
+//
+//        STBI_NO_JPEG
+//        STBI_NO_PNG
+//        STBI_NO_BMP
+//        STBI_NO_PSD
+//        STBI_NO_TGA
+//        STBI_NO_GIF
+//        STBI_NO_HDR
+//        STBI_NO_PIC
+//        STBI_NO_PNM   (.ppm and .pgm)
+//
+//  - You can request *only* certain decoders and suppress all other ones
+//    (this will be more forward-compatible, as addition of new decoders
+//    doesn't require you to disable them explicitly):
+//
+//        STBI_ONLY_JPEG
+//        STBI_ONLY_PNG
+//        STBI_ONLY_BMP
+//        STBI_ONLY_PSD
+//        STBI_ONLY_TGA
+//        STBI_ONLY_GIF
+//        STBI_ONLY_HDR
+//        STBI_ONLY_PIC
+//        STBI_ONLY_PNM   (.ppm and .pgm)
+//
+//   - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still
+//     want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB
+//
+//  - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater
+//    than that size (in either width or height) without further processing.
+//    This is to let programs in the wild set an upper bound to prevent
+//    denial-of-service attacks on untrusted data, as one could generate a
+//    valid image of gigantic dimensions and force stb_image to allocate a
+//    huge block of memory and spend disproportionate time decoding it. By
+//    default this is set to (1 << 24), which is 16777216, but that's still
+//    very big.
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif // STBI_NO_STDIO
+
+#define STBI_VERSION 1
+
+enum
+{
+   STBI_default = 0, // only used for desired_channels
+
+   STBI_grey       = 1,
+   STBI_grey_alpha = 2,
+   STBI_rgb        = 3,
+   STBI_rgb_alpha  = 4
+};
+
+#include <stdlib.h>
+typedef unsigned char stbi_uc;
+typedef unsigned short stbi_us;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef STBIDEF
+#ifdef STB_IMAGE_STATIC
+#define STBIDEF static
+#else
+#define STBIDEF extern
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// PRIMARY API - works on images of any type
+//
+
+//
+// load image by filename, open file, or memory buffer
+//
+
+typedef struct
+{
+   int      (*read)  (void *user,char *data,int size);   // fill 'data' with 'size' bytes.  return number of bytes actually read
+   void     (*skip)  (void *user,int n);                 // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
+   int      (*eof)   (void *user);                       // returns nonzero if we are at end of file/data
+} stbi_io_callbacks;
+
+////////////////////////////////////
+//
+// 8-bits-per-channel interface
+//
+
+STBIDEF stbi_uc *stbi_load_from_memory   (stbi_uc           const *buffer, int len   , int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk  , void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_uc *stbi_load            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_uc *stbi_load_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+// for stbi_load_from_file, file pointer is left pointing immediately after image
+#endif
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+#endif
+
+#ifdef STBI_WINDOWS_UTF8
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
+#endif
+
+////////////////////////////////////
+//
+// 16-bits-per-channel interface
+//
+
+STBIDEF stbi_us *stbi_load_16_from_memory   (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);
+
+#ifndef STBI_NO_STDIO
+STBIDEF stbi_us *stbi_load_16          (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+#endif
+
+////////////////////////////////////
+//
+// float-per-channel interface
+//
+#ifndef STBI_NO_LINEAR
+   STBIDEF float *stbi_loadf_from_memory     (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_callbacks  (stbi_io_callbacks const *clbk, void *user, int *x, int *y,  int *channels_in_file, int desired_channels);
+
+   #ifndef STBI_NO_STDIO
+   STBIDEF float *stbi_loadf            (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);
+   STBIDEF float *stbi_loadf_from_file  (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);
+   #endif
+#endif
+
+#ifndef STBI_NO_HDR
+   STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma);
+   STBIDEF void   stbi_hdr_to_ldr_scale(float scale);
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_LINEAR
+   STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma);
+   STBIDEF void   stbi_ldr_to_hdr_scale(float scale);
+#endif // STBI_NO_LINEAR
+
+// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR
+STBIDEF int    stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+STBIDEF int    stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename);
+STBIDEF int      stbi_is_hdr_from_file(FILE *f);
+#endif // STBI_NO_STDIO
+
+
+// get a VERY brief reason for failure
+// on most compilers (and ALL modern mainstream compilers) this is threadsafe
+STBIDEF const char *stbi_failure_reason  (void);
+
+// free the loaded image -- this is just free()
+STBIDEF void     stbi_image_free      (void *retval_from_stbi_load);
+
+// get image dimensions & components without fully decoding
+STBIDEF int      stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);
+STBIDEF int      stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_info               (char const *filename,     int *x, int *y, int *comp);
+STBIDEF int      stbi_info_from_file     (FILE *f,                  int *x, int *y, int *comp);
+STBIDEF int      stbi_is_16_bit          (char const *filename);
+STBIDEF int      stbi_is_16_bit_from_file(FILE *f);
+#endif
+
+
+
+// for image formats that explicitly notate that they have premultiplied alpha,
+// we just return the colors as stored in the file. set this flag to force
+// unpremultiplication. results are undefined if the unpremultiply overflow.
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
+
+// indicate whether we should process iphone images back to canonical format,
+// or just pass them through "as-is"
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
+
+// flip the image vertically, so the first pixel in the output array is the bottom left
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);
+
+// as above, but only applies to images loaded on the thread that calls the function
+// this function is only available if your compiler supports thread-local variables;
+// calling it will fail to link if your compiler doesn't
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);
+
+// ZLIB client - used by PNG, available for other purposes
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
+STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
+STBIDEF int   stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBI_INCLUDE_STB_IMAGE_H
+
+#ifdef STB_IMAGE_IMPLEMENTATION
+
+#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \
+  || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \
+  || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \
+  || defined(STBI_ONLY_ZLIB)
+   #ifndef STBI_ONLY_JPEG
+   #define STBI_NO_JPEG
+   #endif
+   #ifndef STBI_ONLY_PNG
+   #define STBI_NO_PNG
+   #endif
+   #ifndef STBI_ONLY_BMP
+   #define STBI_NO_BMP
+   #endif
+   #ifndef STBI_ONLY_PSD
+   #define STBI_NO_PSD
+   #endif
+   #ifndef STBI_ONLY_TGA
+   #define STBI_NO_TGA
+   #endif
+   #ifndef STBI_ONLY_GIF
+   #define STBI_NO_GIF
+   #endif
+   #ifndef STBI_ONLY_HDR
+   #define STBI_NO_HDR
+   #endif
+   #ifndef STBI_ONLY_PIC
+   #define STBI_NO_PIC
+   #endif
+   #ifndef STBI_ONLY_PNM
+   #define STBI_NO_PNM
+   #endif
+#endif
+
+#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)
+#define STBI_NO_ZLIB
+#endif
+
+
+#include <stdarg.h>
+#include <stddef.h> // ptrdiff_t on osx
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)
+#include <math.h>  // ldexp, pow
+#endif
+
+#ifndef STBI_NO_STDIO
+#include <stdio.h>
+#endif
+
+#ifndef STBI_ASSERT
+#include <assert.h>
+#define STBI_ASSERT(x) assert(x)
+#endif
+
+#ifdef __cplusplus
+#define STBI_EXTERN extern "C"
+#else
+#define STBI_EXTERN extern
+#endif
+
+
+#ifndef _MSC_VER
+   #ifdef __cplusplus
+   #define stbi_inline inline
+   #else
+   #define stbi_inline
+   #endif
+#else
+   #define stbi_inline __forceinline
+#endif
+
+#ifndef STBI_NO_THREAD_LOCALS
+   #if defined(__cplusplus) &&  __cplusplus >= 201103L
+      #define STBI_THREAD_LOCAL       thread_local
+   #elif defined(__GNUC__) && __GNUC__ < 5
+      #define STBI_THREAD_LOCAL       __thread
+   #elif defined(_MSC_VER)
+      #define STBI_THREAD_LOCAL       __declspec(thread)
+   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
+      #define STBI_THREAD_LOCAL       _Thread_local
+   #endif
+
+   #ifndef STBI_THREAD_LOCAL
+      #if defined(__GNUC__)
+        #define STBI_THREAD_LOCAL       __thread
+      #endif
+   #endif
+#endif
+
+#if defined(_MSC_VER) || defined(__SYMBIAN32__)
+typedef unsigned short stbi__uint16;
+typedef   signed short stbi__int16;
+typedef unsigned int   stbi__uint32;
+typedef   signed int   stbi__int32;
+#else
+#include <stdint.h>
+typedef uint16_t stbi__uint16;
+typedef int16_t  stbi__int16;
+typedef uint32_t stbi__uint32;
+typedef int32_t  stbi__int32;
+#endif
+
+// should produce compiler error if size is wrong
+typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBI_NOTUSED(v)  (void)(v)
+#else
+#define STBI_NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#ifdef _MSC_VER
+#define STBI_HAS_LROTL
+#endif
+
+#ifdef STBI_HAS_LROTL
+   #define stbi_lrot(x,y)  _lrotl(x,y)
+#else
+   #define stbi_lrot(x,y)  (((x) << (y)) | ((x) >> (-(y) & 31)))
+#endif
+
+#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))
+// ok
+#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)
+// ok
+#else
+#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)."
+#endif
+
+#ifndef STBI_MALLOC
+#define STBI_MALLOC(sz)           malloc(sz)
+#define STBI_REALLOC(p,newsz)     realloc(p,newsz)
+#define STBI_FREE(p)              free(p)
+#endif
+
+#ifndef STBI_REALLOC_SIZED
+#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
+#endif
+
+// x86/x64 detection
+#if defined(__x86_64__) || defined(_M_X64)
+#define STBI__X64_TARGET
+#elif defined(__i386) || defined(_M_IX86)
+#define STBI__X86_TARGET
+#endif
+
+#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)
+// gcc doesn't support sse2 intrinsics unless you compile with -msse2,
+// which in turn means it gets to use SSE2 everywhere. This is unfortunate,
+// but previous attempts to provide the SSE2 functions with runtime
+// detection caused numerous issues. The way architecture extensions are
+// exposed in GCC/Clang is, sadly, not really suited for one-file libs.
+// New behavior: if compiled with -msse2, we use SSE2 without any
+// detection; if not, we don't use it at all.
+#define STBI_NO_SIMD
+#endif
+
+#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)
+// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET
+//
+// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the
+// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.
+// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not
+// simultaneously enabling "-mstackrealign".
+//
+// See https://github.com/nothings/stb/issues/81 for more information.
+//
+// So default to no SSE2 on 32-bit MinGW. If you've read this far and added
+// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.
+#define STBI_NO_SIMD
+#endif
+
+#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))
+#define STBI_SSE2
+#include <emmintrin.h>
+
+#ifdef _MSC_VER
+
+#if _MSC_VER >= 1400  // not VC6
+#include <intrin.h> // __cpuid
+static int stbi__cpuid3(void)
+{
+   int info[4];
+   __cpuid(info,1);
+   return info[3];
+}
+#else
+static int stbi__cpuid3(void)
+{
+   int res;
+   __asm {
+      mov  eax,1
+      cpuid
+      mov  res,edx
+   }
+   return res;
+}
+#endif
+
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   int info3 = stbi__cpuid3();
+   return ((info3 >> 26) & 1) != 0;
+}
+#endif
+
+#else // assume GCC-style if not VC++
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+
+#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)
+static int stbi__sse2_available(void)
+{
+   // If we're even attempting to compile this on GCC/Clang, that means
+   // -msse2 is on, which means the compiler is allowed to use SSE2
+   // instructions at will, and so are we.
+   return 1;
+}
+#endif
+
+#endif
+#endif
+
+// ARM NEON
+#if defined(STBI_NO_SIMD) && defined(STBI_NEON)
+#undef STBI_NEON
+#endif
+
+#ifdef STBI_NEON
+#include <arm_neon.h>
+#ifdef _MSC_VER
+#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name
+#else
+#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))
+#endif
+#endif
+
+#ifndef STBI_SIMD_ALIGN
+#define STBI_SIMD_ALIGN(type, name) type name
+#endif
+
+#ifndef STBI_MAX_DIMENSIONS
+#define STBI_MAX_DIMENSIONS (1 << 24)
+#endif
+
+///////////////////////////////////////////////
+//
+//  stbi__context struct and start_xxx functions
+
+// stbi__context structure is our basic context used by all images, so it
+// contains all the IO context, plus some basic image information
+typedef struct
+{
+   stbi__uint32 img_x, img_y;
+   int img_n, img_out_n;
+
+   stbi_io_callbacks io;
+   void *io_user_data;
+
+   int read_from_callbacks;
+   int buflen;
+   stbi_uc buffer_start[128];
+   int callback_already_read;
+
+   stbi_uc *img_buffer, *img_buffer_end;
+   stbi_uc *img_buffer_original, *img_buffer_original_end;
+} stbi__context;
+
+
+static void stbi__refill_buffer(stbi__context *s);
+
+// initialize a memory-decode context
+static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
+{
+   s->io.read = NULL;
+   s->read_from_callbacks = 0;
+   s->callback_already_read = 0;
+   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
+   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
+}
+
+// initialize a callback-based context
+static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
+{
+   s->io = *c;
+   s->io_user_data = user;
+   s->buflen = sizeof(s->buffer_start);
+   s->read_from_callbacks = 1;
+   s->callback_already_read = 0;
+   s->img_buffer = s->img_buffer_original = s->buffer_start;
+   stbi__refill_buffer(s);
+   s->img_buffer_original_end = s->img_buffer_end;
+}
+
+#ifndef STBI_NO_STDIO
+
+static int stbi__stdio_read(void *user, char *data, int size)
+{
+   return (int) fread(data,1,size,(FILE*) user);
+}
+
+static void stbi__stdio_skip(void *user, int n)
+{
+   int ch;
+   fseek((FILE*) user, n, SEEK_CUR);
+   ch = fgetc((FILE*) user);  /* have to read a byte to reset feof()'s flag */
+   if (ch != EOF) {
+      ungetc(ch, (FILE *) user);  /* push byte back onto stream if valid. */
+   }
+}
+
+static int stbi__stdio_eof(void *user)
+{
+   return feof((FILE*) user) || ferror((FILE *) user);
+}
+
+static stbi_io_callbacks stbi__stdio_callbacks =
+{
+   stbi__stdio_read,
+   stbi__stdio_skip,
+   stbi__stdio_eof,
+};
+
+static void stbi__start_file(stbi__context *s, FILE *f)
+{
+   stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);
+}
+
+//static void stop_file(stbi__context *s) { }
+
+#endif // !STBI_NO_STDIO
+
+static void stbi__rewind(stbi__context *s)
+{
+   // conceptually rewind SHOULD rewind to the beginning of the stream,
+   // but we just rewind to the beginning of the initial buffer, because
+   // we only use it after doing 'test', which only ever looks at at most 92 bytes
+   s->img_buffer = s->img_buffer_original;
+   s->img_buffer_end = s->img_buffer_original_end;
+}
+
+enum
+{
+   STBI_ORDER_RGB,
+   STBI_ORDER_BGR
+};
+
+typedef struct
+{
+   int bits_per_channel;
+   int num_channels;
+   int channel_order;
+} stbi__result_info;
+
+#ifndef STBI_NO_JPEG
+static int      stbi__jpeg_test(stbi__context *s);
+static void    *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNG
+static int      stbi__png_test(stbi__context *s);
+static void    *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__png_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__png_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_BMP
+static int      stbi__bmp_test(stbi__context *s);
+static void    *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_TGA
+static int      stbi__tga_test(stbi__context *s);
+static void    *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PSD
+static int      stbi__psd_test(stbi__context *s);
+static void    *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);
+static int      stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__psd_is16(stbi__context *s);
+#endif
+
+#ifndef STBI_NO_HDR
+static int      stbi__hdr_test(stbi__context *s);
+static float   *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PIC
+static int      stbi__pic_test(stbi__context *s);
+static void    *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_GIF
+static int      stbi__gif_test(stbi__context *s);
+static void    *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static void    *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);
+static int      stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);
+#endif
+
+#ifndef STBI_NO_PNM
+static int      stbi__pnm_test(stbi__context *s);
+static void    *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);
+static int      stbi__pnm_is16(stbi__context *s);
+#endif
+
+static
+#ifdef STBI_THREAD_LOCAL
+STBI_THREAD_LOCAL
+#endif
+const char *stbi__g_failure_reason;
+
+STBIDEF const char *stbi_failure_reason(void)
+{
+   return stbi__g_failure_reason;
+}
+
+#ifndef STBI_NO_FAILURE_STRINGS
+static int stbi__err(const char *str)
+{
+   stbi__g_failure_reason = str;
+   return 0;
+}
+#endif
+
+static void *stbi__malloc(size_t size)
+{
+    return STBI_MALLOC(size);
+}
+
+// stb_image uses ints pervasively, including for offset calculations.
+// therefore the largest decoded image size we can support with the
+// current code, even on 64-bit targets, is INT_MAX. this is not a
+// significant limitation for the intended use case.
+//
+// we do, however, need to make sure our size calculations don't
+// overflow. hence a few helper functions for size calculations that
+// multiply integers together, making sure that they're non-negative
+// and no overflow occurs.
+
+// return 1 if the sum is valid, 0 on overflow.
+// negative terms are considered invalid.
+static int stbi__addsizes_valid(int a, int b)
+{
+   if (b < 0) return 0;
+   // now 0 <= b <= INT_MAX, hence also
+   // 0 <= INT_MAX - b <= INTMAX.
+   // And "a + b <= INT_MAX" (which might overflow) is the
+   // same as a <= INT_MAX - b (no overflow)
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product is valid, 0 on overflow.
+// negative factors are considered invalid.
+static int stbi__mul2sizes_valid(int a, int b)
+{
+   if (a < 0 || b < 0) return 0;
+   if (b == 0) return 1; // mul-by-0 is always safe
+   // portable way to check for no overflows in a*b
+   return a <= INT_MAX/b;
+}
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad2sizes_valid(int a, int b, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);
+}
+#endif
+
+// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow
+static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__addsizes_valid(a*b*c, add);
+}
+
+// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+{
+   return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
+      stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);
+}
+#endif
+
+#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)
+// mallocs with size overflow checking
+static void *stbi__malloc_mad2(int a, int b, int add)
+{
+   if (!stbi__mad2sizes_valid(a, b, add)) return NULL;
+   return stbi__malloc(a*b + add);
+}
+#endif
+
+static void *stbi__malloc_mad3(int a, int b, int c, int add)
+{
+   if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;
+   return stbi__malloc(a*b*c + add);
+}
+
+#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)
+static void *stbi__malloc_mad4(int a, int b, int c, int d, int add)
+{
+   if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;
+   return stbi__malloc(a*b*c*d + add);
+}
+#endif
+
+// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.
+static int stbi__addints_valid(int a, int b)
+{
+   if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow
+   if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.
+   return a <= INT_MAX - b;
+}
+
+// returns 1 if the product of two ints fits in a signed short, 0 on overflow.
+static int stbi__mul2shorts_valid(int a, int b)
+{
+   if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow
+   if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid
+   if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN
+   return a >= SHRT_MIN / b;
+}
+
+// stbi__err - error
+// stbi__errpf - error returning pointer to float
+// stbi__errpuc - error returning pointer to unsigned char
+
+#ifdef STBI_NO_FAILURE_STRINGS
+   #define stbi__err(x,y)  0
+#elif defined(STBI_FAILURE_USERMSG)
+   #define stbi__err(x,y)  stbi__err(y)
+#else
+   #define stbi__err(x,y)  stbi__err(x)
+#endif
+
+#define stbi__errpf(x,y)   ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))
+#define stbi__errpuc(x,y)  ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))
+
+STBIDEF void stbi_image_free(void *retval_from_stbi_load)
+{
+   STBI_FREE(retval_from_stbi_load);
+}
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);
+#endif
+
+#ifndef STBI_NO_HDR
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp);
+#endif
+
+static int stbi__vertically_flip_on_load_global = 0;
+
+STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__vertically_flip_on_load  stbi__vertically_flip_on_load_global
+#else
+static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;
+
+STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
+{
+   stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
+   stbi__vertically_flip_on_load_set = 1;
+}
+
+#define stbi__vertically_flip_on_load  (stbi__vertically_flip_on_load_set       \
+                                         ? stbi__vertically_flip_on_load_local  \
+                                         : stbi__vertically_flip_on_load_global)
+#endif // STBI_THREAD_LOCAL
+
+static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields
+   ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed
+   ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order
+   ri->num_channels = 0;
+
+   // test the formats with a very explicit header first (at least a FOURCC
+   // or distinctive magic number first)
+   #ifndef STBI_NO_PNG
+   if (stbi__png_test(s))  return stbi__png_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_test(s))  return stbi__bmp_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_test(s))  return stbi__gif_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_test(s))  return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);
+   #else
+   STBI_NOTUSED(bpc);
+   #endif
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_test(s))  return stbi__pic_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   // then the formats that can end up attempting to load with just 1 or 2
+   // bytes matching expectations; these are prone to false positives, so
+   // try them later
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);
+   #endif
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_test(s))  return stbi__pnm_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);
+      return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);
+   }
+   #endif
+
+   #ifndef STBI_NO_TGA
+   // test tga last because it's a crappy test!
+   if (stbi__tga_test(s))
+      return stbi__tga_load(s,x,y,comp,req_comp, ri);
+   #endif
+
+   return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi_uc *reduced;
+
+   reduced = (stbi_uc *) stbi__malloc(img_len);
+   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling
+
+   STBI_FREE(orig);
+   return reduced;
+}
+
+static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
+{
+   int i;
+   int img_len = w * h * channels;
+   stbi__uint16 *enlarged;
+
+   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
+   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+
+   for (i = 0; i < img_len; ++i)
+      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
+
+   STBI_FREE(orig);
+   return enlarged;
+}
+
+static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
+{
+   int row;
+   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
+   stbi_uc temp[2048];
+   stbi_uc *bytes = (stbi_uc *)image;
+
+   for (row = 0; row < (h>>1); row++) {
+      stbi_uc *row0 = bytes + row*bytes_per_row;
+      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
+      // swap row0 with row1
+      size_t bytes_left = bytes_per_row;
+      while (bytes_left) {
+         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
+         memcpy(temp, row0, bytes_copy);
+         memcpy(row0, row1, bytes_copy);
+         memcpy(row1, temp, bytes_copy);
+         row0 += bytes_copy;
+         row1 += bytes_copy;
+         bytes_left -= bytes_copy;
+      }
+   }
+}
+
+#ifndef STBI_NO_GIF
+static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
+{
+   int slice;
+   int slice_size = w * h * bytes_per_pixel;
+
+   stbi_uc *bytes = (stbi_uc *)image;
+   for (slice = 0; slice < z; ++slice) {
+      stbi__vertical_flip(bytes, w, h, bytes_per_pixel);
+      bytes += slice_size;
+   }
+}
+#endif
+
+static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
+
+   if (result == NULL)
+      return NULL;
+
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+   if (ri.bits_per_channel != 8) {
+      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 8;
+   }
+
+   // @TODO: move stbi__convert_format to here
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
+   }
+
+   return (unsigned char *) result;
+}
+
+static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__result_info ri;
+   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
+
+   if (result == NULL)
+      return NULL;
+
+   // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.
+   STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);
+
+   if (ri.bits_per_channel != 16) {
+      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
+      ri.bits_per_channel = 16;
+   }
+
+   // @TODO: move stbi__convert_format16 to here
+   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision
+
+   if (stbi__vertically_flip_on_load) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
+   }
+
+   return (stbi__uint16 *) result;
+}
+
+#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)
+static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
+{
+   if (stbi__vertically_flip_on_load && result != NULL) {
+      int channels = req_comp ? req_comp : *comp;
+      stbi__vertical_flip(result, *x, *y, channels * sizeof(float));
+   }
+}
+#endif
+
+#ifndef STBI_NO_STDIO
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
+STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
+#endif
+
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
+{
+	return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
+}
+#endif
+
+static FILE *stbi__fopen(char const *filename, char const *mode)
+{
+   FILE *f;
+#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)
+   wchar_t wMode[64];
+   wchar_t wFilename[1024];
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))
+      return 0;
+
+	if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))
+      return 0;
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+	if (0 != _wfopen_s(&f, wFilename, wMode))
+		f = 0;
+#else
+   f = _wfopen(wFilename, wMode);
+#endif
+
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
+   if (0 != fopen_s(&f, filename, mode))
+      f=0;
+#else
+   f = fopen(filename, mode);
+#endif
+   return f;
+}
+
+
+STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   unsigned char *result;
+   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__uint16 *result;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
+   if (result) {
+      // need to 'unget' all the characters in the IO buffer
+      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
+   }
+   return result;
+}
+
+STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   stbi__uint16 *result;
+   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
+   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+
+#endif //!STBI_NO_STDIO
+
+STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
+   return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
+}
+
+STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_GIF
+STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   unsigned char *result;
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+
+   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
+   if (stbi__vertically_flip_on_load) {
+      stbi__vertical_flip_slices( result, *x, *y, *z, *comp );
+   }
+
+   return result;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
+{
+   unsigned char *data;
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_test(s)) {
+      stbi__result_info ri;
+      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
+      if (hdr_data)
+         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
+      return hdr_data;
+   }
+   #endif
+   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
+   if (data)
+      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
+   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
+}
+
+STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
+{
+   float *result;
+   FILE *f = stbi__fopen(filename, "rb");
+   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
+   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
+   fclose(f);
+   return result;
+}
+
+STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
+{
+   stbi__context s;
+   stbi__start_file(&s,f);
+   return stbi__loadf_main(&s,x,y,comp,req_comp);
+}
+#endif // !STBI_NO_STDIO
+
+#endif // !STBI_NO_LINEAR
+
+// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is
+// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always
+// reports false!
+
+STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(buffer);
+   STBI_NOTUSED(len);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int      stbi_is_hdr          (char const *filename)
+{
+   FILE *f = stbi__fopen(filename, "rb");
+   int result=0;
+   if (f) {
+      result = stbi_is_hdr_from_file(f);
+      fclose(f);
+   }
+   return result;
+}
+
+STBIDEF int stbi_is_hdr_from_file(FILE *f)
+{
+   #ifndef STBI_NO_HDR
+   long pos = ftell(f);
+   int res;
+   stbi__context s;
+   stbi__start_file(&s,f);
+   res = stbi__hdr_test(&s);
+   fseek(f, pos, SEEK_SET);
+   return res;
+   #else
+   STBI_NOTUSED(f);
+   return 0;
+   #endif
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int      stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)
+{
+   #ifndef STBI_NO_HDR
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
+   return stbi__hdr_test(&s);
+   #else
+   STBI_NOTUSED(clbk);
+   STBI_NOTUSED(user);
+   return 0;
+   #endif
+}
+
+#ifndef STBI_NO_LINEAR
+static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;
+
+STBIDEF void   stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }
+STBIDEF void   stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }
+#endif
+
+static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;
+
+STBIDEF void   stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }
+STBIDEF void   stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Common code used by all image loaders
+//
+
+enum
+{
+   STBI__SCAN_load=0,
+   STBI__SCAN_type,
+   STBI__SCAN_header
+};
+
+static void stbi__refill_buffer(stbi__context *s)
+{
+   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
+   s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
+   if (n == 0) {
+      // at end of file, treat same as if from memory, but need to handle case
+      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
+      s->read_from_callbacks = 0;
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start+1;
+      *s->img_buffer = 0;
+   } else {
+      s->img_buffer = s->buffer_start;
+      s->img_buffer_end = s->buffer_start + n;
+   }
+}
+
+stbi_inline static stbi_uc stbi__get8(stbi__context *s)
+{
+   if (s->img_buffer < s->img_buffer_end)
+      return *s->img_buffer++;
+   if (s->read_from_callbacks) {
+      stbi__refill_buffer(s);
+      return *s->img_buffer++;
+   }
+   return 0;
+}
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+stbi_inline static int stbi__at_eof(stbi__context *s)
+{
+   if (s->io.read) {
+      if (!(s->io.eof)(s->io_user_data)) return 0;
+      // if feof() is true, check if buffer = end
+      // special case: we've only got the special 0 character at the end
+      if (s->read_from_callbacks == 0) return 1;
+   }
+
+   return s->img_buffer >= s->img_buffer_end;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)
+// nothing
+#else
+static void stbi__skip(stbi__context *s, int n)
+{
+   if (n == 0) return;  // already there!
+   if (n < 0) {
+      s->img_buffer = s->img_buffer_end;
+      return;
+   }
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         s->img_buffer = s->img_buffer_end;
+         (s->io.skip)(s->io_user_data, n - blen);
+         return;
+      }
+   }
+   s->img_buffer += n;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)
+// nothing
+#else
+static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
+{
+   if (s->io.read) {
+      int blen = (int) (s->img_buffer_end - s->img_buffer);
+      if (blen < n) {
+         int res, count;
+
+         memcpy(buffer, s->img_buffer, blen);
+
+         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
+         res = (count == (n-blen));
+         s->img_buffer = s->img_buffer_end;
+         return res;
+      }
+   }
+
+   if (s->img_buffer+n <= s->img_buffer_end) {
+      memcpy(buffer, s->img_buffer, n);
+      s->img_buffer += n;
+      return 1;
+   } else
+      return 0;
+}
+#endif
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static int stbi__get16be(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return (z << 8) + stbi__get8(s);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)
+// nothing
+#else
+static stbi__uint32 stbi__get32be(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16be(s);
+   return (z << 16) + stbi__get16be(s);
+}
+#endif
+
+#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)
+// nothing
+#else
+static int stbi__get16le(stbi__context *s)
+{
+   int z = stbi__get8(s);
+   return z + (stbi__get8(s) << 8);
+}
+#endif
+
+#ifndef STBI_NO_BMP
+static stbi__uint32 stbi__get32le(stbi__context *s)
+{
+   stbi__uint32 z = stbi__get16le(s);
+   z += (stbi__uint32)stbi__get16le(s) << 16;
+   return z;
+}
+#endif
+
+#define STBI__BYTECAST(x)  ((stbi_uc) ((x) & 255))  // truncate int to byte without warnings
+
+#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+//////////////////////////////////////////////////////////////////////////////
+//
+//  generic converter from built-in img_n to req_comp
+//    individual types do this automatically as much as possible (e.g. jpeg
+//    does all cases internally since it needs to colorspace convert anyway,
+//    and it never has alpha, so very few cases ). png can automatically
+//    interleave an alpha=255 channel, but falls back to this for other cases
+//
+//  assume data buffer is malloced, so malloc a new one and free that one
+//  only failure mode is malloc failing
+
+static stbi_uc stbi__compute_y(int r, int g, int b)
+{
+   return (stbi_uc) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)
+// nothing
+#else
+static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   unsigned char *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      unsigned char *src  = data + j * x * img_n   ;
+      unsigned char *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                  } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                  } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                  } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255;    } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                    } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion");
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 stbi__compute_y_16(int r, int g, int b)
+{
+   return (stbi__uint16) (((r*77) + (g*150) +  (29*b)) >> 8);
+}
+#endif
+
+#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)
+// nothing
+#else
+static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
+{
+   int i,j;
+   stbi__uint16 *good;
+
+   if (req_comp == img_n) return data;
+   STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
+
+   good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);
+   if (good == NULL) {
+      STBI_FREE(data);
+      return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
+   }
+
+   for (j=0; j < (int) y; ++j) {
+      stbi__uint16 *src  = data + j * x * img_n   ;
+      stbi__uint16 *dest = good + j * x * req_comp;
+
+      #define STBI__COMBO(a,b)  ((a)*8+(b))
+      #define STBI__CASE(a,b)   case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
+      // convert source image with img_n components to one with req_comp components;
+      // avoid switch per pixel, so use switch per scanline and massive macros
+      switch (STBI__COMBO(img_n, req_comp)) {
+         STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff;                                     } break;
+         STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff;                     } break;
+         STBI__CASE(2,1) { dest[0]=src[0];                                                     } break;
+         STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0];                                     } break;
+         STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1];                     } break;
+         STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff;        } break;
+         STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;
+         STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]);                   } break;
+         STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;
+         STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];                       } break;
+         default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion");
+      }
+      #undef STBI__CASE
+   }
+
+   STBI_FREE(data);
+   return good;
+}
+#endif
+
+#ifndef STBI_NO_LINEAR
+static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
+{
+   int i,k,n;
+   float *output;
+   if (!data) return NULL;
+   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
+      }
+   }
+   if (n < comp) {
+      for (i=0; i < x*y; ++i) {
+         output[i*comp + n] = data[i*comp + n]/255.0f;
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+#ifndef STBI_NO_HDR
+#define stbi__float2int(x)   ((int) (x))
+static stbi_uc *stbi__hdr_to_ldr(float   *data, int x, int y, int comp)
+{
+   int i,k,n;
+   stbi_uc *output;
+   if (!data) return NULL;
+   output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);
+   if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); }
+   // compute number of non-alpha components
+   if (comp & 1) n = comp; else n = comp-1;
+   for (i=0; i < x*y; ++i) {
+      for (k=0; k < n; ++k) {
+         float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+      if (k < comp) {
+         float z = data[i*comp+k] * 255 + 0.5f;
+         if (z < 0) z = 0;
+         if (z > 255) z = 255;
+         output[i*comp + k] = (stbi_uc) stbi__float2int(z);
+      }
+   }
+   STBI_FREE(data);
+   return output;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//  "baseline" JPEG/JFIF decoder
+//
+//    simple implementation
+//      - doesn't support delayed output of y-dimension
+//      - simple interface (only one output format: 8-bit interleaved RGB)
+//      - doesn't try to recover corrupt jpegs
+//      - doesn't allow partial loading, loading multiple at once
+//      - still fast on x86 (copying globals into locals doesn't help x86)
+//      - allocates lots of intermediate memory (full size of all components)
+//        - non-interleaved case requires this anyway
+//        - allows good upsampling (see next)
+//    high-quality
+//      - upsampled channels are bilinearly interpolated, even across blocks
+//      - quality integer IDCT derived from IJG's 'slow'
+//    performance
+//      - fast huffman; reasonable integer IDCT
+//      - some SIMD kernels for common paths on targets with SSE2/NEON
+//      - uses a lot of intermediate memory, could cache poorly
+
+#ifndef STBI_NO_JPEG
+
+// huffman decoding acceleration
+#define FAST_BITS   9  // larger handles more cases; smaller stomps less cache
+
+typedef struct
+{
+   stbi_uc  fast[1 << FAST_BITS];
+   // weirdly, repacking this into AoS is a 10% speed loss, instead of a win
+   stbi__uint16 code[256];
+   stbi_uc  values[256];
+   stbi_uc  size[257];
+   unsigned int maxcode[18];
+   int    delta[17];   // old 'firstsymbol' - old 'firstcode'
+} stbi__huffman;
+
+typedef struct
+{
+   stbi__context *s;
+   stbi__huffman huff_dc[4];
+   stbi__huffman huff_ac[4];
+   stbi__uint16 dequant[4][64];
+   stbi__int16 fast_ac[4][1 << FAST_BITS];
+
+// sizes for components, interleaved MCUs
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+   struct
+   {
+      int id;
+      int h,v;
+      int tq;
+      int hd,ha;
+      int dc_pred;
+
+      int x,y,w2,h2;
+      stbi_uc *data;
+      void *raw_data, *raw_coeff;
+      stbi_uc *linebuf;
+      short   *coeff;   // progressive only
+      int      coeff_w, coeff_h; // number of 8x8 coefficient blocks
+   } img_comp[4];
+
+   stbi__uint32   code_buffer; // jpeg entropy-coded buffer
+   int            code_bits;   // number of valid bits
+   unsigned char  marker;      // marker seen while filling entropy buffer
+   int            nomore;      // flag if we saw a marker so must stop
+
+   int            progressive;
+   int            spec_start;
+   int            spec_end;
+   int            succ_high;
+   int            succ_low;
+   int            eob_run;
+   int            jfif;
+   int            app14_color_transform; // Adobe APP14 tag
+   int            rgb;
+
+   int scan_n, order[4];
+   int restart_interval, todo;
+
+// kernels
+   void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);
+   stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);
+} stbi__jpeg;
+
+static int stbi__build_huffman(stbi__huffman *h, int *count)
+{
+   int i,j,k=0;
+   unsigned int code;
+   // build size list for each symbol (from JPEG spec)
+   for (i=0; i < 16; ++i) {
+      for (j=0; j < count[i]; ++j) {
+         h->size[k++] = (stbi_uc) (i+1);
+         if(k >= 257) return stbi__err("bad size list","Corrupt JPEG");
+      }
+   }
+   h->size[k] = 0;
+
+   // compute actual symbols (from jpeg spec)
+   code = 0;
+   k = 0;
+   for(j=1; j <= 16; ++j) {
+      // compute delta to add to code to compute symbol id
+      h->delta[j] = k - code;
+      if (h->size[k] == j) {
+         while (h->size[k] == j)
+            h->code[k++] = (stbi__uint16) (code++);
+         if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG");
+      }
+      // compute largest code + 1 for this size, preshifted as needed later
+      h->maxcode[j] = code << (16-j);
+      code <<= 1;
+   }
+   h->maxcode[j] = 0xffffffff;
+
+   // build non-spec acceleration table; 255 is flag for not-accelerated
+   memset(h->fast, 255, 1 << FAST_BITS);
+   for (i=0; i < k; ++i) {
+      int s = h->size[i];
+      if (s <= FAST_BITS) {
+         int c = h->code[i] << (FAST_BITS-s);
+         int m = 1 << (FAST_BITS-s);
+         for (j=0; j < m; ++j) {
+            h->fast[c+j] = (stbi_uc) i;
+         }
+      }
+   }
+   return 1;
+}
+
+// build a table that decodes both magnitude and value of small ACs in
+// one go.
+static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
+{
+   int i;
+   for (i=0; i < (1 << FAST_BITS); ++i) {
+      stbi_uc fast = h->fast[i];
+      fast_ac[i] = 0;
+      if (fast < 255) {
+         int rs = h->values[fast];
+         int run = (rs >> 4) & 15;
+         int magbits = rs & 15;
+         int len = h->size[fast];
+
+         if (magbits && len + magbits <= FAST_BITS) {
+            // magnitude code followed by receive_extend code
+            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
+            int m = 1 << (magbits - 1);
+            if (k < m) k += (~0U << magbits) + 1;
+            // if the result is small enough, we can fit it in fast_ac table
+            if (k >= -128 && k <= 127)
+               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
+         }
+      }
+   }
+}
+
+static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
+{
+   do {
+      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
+      if (b == 0xff) {
+         int c = stbi__get8(j->s);
+         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
+         if (c != 0) {
+            j->marker = (unsigned char) c;
+            j->nomore = 1;
+            return;
+         }
+      }
+      j->code_buffer |= b << (24 - j->code_bits);
+      j->code_bits += 8;
+   } while (j->code_bits <= 24);
+}
+
+// (1 << n) - 1
+static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};
+
+// decode a jpeg huffman value from the bitstream
+stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)
+{
+   unsigned int temp;
+   int c,k;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   // look at the top FAST_BITS and determine what symbol ID it is,
+   // if the code is <= FAST_BITS
+   c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+   k = h->fast[c];
+   if (k < 255) {
+      int s = h->size[k];
+      if (s > j->code_bits)
+         return -1;
+      j->code_buffer <<= s;
+      j->code_bits -= s;
+      return h->values[k];
+   }
+
+   // naive test is to shift the code_buffer down so k bits are
+   // valid, then test against maxcode. To speed this up, we've
+   // preshifted maxcode left so that it has (16-k) 0s at the
+   // end; in other words, regardless of the number of bits, it
+   // wants to be compared against something shifted to have 16;
+   // that way we don't need to shift inside the loop.
+   temp = j->code_buffer >> 16;
+   for (k=FAST_BITS+1 ; ; ++k)
+      if (temp < h->maxcode[k])
+         break;
+   if (k == 17) {
+      // error! code not found
+      j->code_bits -= 16;
+      return -1;
+   }
+
+   if (k > j->code_bits)
+      return -1;
+
+   // convert the huffman code to the symbol id
+   c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];
+   if(c < 0 || c >= 256) // symbol id out of bounds!
+       return -1;
+   STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);
+
+   // convert the id to a symbol
+   j->code_bits -= k;
+   j->code_buffer <<= k;
+   return h->values[c];
+}
+
+// bias[n] = (-1<<n) + 1
+static const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
+
+// combined JPEG 'receive' and JPEG 'extend', since baseline
+// always extends everything it receives.
+stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   int sgn;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+
+   sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k + (stbi__jbias[n] & (sgn - 1));
+}
+
+// get some unsigned bits
+stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
+{
+   unsigned int k;
+   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing
+   k = stbi_lrot(j->code_buffer, n);
+   j->code_buffer = k & ~stbi__bmask[n];
+   k &= stbi__bmask[n];
+   j->code_bits -= n;
+   return k;
+}
+
+stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
+{
+   unsigned int k;
+   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
+   if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing
+   k = j->code_buffer;
+   j->code_buffer <<= 1;
+   --j->code_bits;
+   return k & 0x80000000;
+}
+
+// given a value that's at position X in the zigzag stream,
+// where does it appear in the 8x8 matrix coded as row-major?
+static const stbi_uc stbi__jpeg_dezigzag[64+15] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+   17, 24, 32, 25, 18, 11,  4,  5,
+   12, 19, 26, 33, 40, 48, 41, 34,
+   27, 20, 13,  6,  7, 14, 21, 28,
+   35, 42, 49, 56, 57, 50, 43, 36,
+   29, 22, 15, 23, 30, 37, 44, 51,
+   58, 59, 52, 45, 38, 31, 39, 46,
+   53, 60, 61, 54, 47, 55, 62, 63,
+   // let corrupt input sample past end
+   63, 63, 63, 63, 63, 63, 63, 63,
+   63, 63, 63, 63, 63, 63, 63
+};
+
+// decode one 64-entry block--
+static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
+{
+   int diff,dc,k;
+   int t;
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+   t = stbi__jpeg_huff_decode(j, hdc);
+   if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
+
+   // 0 all the ac values now so we can do it 32-bits at a time
+   memset(data,0,64*sizeof(data[0]));
+
+   diff = t ? stbi__extend_receive(j, t) : 0;
+   if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
+   dc = j->img_comp[b].dc_pred + diff;
+   j->img_comp[b].dc_pred = dc;
+   if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+   data[0] = (short) (dc * dequant[0]);
+
+   // decode AC components, see JPEG spec
+   k = 1;
+   do {
+      unsigned int zig;
+      int c,r,s;
+      if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+      c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+      r = fac[c];
+      if (r) { // fast-AC path
+         k += (r >> 4) & 15; // run
+         s = r & 15; // combined length
+         if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+         j->code_buffer <<= s;
+         j->code_bits -= s;
+         // decode into unzigzag'd location
+         zig = stbi__jpeg_dezigzag[k++];
+         data[zig] = (short) ((r >> 8) * dequant[zig]);
+      } else {
+         int rs = stbi__jpeg_huff_decode(j, hac);
+         if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+         s = rs & 15;
+         r = rs >> 4;
+         if (s == 0) {
+            if (rs != 0xf0) break; // end block
+            k += 16;
+         } else {
+            k += r;
+            // decode into unzigzag'd location
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
+         }
+      }
+   } while (k < 64);
+   return 1;
+}
+
+static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
+{
+   int diff,dc;
+   int t;
+   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+
+   if (j->succ_high == 0) {
+      // first scan for DC coefficient, must be first
+      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
+      t = stbi__jpeg_huff_decode(j, hdc);
+      if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+      diff = t ? stbi__extend_receive(j, t) : 0;
+
+      if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG");
+      dc = j->img_comp[b].dc_pred + diff;
+      j->img_comp[b].dc_pred = dc;
+      if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+      data[0] = (short) (dc * (1 << j->succ_low));
+   } else {
+      // refinement scan for DC coefficient
+      if (stbi__jpeg_get_bit(j))
+         data[0] += (short) (1 << j->succ_low);
+   }
+   return 1;
+}
+
+// @OPTIMIZE: store non-zigzagged during the decode passes,
+// and only de-zigzag when dequantizing
+static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)
+{
+   int k;
+   if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
+
+   if (j->succ_high == 0) {
+      int shift = j->succ_low;
+
+      if (j->eob_run) {
+         --j->eob_run;
+         return 1;
+      }
+
+      k = j->spec_start;
+      do {
+         unsigned int zig;
+         int c,r,s;
+         if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
+         c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
+         r = fac[c];
+         if (r) { // fast-AC path
+            k += (r >> 4) & 15; // run
+            s = r & 15; // combined length
+            if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
+            j->code_buffer <<= s;
+            j->code_bits -= s;
+            zig = stbi__jpeg_dezigzag[k++];
+            data[zig] = (short) ((r >> 8) * (1 << shift));
+         } else {
+            int rs = stbi__jpeg_huff_decode(j, hac);
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r);
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  --j->eob_run;
+                  break;
+               }
+               k += 16;
+            } else {
+               k += r;
+               zig = stbi__jpeg_dezigzag[k++];
+               data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));
+            }
+         }
+      } while (k <= j->spec_end);
+   } else {
+      // refinement scan for these AC coefficients
+
+      short bit = (short) (1 << j->succ_low);
+
+      if (j->eob_run) {
+         --j->eob_run;
+         for (k = j->spec_start; k <= j->spec_end; ++k) {
+            short *p = &data[stbi__jpeg_dezigzag[k]];
+            if (*p != 0)
+               if (stbi__jpeg_get_bit(j))
+                  if ((*p & bit)==0) {
+                     if (*p > 0)
+                        *p += bit;
+                     else
+                        *p -= bit;
+                  }
+         }
+      } else {
+         k = j->spec_start;
+         do {
+            int r,s;
+            int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh
+            if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
+            s = rs & 15;
+            r = rs >> 4;
+            if (s == 0) {
+               if (r < 15) {
+                  j->eob_run = (1 << r) - 1;
+                  if (r)
+                     j->eob_run += stbi__jpeg_get_bits(j, r);
+                  r = 64; // force end of block
+               } else {
+                  // r=15 s=0 should write 16 0s, so we just do
+                  // a run of 15 0s and then write s (which is 0),
+                  // so we don't have to do anything special here
+               }
+            } else {
+               if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG");
+               // sign bit
+               if (stbi__jpeg_get_bit(j))
+                  s = bit;
+               else
+                  s = -bit;
+            }
+
+            // advance by r
+            while (k <= j->spec_end) {
+               short *p = &data[stbi__jpeg_dezigzag[k++]];
+               if (*p != 0) {
+                  if (stbi__jpeg_get_bit(j))
+                     if ((*p & bit)==0) {
+                        if (*p > 0)
+                           *p += bit;
+                        else
+                           *p -= bit;
+                     }
+               } else {
+                  if (r == 0) {
+                     *p = (short) s;
+                     break;
+                  }
+                  --r;
+               }
+            }
+         } while (k <= j->spec_end);
+      }
+   }
+   return 1;
+}
+
+// take a -128..127 value and stbi__clamp it and convert to 0..255
+stbi_inline static stbi_uc stbi__clamp(int x)
+{
+   // trick to use a single test to catch both cases
+   if ((unsigned int) x > 255) {
+      if (x < 0) return 0;
+      if (x > 255) return 255;
+   }
+   return (stbi_uc) x;
+}
+
+#define stbi__f2f(x)  ((int) (((x) * 4096 + 0.5)))
+#define stbi__fsh(x)  ((x) * 4096)
+
+// derived from jidctint -- DCT_ISLOW
+#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \
+   int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \
+   p2 = s2;                                    \
+   p3 = s6;                                    \
+   p1 = (p2+p3) * stbi__f2f(0.5411961f);       \
+   t2 = p1 + p3*stbi__f2f(-1.847759065f);      \
+   t3 = p1 + p2*stbi__f2f( 0.765366865f);      \
+   p2 = s0;                                    \
+   p3 = s4;                                    \
+   t0 = stbi__fsh(p2+p3);                      \
+   t1 = stbi__fsh(p2-p3);                      \
+   x0 = t0+t3;                                 \
+   x3 = t0-t3;                                 \
+   x1 = t1+t2;                                 \
+   x2 = t1-t2;                                 \
+   t0 = s7;                                    \
+   t1 = s5;                                    \
+   t2 = s3;                                    \
+   t3 = s1;                                    \
+   p3 = t0+t2;                                 \
+   p4 = t1+t3;                                 \
+   p1 = t0+t3;                                 \
+   p2 = t1+t2;                                 \
+   p5 = (p3+p4)*stbi__f2f( 1.175875602f);      \
+   t0 = t0*stbi__f2f( 0.298631336f);           \
+   t1 = t1*stbi__f2f( 2.053119869f);           \
+   t2 = t2*stbi__f2f( 3.072711026f);           \
+   t3 = t3*stbi__f2f( 1.501321110f);           \
+   p1 = p5 + p1*stbi__f2f(-0.899976223f);      \
+   p2 = p5 + p2*stbi__f2f(-2.562915447f);      \
+   p3 = p3*stbi__f2f(-1.961570560f);           \
+   p4 = p4*stbi__f2f(-0.390180644f);           \
+   t3 += p1+p4;                                \
+   t2 += p2+p3;                                \
+   t1 += p2+p4;                                \
+   t0 += p1+p3;
+
+static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])
+{
+   int i,val[64],*v=val;
+   stbi_uc *o;
+   short *d = data;
+
+   // columns
+   for (i=0; i < 8; ++i,++d, ++v) {
+      // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing
+      if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0
+           && d[40]==0 && d[48]==0 && d[56]==0) {
+         //    no shortcut                 0     seconds
+         //    (1|2|3|4|5|6|7)==0          0     seconds
+         //    all separate               -0.047 seconds
+         //    1 && 2|3 && 4|5 && 6|7:    -0.047 seconds
+         int dcterm = d[0]*4;
+         v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;
+      } else {
+         STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])
+         // constants scaled things up by 1<<12; let's bring them back
+         // down, but keep 2 extra bits of precision
+         x0 += 512; x1 += 512; x2 += 512; x3 += 512;
+         v[ 0] = (x0+t3) >> 10;
+         v[56] = (x0-t3) >> 10;
+         v[ 8] = (x1+t2) >> 10;
+         v[48] = (x1-t2) >> 10;
+         v[16] = (x2+t1) >> 10;
+         v[40] = (x2-t1) >> 10;
+         v[24] = (x3+t0) >> 10;
+         v[32] = (x3-t0) >> 10;
+      }
+   }
+
+   for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {
+      // no fast case since the first 1D IDCT spread components out
+      STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])
+      // constants scaled things up by 1<<12, plus we had 1<<2 from first
+      // loop, plus horizontal and vertical each scale by sqrt(8) so together
+      // we've got an extra 1<<3, so 1<<17 total we need to remove.
+      // so we want to round that, which means adding 0.5 * 1<<17,
+      // aka 65536. Also, we'll end up with -128 to 127 that we want
+      // to encode as 0..255 by adding 128, so we'll add that before the shift
+      x0 += 65536 + (128<<17);
+      x1 += 65536 + (128<<17);
+      x2 += 65536 + (128<<17);
+      x3 += 65536 + (128<<17);
+      // tried computing the shifts into temps, or'ing the temps to see
+      // if any were out of range, but that was slower
+      o[0] = stbi__clamp((x0+t3) >> 17);
+      o[7] = stbi__clamp((x0-t3) >> 17);
+      o[1] = stbi__clamp((x1+t2) >> 17);
+      o[6] = stbi__clamp((x1-t2) >> 17);
+      o[2] = stbi__clamp((x2+t1) >> 17);
+      o[5] = stbi__clamp((x2-t1) >> 17);
+      o[3] = stbi__clamp((x3+t0) >> 17);
+      o[4] = stbi__clamp((x3-t0) >> 17);
+   }
+}
+
+#ifdef STBI_SSE2
+// sse2 integer IDCT. not the fastest possible implementation but it
+// produces bit-identical results to the generic C version so it's
+// fully "transparent".
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   // This is constructed to match our regular (generic) integer IDCT exactly.
+   __m128i row0, row1, row2, row3, row4, row5, row6, row7;
+   __m128i tmp;
+
+   // dot product constant: even elems=x, odd elems=y
+   #define dct_const(x,y)  _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))
+
+   // out(0) = c0[even]*x + c0[odd]*y   (c0, x, y 16-bit, out 32-bit)
+   // out(1) = c1[even]*x + c1[odd]*y
+   #define dct_rot(out0,out1, x,y,c0,c1) \
+      __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \
+      __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \
+      __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \
+      __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \
+      __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \
+      __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)
+
+   // out = in << 12  (in 16-bit, out 32-bit)
+   #define dct_widen(out, in) \
+      __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \
+      __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)
+
+   // wide add
+   #define dct_wadd(out, a, b) \
+      __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_add_epi32(a##_h, b##_h)
+
+   // wide sub
+   #define dct_wsub(out, a, b) \
+      __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \
+      __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)
+
+   // butterfly a/b, add bias, then shift by "s" and pack
+   #define dct_bfly32o(out0, out1, a,b,bias,s) \
+      { \
+         __m128i abiased_l = _mm_add_epi32(a##_l, bias); \
+         __m128i abiased_h = _mm_add_epi32(a##_h, bias); \
+         dct_wadd(sum, abiased, b); \
+         dct_wsub(dif, abiased, b); \
+         out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \
+         out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \
+      }
+
+   // 8-bit interleave step (for transposes)
+   #define dct_interleave8(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi8(a, b); \
+      b = _mm_unpackhi_epi8(tmp, b)
+
+   // 16-bit interleave step (for transposes)
+   #define dct_interleave16(a, b) \
+      tmp = a; \
+      a = _mm_unpacklo_epi16(a, b); \
+      b = _mm_unpackhi_epi16(tmp, b)
+
+   #define dct_pass(bias,shift) \
+      { \
+         /* even part */ \
+         dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \
+         __m128i sum04 = _mm_add_epi16(row0, row4); \
+         __m128i dif04 = _mm_sub_epi16(row0, row4); \
+         dct_widen(t0e, sum04); \
+         dct_widen(t1e, dif04); \
+         dct_wadd(x0, t0e, t3e); \
+         dct_wsub(x3, t0e, t3e); \
+         dct_wadd(x1, t1e, t2e); \
+         dct_wsub(x2, t1e, t2e); \
+         /* odd part */ \
+         dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \
+         dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \
+         __m128i sum17 = _mm_add_epi16(row1, row7); \
+         __m128i sum35 = _mm_add_epi16(row3, row5); \
+         dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \
+         dct_wadd(x4, y0o, y4o); \
+         dct_wadd(x5, y1o, y5o); \
+         dct_wadd(x6, y2o, y5o); \
+         dct_wadd(x7, y3o, y4o); \
+         dct_bfly32o(row0,row7, x0,x7,bias,shift); \
+         dct_bfly32o(row1,row6, x1,x6,bias,shift); \
+         dct_bfly32o(row2,row5, x2,x5,bias,shift); \
+         dct_bfly32o(row3,row4, x3,x4,bias,shift); \
+      }
+
+   __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));
+   __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));
+   __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));
+   __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));
+   __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));
+   __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));
+   __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));
+   __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));
+
+   // rounding biases in column/row passes, see stbi__idct_block for explanation.
+   __m128i bias_0 = _mm_set1_epi32(512);
+   __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));
+
+   // load
+   row0 = _mm_load_si128((const __m128i *) (data + 0*8));
+   row1 = _mm_load_si128((const __m128i *) (data + 1*8));
+   row2 = _mm_load_si128((const __m128i *) (data + 2*8));
+   row3 = _mm_load_si128((const __m128i *) (data + 3*8));
+   row4 = _mm_load_si128((const __m128i *) (data + 4*8));
+   row5 = _mm_load_si128((const __m128i *) (data + 5*8));
+   row6 = _mm_load_si128((const __m128i *) (data + 6*8));
+   row7 = _mm_load_si128((const __m128i *) (data + 7*8));
+
+   // column pass
+   dct_pass(bias_0, 10);
+
+   {
+      // 16bit 8x8 transpose pass 1
+      dct_interleave16(row0, row4);
+      dct_interleave16(row1, row5);
+      dct_interleave16(row2, row6);
+      dct_interleave16(row3, row7);
+
+      // transpose pass 2
+      dct_interleave16(row0, row2);
+      dct_interleave16(row1, row3);
+      dct_interleave16(row4, row6);
+      dct_interleave16(row5, row7);
+
+      // transpose pass 3
+      dct_interleave16(row0, row1);
+      dct_interleave16(row2, row3);
+      dct_interleave16(row4, row5);
+      dct_interleave16(row6, row7);
+   }
+
+   // row pass
+   dct_pass(bias_1, 17);
+
+   {
+      // pack
+      __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7
+      __m128i p1 = _mm_packus_epi16(row2, row3);
+      __m128i p2 = _mm_packus_epi16(row4, row5);
+      __m128i p3 = _mm_packus_epi16(row6, row7);
+
+      // 8bit 8x8 transpose pass 1
+      dct_interleave8(p0, p2); // a0e0a1e1...
+      dct_interleave8(p1, p3); // c0g0c1g1...
+
+      // transpose pass 2
+      dct_interleave8(p0, p1); // a0c0e0g0...
+      dct_interleave8(p2, p3); // b0d0f0h0...
+
+      // transpose pass 3
+      dct_interleave8(p0, p2); // a0b0c0d0...
+      dct_interleave8(p1, p3); // a4b4c4d4...
+
+      // store
+      _mm_storel_epi64((__m128i *) out, p0); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p2); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p1); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, p3); out += out_stride;
+      _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));
+   }
+
+#undef dct_const
+#undef dct_rot
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_interleave8
+#undef dct_interleave16
+#undef dct_pass
+}
+
+#endif // STBI_SSE2
+
+#ifdef STBI_NEON
+
+// NEON integer IDCT. should produce bit-identical
+// results to the generic C version.
+static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
+{
+   int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;
+
+   int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));
+   int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));
+   int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));
+   int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));
+   int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));
+   int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));
+   int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));
+   int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));
+   int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));
+   int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));
+   int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));
+   int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));
+
+#define dct_long_mul(out, inq, coeff) \
+   int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)
+
+#define dct_long_mac(out, acc, inq, coeff) \
+   int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \
+   int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)
+
+#define dct_widen(out, inq) \
+   int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \
+   int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)
+
+// wide add
+#define dct_wadd(out, a, b) \
+   int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vaddq_s32(a##_h, b##_h)
+
+// wide sub
+#define dct_wsub(out, a, b) \
+   int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \
+   int32x4_t out##_h = vsubq_s32(a##_h, b##_h)
+
+// butterfly a/b, then shift using "shiftop" by "s" and pack
+#define dct_bfly32o(out0,out1, a,b,shiftop,s) \
+   { \
+      dct_wadd(sum, a, b); \
+      dct_wsub(dif, a, b); \
+      out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \
+      out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \
+   }
+
+#define dct_pass(shiftop, shift) \
+   { \
+      /* even part */ \
+      int16x8_t sum26 = vaddq_s16(row2, row6); \
+      dct_long_mul(p1e, sum26, rot0_0); \
+      dct_long_mac(t2e, p1e, row6, rot0_1); \
+      dct_long_mac(t3e, p1e, row2, rot0_2); \
+      int16x8_t sum04 = vaddq_s16(row0, row4); \
+      int16x8_t dif04 = vsubq_s16(row0, row4); \
+      dct_widen(t0e, sum04); \
+      dct_widen(t1e, dif04); \
+      dct_wadd(x0, t0e, t3e); \
+      dct_wsub(x3, t0e, t3e); \
+      dct_wadd(x1, t1e, t2e); \
+      dct_wsub(x2, t1e, t2e); \
+      /* odd part */ \
+      int16x8_t sum15 = vaddq_s16(row1, row5); \
+      int16x8_t sum17 = vaddq_s16(row1, row7); \
+      int16x8_t sum35 = vaddq_s16(row3, row5); \
+      int16x8_t sum37 = vaddq_s16(row3, row7); \
+      int16x8_t sumodd = vaddq_s16(sum17, sum35); \
+      dct_long_mul(p5o, sumodd, rot1_0); \
+      dct_long_mac(p1o, p5o, sum17, rot1_1); \
+      dct_long_mac(p2o, p5o, sum35, rot1_2); \
+      dct_long_mul(p3o, sum37, rot2_0); \
+      dct_long_mul(p4o, sum15, rot2_1); \
+      dct_wadd(sump13o, p1o, p3o); \
+      dct_wadd(sump24o, p2o, p4o); \
+      dct_wadd(sump23o, p2o, p3o); \
+      dct_wadd(sump14o, p1o, p4o); \
+      dct_long_mac(x4, sump13o, row7, rot3_0); \
+      dct_long_mac(x5, sump24o, row5, rot3_1); \
+      dct_long_mac(x6, sump23o, row3, rot3_2); \
+      dct_long_mac(x7, sump14o, row1, rot3_3); \
+      dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \
+      dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \
+      dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \
+      dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \
+   }
+
+   // load
+   row0 = vld1q_s16(data + 0*8);
+   row1 = vld1q_s16(data + 1*8);
+   row2 = vld1q_s16(data + 2*8);
+   row3 = vld1q_s16(data + 3*8);
+   row4 = vld1q_s16(data + 4*8);
+   row5 = vld1q_s16(data + 5*8);
+   row6 = vld1q_s16(data + 6*8);
+   row7 = vld1q_s16(data + 7*8);
+
+   // add DC bias
+   row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));
+
+   // column pass
+   dct_pass(vrshrn_n_s32, 10);
+
+   // 16bit 8x8 transpose
+   {
+// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.
+// whether compilers actually get this is another story, sadly.
+#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }
+#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }
+
+      // pass 1
+      dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6
+      dct_trn16(row2, row3);
+      dct_trn16(row4, row5);
+      dct_trn16(row6, row7);
+
+      // pass 2
+      dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4
+      dct_trn32(row1, row3);
+      dct_trn32(row4, row6);
+      dct_trn32(row5, row7);
+
+      // pass 3
+      dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0
+      dct_trn64(row1, row5);
+      dct_trn64(row2, row6);
+      dct_trn64(row3, row7);
+
+#undef dct_trn16
+#undef dct_trn32
+#undef dct_trn64
+   }
+
+   // row pass
+   // vrshrn_n_s32 only supports shifts up to 16, we need
+   // 17. so do a non-rounding shift of 16 first then follow
+   // up with a rounding shift by 1.
+   dct_pass(vshrn_n_s32, 16);
+
+   {
+      // pack and round
+      uint8x8_t p0 = vqrshrun_n_s16(row0, 1);
+      uint8x8_t p1 = vqrshrun_n_s16(row1, 1);
+      uint8x8_t p2 = vqrshrun_n_s16(row2, 1);
+      uint8x8_t p3 = vqrshrun_n_s16(row3, 1);
+      uint8x8_t p4 = vqrshrun_n_s16(row4, 1);
+      uint8x8_t p5 = vqrshrun_n_s16(row5, 1);
+      uint8x8_t p6 = vqrshrun_n_s16(row6, 1);
+      uint8x8_t p7 = vqrshrun_n_s16(row7, 1);
+
+      // again, these can translate into one instruction, but often don't.
+#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }
+#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }
+#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }
+
+      // sadly can't use interleaved stores here since we only write
+      // 8 bytes to each scan line!
+
+      // 8x8 8-bit transpose pass 1
+      dct_trn8_8(p0, p1);
+      dct_trn8_8(p2, p3);
+      dct_trn8_8(p4, p5);
+      dct_trn8_8(p6, p7);
+
+      // pass 2
+      dct_trn8_16(p0, p2);
+      dct_trn8_16(p1, p3);
+      dct_trn8_16(p4, p6);
+      dct_trn8_16(p5, p7);
+
+      // pass 3
+      dct_trn8_32(p0, p4);
+      dct_trn8_32(p1, p5);
+      dct_trn8_32(p2, p6);
+      dct_trn8_32(p3, p7);
+
+      // store
+      vst1_u8(out, p0); out += out_stride;
+      vst1_u8(out, p1); out += out_stride;
+      vst1_u8(out, p2); out += out_stride;
+      vst1_u8(out, p3); out += out_stride;
+      vst1_u8(out, p4); out += out_stride;
+      vst1_u8(out, p5); out += out_stride;
+      vst1_u8(out, p6); out += out_stride;
+      vst1_u8(out, p7);
+
+#undef dct_trn8_8
+#undef dct_trn8_16
+#undef dct_trn8_32
+   }
+
+#undef dct_long_mul
+#undef dct_long_mac
+#undef dct_widen
+#undef dct_wadd
+#undef dct_wsub
+#undef dct_bfly32o
+#undef dct_pass
+}
+
+#endif // STBI_NEON
+
+#define STBI__MARKER_none  0xff
+// if there's a pending marker from the entropy stream, return that
+// otherwise, fetch from the stream and get a marker. if there's no
+// marker, return 0xff, which is never a valid marker value
+static stbi_uc stbi__get_marker(stbi__jpeg *j)
+{
+   stbi_uc x;
+   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
+   x = stbi__get8(j->s);
+   if (x != 0xff) return STBI__MARKER_none;
+   while (x == 0xff)
+      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
+   return x;
+}
+
+// in each scan, we'll have scan_n components, and the order
+// of the components is specified by order[]
+#define STBI__RESTART(x)     ((x) >= 0xd0 && (x) <= 0xd7)
+
+// after a restart interval, stbi__jpeg_reset the entropy decoder and
+// the dc prediction
+static void stbi__jpeg_reset(stbi__jpeg *j)
+{
+   j->code_bits = 0;
+   j->code_buffer = 0;
+   j->nomore = 0;
+   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
+   j->marker = STBI__MARKER_none;
+   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
+   j->eob_run = 0;
+   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
+   // since we don't even allow 1<<30 pixels
+}
+
+static int stbi__parse_entropy_coded_data(stbi__jpeg *z)
+{
+   stbi__jpeg_reset(z);
+   if (!z->progressive) {
+      if (z->scan_n == 1) {
+         int i,j;
+         STBI_SIMD_ALIGN(short, data[64]);
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               int ha = z->img_comp[n].ha;
+               if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  // if it's NOT a restart, then just bail, so we get corrupt data
+                  // rather than no data
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         STBI_SIMD_ALIGN(short, data[64]);
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x)*8;
+                        int y2 = (j*z->img_comp[n].v + y)*8;
+                        int ha = z->img_comp[n].ha;
+                        if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;
+                        z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   } else {
+      if (z->scan_n == 1) {
+         int i,j;
+         int n = z->order[0];
+         // non-interleaved data, we just need to process one block at a time,
+         // in trivial scanline order
+         // number of blocks to do just depends on how many actual "pixels" this
+         // component has, independent of interleaved MCU blocking and such
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               if (z->spec_start == 0) {
+                  if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                     return 0;
+               } else {
+                  int ha = z->img_comp[n].ha;
+                  if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))
+                     return 0;
+               }
+               // every data block is an MCU, so countdown the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      } else { // interleaved
+         int i,j,k,x,y;
+         for (j=0; j < z->img_mcu_y; ++j) {
+            for (i=0; i < z->img_mcu_x; ++i) {
+               // scan an interleaved mcu... process scan_n components in order
+               for (k=0; k < z->scan_n; ++k) {
+                  int n = z->order[k];
+                  // scan out an mcu's worth of this component; that's just determined
+                  // by the basic H and V specified for the component
+                  for (y=0; y < z->img_comp[n].v; ++y) {
+                     for (x=0; x < z->img_comp[n].h; ++x) {
+                        int x2 = (i*z->img_comp[n].h + x);
+                        int y2 = (j*z->img_comp[n].v + y);
+                        short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);
+                        if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))
+                           return 0;
+                     }
+                  }
+               }
+               // after all interleaved components, that's an interleaved MCU,
+               // so now count down the restart interval
+               if (--z->todo <= 0) {
+                  if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);
+                  if (!STBI__RESTART(z->marker)) return 1;
+                  stbi__jpeg_reset(z);
+               }
+            }
+         }
+         return 1;
+      }
+   }
+}
+
+static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)
+{
+   int i;
+   for (i=0; i < 64; ++i)
+      data[i] *= dequant[i];
+}
+
+static void stbi__jpeg_finish(stbi__jpeg *z)
+{
+   if (z->progressive) {
+      // dequantize and idct the data
+      int i,j,n;
+      for (n=0; n < z->s->img_n; ++n) {
+         int w = (z->img_comp[n].x+7) >> 3;
+         int h = (z->img_comp[n].y+7) >> 3;
+         for (j=0; j < h; ++j) {
+            for (i=0; i < w; ++i) {
+               short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);
+               stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);
+               z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);
+            }
+         }
+      }
+   }
+}
+
+static int stbi__process_marker(stbi__jpeg *z, int m)
+{
+   int L;
+   switch (m) {
+      case STBI__MARKER_none: // no marker found
+         return stbi__err("expected marker","Corrupt JPEG");
+
+      case 0xDD: // DRI - specify restart interval
+         if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG");
+         z->restart_interval = stbi__get16be(z->s);
+         return 1;
+
+      case 0xDB: // DQT - define quantization table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            int q = stbi__get8(z->s);
+            int p = q >> 4, sixteen = (p != 0);
+            int t = q & 15,i;
+            if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG");
+            if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG");
+
+            for (i=0; i < 64; ++i)
+               z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));
+            L -= (sixteen ? 129 : 65);
+         }
+         return L==0;
+
+      case 0xC4: // DHT - define huffman table
+         L = stbi__get16be(z->s)-2;
+         while (L > 0) {
+            stbi_uc *v;
+            int sizes[16],i,n=0;
+            int q = stbi__get8(z->s);
+            int tc = q >> 4;
+            int th = q & 15;
+            if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG");
+            for (i=0; i < 16; ++i) {
+               sizes[i] = stbi__get8(z->s);
+               n += sizes[i];
+            }
+            if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values!
+            L -= 17;
+            if (tc == 0) {
+               if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;
+               v = z->huff_dc[th].values;
+            } else {
+               if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;
+               v = z->huff_ac[th].values;
+            }
+            for (i=0; i < n; ++i)
+               v[i] = stbi__get8(z->s);
+            if (tc != 0)
+               stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);
+            L -= n;
+         }
+         return L==0;
+   }
+
+   // check for comment block or APP blocks
+   if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {
+      L = stbi__get16be(z->s);
+      if (L < 2) {
+         if (m == 0xFE)
+            return stbi__err("bad COM len","Corrupt JPEG");
+         else
+            return stbi__err("bad APP len","Corrupt JPEG");
+      }
+      L -= 2;
+
+      if (m == 0xE0 && L >= 5) { // JFIF APP0 segment
+         static const unsigned char tag[5] = {'J','F','I','F','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 5; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 5;
+         if (ok)
+            z->jfif = 1;
+      } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment
+         static const unsigned char tag[6] = {'A','d','o','b','e','\0'};
+         int ok = 1;
+         int i;
+         for (i=0; i < 6; ++i)
+            if (stbi__get8(z->s) != tag[i])
+               ok = 0;
+         L -= 6;
+         if (ok) {
+            stbi__get8(z->s); // version
+            stbi__get16be(z->s); // flags0
+            stbi__get16be(z->s); // flags1
+            z->app14_color_transform = stbi__get8(z->s); // color transform
+            L -= 6;
+         }
+      }
+
+      stbi__skip(z->s, L);
+      return 1;
+   }
+
+   return stbi__err("unknown marker","Corrupt JPEG");
+}
+
+// after we see SOS
+static int stbi__process_scan_header(stbi__jpeg *z)
+{
+   int i;
+   int Ls = stbi__get16be(z->s);
+   z->scan_n = stbi__get8(z->s);
+   if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG");
+   if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG");
+   for (i=0; i < z->scan_n; ++i) {
+      int id = stbi__get8(z->s), which;
+      int q = stbi__get8(z->s);
+      for (which = 0; which < z->s->img_n; ++which)
+         if (z->img_comp[which].id == id)
+            break;
+      if (which == z->s->img_n) return 0; // no match
+      z->img_comp[which].hd = q >> 4;   if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG");
+      z->img_comp[which].ha = q & 15;   if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG");
+      z->order[i] = which;
+   }
+
+   {
+      int aa;
+      z->spec_start = stbi__get8(z->s);
+      z->spec_end   = stbi__get8(z->s); // should be 63, but might be 0
+      aa = stbi__get8(z->s);
+      z->succ_high = (aa >> 4);
+      z->succ_low  = (aa & 15);
+      if (z->progressive) {
+         if (z->spec_start > 63 || z->spec_end > 63  || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)
+            return stbi__err("bad SOS", "Corrupt JPEG");
+      } else {
+         if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG");
+         z->spec_end = 63;
+      }
+   }
+
+   return 1;
+}
+
+static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
+{
+   int i;
+   for (i=0; i < ncomp; ++i) {
+      if (z->img_comp[i].raw_data) {
+         STBI_FREE(z->img_comp[i].raw_data);
+         z->img_comp[i].raw_data = NULL;
+         z->img_comp[i].data = NULL;
+      }
+      if (z->img_comp[i].raw_coeff) {
+         STBI_FREE(z->img_comp[i].raw_coeff);
+         z->img_comp[i].raw_coeff = 0;
+         z->img_comp[i].coeff = 0;
+      }
+      if (z->img_comp[i].linebuf) {
+         STBI_FREE(z->img_comp[i].linebuf);
+         z->img_comp[i].linebuf = NULL;
+      }
+   }
+   return why;
+}
+
+static int stbi__process_frame_header(stbi__jpeg *z, int scan)
+{
+   stbi__context *s = z->s;
+   int Lf,p,i,q, h_max=1,v_max=1,c;
+   Lf = stbi__get16be(s);         if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
+   p  = stbi__get8(s);            if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline
+   s->img_y = stbi__get16be(s);   if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG
+   s->img_x = stbi__get16be(s);   if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   c = stbi__get8(s);
+   if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG");
+   s->img_n = c;
+   for (i=0; i < c; ++i) {
+      z->img_comp[i].data = NULL;
+      z->img_comp[i].linebuf = NULL;
+   }
+
+   if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG");
+
+   z->rgb = 0;
+   for (i=0; i < s->img_n; ++i) {
+      static const unsigned char rgb[3] = { 'R', 'G', 'B' };
+      z->img_comp[i].id = stbi__get8(s);
+      if (s->img_n == 3 && z->img_comp[i].id == rgb[i])
+         ++z->rgb;
+      q = stbi__get8(s);
+      z->img_comp[i].h = (q >> 4);  if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG");
+      z->img_comp[i].v = q & 15;    if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG");
+      z->img_comp[i].tq = stbi__get8(s);  if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG");
+   }
+
+   if (scan != STBI__SCAN_load) return 1;
+
+   if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode");
+
+   for (i=0; i < s->img_n; ++i) {
+      if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;
+      if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;
+   }
+
+   // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios
+   // and I've never seen a non-corrupted JPEG file actually use them
+   for (i=0; i < s->img_n; ++i) {
+      if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG");
+      if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG");
+   }
+
+   // compute interleaved mcu info
+   z->img_h_max = h_max;
+   z->img_v_max = v_max;
+   z->img_mcu_w = h_max * 8;
+   z->img_mcu_h = v_max * 8;
+   // these sizes can't be more than 17 bits
+   z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;
+   z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;
+
+   for (i=0; i < s->img_n; ++i) {
+      // number of effective pixels (e.g. for non-interleaved MCU)
+      z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;
+      z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;
+      // to simplify generation, we'll allocate enough memory to decode
+      // the bogus oversized data from using interleaved MCUs and their
+      // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't
+      // discard the extra data until colorspace conversion
+      //
+      // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)
+      // so these muls can't overflow with 32-bit ints (which we require)
+      z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;
+      z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;
+      z->img_comp[i].coeff = 0;
+      z->img_comp[i].raw_coeff = 0;
+      z->img_comp[i].linebuf = NULL;
+      z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);
+      if (z->img_comp[i].raw_data == NULL)
+         return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+      // align blocks for idct using mmx/sse
+      z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);
+      if (z->progressive) {
+         // w2, h2 are multiples of 8 (see above)
+         z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;
+         z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;
+         z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);
+         if (z->img_comp[i].raw_coeff == NULL)
+            return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory"));
+         z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);
+      }
+   }
+
+   return 1;
+}
+
+// use comparisons since in some cases we handle more than one case (e.g. SOF)
+#define stbi__DNL(x)         ((x) == 0xdc)
+#define stbi__SOI(x)         ((x) == 0xd8)
+#define stbi__EOI(x)         ((x) == 0xd9)
+#define stbi__SOF(x)         ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
+#define stbi__SOS(x)         ((x) == 0xda)
+
+#define stbi__SOF_progressive(x)   ((x) == 0xc2)
+
+static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
+{
+   int m;
+   z->jfif = 0;
+   z->app14_color_transform = -1; // valid values are 0,1,2
+   z->marker = STBI__MARKER_none; // initialize cached marker to empty
+   m = stbi__get_marker(z);
+   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
+   if (scan == STBI__SCAN_type) return 1;
+   m = stbi__get_marker(z);
+   while (!stbi__SOF(m)) {
+      if (!stbi__process_marker(z,m)) return 0;
+      m = stbi__get_marker(z);
+      while (m == STBI__MARKER_none) {
+         // some files have extra padding after their blocks, so ok, we'll scan
+         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
+         m = stbi__get_marker(z);
+      }
+   }
+   z->progressive = stbi__SOF_progressive(m);
+   if (!stbi__process_frame_header(z, scan)) return 0;
+   return 1;
+}
+
+static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)
+{
+   // some JPEGs have junk at end, skip over it but if we find what looks
+   // like a valid marker, resume there
+   while (!stbi__at_eof(j->s)) {
+      stbi_uc x = stbi__get8(j->s);
+      while (x == 0xff) { // might be a marker
+         if (stbi__at_eof(j->s)) return STBI__MARKER_none;
+         x = stbi__get8(j->s);
+         if (x != 0x00 && x != 0xff) {
+            // not a stuffed zero or lead-in to another marker, looks
+            // like an actual marker, return it
+            return x;
+         }
+         // stuffed zero has x=0 now which ends the loop, meaning we go
+         // back to regular scan loop.
+         // repeated 0xff keeps trying to read the next byte of the marker.
+      }
+   }
+   return STBI__MARKER_none;
+}
+
+// decode image to YCbCr format
+static int stbi__decode_jpeg_image(stbi__jpeg *j)
+{
+   int m;
+   for (m = 0; m < 4; m++) {
+      j->img_comp[m].raw_data = NULL;
+      j->img_comp[m].raw_coeff = NULL;
+   }
+   j->restart_interval = 0;
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
+   m = stbi__get_marker(j);
+   while (!stbi__EOI(m)) {
+      if (stbi__SOS(m)) {
+         if (!stbi__process_scan_header(j)) return 0;
+         if (!stbi__parse_entropy_coded_data(j)) return 0;
+         if (j->marker == STBI__MARKER_none ) {
+         j->marker = stbi__skip_jpeg_junk_at_end(j);
+            // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
+         }
+         m = stbi__get_marker(j);
+         if (STBI__RESTART(m))
+            m = stbi__get_marker(j);
+      } else if (stbi__DNL(m)) {
+         int Ld = stbi__get16be(j->s);
+         stbi__uint32 NL = stbi__get16be(j->s);
+         if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
+         if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
+         m = stbi__get_marker(j);
+      } else {
+         if (!stbi__process_marker(j, m)) return 1;
+         m = stbi__get_marker(j);
+      }
+   }
+   if (j->progressive)
+      stbi__jpeg_finish(j);
+   return 1;
+}
+
+// static jfif-centered resampling (across block boundaries)
+
+typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,
+                                    int w, int hs);
+
+#define stbi__div4(x) ((stbi_uc) ((x) >> 2))
+
+static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   STBI_NOTUSED(out);
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(w);
+   STBI_NOTUSED(hs);
+   return in_near;
+}
+
+static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples vertically for every one in input
+   int i;
+   STBI_NOTUSED(hs);
+   for (i=0; i < w; ++i)
+      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
+   return out;
+}
+
+static stbi_uc*  stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate two samples horizontally for every one in input
+   int i;
+   stbi_uc *input = in_near;
+
+   if (w == 1) {
+      // if only one sample, can't do any interpolation
+      out[0] = out[1] = input[0];
+      return out;
+   }
+
+   out[0] = input[0];
+   out[1] = stbi__div4(input[0]*3 + input[1] + 2);
+   for (i=1; i < w-1; ++i) {
+      int n = 3*input[i]+2;
+      out[i*2+0] = stbi__div4(n+input[i-1]);
+      out[i*2+1] = stbi__div4(n+input[i+1]);
+   }
+   out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);
+   out[i*2+1] = input[w-1];
+
+   STBI_NOTUSED(in_far);
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#define stbi__div16(x) ((stbi_uc) ((x) >> 4))
+
+static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i,t0,t1;
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   out[0] = stbi__div4(t1+2);
+   for (i=1; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // need to generate 2x2 samples for every one in input
+   int i=0,t0,t1;
+
+   if (w == 1) {
+      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
+      return out;
+   }
+
+   t1 = 3*in_near[0] + in_far[0];
+   // process groups of 8 pixels for as long as we can.
+   // note we can't handle the last pixel in a row in this loop
+   // because we need to handle the filter boundary conditions.
+   for (; i < ((w-1) & ~7); i += 8) {
+#if defined(STBI_SSE2)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      __m128i zero  = _mm_setzero_si128();
+      __m128i farb  = _mm_loadl_epi64((__m128i *) (in_far + i));
+      __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));
+      __m128i farw  = _mm_unpacklo_epi8(farb, zero);
+      __m128i nearw = _mm_unpacklo_epi8(nearb, zero);
+      __m128i diff  = _mm_sub_epi16(farw, nearw);
+      __m128i nears = _mm_slli_epi16(nearw, 2);
+      __m128i curr  = _mm_add_epi16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      __m128i prv0 = _mm_slli_si128(curr, 2);
+      __m128i nxt0 = _mm_srli_si128(curr, 2);
+      __m128i prev = _mm_insert_epi16(prv0, t1, 0);
+      __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      __m128i bias  = _mm_set1_epi16(8);
+      __m128i curs = _mm_slli_epi16(curr, 2);
+      __m128i prvd = _mm_sub_epi16(prev, curr);
+      __m128i nxtd = _mm_sub_epi16(next, curr);
+      __m128i curb = _mm_add_epi16(curs, bias);
+      __m128i even = _mm_add_epi16(prvd, curb);
+      __m128i odd  = _mm_add_epi16(nxtd, curb);
+
+      // interleave even and odd pixels, then undo scaling.
+      __m128i int0 = _mm_unpacklo_epi16(even, odd);
+      __m128i int1 = _mm_unpackhi_epi16(even, odd);
+      __m128i de0  = _mm_srli_epi16(int0, 4);
+      __m128i de1  = _mm_srli_epi16(int1, 4);
+
+      // pack and write output
+      __m128i outv = _mm_packus_epi16(de0, de1);
+      _mm_storeu_si128((__m128i *) (out + i*2), outv);
+#elif defined(STBI_NEON)
+      // load and perform the vertical filtering pass
+      // this uses 3*x + y = 4*x + (y - x)
+      uint8x8_t farb  = vld1_u8(in_far + i);
+      uint8x8_t nearb = vld1_u8(in_near + i);
+      int16x8_t diff  = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));
+      int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));
+      int16x8_t curr  = vaddq_s16(nears, diff); // current row
+
+      // horizontal filter works the same based on shifted vers of current
+      // row. "prev" is current row shifted right by 1 pixel; we need to
+      // insert the previous pixel value (from t1).
+      // "next" is current row shifted left by 1 pixel, with first pixel
+      // of next block of 8 pixels added in.
+      int16x8_t prv0 = vextq_s16(curr, curr, 7);
+      int16x8_t nxt0 = vextq_s16(curr, curr, 1);
+      int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);
+      int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);
+
+      // horizontal filter, polyphase implementation since it's convenient:
+      // even pixels = 3*cur + prev = cur*4 + (prev - cur)
+      // odd  pixels = 3*cur + next = cur*4 + (next - cur)
+      // note the shared term.
+      int16x8_t curs = vshlq_n_s16(curr, 2);
+      int16x8_t prvd = vsubq_s16(prev, curr);
+      int16x8_t nxtd = vsubq_s16(next, curr);
+      int16x8_t even = vaddq_s16(curs, prvd);
+      int16x8_t odd  = vaddq_s16(curs, nxtd);
+
+      // undo scaling and round, then store with even/odd phases interleaved
+      uint8x8x2_t o;
+      o.val[0] = vqrshrun_n_s16(even, 4);
+      o.val[1] = vqrshrun_n_s16(odd,  4);
+      vst2_u8(out + i*2, o);
+#endif
+
+      // "previous" value for next iter
+      t1 = 3*in_near[i+7] + in_far[i+7];
+   }
+
+   t0 = t1;
+   t1 = 3*in_near[i] + in_far[i];
+   out[i*2] = stbi__div16(3*t1 + t0 + 8);
+
+   for (++i; i < w; ++i) {
+      t0 = t1;
+      t1 = 3*in_near[i]+in_far[i];
+      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
+      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
+   }
+   out[w*2-1] = stbi__div4(t1+2);
+
+   STBI_NOTUSED(hs);
+
+   return out;
+}
+#endif
+
+static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
+{
+   // resample with nearest-neighbor
+   int i,j;
+   STBI_NOTUSED(in_far);
+   for (i=0; i < w; ++i)
+      for (j=0; j < hs; ++j)
+         out[i*hs+j] = in_near[i];
+   return out;
+}
+
+// this is a reduced-precision calculation of YCbCr-to-RGB introduced
+// to make sure the code produces the same results in both SIMD and scalar
+#define stbi__float2fixed(x)  (((int) ((x) * 4096.0f + 0.5f)) << 8)
+static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
+{
+   int i;
+   for (i=0; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed +  cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                     +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+
+#if defined(STBI_SSE2) || defined(STBI_NEON)
+static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
+{
+   int i = 0;
+
+#ifdef STBI_SSE2
+   // step == 3 is pretty ugly on the final interleave, and i'm not convinced
+   // it's useful in practice (you wouldn't use it for textures, for example).
+   // so just accelerate step == 4 case.
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      __m128i signflip  = _mm_set1_epi8(-0x80);
+      __m128i cr_const0 = _mm_set1_epi16(   (short) ( 1.40200f*4096.0f+0.5f));
+      __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));
+      __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));
+      __m128i cb_const1 = _mm_set1_epi16(   (short) ( 1.77200f*4096.0f+0.5f));
+      __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);
+      __m128i xw = _mm_set1_epi16(255); // alpha channel
+
+      for (; i+7 < count; i += 8) {
+         // load
+         __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));
+         __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));
+         __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));
+         __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128
+         __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128
+
+         // unpack to short (and left-shift cr, cb by 8)
+         __m128i yw  = _mm_unpacklo_epi8(y_bias, y_bytes);
+         __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);
+         __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);
+
+         // color transform
+         __m128i yws = _mm_srli_epi16(yw, 4);
+         __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);
+         __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);
+         __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);
+         __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);
+         __m128i rws = _mm_add_epi16(cr0, yws);
+         __m128i gwt = _mm_add_epi16(cb0, yws);
+         __m128i bws = _mm_add_epi16(yws, cb1);
+         __m128i gws = _mm_add_epi16(gwt, cr1);
+
+         // descale
+         __m128i rw = _mm_srai_epi16(rws, 4);
+         __m128i bw = _mm_srai_epi16(bws, 4);
+         __m128i gw = _mm_srai_epi16(gws, 4);
+
+         // back to byte, set up for transpose
+         __m128i brb = _mm_packus_epi16(rw, bw);
+         __m128i gxb = _mm_packus_epi16(gw, xw);
+
+         // transpose to interleave channels
+         __m128i t0 = _mm_unpacklo_epi8(brb, gxb);
+         __m128i t1 = _mm_unpackhi_epi8(brb, gxb);
+         __m128i o0 = _mm_unpacklo_epi16(t0, t1);
+         __m128i o1 = _mm_unpackhi_epi16(t0, t1);
+
+         // store
+         _mm_storeu_si128((__m128i *) (out + 0), o0);
+         _mm_storeu_si128((__m128i *) (out + 16), o1);
+         out += 32;
+      }
+   }
+#endif
+
+#ifdef STBI_NEON
+   // in this version, step=3 support would be easy to add. but is there demand?
+   if (step == 4) {
+      // this is a fairly straightforward implementation and not super-optimized.
+      uint8x8_t signflip = vdup_n_u8(0x80);
+      int16x8_t cr_const0 = vdupq_n_s16(   (short) ( 1.40200f*4096.0f+0.5f));
+      int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));
+      int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));
+      int16x8_t cb_const1 = vdupq_n_s16(   (short) ( 1.77200f*4096.0f+0.5f));
+
+      for (; i+7 < count; i += 8) {
+         // load
+         uint8x8_t y_bytes  = vld1_u8(y + i);
+         uint8x8_t cr_bytes = vld1_u8(pcr + i);
+         uint8x8_t cb_bytes = vld1_u8(pcb + i);
+         int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));
+         int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));
+
+         // expand to s16
+         int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));
+         int16x8_t crw = vshll_n_s8(cr_biased, 7);
+         int16x8_t cbw = vshll_n_s8(cb_biased, 7);
+
+         // color transform
+         int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);
+         int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);
+         int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);
+         int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);
+         int16x8_t rws = vaddq_s16(yws, cr0);
+         int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);
+         int16x8_t bws = vaddq_s16(yws, cb1);
+
+         // undo scaling, round, convert to byte
+         uint8x8x4_t o;
+         o.val[0] = vqrshrun_n_s16(rws, 4);
+         o.val[1] = vqrshrun_n_s16(gws, 4);
+         o.val[2] = vqrshrun_n_s16(bws, 4);
+         o.val[3] = vdup_n_u8(255);
+
+         // store, interleaving r/g/b/a
+         vst4_u8(out, o);
+         out += 8*4;
+      }
+   }
+#endif
+
+   for (; i < count; ++i) {
+      int y_fixed = (y[i] << 20) + (1<<19); // rounding
+      int r,g,b;
+      int cr = pcr[i] - 128;
+      int cb = pcb[i] - 128;
+      r = y_fixed + cr* stbi__float2fixed(1.40200f);
+      g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);
+      b = y_fixed                                   +   cb* stbi__float2fixed(1.77200f);
+      r >>= 20;
+      g >>= 20;
+      b >>= 20;
+      if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }
+      if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }
+      if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }
+      out[0] = (stbi_uc)r;
+      out[1] = (stbi_uc)g;
+      out[2] = (stbi_uc)b;
+      out[3] = 255;
+      out += step;
+   }
+}
+#endif
+
+// set up the kernels
+static void stbi__setup_jpeg(stbi__jpeg *j)
+{
+   j->idct_block_kernel = stbi__idct_block;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+
+#ifdef STBI_SSE2
+   if (stbi__sse2_available()) {
+      j->idct_block_kernel = stbi__idct_simd;
+      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+   }
+#endif
+
+#ifdef STBI_NEON
+   j->idct_block_kernel = stbi__idct_simd;
+   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
+   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
+#endif
+}
+
+// clean up the temporary component buffers
+static void stbi__cleanup_jpeg(stbi__jpeg *j)
+{
+   stbi__free_jpeg_components(j, j->s->img_n, 0);
+}
+
+typedef struct
+{
+   resample_row_func resample;
+   stbi_uc *line0,*line1;
+   int hs,vs;   // expansion factor in each axis
+   int w_lores; // horizontal pixels pre-expansion
+   int ystep;   // how far through vertical expansion we are
+   int ypos;    // which pre-expansion row we're on
+} stbi__resample;
+
+// fast 0..255 * 0..255 => 0..255 rounded multiplication
+static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)
+{
+   unsigned int t = x*y + 128;
+   return (stbi_uc) ((t + (t >>8)) >> 8);
+}
+
+static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)
+{
+   int n, decode_n, is_rgb;
+   z->s->img_n = 0; // make stbi__cleanup_jpeg safe
+
+   // validate req_comp
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+
+   // load a jpeg image from whichever source, but leave in YCbCr format
+   if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // determine actual number of components to generate
+   n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;
+
+   is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));
+
+   if (z->s->img_n == 3 && n < 3 && !is_rgb)
+      decode_n = 1;
+   else
+      decode_n = z->s->img_n;
+
+   // nothing to do if no components requested; check this now to avoid
+   // accessing uninitialized coutput[0] later
+   if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }
+
+   // resample and color-convert
+   {
+      int k;
+      unsigned int i,j;
+      stbi_uc *output;
+      stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };
+
+      stbi__resample res_comp[4];
+
+      for (k=0; k < decode_n; ++k) {
+         stbi__resample *r = &res_comp[k];
+
+         // allocate line buffer big enough for upsampling off the edges
+         // with upsample factor of 4
+         z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);
+         if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+         r->hs      = z->img_h_max / z->img_comp[k].h;
+         r->vs      = z->img_v_max / z->img_comp[k].v;
+         r->ystep   = r->vs >> 1;
+         r->w_lores = (z->s->img_x + r->hs-1) / r->hs;
+         r->ypos    = 0;
+         r->line0   = r->line1 = z->img_comp[k].data;
+
+         if      (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;
+         else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;
+         else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;
+         else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;
+         else                               r->resample = stbi__resample_row_generic;
+      }
+
+      // can't error after this so, this is safe
+      output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);
+      if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); }
+
+      // now go ahead and resample
+      for (j=0; j < z->s->img_y; ++j) {
+         stbi_uc *out = output + n * z->s->img_x * j;
+         for (k=0; k < decode_n; ++k) {
+            stbi__resample *r = &res_comp[k];
+            int y_bot = r->ystep >= (r->vs >> 1);
+            coutput[k] = r->resample(z->img_comp[k].linebuf,
+                                     y_bot ? r->line1 : r->line0,
+                                     y_bot ? r->line0 : r->line1,
+                                     r->w_lores, r->hs);
+            if (++r->ystep >= r->vs) {
+               r->ystep = 0;
+               r->line0 = r->line1;
+               if (++r->ypos < z->img_comp[k].y)
+                  r->line1 += z->img_comp[k].w2;
+            }
+         }
+         if (n >= 3) {
+            stbi_uc *y = coutput[0];
+            if (z->s->img_n == 3) {
+               if (is_rgb) {
+                  for (i=0; i < z->s->img_x; ++i) {
+                     out[0] = y[i];
+                     out[1] = coutput[1][i];
+                     out[2] = coutput[2][i];
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else {
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else if (z->s->img_n == 4) {
+               if (z->app14_color_transform == 0) { // CMYK
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(coutput[0][i], m);
+                     out[1] = stbi__blinn_8x8(coutput[1][i], m);
+                     out[2] = stbi__blinn_8x8(coutput[2][i], m);
+                     out[3] = 255;
+                     out += n;
+                  }
+               } else if (z->app14_color_transform == 2) { // YCCK
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+                  for (i=0; i < z->s->img_x; ++i) {
+                     stbi_uc m = coutput[3][i];
+                     out[0] = stbi__blinn_8x8(255 - out[0], m);
+                     out[1] = stbi__blinn_8x8(255 - out[1], m);
+                     out[2] = stbi__blinn_8x8(255 - out[2], m);
+                     out += n;
+                  }
+               } else { // YCbCr + alpha?  Ignore the fourth channel for now
+                  z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);
+               }
+            } else
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = out[1] = out[2] = y[i];
+                  out[3] = 255; // not used if n==3
+                  out += n;
+               }
+         } else {
+            if (is_rgb) {
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i)
+                     *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+               else {
+                  for (i=0; i < z->s->img_x; ++i, out += 2) {
+                     out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);
+                     out[1] = 255;
+                  }
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  stbi_uc m = coutput[3][i];
+                  stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);
+                  stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);
+                  stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);
+                  out[0] = stbi__compute_y(r, g, b);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {
+               for (i=0; i < z->s->img_x; ++i) {
+                  out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);
+                  out[1] = 255;
+                  out += n;
+               }
+            } else {
+               stbi_uc *y = coutput[0];
+               if (n == 1)
+                  for (i=0; i < z->s->img_x; ++i) out[i] = y[i];
+               else
+                  for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }
+            }
+         }
+      }
+      stbi__cleanup_jpeg(z);
+      *out_x = z->s->img_x;
+      *out_y = z->s->img_y;
+      if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output
+      return output;
+   }
+}
+
+static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   unsigned char* result;
+   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
+   if (!j) return stbi__errpuc("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   STBI_NOTUSED(ri);
+   j->s = s;
+   stbi__setup_jpeg(j);
+   result = load_jpeg_image(j, x,y,comp,req_comp);
+   STBI_FREE(j);
+   return result;
+}
+
+static int stbi__jpeg_test(stbi__context *s)
+{
+   int r;
+   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
+   if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   j->s = s;
+   stbi__setup_jpeg(j);
+   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
+   stbi__rewind(s);
+   STBI_FREE(j);
+   return r;
+}
+
+static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
+{
+   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
+      stbi__rewind( j->s );
+      return 0;
+   }
+   if (x) *x = j->s->img_x;
+   if (y) *y = j->s->img_y;
+   if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;
+   return 1;
+}
+
+static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int result;
+   stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));
+   if (!j) return stbi__err("outofmem", "Out of memory");
+   memset(j, 0, sizeof(stbi__jpeg));
+   j->s = s;
+   result = stbi__jpeg_info_raw(j, x, y, comp);
+   STBI_FREE(j);
+   return result;
+}
+#endif
+
+// public domain zlib decode    v0.2  Sean Barrett 2006-11-18
+//    simple implementation
+//      - all input must be provided in an upfront buffer
+//      - all output is written to a single output buffer (can malloc/realloc)
+//    performance
+//      - fast huffman
+
+#ifndef STBI_NO_ZLIB
+
+// fast-way is faster to check than jpeg huffman, but slow way is slower
+#define STBI__ZFAST_BITS  9 // accelerate all cases in default tables
+#define STBI__ZFAST_MASK  ((1 << STBI__ZFAST_BITS) - 1)
+#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet
+
+// zlib-style huffman encoding
+// (jpegs packs from left, zlib from right, so can't share code)
+typedef struct
+{
+   stbi__uint16 fast[1 << STBI__ZFAST_BITS];
+   stbi__uint16 firstcode[16];
+   int maxcode[17];
+   stbi__uint16 firstsymbol[16];
+   stbi_uc  size[STBI__ZNSYMS];
+   stbi__uint16 value[STBI__ZNSYMS];
+} stbi__zhuffman;
+
+stbi_inline static int stbi__bitreverse16(int n)
+{
+  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
+  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
+  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
+  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
+  return n;
+}
+
+stbi_inline static int stbi__bit_reverse(int v, int bits)
+{
+   STBI_ASSERT(bits <= 16);
+   // to bit reverse n bits, reverse 16 and shift
+   // e.g. 11 bits, bit reverse and shift away 5
+   return stbi__bitreverse16(v) >> (16-bits);
+}
+
+static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
+{
+   int i,k=0;
+   int code, next_code[16], sizes[17];
+
+   // DEFLATE spec for generating codes
+   memset(sizes, 0, sizeof(sizes));
+   memset(z->fast, 0, sizeof(z->fast));
+   for (i=0; i < num; ++i)
+      ++sizes[sizelist[i]];
+   sizes[0] = 0;
+   for (i=1; i < 16; ++i)
+      if (sizes[i] > (1 << i))
+         return stbi__err("bad sizes", "Corrupt PNG");
+   code = 0;
+   for (i=1; i < 16; ++i) {
+      next_code[i] = code;
+      z->firstcode[i] = (stbi__uint16) code;
+      z->firstsymbol[i] = (stbi__uint16) k;
+      code = (code + sizes[i]);
+      if (sizes[i])
+         if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG");
+      z->maxcode[i] = code << (16-i); // preshift for inner loop
+      code <<= 1;
+      k += sizes[i];
+   }
+   z->maxcode[16] = 0x10000; // sentinel
+   for (i=0; i < num; ++i) {
+      int s = sizelist[i];
+      if (s) {
+         int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
+         stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);
+         z->size [c] = (stbi_uc     ) s;
+         z->value[c] = (stbi__uint16) i;
+         if (s <= STBI__ZFAST_BITS) {
+            int j = stbi__bit_reverse(next_code[s],s);
+            while (j < (1 << STBI__ZFAST_BITS)) {
+               z->fast[j] = fastv;
+               j += (1 << s);
+            }
+         }
+         ++next_code[s];
+      }
+   }
+   return 1;
+}
+
+// zlib-from-memory implementation for PNG reading
+//    because PNG allows splitting the zlib stream arbitrarily,
+//    and it's annoying structurally to have PNG call ZLIB call PNG,
+//    we require PNG read all the IDATs and combine them into a single
+//    memory buffer
+
+typedef struct
+{
+   stbi_uc *zbuffer, *zbuffer_end;
+   int num_bits;
+   int hit_zeof_once;
+   stbi__uint32 code_buffer;
+
+   char *zout;
+   char *zout_start;
+   char *zout_end;
+   int   z_expandable;
+
+   stbi__zhuffman z_length, z_distance;
+} stbi__zbuf;
+
+stbi_inline static int stbi__zeof(stbi__zbuf *z)
+{
+   return (z->zbuffer >= z->zbuffer_end);
+}
+
+stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)
+{
+   return stbi__zeof(z) ? 0 : *z->zbuffer++;
+}
+
+static void stbi__fill_bits(stbi__zbuf *z)
+{
+   do {
+      if (z->code_buffer >= (1U << z->num_bits)) {
+        z->zbuffer = z->zbuffer_end;  /* treat this as EOF so we fail. */
+        return;
+      }
+      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
+      z->num_bits += 8;
+   } while (z->num_bits <= 24);
+}
+
+stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
+{
+   unsigned int k;
+   if (z->num_bits < n) stbi__fill_bits(z);
+   k = z->code_buffer & ((1 << n) - 1);
+   z->code_buffer >>= n;
+   z->num_bits -= n;
+   return k;
+}
+
+static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s,k;
+   // not resolved by fast table, so compute it the slow way
+   // use jpeg approach, which requires MSbits at top
+   k = stbi__bit_reverse(a->code_buffer, 16);
+   for (s=STBI__ZFAST_BITS+1; ; ++s)
+      if (k < z->maxcode[s])
+         break;
+   if (s >= 16) return -1; // invalid code!
+   // code size is s, so:
+   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
+   if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!
+   if (z->size[b] != s) return -1;  // was originally an assert, but report failure instead.
+   a->code_buffer >>= s;
+   a->num_bits -= s;
+   return z->value[b];
+}
+
+stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
+{
+   int b,s;
+   if (a->num_bits < 16) {
+      if (stbi__zeof(a)) {
+         if (!a->hit_zeof_once) {
+            // This is the first time we hit eof, insert 16 extra padding btis
+            // to allow us to keep going; if we actually consume any of them
+            // though, that is invalid data. This is caught later.
+            a->hit_zeof_once = 1;
+            a->num_bits += 16; // add 16 implicit zero bits
+         } else {
+            // We already inserted our extra 16 padding bits and are again
+            // out, this stream is actually prematurely terminated.
+            return -1;
+         }
+      } else {
+         stbi__fill_bits(a);
+      }
+   }
+   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
+   if (b) {
+      s = b >> 9;
+      a->code_buffer >>= s;
+      a->num_bits -= s;
+      return b & 511;
+   }
+   return stbi__zhuffman_decode_slowpath(a, z);
+}
+
+static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
+{
+   char *q;
+   unsigned int cur, limit, old_limit;
+   z->zout = zout;
+   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
+   cur   = (unsigned int) (z->zout - z->zout_start);
+   limit = old_limit = (unsigned) (z->zout_end - z->zout_start);
+   if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory");
+   while (cur + n > limit) {
+      if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory");
+      limit *= 2;
+   }
+   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
+   STBI_NOTUSED(old_limit);
+   if (q == NULL) return stbi__err("outofmem", "Out of memory");
+   z->zout_start = q;
+   z->zout       = q + cur;
+   z->zout_end   = q + limit;
+   return 1;
+}
+
+static const int stbi__zlength_base[31] = {
+   3,4,5,6,7,8,9,10,11,13,
+   15,17,19,23,27,31,35,43,51,59,
+   67,83,99,115,131,163,195,227,258,0,0 };
+
+static const int stbi__zlength_extra[31]=
+{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
+
+static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
+257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
+
+static const int stbi__zdist_extra[32] =
+{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+static int stbi__parse_huffman_block(stbi__zbuf *a)
+{
+   char *zout = a->zout;
+   for(;;) {
+      int z = stbi__zhuffman_decode(a, &a->z_length);
+      if (z < 256) {
+         if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes
+         if (zout >= a->zout_end) {
+            if (!stbi__zexpand(a, zout, 1)) return 0;
+            zout = a->zout;
+         }
+         *zout++ = (char) z;
+      } else {
+         stbi_uc *p;
+         int len,dist;
+         if (z == 256) {
+            a->zout = zout;
+            if (a->hit_zeof_once && a->num_bits < 16) {
+               // The first time we hit zeof, we inserted 16 extra zero bits into our bit
+               // buffer so the decoder can just do its speculative decoding. But if we
+               // actually consumed any of those bits (which is the case when num_bits < 16),
+               // the stream actually read past the end so it is malformed.
+               return stbi__err("unexpected end","Corrupt PNG");
+            }
+            return 1;
+         }
+         if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data
+         z -= 257;
+         len = stbi__zlength_base[z];
+         if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);
+         z = stbi__zhuffman_decode(a, &a->z_distance);
+         if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data
+         dist = stbi__zdist_base[z];
+         if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);
+         if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG");
+         if (len > a->zout_end - zout) {
+            if (!stbi__zexpand(a, zout, len)) return 0;
+            zout = a->zout;
+         }
+         p = (stbi_uc *) (zout - dist);
+         if (dist == 1) { // run of one byte; common in images.
+            stbi_uc v = *p;
+            if (len) { do *zout++ = v; while (--len); }
+         } else {
+            if (len) { do *zout++ = *p++; while (--len); }
+         }
+      }
+   }
+}
+
+static int stbi__compute_huffman_codes(stbi__zbuf *a)
+{
+   static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
+   stbi__zhuffman z_codelength;
+   stbi_uc lencodes[286+32+137];//padding for maximum single op
+   stbi_uc codelength_sizes[19];
+   int i,n;
+
+   int hlit  = stbi__zreceive(a,5) + 257;
+   int hdist = stbi__zreceive(a,5) + 1;
+   int hclen = stbi__zreceive(a,4) + 4;
+   int ntot  = hlit + hdist;
+
+   memset(codelength_sizes, 0, sizeof(codelength_sizes));
+   for (i=0; i < hclen; ++i) {
+      int s = stbi__zreceive(a,3);
+      codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;
+   }
+   if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
+
+   n = 0;
+   while (n < ntot) {
+      int c = stbi__zhuffman_decode(a, &z_codelength);
+      if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG");
+      if (c < 16)
+         lencodes[n++] = (stbi_uc) c;
+      else {
+         stbi_uc fill = 0;
+         if (c == 16) {
+            c = stbi__zreceive(a,2)+3;
+            if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG");
+            fill = lencodes[n-1];
+         } else if (c == 17) {
+            c = stbi__zreceive(a,3)+3;
+         } else if (c == 18) {
+            c = stbi__zreceive(a,7)+11;
+         } else {
+            return stbi__err("bad codelengths", "Corrupt PNG");
+         }
+         if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG");
+         memset(lencodes+n, fill, c);
+         n += c;
+      }
+   }
+   if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG");
+   if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
+   if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
+   return 1;
+}
+
+static int stbi__parse_uncompressed_block(stbi__zbuf *a)
+{
+   stbi_uc header[4];
+   int len,nlen,k;
+   if (a->num_bits & 7)
+      stbi__zreceive(a, a->num_bits & 7); // discard
+   // drain the bit-packed data into header
+   k = 0;
+   while (a->num_bits > 0) {
+      header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check
+      a->code_buffer >>= 8;
+      a->num_bits -= 8;
+   }
+   if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG");
+   // now fill header the normal way
+   while (k < 4)
+      header[k++] = stbi__zget8(a);
+   len  = header[1] * 256 + header[0];
+   nlen = header[3] * 256 + header[2];
+   if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG");
+   if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG");
+   if (a->zout + len > a->zout_end)
+      if (!stbi__zexpand(a, a->zout, len)) return 0;
+   memcpy(a->zout, a->zbuffer, len);
+   a->zbuffer += len;
+   a->zout += len;
+   return 1;
+}
+
+static int stbi__parse_zlib_header(stbi__zbuf *a)
+{
+   int cmf   = stbi__zget8(a);
+   int cm    = cmf & 15;
+   /* int cinfo = cmf >> 4; */
+   int flg   = stbi__zget8(a);
+   if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
+   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
+   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
+   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
+   return 1;
+}
+
+static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =
+{
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
+   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8
+};
+static const stbi_uc stbi__zdefault_distance[32] =
+{
+   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
+};
+/*
+Init algorithm:
+{
+   int i;   // use <= to match clearly with spec
+   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
+   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
+   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
+   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;
+
+   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
+}
+*/
+
+static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
+{
+   int final, type;
+   if (parse_header)
+      if (!stbi__parse_zlib_header(a)) return 0;
+   a->num_bits = 0;
+   a->code_buffer = 0;
+   a->hit_zeof_once = 0;
+   do {
+      final = stbi__zreceive(a,1);
+      type = stbi__zreceive(a,2);
+      if (type == 0) {
+         if (!stbi__parse_uncompressed_block(a)) return 0;
+      } else if (type == 3) {
+         return 0;
+      } else {
+         if (type == 1) {
+            // use fixed code lengths
+            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , STBI__ZNSYMS)) return 0;
+            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
+         } else {
+            if (!stbi__compute_huffman_codes(a)) return 0;
+         }
+         if (!stbi__parse_huffman_block(a)) return 0;
+      }
+   } while (!final);
+   return 1;
+}
+
+static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
+{
+   a->zout_start = obuf;
+   a->zout       = obuf;
+   a->zout_end   = obuf + olen;
+   a->z_expandable = exp;
+
+   return stbi__parse_zlib(a, parse_header);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)
+{
+   return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);
+}
+
+STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(initial_size);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer + len;
+   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+
+STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
+{
+   stbi__zbuf a;
+   char *p = (char *) stbi__malloc(16384);
+   if (p == NULL) return NULL;
+   a.zbuffer = (stbi_uc *) buffer;
+   a.zbuffer_end = (stbi_uc *) buffer+len;
+   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
+      if (outlen) *outlen = (int) (a.zout - a.zout_start);
+      return a.zout_start;
+   } else {
+      STBI_FREE(a.zout_start);
+      return NULL;
+   }
+}
+
+STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
+{
+   stbi__zbuf a;
+   a.zbuffer = (stbi_uc *) ibuffer;
+   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
+   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
+      return (int) (a.zout - a.zout_start);
+   else
+      return -1;
+}
+#endif
+
+// public domain "baseline" PNG decoder   v0.10  Sean Barrett 2006-11-18
+//    simple implementation
+//      - only 8-bit samples
+//      - no CRC checking
+//      - allocates lots of intermediate memory
+//        - avoids problem of streaming data between subsystems
+//        - avoids explicit window management
+//    performance
+//      - uses stb_zlib, a PD zlib implementation with fast huffman decoding
+
+#ifndef STBI_NO_PNG
+typedef struct
+{
+   stbi__uint32 length;
+   stbi__uint32 type;
+} stbi__pngchunk;
+
+static stbi__pngchunk stbi__get_chunk_header(stbi__context *s)
+{
+   stbi__pngchunk c;
+   c.length = stbi__get32be(s);
+   c.type   = stbi__get32be(s);
+   return c;
+}
+
+static int stbi__check_png_header(stbi__context *s)
+{
+   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
+   int i;
+   for (i=0; i < 8; ++i)
+      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
+   return 1;
+}
+
+typedef struct
+{
+   stbi__context *s;
+   stbi_uc *idata, *expanded, *out;
+   int depth;
+} stbi__png;
+
+
+enum {
+   STBI__F_none=0,
+   STBI__F_sub=1,
+   STBI__F_up=2,
+   STBI__F_avg=3,
+   STBI__F_paeth=4,
+   // synthetic filter used for first scanline to avoid needing a dummy row of 0s
+   STBI__F_avg_first
+};
+
+static stbi_uc first_row_filter[5] =
+{
+   STBI__F_none,
+   STBI__F_sub,
+   STBI__F_none,
+   STBI__F_avg_first,
+   STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub
+};
+
+static int stbi__paeth(int a, int b, int c)
+{
+   // This formulation looks very different from the reference in the PNG spec, but is
+   // actually equivalent and has favorable data dependencies and admits straightforward
+   // generation of branch-free code, which helps performance significantly.
+   int thresh = c*3 - (a + b);
+   int lo = a < b ? a : b;
+   int hi = a < b ? b : a;
+   int t0 = (hi <= thresh) ? lo : c;
+   int t1 = (thresh <= lo) ? hi : t0;
+   return t1;
+}
+
+static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
+
+// adds an extra all-255 alpha channel
+// dest == src is legal
+// img_n must be 1 or 3
+static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)
+{
+   int i;
+   // must process data backwards since we allow dest==src
+   if (img_n == 1) {
+      for (i=x-1; i >= 0; --i) {
+         dest[i*2+1] = 255;
+         dest[i*2+0] = src[i];
+      }
+   } else {
+      STBI_ASSERT(img_n == 3);
+      for (i=x-1; i >= 0; --i) {
+         dest[i*4+3] = 255;
+         dest[i*4+2] = src[i*3+2];
+         dest[i*4+1] = src[i*3+1];
+         dest[i*4+0] = src[i*3+0];
+      }
+   }
+}
+
+// create the png data from post-deflated data
+static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   stbi__context *s = a->s;
+   stbi__uint32 i,j,stride = x*out_n*bytes;
+   stbi__uint32 img_len, img_width_bytes;
+   stbi_uc *filter_buf;
+   int all_ok = 1;
+   int k;
+   int img_n = s->img_n; // copy it into a local for later
+
+   int output_bytes = out_n*bytes;
+   int filter_bytes = img_n*bytes;
+   int width = x;
+
+   STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
+   a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into
+   if (!a->out) return stbi__err("outofmem", "Out of memory");
+
+   // note: error exits here don't need to clean up a->out individually,
+   // stbi__do_png always does on error.
+   if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG");
+   img_width_bytes = (((img_n * x * depth) + 7) >> 3);
+   if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG");
+   img_len = (img_width_bytes + 1) * y;
+
+   // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,
+   // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),
+   // so just check for raw_len < img_len always.
+   if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG");
+
+   // Allocate two scan lines worth of filter workspace buffer.
+   filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);
+   if (!filter_buf) return stbi__err("outofmem", "Out of memory");
+
+   // Filtering for low-bit-depth images
+   if (depth < 8) {
+      filter_bytes = 1;
+      width = img_width_bytes;
+   }
+
+   for (j=0; j < y; ++j) {
+      // cur/prior filter buffers alternate
+      stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;
+      stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;
+      stbi_uc *dest = a->out + stride*j;
+      int nk = width * filter_bytes;
+      int filter = *raw++;
+
+      // check filter type
+      if (filter > 4) {
+         all_ok = stbi__err("invalid filter","Corrupt PNG");
+         break;
+      }
+
+      // if first row, use special filter that doesn't sample previous row
+      if (j == 0) filter = first_row_filter[filter];
+
+      // perform actual filtering
+      switch (filter) {
+      case STBI__F_none:
+         memcpy(cur, raw, nk);
+         break;
+      case STBI__F_sub:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);
+         break;
+      case STBI__F_up:
+         for (k = 0; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]);
+         break;
+      case STBI__F_avg:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));
+         break;
+      case STBI__F_paeth:
+         for (k = 0; k < filter_bytes; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));
+         break;
+      case STBI__F_avg_first:
+         memcpy(cur, raw, filter_bytes);
+         for (k = filter_bytes; k < nk; ++k)
+            cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));
+         break;
+      }
+
+      raw += nk;
+
+      // expand decoded bits in cur to dest, also adding an extra alpha channel if desired
+      if (depth < 8) {
+         stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range
+         stbi_uc *in = cur;
+         stbi_uc *out = dest;
+         stbi_uc inb = 0;
+         stbi__uint32 nsmp = x*img_n;
+
+         // expand bits to bytes first
+         if (depth == 4) {
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 1) == 0) inb = *in++;
+               *out++ = scale * (inb >> 4);
+               inb <<= 4;
+            }
+         } else if (depth == 2) {
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 3) == 0) inb = *in++;
+               *out++ = scale * (inb >> 6);
+               inb <<= 2;
+            }
+         } else {
+            STBI_ASSERT(depth == 1);
+            for (i=0; i < nsmp; ++i) {
+               if ((i & 7) == 0) inb = *in++;
+               *out++ = scale * (inb >> 7);
+               inb <<= 1;
+            }
+         }
+
+         // insert alpha=255 values if desired
+         if (img_n != out_n)
+            stbi__create_png_alpha_expand8(dest, dest, x, img_n);
+      } else if (depth == 8) {
+         if (img_n == out_n)
+            memcpy(dest, cur, x*img_n);
+         else
+            stbi__create_png_alpha_expand8(dest, cur, x, img_n);
+      } else if (depth == 16) {
+         // convert the image data from big-endian to platform-native
+         stbi__uint16 *dest16 = (stbi__uint16*)dest;
+         stbi__uint32 nsmp = x*img_n;
+
+         if (img_n == out_n) {
+            for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)
+               *dest16 = (cur[0] << 8) | cur[1];
+         } else {
+            STBI_ASSERT(img_n+1 == out_n);
+            if (img_n == 1) {
+               for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = 0xffff;
+               }
+            } else {
+               STBI_ASSERT(img_n == 3);
+               for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {
+                  dest16[0] = (cur[0] << 8) | cur[1];
+                  dest16[1] = (cur[2] << 8) | cur[3];
+                  dest16[2] = (cur[4] << 8) | cur[5];
+                  dest16[3] = 0xffff;
+               }
+            }
+         }
+      }
+   }
+
+   STBI_FREE(filter_buf);
+   if (!all_ok) return 0;
+
+   return 1;
+}
+
+static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
+{
+   int bytes = (depth == 16 ? 2 : 1);
+   int out_bytes = out_n * bytes;
+   stbi_uc *final;
+   int p;
+   if (!interlaced)
+      return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
+
+   // de-interlacing
+   final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
+   if (!final) return stbi__err("outofmem", "Out of memory");
+   for (p=0; p < 7; ++p) {
+      int xorig[] = { 0,4,0,2,0,1,0 };
+      int yorig[] = { 0,0,4,0,2,0,1 };
+      int xspc[]  = { 8,8,4,4,2,2,1 };
+      int yspc[]  = { 8,8,8,4,4,2,2 };
+      int i,j,x,y;
+      // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1
+      x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
+      y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
+      if (x && y) {
+         stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
+         if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
+            STBI_FREE(final);
+            return 0;
+         }
+         for (j=0; j < y; ++j) {
+            for (i=0; i < x; ++i) {
+               int out_y = j*yspc[p]+yorig[p];
+               int out_x = i*xspc[p]+xorig[p];
+               memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
+                      a->out + (j*x+i)*out_bytes, out_bytes);
+            }
+         }
+         STBI_FREE(a->out);
+         image_data += img_len;
+         image_data_len -= img_len;
+      }
+   }
+   a->out = final;
+
+   return 1;
+}
+
+static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 255 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i=0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 255);
+         p += 2;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi__uint16 *p = (stbi__uint16*) z->out;
+
+   // compute color-based transparency, assuming we've
+   // already got 65535 as the alpha value in the output
+   STBI_ASSERT(out_n == 2 || out_n == 4);
+
+   if (out_n == 2) {
+      for (i = 0; i < pixel_count; ++i) {
+         p[1] = (p[0] == tc[0] ? 0 : 65535);
+         p += 2;
+      }
+   } else {
+      for (i = 0; i < pixel_count; ++i) {
+         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
+            p[3] = 0;
+         p += 4;
+      }
+   }
+   return 1;
+}
+
+static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)
+{
+   stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
+   stbi_uc *p, *temp_out, *orig = a->out;
+
+   p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);
+   if (p == NULL) return stbi__err("outofmem", "Out of memory");
+
+   // between here and free(out) below, exitting would leak
+   temp_out = p;
+
+   if (pal_img_n == 3) {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p += 3;
+      }
+   } else {
+      for (i=0; i < pixel_count; ++i) {
+         int n = orig[i]*4;
+         p[0] = palette[n  ];
+         p[1] = palette[n+1];
+         p[2] = palette[n+2];
+         p[3] = palette[n+3];
+         p += 4;
+      }
+   }
+   STBI_FREE(a->out);
+   a->out = temp_out;
+
+   STBI_NOTUSED(len);
+
+   return 1;
+}
+
+static int stbi__unpremultiply_on_load_global = 0;
+static int stbi__de_iphone_flag_global = 0;
+
+STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag_global = flag_true_if_should_convert;
+}
+
+#ifndef STBI_THREAD_LOCAL
+#define stbi__unpremultiply_on_load  stbi__unpremultiply_on_load_global
+#define stbi__de_iphone_flag  stbi__de_iphone_flag_global
+#else
+static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;
+static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;
+
+STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
+{
+   stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
+   stbi__unpremultiply_on_load_set = 1;
+}
+
+STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
+{
+   stbi__de_iphone_flag_local = flag_true_if_should_convert;
+   stbi__de_iphone_flag_set = 1;
+}
+
+#define stbi__unpremultiply_on_load  (stbi__unpremultiply_on_load_set           \
+                                       ? stbi__unpremultiply_on_load_local      \
+                                       : stbi__unpremultiply_on_load_global)
+#define stbi__de_iphone_flag  (stbi__de_iphone_flag_set                         \
+                                ? stbi__de_iphone_flag_local                    \
+                                : stbi__de_iphone_flag_global)
+#endif // STBI_THREAD_LOCAL
+
+static void stbi__de_iphone(stbi__png *z)
+{
+   stbi__context *s = z->s;
+   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
+   stbi_uc *p = z->out;
+
+   if (s->img_out_n == 3) {  // convert bgr to rgb
+      for (i=0; i < pixel_count; ++i) {
+         stbi_uc t = p[0];
+         p[0] = p[2];
+         p[2] = t;
+         p += 3;
+      }
+   } else {
+      STBI_ASSERT(s->img_out_n == 4);
+      if (stbi__unpremultiply_on_load) {
+         // convert bgr to rgb and unpremultiply
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc a = p[3];
+            stbi_uc t = p[0];
+            if (a) {
+               stbi_uc half = a / 2;
+               p[0] = (p[2] * 255 + half) / a;
+               p[1] = (p[1] * 255 + half) / a;
+               p[2] = ( t   * 255 + half) / a;
+            } else {
+               p[0] = p[2];
+               p[2] = t;
+            }
+            p += 4;
+         }
+      } else {
+         // convert bgr to rgb
+         for (i=0; i < pixel_count; ++i) {
+            stbi_uc t = p[0];
+            p[0] = p[2];
+            p[2] = t;
+            p += 4;
+         }
+      }
+   }
+}
+
+#define STBI__PNG_TYPE(a,b,c,d)  (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
+
+static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)
+{
+   stbi_uc palette[1024], pal_img_n=0;
+   stbi_uc has_trans=0, tc[3]={0};
+   stbi__uint16 tc16[3];
+   stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
+   int first=1,k,interlace=0, color=0, is_iphone=0;
+   stbi__context *s = z->s;
+
+   z->expanded = NULL;
+   z->idata = NULL;
+   z->out = NULL;
+
+   if (!stbi__check_png_header(s)) return 0;
+
+   if (scan == STBI__SCAN_type) return 1;
+
+   for (;;) {
+      stbi__pngchunk c = stbi__get_chunk_header(s);
+      switch (c.type) {
+         case STBI__PNG_TYPE('C','g','B','I'):
+            is_iphone = 1;
+            stbi__skip(s, c.length);
+            break;
+         case STBI__PNG_TYPE('I','H','D','R'): {
+            int comp,filter;
+            if (!first) return stbi__err("multiple IHDR","Corrupt PNG");
+            first = 0;
+            if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG");
+            s->img_x = stbi__get32be(s);
+            s->img_y = stbi__get32be(s);
+            if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+            if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+            z->depth = stbi__get8(s);  if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16)  return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
+            color = stbi__get8(s);  if (color > 6)         return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3 && z->depth == 16)                  return stbi__err("bad ctype","Corrupt PNG");
+            if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG");
+            comp  = stbi__get8(s);  if (comp) return stbi__err("bad comp method","Corrupt PNG");
+            filter= stbi__get8(s);  if (filter) return stbi__err("bad filter method","Corrupt PNG");
+            interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG");
+            if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG");
+            if (!pal_img_n) {
+               s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
+               if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode");
+            } else {
+               // if paletted, then pal_n is our final components, and
+               // img_n is # components to decompress/filter.
+               s->img_n = 1;
+               if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG");
+            }
+            // even with SCAN_header, have to scan to see if we have a tRNS
+            break;
+         }
+
+         case STBI__PNG_TYPE('P','L','T','E'):  {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG");
+            pal_len = c.length / 3;
+            if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG");
+            for (i=0; i < pal_len; ++i) {
+               palette[i*4+0] = stbi__get8(s);
+               palette[i*4+1] = stbi__get8(s);
+               palette[i*4+2] = stbi__get8(s);
+               palette[i*4+3] = 255;
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('t','R','N','S'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG");
+            if (pal_img_n) {
+               if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
+               if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG");
+               if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG");
+               pal_img_n = 4;
+               for (i=0; i < c.length; ++i)
+                  palette[i*4+3] = stbi__get8(s);
+            } else {
+               if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG");
+               if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG");
+               has_trans = 1;
+               // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.
+               if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }
+               if (z->depth == 16) {
+                  for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning
+                     tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is
+               } else {
+                  for (k = 0; k < s->img_n && k < 3; ++k)
+                     tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger
+               }
+            }
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','D','A','T'): {
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG");
+            if (scan == STBI__SCAN_header) {
+               // header scan definitely stops at first IDAT
+               if (pal_img_n)
+                  s->img_n = pal_img_n;
+               return 1;
+            }
+            if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes");
+            if ((int)(ioff + c.length) < (int)ioff) return 0;
+            if (ioff + c.length > idata_limit) {
+               stbi__uint32 idata_limit_old = idata_limit;
+               stbi_uc *p;
+               if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
+               while (ioff + c.length > idata_limit)
+                  idata_limit *= 2;
+               STBI_NOTUSED(idata_limit_old);
+               p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory");
+               z->idata = p;
+            }
+            if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG");
+            ioff += c.length;
+            break;
+         }
+
+         case STBI__PNG_TYPE('I','E','N','D'): {
+            stbi__uint32 raw_len, bpl;
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if (scan != STBI__SCAN_load) return 1;
+            if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG");
+            // initial guess for decoded data size to avoid unnecessary reallocs
+            bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component
+            raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
+            z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);
+            if (z->expanded == NULL) return 0; // zlib should set error
+            STBI_FREE(z->idata); z->idata = NULL;
+            if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
+               s->img_out_n = s->img_n+1;
+            else
+               s->img_out_n = s->img_n;
+            if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
+            if (has_trans) {
+               if (z->depth == 16) {
+                  if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
+               } else {
+                  if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;
+               }
+            }
+            if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)
+               stbi__de_iphone(z);
+            if (pal_img_n) {
+               // pal_img_n == 3 or 4
+               s->img_n = pal_img_n; // record the actual colors we had
+               s->img_out_n = pal_img_n;
+               if (req_comp >= 3) s->img_out_n = req_comp;
+               if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
+                  return 0;
+            } else if (has_trans) {
+               // non-paletted image with tRNS -> source image has (constant) alpha
+               ++s->img_n;
+            }
+            STBI_FREE(z->expanded); z->expanded = NULL;
+            // end of PNG chunk, read and skip CRC
+            stbi__get32be(s);
+            return 1;
+         }
+
+         default:
+            // if critical, fail
+            if (first) return stbi__err("first not IHDR", "Corrupt PNG");
+            if ((c.type & (1 << 29)) == 0) {
+               #ifndef STBI_NO_FAILURE_STRINGS
+               // not threadsafe
+               static char invalid_chunk[] = "XXXX PNG chunk not known";
+               invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);
+               invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);
+               invalid_chunk[2] = STBI__BYTECAST(c.type >>  8);
+               invalid_chunk[3] = STBI__BYTECAST(c.type >>  0);
+               #endif
+               return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type");
+            }
+            stbi__skip(s, c.length);
+            break;
+      }
+      // end of PNG chunk, read and skip CRC
+      stbi__get32be(s);
+   }
+}
+
+static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)
+{
+   void *result=NULL;
+   if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error");
+   if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
+      if (p->depth <= 8)
+         ri->bits_per_channel = 8;
+      else if (p->depth == 16)
+         ri->bits_per_channel = 16;
+      else
+         return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth");
+      result = p->out;
+      p->out = NULL;
+      if (req_comp && req_comp != p->s->img_out_n) {
+         if (ri->bits_per_channel == 8)
+            result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         else
+            result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
+         p->s->img_out_n = req_comp;
+         if (result == NULL) return result;
+      }
+      *x = p->s->img_x;
+      *y = p->s->img_y;
+      if (n) *n = p->s->img_n;
+   }
+   STBI_FREE(p->out);      p->out      = NULL;
+   STBI_FREE(p->expanded); p->expanded = NULL;
+   STBI_FREE(p->idata);    p->idata    = NULL;
+
+   return result;
+}
+
+static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__do_png(&p, x,y,comp,req_comp, ri);
+}
+
+static int stbi__png_test(stbi__context *s)
+{
+   int r;
+   r = stbi__check_png_header(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
+{
+   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
+      stbi__rewind( p->s );
+      return 0;
+   }
+   if (x) *x = p->s->img_x;
+   if (y) *y = p->s->img_y;
+   if (comp) *comp = p->s->img_n;
+   return 1;
+}
+
+static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__png p;
+   p.s = s;
+   return stbi__png_info_raw(&p, x, y, comp);
+}
+
+static int stbi__png_is16(stbi__context *s)
+{
+   stbi__png p;
+   p.s = s;
+   if (!stbi__png_info_raw(&p, NULL, NULL, NULL))
+	   return 0;
+   if (p.depth != 16) {
+      stbi__rewind(p.s);
+      return 0;
+   }
+   return 1;
+}
+#endif
+
+// Microsoft/Windows BMP image
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_test_raw(stbi__context *s)
+{
+   int r;
+   int sz;
+   if (stbi__get8(s) != 'B') return 0;
+   if (stbi__get8(s) != 'M') return 0;
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   stbi__get32le(s); // discard data offset
+   sz = stbi__get32le(s);
+   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
+   return r;
+}
+
+static int stbi__bmp_test(stbi__context *s)
+{
+   int r = stbi__bmp_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+
+// returns 0..31 for the highest set bit
+static int stbi__high_bit(unsigned int z)
+{
+   int n=0;
+   if (z == 0) return -1;
+   if (z >= 0x10000) { n += 16; z >>= 16; }
+   if (z >= 0x00100) { n +=  8; z >>=  8; }
+   if (z >= 0x00010) { n +=  4; z >>=  4; }
+   if (z >= 0x00004) { n +=  2; z >>=  2; }
+   if (z >= 0x00002) { n +=  1;/* >>=  1;*/ }
+   return n;
+}
+
+static int stbi__bitcount(unsigned int a)
+{
+   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
+   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
+   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
+   a = (a + (a >> 8)); // max 16 per 8 bits
+   a = (a + (a >> 16)); // max 32 per 8 bits
+   return a & 0xff;
+}
+
+// extract an arbitrarily-aligned N-bit value (N=bits)
+// from v, and then make it 8-bits long and fractionally
+// extend it to full full range.
+static int stbi__shiftsigned(unsigned int v, int shift, int bits)
+{
+   static unsigned int mul_table[9] = {
+      0,
+      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
+      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
+   };
+   static unsigned int shift_table[9] = {
+      0, 0,0,1,0,2,4,6,0,
+   };
+   if (shift < 0)
+      v <<= -shift;
+   else
+      v >>= shift;
+   STBI_ASSERT(v < 256);
+   v >>= (8-bits);
+   STBI_ASSERT(bits >= 0 && bits <= 8);
+   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
+}
+
+typedef struct
+{
+   int bpp, offset, hsz;
+   unsigned int mr,mg,mb,ma, all_a;
+   int extra_read;
+} stbi__bmp_data;
+
+static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)
+{
+   // BI_BITFIELDS specifies masks explicitly, don't override
+   if (compress == 3)
+      return 1;
+
+   if (compress == 0) {
+      if (info->bpp == 16) {
+         info->mr = 31u << 10;
+         info->mg = 31u <<  5;
+         info->mb = 31u <<  0;
+      } else if (info->bpp == 32) {
+         info->mr = 0xffu << 16;
+         info->mg = 0xffu <<  8;
+         info->mb = 0xffu <<  0;
+         info->ma = 0xffu << 24;
+         info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0
+      } else {
+         // otherwise, use defaults, which is all-0
+         info->mr = info->mg = info->mb = info->ma = 0;
+      }
+      return 1;
+   }
+   return 0; // error
+}
+
+static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
+{
+   int hsz;
+   if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
+   stbi__get32le(s); // discard filesize
+   stbi__get16le(s); // discard reserved
+   stbi__get16le(s); // discard reserved
+   info->offset = stbi__get32le(s);
+   info->hsz = hsz = stbi__get32le(s);
+   info->mr = info->mg = info->mb = info->ma = 0;
+   info->extra_read = 14;
+
+   if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP");
+
+   if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown");
+   if (hsz == 12) {
+      s->img_x = stbi__get16le(s);
+      s->img_y = stbi__get16le(s);
+   } else {
+      s->img_x = stbi__get32le(s);
+      s->img_y = stbi__get32le(s);
+   }
+   if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP");
+   info->bpp = stbi__get16le(s);
+   if (hsz != 12) {
+      int compress = stbi__get32le(s);
+      if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE");
+      if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes
+      if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel
+      stbi__get32le(s); // discard sizeof
+      stbi__get32le(s); // discard hres
+      stbi__get32le(s); // discard vres
+      stbi__get32le(s); // discard colorsused
+      stbi__get32le(s); // discard max important
+      if (hsz == 40 || hsz == 56) {
+         if (hsz == 56) {
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+            stbi__get32le(s);
+         }
+         if (info->bpp == 16 || info->bpp == 32) {
+            if (compress == 0) {
+               stbi__bmp_set_mask_defaults(info, compress);
+            } else if (compress == 3) {
+               info->mr = stbi__get32le(s);
+               info->mg = stbi__get32le(s);
+               info->mb = stbi__get32le(s);
+               info->extra_read += 12;
+               // not documented, but generated by photoshop and handled by mspaint
+               if (info->mr == info->mg && info->mg == info->mb) {
+                  // ?!?!?
+                  return stbi__errpuc("bad BMP", "bad BMP");
+               }
+            } else
+               return stbi__errpuc("bad BMP", "bad BMP");
+         }
+      } else {
+         // V4/V5 header
+         int i;
+         if (hsz != 108 && hsz != 124)
+            return stbi__errpuc("bad BMP", "bad BMP");
+         info->mr = stbi__get32le(s);
+         info->mg = stbi__get32le(s);
+         info->mb = stbi__get32le(s);
+         info->ma = stbi__get32le(s);
+         if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs
+            stbi__bmp_set_mask_defaults(info, compress);
+         stbi__get32le(s); // discard color space
+         for (i=0; i < 12; ++i)
+            stbi__get32le(s); // discard color space parameters
+         if (hsz == 124) {
+            stbi__get32le(s); // discard rendering intent
+            stbi__get32le(s); // discard offset of profile data
+            stbi__get32le(s); // discard size of profile data
+            stbi__get32le(s); // discard reserved
+         }
+      }
+   }
+   return (void *) 1;
+}
+
+
+static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   unsigned int mr=0,mg=0,mb=0,ma=0, all_a;
+   stbi_uc pal[256][4];
+   int psize=0,i,j,width;
+   int flip_vertically, pad, target;
+   stbi__bmp_data info;
+   STBI_NOTUSED(ri);
+
+   info.all_a = 255;
+   if (stbi__bmp_parse_header(s, &info) == NULL)
+      return NULL; // error code already set
+
+   flip_vertically = ((int) s->img_y) > 0;
+   s->img_y = abs((int) s->img_y);
+
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   mr = info.mr;
+   mg = info.mg;
+   mb = info.mb;
+   ma = info.ma;
+   all_a = info.all_a;
+
+   if (info.hsz == 12) {
+      if (info.bpp < 24)
+         psize = (info.offset - info.extra_read - 24) / 3;
+   } else {
+      if (info.bpp < 16)
+         psize = (info.offset - info.extra_read - info.hsz) >> 2;
+   }
+   if (psize == 0) {
+      // accept some number of extra bytes after the header, but if the offset points either to before
+      // the header ends or implies a large amount of extra data, reject the file as malformed
+      int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);
+      int header_limit = 1024; // max we actually read is below 256 bytes currently.
+      int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.
+      if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {
+         return stbi__errpuc("bad header", "Corrupt BMP");
+      }
+      // we established that bytes_read_so_far is positive and sensible.
+      // the first half of this test rejects offsets that are either too small positives, or
+      // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn
+      // ensures the number computed in the second half of the test can't overflow.
+      if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {
+         return stbi__errpuc("bad offset", "Corrupt BMP");
+      } else {
+         stbi__skip(s, info.offset - bytes_read_so_far);
+      }
+   }
+
+   if (info.bpp == 24 && ma == 0xff000000)
+      s->img_n = 3;
+   else
+      s->img_n = ma ? 4 : 3;
+   if (req_comp && req_comp >= 3) // we can directly decode 3 or 4
+      target = req_comp;
+   else
+      target = s->img_n; // if they want monochrome, we'll post-convert
+
+   // sanity-check size
+   if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))
+      return stbi__errpuc("too large", "Corrupt BMP");
+
+   out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (info.bpp < 16) {
+      int z=0;
+      if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); }
+      for (i=0; i < psize; ++i) {
+         pal[i][2] = stbi__get8(s);
+         pal[i][1] = stbi__get8(s);
+         pal[i][0] = stbi__get8(s);
+         if (info.hsz != 12) stbi__get8(s);
+         pal[i][3] = 255;
+      }
+      stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));
+      if (info.bpp == 1) width = (s->img_x + 7) >> 3;
+      else if (info.bpp == 4) width = (s->img_x + 1) >> 1;
+      else if (info.bpp == 8) width = s->img_x;
+      else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); }
+      pad = (-width)&3;
+      if (info.bpp == 1) {
+         for (j=0; j < (int) s->img_y; ++j) {
+            int bit_offset = 7, v = stbi__get8(s);
+            for (i=0; i < (int) s->img_x; ++i) {
+               int color = (v>>bit_offset)&0x1;
+               out[z++] = pal[color][0];
+               out[z++] = pal[color][1];
+               out[z++] = pal[color][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               if((--bit_offset) < 0) {
+                  bit_offset = 7;
+                  v = stbi__get8(s);
+               }
+            }
+            stbi__skip(s, pad);
+         }
+      } else {
+         for (j=0; j < (int) s->img_y; ++j) {
+            for (i=0; i < (int) s->img_x; i += 2) {
+               int v=stbi__get8(s),v2=0;
+               if (info.bpp == 4) {
+                  v2 = v & 15;
+                  v >>= 4;
+               }
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+               if (i+1 == (int) s->img_x) break;
+               v = (info.bpp == 8) ? stbi__get8(s) : v2;
+               out[z++] = pal[v][0];
+               out[z++] = pal[v][1];
+               out[z++] = pal[v][2];
+               if (target == 4) out[z++] = 255;
+            }
+            stbi__skip(s, pad);
+         }
+      }
+   } else {
+      int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;
+      int z = 0;
+      int easy=0;
+      stbi__skip(s, info.offset - info.extra_read - info.hsz);
+      if (info.bpp == 24) width = 3 * s->img_x;
+      else if (info.bpp == 16) width = 2*s->img_x;
+      else /* bpp = 32 and pad = 0 */ width=0;
+      pad = (-width) & 3;
+      if (info.bpp == 24) {
+         easy = 1;
+      } else if (info.bpp == 32) {
+         if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)
+            easy = 2;
+      }
+      if (!easy) {
+         if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+         // right shift amt to put high bit in position #7
+         rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);
+         gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);
+         bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);
+         ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);
+         if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); }
+      }
+      for (j=0; j < (int) s->img_y; ++j) {
+         if (easy) {
+            for (i=0; i < (int) s->img_x; ++i) {
+               unsigned char a;
+               out[z+2] = stbi__get8(s);
+               out[z+1] = stbi__get8(s);
+               out[z+0] = stbi__get8(s);
+               z += 3;
+               a = (easy == 2 ? stbi__get8(s) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = a;
+            }
+         } else {
+            int bpp = info.bpp;
+            for (i=0; i < (int) s->img_x; ++i) {
+               stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));
+               unsigned int a;
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));
+               out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));
+               a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);
+               all_a |= a;
+               if (target == 4) out[z++] = STBI__BYTECAST(a);
+            }
+         }
+         stbi__skip(s, pad);
+      }
+   }
+
+   // if alpha channel is all 0s, replace with all 255s
+   if (target == 4 && all_a == 0)
+      for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)
+         out[i] = 255;
+
+   if (flip_vertically) {
+      stbi_uc t;
+      for (j=0; j < (int) s->img_y>>1; ++j) {
+         stbi_uc *p1 = out +      j     *s->img_x*target;
+         stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;
+         for (i=0; i < (int) s->img_x*target; ++i) {
+            t = p1[i]; p1[i] = p2[i]; p2[i] = t;
+         }
+      }
+   }
+
+   if (req_comp && req_comp != target) {
+      out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+   return out;
+}
+#endif
+
+// Targa Truevision - TGA
+// by Jonathan Dummer
+#ifndef STBI_NO_TGA
+// returns STBI_rgb or whatever, 0 on error
+static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+{
+   // only RGB or RGBA (incl. 16bit) or grey allowed
+   if (is_rgb16) *is_rgb16 = 0;
+   switch(bits_per_pixel) {
+      case 8:  return STBI_grey;
+      case 16: if(is_grey) return STBI_grey_alpha;
+               // fallthrough
+      case 15: if(is_rgb16) *is_rgb16 = 1;
+               return STBI_rgb;
+      case 24: // fallthrough
+      case 32: return bits_per_pixel/8;
+      default: return 0;
+   }
+}
+
+static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
+{
+    int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
+    int sz, tga_colormap_type;
+    stbi__get8(s);                   // discard Offset
+    tga_colormap_type = stbi__get8(s); // colormap type
+    if( tga_colormap_type > 1 ) {
+        stbi__rewind(s);
+        return 0;      // only RGB or indexed allowed
+    }
+    tga_image_type = stbi__get8(s); // image type
+    if ( tga_colormap_type == 1 ) { // colormapped (paletted) image
+        if (tga_image_type != 1 && tga_image_type != 9) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+        sz = stbi__get8(s);    //   check bits per palette color entry
+        if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {
+            stbi__rewind(s);
+            return 0;
+        }
+        stbi__skip(s,4);       // skip image x and y origin
+        tga_colormap_bpp = sz;
+    } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE
+        if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {
+            stbi__rewind(s);
+            return 0; // only RGB or grey allowed, +/- RLE
+        }
+        stbi__skip(s,9); // skip colormap specification and image x/y origin
+        tga_colormap_bpp = 0;
+    }
+    tga_w = stbi__get16le(s);
+    if( tga_w < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test width
+    }
+    tga_h = stbi__get16le(s);
+    if( tga_h < 1 ) {
+        stbi__rewind(s);
+        return 0;   // test height
+    }
+    tga_bits_per_pixel = stbi__get8(s); // bits per pixel
+    stbi__get8(s); // ignore alpha bits
+    if (tga_colormap_bpp != 0) {
+        if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {
+            // when using a colormap, tga_bits_per_pixel is the size of the indexes
+            // I don't think anything but 8 or 16bit indexes makes sense
+            stbi__rewind(s);
+            return 0;
+        }
+        tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);
+    } else {
+        tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);
+    }
+    if(!tga_comp) {
+      stbi__rewind(s);
+      return 0;
+    }
+    if (x) *x = tga_w;
+    if (y) *y = tga_h;
+    if (comp) *comp = tga_comp;
+    return 1;                   // seems to have passed everything
+}
+
+static int stbi__tga_test(stbi__context *s)
+{
+   int res = 0;
+   int sz, tga_color_type;
+   stbi__get8(s);      //   discard Offset
+   tga_color_type = stbi__get8(s);   //   color type
+   if ( tga_color_type > 1 ) goto errorEnd;   //   only RGB or indexed allowed
+   sz = stbi__get8(s);   //   image type
+   if ( tga_color_type == 1 ) { // colormapped (paletted) image
+      if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9
+      stbi__skip(s,4);       // skip index of first colormap entry and number of entries
+      sz = stbi__get8(s);    //   check bits per palette color entry
+      if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+      stbi__skip(s,4);       // skip image x and y origin
+   } else { // "normal" image w/o colormap
+      if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE
+      stbi__skip(s,9); // skip colormap specification and image x/y origin
+   }
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test width
+   if ( stbi__get16le(s) < 1 ) goto errorEnd;      //   test height
+   sz = stbi__get8(s);   //   bits per pixel
+   if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index
+   if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;
+
+   res = 1; // if we got this far, everything's good and we can return 1 instead of 0
+
+errorEnd:
+   stbi__rewind(s);
+   return res;
+}
+
+// read 16bit value and convert to 24bit RGB
+static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
+{
+   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
+   stbi__uint16 fiveBitMask = 31;
+   // we have 3 channels with 5bits each
+   int r = (px >> 10) & fiveBitMask;
+   int g = (px >> 5) & fiveBitMask;
+   int b = px & fiveBitMask;
+   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
+   out[0] = (stbi_uc)((r * 255)/31);
+   out[1] = (stbi_uc)((g * 255)/31);
+   out[2] = (stbi_uc)((b * 255)/31);
+
+   // some people claim that the most significant bit might be used for alpha
+   // (possibly if an alpha-bit is set in the "image descriptor byte")
+   // but that only made 16bit test images completely translucent..
+   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
+}
+
+static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   //   read in the TGA header stuff
+   int tga_offset = stbi__get8(s);
+   int tga_indexed = stbi__get8(s);
+   int tga_image_type = stbi__get8(s);
+   int tga_is_RLE = 0;
+   int tga_palette_start = stbi__get16le(s);
+   int tga_palette_len = stbi__get16le(s);
+   int tga_palette_bits = stbi__get8(s);
+   int tga_x_origin = stbi__get16le(s);
+   int tga_y_origin = stbi__get16le(s);
+   int tga_width = stbi__get16le(s);
+   int tga_height = stbi__get16le(s);
+   int tga_bits_per_pixel = stbi__get8(s);
+   int tga_comp, tga_rgb16=0;
+   int tga_inverted = stbi__get8(s);
+   // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)
+   //   image data
+   unsigned char *tga_data;
+   unsigned char *tga_palette = NULL;
+   int i, j;
+   unsigned char raw_data[4] = {0};
+   int RLE_count = 0;
+   int RLE_repeating = 0;
+   int read_next_pixel = 1;
+   STBI_NOTUSED(ri);
+   STBI_NOTUSED(tga_x_origin); // @TODO
+   STBI_NOTUSED(tga_y_origin); // @TODO
+
+   if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   //   do a tiny bit of precessing
+   if ( tga_image_type >= 8 )
+   {
+      tga_image_type -= 8;
+      tga_is_RLE = 1;
+   }
+   tga_inverted = 1 - ((tga_inverted >> 5) & 1);
+
+   //   If I'm paletted, then I'll use the number of bits from the palette
+   if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);
+   else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);
+
+   if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency
+      return stbi__errpuc("bad format", "Can't find out TGA pixelformat");
+
+   //   tga info
+   *x = tga_width;
+   *y = tga_height;
+   if (comp) *comp = tga_comp;
+
+   if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))
+      return stbi__errpuc("too large", "Corrupt TGA");
+
+   tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);
+   if (!tga_data) return stbi__errpuc("outofmem", "Out of memory");
+
+   // skip to the data's starting position (offset usually = 0)
+   stbi__skip(s, tga_offset );
+
+   if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {
+      for (i=0; i < tga_height; ++i) {
+         int row = tga_inverted ? tga_height -i - 1 : i;
+         stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;
+         stbi__getn(s, tga_row, tga_width * tga_comp);
+      }
+   } else  {
+      //   do I need to load a palette?
+      if ( tga_indexed)
+      {
+         if (tga_palette_len == 0) {  /* you have to have at least one entry! */
+            STBI_FREE(tga_data);
+            return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+
+         //   any data to skip? (offset usually = 0)
+         stbi__skip(s, tga_palette_start );
+         //   load the palette
+         tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);
+         if (!tga_palette) {
+            STBI_FREE(tga_data);
+            return stbi__errpuc("outofmem", "Out of memory");
+         }
+         if (tga_rgb16) {
+            stbi_uc *pal_entry = tga_palette;
+            STBI_ASSERT(tga_comp == STBI_rgb);
+            for (i=0; i < tga_palette_len; ++i) {
+               stbi__tga_read_rgb16(s, pal_entry);
+               pal_entry += tga_comp;
+            }
+         } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {
+               STBI_FREE(tga_data);
+               STBI_FREE(tga_palette);
+               return stbi__errpuc("bad palette", "Corrupt TGA");
+         }
+      }
+      //   load the data
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         //   if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?
+         if ( tga_is_RLE )
+         {
+            if ( RLE_count == 0 )
+            {
+               //   yep, get the next byte as a RLE command
+               int RLE_cmd = stbi__get8(s);
+               RLE_count = 1 + (RLE_cmd & 127);
+               RLE_repeating = RLE_cmd >> 7;
+               read_next_pixel = 1;
+            } else if ( !RLE_repeating )
+            {
+               read_next_pixel = 1;
+            }
+         } else
+         {
+            read_next_pixel = 1;
+         }
+         //   OK, if I need to read a pixel, do it now
+         if ( read_next_pixel )
+         {
+            //   load however much data we did have
+            if ( tga_indexed )
+            {
+               // read in index, then perform the lookup
+               int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);
+               if ( pal_idx >= tga_palette_len ) {
+                  // invalid index
+                  pal_idx = 0;
+               }
+               pal_idx *= tga_comp;
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = tga_palette[pal_idx+j];
+               }
+            } else if(tga_rgb16) {
+               STBI_ASSERT(tga_comp == STBI_rgb);
+               stbi__tga_read_rgb16(s, raw_data);
+            } else {
+               //   read in the data raw
+               for (j = 0; j < tga_comp; ++j) {
+                  raw_data[j] = stbi__get8(s);
+               }
+            }
+            //   clear the reading flag for the next pixel
+            read_next_pixel = 0;
+         } // end of reading a pixel
+
+         // copy data
+         for (j = 0; j < tga_comp; ++j)
+           tga_data[i*tga_comp+j] = raw_data[j];
+
+         //   in case we're in RLE mode, keep counting down
+         --RLE_count;
+      }
+      //   do I need to invert the image?
+      if ( tga_inverted )
+      {
+         for (j = 0; j*2 < tga_height; ++j)
+         {
+            int index1 = j * tga_width * tga_comp;
+            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+            for (i = tga_width * tga_comp; i > 0; --i)
+            {
+               unsigned char temp = tga_data[index1];
+               tga_data[index1] = tga_data[index2];
+               tga_data[index2] = temp;
+               ++index1;
+               ++index2;
+            }
+         }
+      }
+      //   clear my palette, if I had one
+      if ( tga_palette != NULL )
+      {
+         STBI_FREE( tga_palette );
+      }
+   }
+
+   // swap RGB - if the source data was RGB16, it already is in the right order
+   if (tga_comp >= 3 && !tga_rgb16)
+   {
+      unsigned char* tga_pixel = tga_data;
+      for (i=0; i < tga_width * tga_height; ++i)
+      {
+         unsigned char temp = tga_pixel[0];
+         tga_pixel[0] = tga_pixel[2];
+         tga_pixel[2] = temp;
+         tga_pixel += tga_comp;
+      }
+   }
+
+   // convert to target component count
+   if (req_comp && req_comp != tga_comp)
+      tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
+
+   //   the things I do to get rid of an error message, and yet keep
+   //   Microsoft's C compilers happy... [8^(
+   tga_palette_start = tga_palette_len = tga_palette_bits =
+         tga_x_origin = tga_y_origin = 0;
+   STBI_NOTUSED(tga_palette_start);
+   //   OK, done
+   return tga_data;
+}
+#endif
+
+// *************************************************************************************************
+// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_test(stbi__context *s)
+{
+   int r = (stbi__get32be(s) == 0x38425053);
+   stbi__rewind(s);
+   return r;
+}
+
+static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
+{
+   int count, nleft, len;
+
+   count = 0;
+   while ((nleft = pixelCount - count) > 0) {
+      len = stbi__get8(s);
+      if (len == 128) {
+         // No-op.
+      } else if (len < 128) {
+         // Copy next len+1 bytes literally.
+         len++;
+         if (len > nleft) return 0; // corrupt data
+         count += len;
+         while (len) {
+            *p = stbi__get8(s);
+            p += 4;
+            len--;
+         }
+      } else if (len > 128) {
+         stbi_uc   val;
+         // Next -len+1 bytes in the dest are replicated from next source byte.
+         // (Interpret len as a negative 8-bit int.)
+         len = 257 - len;
+         if (len > nleft) return 0; // corrupt data
+         val = stbi__get8(s);
+         count += len;
+         while (len) {
+            *p = val;
+            p += 4;
+            len--;
+         }
+      }
+   }
+
+   return 1;
+}
+
+static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)
+{
+   int pixelCount;
+   int channelCount, compression;
+   int channel, i;
+   int bitdepth;
+   int w,h;
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   if (stbi__get32be(s) != 0x38425053)   // "8BPS"
+      return stbi__errpuc("not PSD", "Corrupt PSD image");
+
+   // Check file type version.
+   if (stbi__get16be(s) != 1)
+      return stbi__errpuc("wrong version", "Unsupported version of PSD image");
+
+   // Skip 6 reserved bytes.
+   stbi__skip(s, 6 );
+
+   // Read the number of channels (R, G, B, A, etc).
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16)
+      return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image");
+
+   // Read the rows and columns of the image.
+   h = stbi__get32be(s);
+   w = stbi__get32be(s);
+
+   if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   // Make sure the depth is 8 bits.
+   bitdepth = stbi__get16be(s);
+   if (bitdepth != 8 && bitdepth != 16)
+      return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit");
+
+   // Make sure the color mode is RGB.
+   // Valid options are:
+   //   0: Bitmap
+   //   1: Grayscale
+   //   2: Indexed color
+   //   3: RGB color
+   //   4: CMYK color
+   //   7: Multichannel
+   //   8: Duotone
+   //   9: Lab color
+   if (stbi__get16be(s) != 3)
+      return stbi__errpuc("wrong color format", "PSD is not in RGB color format");
+
+   // Skip the Mode Data.  (It's the palette for indexed color; other info for other modes.)
+   stbi__skip(s,stbi__get32be(s) );
+
+   // Skip the image resources.  (resolution, pen tool paths, etc)
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Skip the reserved data.
+   stbi__skip(s, stbi__get32be(s) );
+
+   // Find out if the data is compressed.
+   // Known values:
+   //   0: no compression
+   //   1: RLE compressed
+   compression = stbi__get16be(s);
+   if (compression > 1)
+      return stbi__errpuc("bad compression", "PSD has an unknown compression format");
+
+   // Check size
+   if (!stbi__mad3sizes_valid(4, w, h, 0))
+      return stbi__errpuc("too large", "Corrupt PSD");
+
+   // Create the destination image.
+
+   if (!compression && bitdepth == 16 && bpc == 16) {
+      out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);
+      ri->bits_per_channel = 16;
+   } else
+      out = (stbi_uc *) stbi__malloc(4 * w*h);
+
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   pixelCount = w*h;
+
+   // Initialize the data to zero.
+   //memset( out, 0, pixelCount * 4 );
+
+   // Finally, the image data.
+   if (compression) {
+      // RLE as used by .PSD and .TIFF
+      // Loop until you get the number of unpacked bytes you are expecting:
+      //     Read the next source byte into n.
+      //     If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.
+      //     Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.
+      //     Else if n is 128, noop.
+      // Endloop
+
+      // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,
+      // which we're going to just skip.
+      stbi__skip(s, h * channelCount * 2 );
+
+      // Read the RLE data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         stbi_uc *p;
+
+         p = out+channel;
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            for (i = 0; i < pixelCount; i++, p += 4)
+               *p = (channel == 3 ? 255 : 0);
+         } else {
+            // Read the RLE data.
+            if (!stbi__psd_decode_rle(s, p, pixelCount)) {
+               STBI_FREE(out);
+               return stbi__errpuc("corrupt", "bad RLE data");
+            }
+         }
+      }
+
+   } else {
+      // We're at the raw image data.  It's each channel in order (Red, Green, Blue, Alpha, ...)
+      // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.
+
+      // Read the data by channel.
+      for (channel = 0; channel < 4; channel++) {
+         if (channel >= channelCount) {
+            // Fill this channel with default data.
+            if (bitdepth == 16 && bpc == 16) {
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               stbi__uint16 val = channel == 3 ? 65535 : 0;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = val;
+            } else {
+               stbi_uc *p = out+channel;
+               stbi_uc val = channel == 3 ? 255 : 0;
+               for (i = 0; i < pixelCount; i++, p += 4)
+                  *p = val;
+            }
+         } else {
+            if (ri->bits_per_channel == 16) {    // output bpc
+               stbi__uint16 *q = ((stbi__uint16 *) out) + channel;
+               for (i = 0; i < pixelCount; i++, q += 4)
+                  *q = (stbi__uint16) stbi__get16be(s);
+            } else {
+               stbi_uc *p = out+channel;
+               if (bitdepth == 16) {  // input bpc
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = (stbi_uc) (stbi__get16be(s) >> 8);
+               } else {
+                  for (i = 0; i < pixelCount; i++, p += 4)
+                     *p = stbi__get8(s);
+               }
+            }
+         }
+      }
+   }
+
+   // remove weird white matte from PSD
+   if (channelCount >= 4) {
+      if (ri->bits_per_channel == 16) {
+         for (i=0; i < w*h; ++i) {
+            stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 65535) {
+               float a = pixel[3] / 65535.0f;
+               float ra = 1.0f / a;
+               float inv_a = 65535.0f * (1 - ra);
+               pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);
+               pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);
+               pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);
+            }
+         }
+      } else {
+         for (i=0; i < w*h; ++i) {
+            unsigned char *pixel = out + 4*i;
+            if (pixel[3] != 0 && pixel[3] != 255) {
+               float a = pixel[3] / 255.0f;
+               float ra = 1.0f / a;
+               float inv_a = 255.0f * (1 - ra);
+               pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);
+               pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);
+               pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);
+            }
+         }
+      }
+   }
+
+   // convert to desired output format
+   if (req_comp && req_comp != 4) {
+      if (ri->bits_per_channel == 16)
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);
+      else
+         out = stbi__convert_format(out, 4, req_comp, w, h);
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+
+   if (comp) *comp = 4;
+   *y = h;
+   *x = w;
+
+   return out;
+}
+#endif
+
+// *************************************************************************************************
+// Softimage PIC loader
+// by Tom Seddon
+//
+// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format
+// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_is4(stbi__context *s,const char *str)
+{
+   int i;
+   for (i=0; i<4; ++i)
+      if (stbi__get8(s) != (stbi_uc)str[i])
+         return 0;
+
+   return 1;
+}
+
+static int stbi__pic_test_core(stbi__context *s)
+{
+   int i;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
+      return 0;
+
+   for(i=0;i<84;++i)
+      stbi__get8(s);
+
+   if (!stbi__pic_is4(s,"PICT"))
+      return 0;
+
+   return 1;
+}
+
+typedef struct
+{
+   stbi_uc size,type,channel;
+} stbi__pic_packet;
+
+static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
+{
+   int mask=0x80, i;
+
+   for (i=0; i<4; ++i, mask>>=1) {
+      if (channel & mask) {
+         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
+         dest[i]=stbi__get8(s);
+      }
+   }
+
+   return dest;
+}
+
+static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
+{
+   int mask=0x80,i;
+
+   for (i=0;i<4; ++i, mask>>=1)
+      if (channel&mask)
+         dest[i]=src[i];
+}
+
+static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)
+{
+   int act_comp=0,num_packets=0,y,chained;
+   stbi__pic_packet packets[10];
+
+   // this will (should...) cater for even some bizarre stuff like having data
+    // for the same channel in multiple packets.
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return stbi__errpuc("bad format","too many packets");
+
+      packet = &packets[num_packets++];
+
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s))          return stbi__errpuc("bad file","file too short (reading packets)");
+      if (packet->size != 8)  return stbi__errpuc("bad format","packet isn't 8bpp");
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?
+
+   for(y=0; y<height; ++y) {
+      int packet_idx;
+
+      for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {
+         stbi__pic_packet *packet = &packets[packet_idx];
+         stbi_uc *dest = result+y*width*4;
+
+         switch (packet->type) {
+            default:
+               return stbi__errpuc("bad format","packet has bad compression type");
+
+            case 0: {//uncompressed
+               int x;
+
+               for(x=0;x<width;++x, dest+=4)
+                  if (!stbi__readval(s,packet->channel,dest))
+                     return 0;
+               break;
+            }
+
+            case 1://Pure RLE
+               {
+                  int left=width, i;
+
+                  while (left>0) {
+                     stbi_uc count,value[4];
+
+                     count=stbi__get8(s);
+                     if (stbi__at_eof(s))   return stbi__errpuc("bad file","file too short (pure read count)");
+
+                     if (count > left)
+                        count = (stbi_uc) left;
+
+                     if (!stbi__readval(s,packet->channel,value))  return 0;
+
+                     for(i=0; i<count; ++i,dest+=4)
+                        stbi__copyval(packet->channel,dest,value);
+                     left -= count;
+                  }
+               }
+               break;
+
+            case 2: {//Mixed RLE
+               int left=width;
+               while (left>0) {
+                  int count = stbi__get8(s), i;
+                  if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (mixed read count)");
+
+                  if (count >= 128) { // Repeated
+                     stbi_uc value[4];
+
+                     if (count==128)
+                        count = stbi__get16be(s);
+                     else
+                        count -= 127;
+                     if (count > left)
+                        return stbi__errpuc("bad file","scanline overrun");
+
+                     if (!stbi__readval(s,packet->channel,value))
+                        return 0;
+
+                     for(i=0;i<count;++i, dest += 4)
+                        stbi__copyval(packet->channel,dest,value);
+                  } else { // Raw
+                     ++count;
+                     if (count>left) return stbi__errpuc("bad file","scanline overrun");
+
+                     for(i=0;i<count;++i, dest+=4)
+                        if (!stbi__readval(s,packet->channel,dest))
+                           return 0;
+                  }
+                  left-=count;
+               }
+               break;
+            }
+         }
+      }
+   }
+
+   return result;
+}
+
+static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *result;
+   int i, x,y, internal_comp;
+   STBI_NOTUSED(ri);
+
+   if (!comp) comp = &internal_comp;
+
+   for (i=0; i<92; ++i)
+      stbi__get8(s);
+
+   x = stbi__get16be(s);
+   y = stbi__get16be(s);
+
+   if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
+   if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode");
+
+   stbi__get32be(s); //skip `ratio'
+   stbi__get16be(s); //skip `fields'
+   stbi__get16be(s); //skip `pad'
+
+   // intermediate buffer is RGBA
+   result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);
+   if (!result) return stbi__errpuc("outofmem", "Out of memory");
+   memset(result, 0xff, x*y*4);
+
+   if (!stbi__pic_load_core(s,x,y,comp, result)) {
+      STBI_FREE(result);
+      result=0;
+   }
+   *px = x;
+   *py = y;
+   if (req_comp == 0) req_comp = *comp;
+   result=stbi__convert_format(result,4,req_comp,x,y);
+
+   return result;
+}
+
+static int stbi__pic_test(stbi__context *s)
+{
+   int r = stbi__pic_test_core(s);
+   stbi__rewind(s);
+   return r;
+}
+#endif
+
+// *************************************************************************************************
+// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb
+
+#ifndef STBI_NO_GIF
+typedef struct
+{
+   stbi__int16 prefix;
+   stbi_uc first;
+   stbi_uc suffix;
+} stbi__gif_lzw;
+
+typedef struct
+{
+   int w,h;
+   stbi_uc *out;                 // output buffer (always 4 components)
+   stbi_uc *background;          // The current "background" as far as a gif is concerned
+   stbi_uc *history;
+   int flags, bgindex, ratio, transparent, eflags;
+   stbi_uc  pal[256][4];
+   stbi_uc lpal[256][4];
+   stbi__gif_lzw codes[8192];
+   stbi_uc *color_table;
+   int parse, step;
+   int lflags;
+   int start_x, start_y;
+   int max_x, max_y;
+   int cur_x, cur_y;
+   int line_size;
+   int delay;
+} stbi__gif;
+
+static int stbi__gif_test_raw(stbi__context *s)
+{
+   int sz;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
+   sz = stbi__get8(s);
+   if (sz != '9' && sz != '7') return 0;
+   if (stbi__get8(s) != 'a') return 0;
+   return 1;
+}
+
+static int stbi__gif_test(stbi__context *s)
+{
+   int r = stbi__gif_test_raw(s);
+   stbi__rewind(s);
+   return r;
+}
+
+static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
+{
+   int i;
+   for (i=0; i < num_entries; ++i) {
+      pal[i][2] = stbi__get8(s);
+      pal[i][1] = stbi__get8(s);
+      pal[i][0] = stbi__get8(s);
+      pal[i][3] = transp == i ? 0 : 255;
+   }
+}
+
+static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
+{
+   stbi_uc version;
+   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
+      return stbi__err("not GIF", "Corrupt GIF");
+
+   version = stbi__get8(s);
+   if (version != '7' && version != '9')    return stbi__err("not GIF", "Corrupt GIF");
+   if (stbi__get8(s) != 'a')                return stbi__err("not GIF", "Corrupt GIF");
+
+   stbi__g_failure_reason = "";
+   g->w = stbi__get16le(s);
+   g->h = stbi__get16le(s);
+   g->flags = stbi__get8(s);
+   g->bgindex = stbi__get8(s);
+   g->ratio = stbi__get8(s);
+   g->transparent = -1;
+
+   if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+   if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)");
+
+   if (comp != 0) *comp = 4;  // can't actually tell whether it's 3 or 4 until we parse the comments
+
+   if (is_info) return 1;
+
+   if (g->flags & 0x80)
+      stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);
+
+   return 1;
+}
+
+static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
+{
+   stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));
+   if (!g) return stbi__err("outofmem", "Out of memory");
+   if (!stbi__gif_header(s, g, comp, 1)) {
+      STBI_FREE(g);
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = g->w;
+   if (y) *y = g->h;
+   STBI_FREE(g);
+   return 1;
+}
+
+static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
+{
+   stbi_uc *p, *c;
+   int idx;
+
+   // recurse to decode the prefixes, since the linked-list is backwards,
+   // and working backwards through an interleaved image would be nasty
+   if (g->codes[code].prefix >= 0)
+      stbi__out_gif_code(g, g->codes[code].prefix);
+
+   if (g->cur_y >= g->max_y) return;
+
+   idx = g->cur_x + g->cur_y;
+   p = &g->out[idx];
+   g->history[idx / 4] = 1;
+
+   c = &g->color_table[g->codes[code].suffix * 4];
+   if (c[3] > 128) { // don't render transparent pixels;
+      p[0] = c[2];
+      p[1] = c[1];
+      p[2] = c[0];
+      p[3] = c[3];
+   }
+   g->cur_x += 4;
+
+   if (g->cur_x >= g->max_x) {
+      g->cur_x = g->start_x;
+      g->cur_y += g->step;
+
+      while (g->cur_y >= g->max_y && g->parse > 0) {
+         g->step = (1 << g->parse) * g->line_size;
+         g->cur_y = g->start_y + (g->step >> 1);
+         --g->parse;
+      }
+   }
+}
+
+static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)
+{
+   stbi_uc lzw_cs;
+   stbi__int32 len, init_code;
+   stbi__uint32 first;
+   stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;
+   stbi__gif_lzw *p;
+
+   lzw_cs = stbi__get8(s);
+   if (lzw_cs > 12) return NULL;
+   clear = 1 << lzw_cs;
+   first = 1;
+   codesize = lzw_cs + 1;
+   codemask = (1 << codesize) - 1;
+   bits = 0;
+   valid_bits = 0;
+   for (init_code = 0; init_code < clear; init_code++) {
+      g->codes[init_code].prefix = -1;
+      g->codes[init_code].first = (stbi_uc) init_code;
+      g->codes[init_code].suffix = (stbi_uc) init_code;
+   }
+
+   // support no starting clear code
+   avail = clear+2;
+   oldcode = -1;
+
+   len = 0;
+   for(;;) {
+      if (valid_bits < codesize) {
+         if (len == 0) {
+            len = stbi__get8(s); // start new block
+            if (len == 0)
+               return g->out;
+         }
+         --len;
+         bits |= (stbi__int32) stbi__get8(s) << valid_bits;
+         valid_bits += 8;
+      } else {
+         stbi__int32 code = bits & codemask;
+         bits >>= codesize;
+         valid_bits -= codesize;
+         // @OPTIMIZE: is there some way we can accelerate the non-clear path?
+         if (code == clear) {  // clear code
+            codesize = lzw_cs + 1;
+            codemask = (1 << codesize) - 1;
+            avail = clear + 2;
+            oldcode = -1;
+            first = 0;
+         } else if (code == clear + 1) { // end of stream code
+            stbi__skip(s, len);
+            while ((len = stbi__get8(s)) > 0)
+               stbi__skip(s,len);
+            return g->out;
+         } else if (code <= avail) {
+            if (first) {
+               return stbi__errpuc("no clear code", "Corrupt GIF");
+            }
+
+            if (oldcode >= 0) {
+               p = &g->codes[avail++];
+               if (avail > 8192) {
+                  return stbi__errpuc("too many codes", "Corrupt GIF");
+               }
+
+               p->prefix = (stbi__int16) oldcode;
+               p->first = g->codes[oldcode].first;
+               p->suffix = (code == avail) ? p->first : g->codes[code].first;
+            } else if (code == avail)
+               return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+
+            stbi__out_gif_code(g, (stbi__uint16) code);
+
+            if ((avail & codemask) == 0 && avail <= 0x0FFF) {
+               codesize++;
+               codemask = (1 << codesize) - 1;
+            }
+
+            oldcode = code;
+         } else {
+            return stbi__errpuc("illegal code in raster", "Corrupt GIF");
+         }
+      }
+   }
+}
+
+// this function is designed to support animated gifs, although stb_image doesn't support it
+// two back is the image from two frames ago, used for a very specific disposal format
+static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
+{
+   int dispose;
+   int first_frame;
+   int pi;
+   int pcount;
+   STBI_NOTUSED(req_comp);
+
+   // on first frame, any non-written pixels get the background colour (non-transparent)
+   first_frame = 0;
+   if (g->out == 0) {
+      if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header
+      if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))
+         return stbi__errpuc("too large", "GIF image is too large");
+      pcount = g->w * g->h;
+      g->out = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->background = (stbi_uc *) stbi__malloc(4 * pcount);
+      g->history = (stbi_uc *) stbi__malloc(pcount);
+      if (!g->out || !g->background || !g->history)
+         return stbi__errpuc("outofmem", "Out of memory");
+
+      // image is treated as "transparent" at the start - ie, nothing overwrites the current background;
+      // background colour is only used for pixels that are not rendered first frame, after that "background"
+      // color refers to the color that was there the previous frame.
+      memset(g->out, 0x00, 4 * pcount);
+      memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)
+      memset(g->history, 0x00, pcount);        // pixels that were affected previous frame
+      first_frame = 1;
+   } else {
+      // second frame - how do we dispose of the previous one?
+      dispose = (g->eflags & 0x1C) >> 2;
+      pcount = g->w * g->h;
+
+      if ((dispose == 3) && (two_back == 0)) {
+         dispose = 2; // if I don't have an image to revert back to, default to the old background
+      }
+
+      if (dispose == 3) { // use previous graphic
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );
+            }
+         }
+      } else if (dispose == 2) {
+         // restore what was changed last frame to background before that frame;
+         for (pi = 0; pi < pcount; ++pi) {
+            if (g->history[pi]) {
+               memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );
+            }
+         }
+      } else {
+         // This is a non-disposal case eithe way, so just
+         // leave the pixels as is, and they will become the new background
+         // 1: do not dispose
+         // 0:  not specified.
+      }
+
+      // background is what out is after the undoing of the previou frame;
+      memcpy( g->background, g->out, 4 * g->w * g->h );
+   }
+
+   // clear my history;
+   memset( g->history, 0x00, g->w * g->h );        // pixels that were affected previous frame
+
+   for (;;) {
+      int tag = stbi__get8(s);
+      switch (tag) {
+         case 0x2C: /* Image Descriptor */
+         {
+            stbi__int32 x, y, w, h;
+            stbi_uc *o;
+
+            x = stbi__get16le(s);
+            y = stbi__get16le(s);
+            w = stbi__get16le(s);
+            h = stbi__get16le(s);
+            if (((x + w) > (g->w)) || ((y + h) > (g->h)))
+               return stbi__errpuc("bad Image Descriptor", "Corrupt GIF");
+
+            g->line_size = g->w * 4;
+            g->start_x = x * 4;
+            g->start_y = y * g->line_size;
+            g->max_x   = g->start_x + w * 4;
+            g->max_y   = g->start_y + h * g->line_size;
+            g->cur_x   = g->start_x;
+            g->cur_y   = g->start_y;
+
+            // if the width of the specified rectangle is 0, that means
+            // we may not see *any* pixels or the image is malformed;
+            // to make sure this is caught, move the current y down to
+            // max_y (which is what out_gif_code checks).
+            if (w == 0)
+               g->cur_y = g->max_y;
+
+            g->lflags = stbi__get8(s);
+
+            if (g->lflags & 0x40) {
+               g->step = 8 * g->line_size; // first interlaced spacing
+               g->parse = 3;
+            } else {
+               g->step = g->line_size;
+               g->parse = 0;
+            }
+
+            if (g->lflags & 0x80) {
+               stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);
+               g->color_table = (stbi_uc *) g->lpal;
+            } else if (g->flags & 0x80) {
+               g->color_table = (stbi_uc *) g->pal;
+            } else
+               return stbi__errpuc("missing color table", "Corrupt GIF");
+
+            o = stbi__process_gif_raster(s, g);
+            if (!o) return NULL;
+
+            // if this was the first frame,
+            pcount = g->w * g->h;
+            if (first_frame && (g->bgindex > 0)) {
+               // if first frame, any pixel not drawn to gets the background color
+               for (pi = 0; pi < pcount; ++pi) {
+                  if (g->history[pi] == 0) {
+                     g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;
+                     memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );
+                  }
+               }
+            }
+
+            return o;
+         }
+
+         case 0x21: // Comment Extension.
+         {
+            int len;
+            int ext = stbi__get8(s);
+            if (ext == 0xF9) { // Graphic Control Extension.
+               len = stbi__get8(s);
+               if (len == 4) {
+                  g->eflags = stbi__get8(s);
+                  g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.
+
+                  // unset old transparent
+                  if (g->transparent >= 0) {
+                     g->pal[g->transparent][3] = 255;
+                  }
+                  if (g->eflags & 0x01) {
+                     g->transparent = stbi__get8(s);
+                     if (g->transparent >= 0) {
+                        g->pal[g->transparent][3] = 0;
+                     }
+                  } else {
+                     // don't need transparent
+                     stbi__skip(s, 1);
+                     g->transparent = -1;
+                  }
+               } else {
+                  stbi__skip(s, len);
+                  break;
+               }
+            }
+            while ((len = stbi__get8(s)) != 0) {
+               stbi__skip(s, len);
+            }
+            break;
+         }
+
+         case 0x3B: // gif stream termination code
+            return (stbi_uc *) s; // using '1' causes warning on some compilers
+
+         default:
+            return stbi__errpuc("unknown code", "Corrupt GIF");
+      }
+   }
+}
+
+static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
+{
+   STBI_FREE(g->out);
+   STBI_FREE(g->history);
+   STBI_FREE(g->background);
+
+   if (out) STBI_FREE(out);
+   if (delays && *delays) STBI_FREE(*delays);
+   return stbi__errpuc("outofmem", "Out of memory");
+}
+
+static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
+{
+   if (stbi__gif_test(s)) {
+      int layers = 0;
+      stbi_uc *u = 0;
+      stbi_uc *out = 0;
+      stbi_uc *two_back = 0;
+      stbi__gif g;
+      int stride;
+      int out_size = 0;
+      int delays_size = 0;
+
+      STBI_NOTUSED(out_size);
+      STBI_NOTUSED(delays_size);
+
+      memset(&g, 0, sizeof(g));
+      if (delays) {
+         *delays = 0;
+      }
+
+      do {
+         u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);
+         if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+
+         if (u) {
+            *x = g.w;
+            *y = g.h;
+            ++layers;
+            stride = g.w * g.h * 4;
+
+            if (out) {
+               void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );
+               if (!tmp)
+                  return stbi__load_gif_main_outofmem(&g, out, delays);
+               else {
+                   out = (stbi_uc*) tmp;
+                   out_size = layers * stride;
+               }
+
+               if (delays) {
+                  int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );
+                  if (!new_delays)
+                     return stbi__load_gif_main_outofmem(&g, out, delays);
+                  *delays = new_delays;
+                  delays_size = layers * sizeof(int);
+               }
+            } else {
+               out = (stbi_uc*)stbi__malloc( layers * stride );
+               if (!out)
+                  return stbi__load_gif_main_outofmem(&g, out, delays);
+               out_size = layers * stride;
+               if (delays) {
+                  *delays = (int*) stbi__malloc( layers * sizeof(int) );
+                  if (!*delays)
+                     return stbi__load_gif_main_outofmem(&g, out, delays);
+                  delays_size = layers * sizeof(int);
+               }
+            }
+            memcpy( out + ((layers - 1) * stride), u, stride );
+            if (layers >= 2) {
+               two_back = out - 2 * stride;
+            }
+
+            if (delays) {
+               (*delays)[layers - 1U] = g.delay;
+            }
+         }
+      } while (u != 0);
+
+      // free temp buffer;
+      STBI_FREE(g.out);
+      STBI_FREE(g.history);
+      STBI_FREE(g.background);
+
+      // do the final conversion after loading everything;
+      if (req_comp && req_comp != 4)
+         out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);
+
+      *z = layers;
+      return out;
+   } else {
+      return stbi__errpuc("not GIF", "Image was not as a gif type.");
+   }
+}
+
+static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *u = 0;
+   stbi__gif g;
+   memset(&g, 0, sizeof(g));
+   STBI_NOTUSED(ri);
+
+   u = stbi__gif_load_next(s, &g, comp, req_comp, 0);
+   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
+   if (u) {
+      *x = g.w;
+      *y = g.h;
+
+      // moved conversion to after successful load so that the same
+      // can be done for multiple frames.
+      if (req_comp && req_comp != 4)
+         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
+   } else if (g.out) {
+      // if there was an error and we allocated an image buffer, free it!
+      STBI_FREE(g.out);
+   }
+
+   // free buffers needed for multiple frame loading;
+   STBI_FREE(g.history);
+   STBI_FREE(g.background);
+
+   return u;
+}
+
+static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   return stbi__gif_info_raw(s,x,y,comp);
+}
+#endif
+
+// *************************************************************************************************
+// Radiance RGBE HDR loader
+// originally by Nicolas Schulz
+#ifndef STBI_NO_HDR
+static int stbi__hdr_test_core(stbi__context *s, const char *signature)
+{
+   int i;
+   for (i=0; signature[i]; ++i)
+      if (stbi__get8(s) != signature[i])
+          return 0;
+   stbi__rewind(s);
+   return 1;
+}
+
+static int stbi__hdr_test(stbi__context* s)
+{
+   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
+   stbi__rewind(s);
+   if(!r) {
+       r = stbi__hdr_test_core(s, "#?RGBE\n");
+       stbi__rewind(s);
+   }
+   return r;
+}
+
+#define STBI__HDR_BUFLEN  1024
+static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
+{
+   int len=0;
+   char c = '\0';
+
+   c = (char) stbi__get8(z);
+
+   while (!stbi__at_eof(z) && c != '\n') {
+      buffer[len++] = c;
+      if (len == STBI__HDR_BUFLEN-1) {
+         // flush to end of line
+         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
+            ;
+         break;
+      }
+      c = (char) stbi__get8(z);
+   }
+
+   buffer[len] = 0;
+   return buffer;
+}
+
+static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
+{
+   if ( input[3] != 0 ) {
+      float f1;
+      // Exponent
+      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
+      if (req_comp <= 2)
+         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
+      else {
+         output[0] = input[0] * f1;
+         output[1] = input[1] * f1;
+         output[2] = input[2] * f1;
+      }
+      if (req_comp == 2) output[1] = 1;
+      if (req_comp == 4) output[3] = 1;
+   } else {
+      switch (req_comp) {
+         case 4: output[3] = 1; /* fallthrough */
+         case 3: output[0] = output[1] = output[2] = 0;
+                 break;
+         case 2: output[1] = 1; /* fallthrough */
+         case 1: output[0] = 0;
+                 break;
+      }
+   }
+}
+
+static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int width, height;
+   stbi_uc *scanline;
+   float *hdr_data;
+   int len;
+   unsigned char count, value;
+   int i, j, k, c1,c2, z;
+   const char *headerToken;
+   STBI_NOTUSED(ri);
+
+   // Check identifier
+   headerToken = stbi__hdr_gettoken(s,buffer);
+   if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0)
+      return stbi__errpf("not HDR", "Corrupt HDR image");
+
+   // Parse header
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid)    return stbi__errpf("unsupported format", "Unsupported HDR format");
+
+   // Parse width and height
+   // can't use sscanf() if we're not using stdio!
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   height = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3))  return stbi__errpf("unsupported data layout", "Unsupported HDR format");
+   token += 3;
+   width = (int) strtol(token, NULL, 10);
+
+   if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+   if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)");
+
+   *x = width;
+   *y = height;
+
+   if (comp) *comp = 3;
+   if (req_comp == 0) req_comp = 3;
+
+   if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))
+      return stbi__errpf("too large", "HDR image is too large");
+
+   // Read data
+   hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);
+   if (!hdr_data)
+      return stbi__errpf("outofmem", "Out of memory");
+
+   // Load image data
+   // image data is stored as some number of sca
+   if ( width < 8 || width >= 32768) {
+      // Read flat data
+      for (j=0; j < height; ++j) {
+         for (i=0; i < width; ++i) {
+            stbi_uc rgbe[4];
+           main_decode_loop:
+            stbi__getn(s, rgbe, 4);
+            stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);
+         }
+      }
+   } else {
+      // Read RLE-encoded data
+      scanline = NULL;
+
+      for (j = 0; j < height; ++j) {
+         c1 = stbi__get8(s);
+         c2 = stbi__get8(s);
+         len = stbi__get8(s);
+         if (c1 != 2 || c2 != 2 || (len & 0x80)) {
+            // not run-length encoded, so we have to actually use THIS data as a decoded
+            // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
+            stbi_uc rgbe[4];
+            rgbe[0] = (stbi_uc) c1;
+            rgbe[1] = (stbi_uc) c2;
+            rgbe[2] = (stbi_uc) len;
+            rgbe[3] = (stbi_uc) stbi__get8(s);
+            stbi__hdr_convert(hdr_data, rgbe, req_comp);
+            i = 1;
+            j = 0;
+            STBI_FREE(scanline);
+            goto main_decode_loop; // yes, this makes no sense
+         }
+         len <<= 8;
+         len |= stbi__get8(s);
+         if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); }
+         if (scanline == NULL) {
+            scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);
+            if (!scanline) {
+               STBI_FREE(hdr_data);
+               return stbi__errpf("outofmem", "Out of memory");
+            }
+         }
+
+         for (k = 0; k < 4; ++k) {
+            int nleft;
+            i = 0;
+            while ((nleft = width - i) > 0) {
+               count = stbi__get8(s);
+               if (count > 128) {
+                  // Run
+                  value = stbi__get8(s);
+                  count -= 128;
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = value;
+               } else {
+                  // Dump
+                  if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); }
+                  for (z = 0; z < count; ++z)
+                     scanline[i++ * 4 + k] = stbi__get8(s);
+               }
+            }
+         }
+         for (i=0; i < width; ++i)
+            stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);
+      }
+      if (scanline)
+         STBI_FREE(scanline);
+   }
+
+   return hdr_data;
+}
+
+static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   char buffer[STBI__HDR_BUFLEN];
+   char *token;
+   int valid = 0;
+   int dummy;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (stbi__hdr_test(s) == 0) {
+       stbi__rewind( s );
+       return 0;
+   }
+
+   for(;;) {
+      token = stbi__hdr_gettoken(s,buffer);
+      if (token[0] == 0) break;
+      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
+   }
+
+   if (!valid) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token = stbi__hdr_gettoken(s,buffer);
+   if (strncmp(token, "-Y ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *y = (int) strtol(token, &token, 10);
+   while (*token == ' ') ++token;
+   if (strncmp(token, "+X ", 3)) {
+       stbi__rewind( s );
+       return 0;
+   }
+   token += 3;
+   *x = (int) strtol(token, NULL, 10);
+   *comp = 3;
+   return 1;
+}
+#endif // STBI_NO_HDR
+
+#ifndef STBI_NO_BMP
+static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   void *p;
+   stbi__bmp_data info;
+
+   info.all_a = 255;
+   p = stbi__bmp_parse_header(s, &info);
+   if (p == NULL) {
+      stbi__rewind( s );
+      return 0;
+   }
+   if (x) *x = s->img_x;
+   if (y) *y = s->img_y;
+   if (comp) {
+      if (info.bpp == 24 && info.ma == 0xff000000)
+         *comp = 3;
+      else
+         *comp = info.ma ? 4 : 3;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PSD
+static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int channelCount, dummy, depth;
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *y = stbi__get32be(s);
+   *x = stbi__get32be(s);
+   depth = stbi__get16be(s);
+   if (depth != 8 && depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 3) {
+       stbi__rewind( s );
+       return 0;
+   }
+   *comp = 4;
+   return 1;
+}
+
+static int stbi__psd_is16(stbi__context *s)
+{
+   int channelCount, depth;
+   if (stbi__get32be(s) != 0x38425053) {
+       stbi__rewind( s );
+       return 0;
+   }
+   if (stbi__get16be(s) != 1) {
+       stbi__rewind( s );
+       return 0;
+   }
+   stbi__skip(s, 6);
+   channelCount = stbi__get16be(s);
+   if (channelCount < 0 || channelCount > 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   STBI_NOTUSED(stbi__get32be(s));
+   STBI_NOTUSED(stbi__get32be(s));
+   depth = stbi__get16be(s);
+   if (depth != 16) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+#endif
+
+#ifndef STBI_NO_PIC
+static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int act_comp=0,num_packets=0,chained,dummy;
+   stbi__pic_packet packets[10];
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
+      stbi__rewind(s);
+      return 0;
+   }
+
+   stbi__skip(s, 88);
+
+   *x = stbi__get16be(s);
+   *y = stbi__get16be(s);
+   if (stbi__at_eof(s)) {
+      stbi__rewind( s);
+      return 0;
+   }
+   if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {
+      stbi__rewind( s );
+      return 0;
+   }
+
+   stbi__skip(s, 8);
+
+   do {
+      stbi__pic_packet *packet;
+
+      if (num_packets==sizeof(packets)/sizeof(packets[0]))
+         return 0;
+
+      packet = &packets[num_packets++];
+      chained = stbi__get8(s);
+      packet->size    = stbi__get8(s);
+      packet->type    = stbi__get8(s);
+      packet->channel = stbi__get8(s);
+      act_comp |= packet->channel;
+
+      if (stbi__at_eof(s)) {
+          stbi__rewind( s );
+          return 0;
+      }
+      if (packet->size != 8) {
+          stbi__rewind( s );
+          return 0;
+      }
+   } while (chained);
+
+   *comp = (act_comp & 0x10 ? 4 : 3);
+
+   return 1;
+}
+#endif
+
+// *************************************************************************************************
+// Portable Gray Map and Portable Pixel Map loader
+// by Ken Miller
+//
+// PGM: http://netpbm.sourceforge.net/doc/pgm.html
+// PPM: http://netpbm.sourceforge.net/doc/ppm.html
+//
+// Known limitations:
+//    Does not support comments in the header section
+//    Does not support ASCII image data (formats P2 and P3)
+
+#ifndef STBI_NO_PNM
+
+static int      stbi__pnm_test(stbi__context *s)
+{
+   char p, t;
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind( s );
+       return 0;
+   }
+   return 1;
+}
+
+static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
+{
+   stbi_uc *out;
+   STBI_NOTUSED(ri);
+
+   ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
+   if (ri->bits_per_channel == 0)
+      return 0;
+
+   if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+   if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)");
+
+   *x = s->img_x;
+   *y = s->img_y;
+   if (comp) *comp = s->img_n;
+
+   if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))
+      return stbi__errpuc("too large", "PNM too large");
+
+   out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);
+   if (!out) return stbi__errpuc("outofmem", "Out of memory");
+   if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {
+      STBI_FREE(out);
+      return stbi__errpuc("bad PNM", "PNM file truncated");
+   }
+
+   if (req_comp && req_comp != s->img_n) {
+      if (ri->bits_per_channel == 16) {
+         out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);
+      } else {
+         out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
+      }
+      if (out == NULL) return out; // stbi__convert_format frees input on failure
+   }
+   return out;
+}
+
+static int      stbi__pnm_isspace(char c)
+{
+   return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
+}
+
+static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
+{
+   for (;;) {
+      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
+         *c = (char) stbi__get8(s);
+
+      if (stbi__at_eof(s) || *c != '#')
+         break;
+
+      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
+         *c = (char) stbi__get8(s);
+   }
+}
+
+static int      stbi__pnm_isdigit(char c)
+{
+   return c >= '0' && c <= '9';
+}
+
+static int      stbi__pnm_getinteger(stbi__context *s, char *c)
+{
+   int value = 0;
+
+   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
+      value = value*10 + (*c - '0');
+      *c = (char) stbi__get8(s);
+      if((value > 214748364) || (value == 214748364 && *c > '7'))
+          return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int");
+   }
+
+   return value;
+}
+
+static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
+{
+   int maxv, dummy;
+   char c, p, t;
+
+   if (!x) x = &dummy;
+   if (!y) y = &dummy;
+   if (!comp) comp = &dummy;
+
+   stbi__rewind(s);
+
+   // Get identifier
+   p = (char) stbi__get8(s);
+   t = (char) stbi__get8(s);
+   if (p != 'P' || (t != '5' && t != '6')) {
+       stbi__rewind(s);
+       return 0;
+   }
+
+   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm
+
+   c = (char) stbi__get8(s);
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *x = stbi__pnm_getinteger(s, &c); // read width
+   if(*x == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+   stbi__pnm_skip_whitespace(s, &c);
+
+   *y = stbi__pnm_getinteger(s, &c); // read height
+   if (*y == 0)
+       return stbi__err("invalid width", "PPM image header had zero or overflowing width");
+   stbi__pnm_skip_whitespace(s, &c);
+
+   maxv = stbi__pnm_getinteger(s, &c);  // read max value
+   if (maxv > 65535)
+      return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
+   else if (maxv > 255)
+      return 16;
+   else
+      return 8;
+}
+
+static int stbi__pnm_is16(stbi__context *s)
+{
+   if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)
+	   return 1;
+   return 0;
+}
+#endif
+
+static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
+{
+   #ifndef STBI_NO_JPEG
+   if (stbi__jpeg_info(s, x, y, comp)) return 1;
+   #endif
+
+   #ifndef STBI_NO_PNG
+   if (stbi__png_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_GIF
+   if (stbi__gif_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_BMP
+   if (stbi__bmp_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PIC
+   if (stbi__pic_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_info(s, x, y, comp))  return 1;
+   #endif
+
+   #ifndef STBI_NO_HDR
+   if (stbi__hdr_info(s, x, y, comp))  return 1;
+   #endif
+
+   // test tga last because it's a crappy test!
+   #ifndef STBI_NO_TGA
+   if (stbi__tga_info(s, x, y, comp))
+       return 1;
+   #endif
+   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
+}
+
+static int stbi__is_16_main(stbi__context *s)
+{
+   #ifndef STBI_NO_PNG
+   if (stbi__png_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PSD
+   if (stbi__psd_is16(s))  return 1;
+   #endif
+
+   #ifndef STBI_NO_PNM
+   if (stbi__pnm_is16(s))  return 1;
+   #endif
+   return 0;
+}
+
+#ifndef STBI_NO_STDIO
+STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_info_from_file(f, x, y, comp);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__info_main(&s,x,y,comp);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+
+STBIDEF int stbi_is_16_bit(char const *filename)
+{
+    FILE *f = stbi__fopen(filename, "rb");
+    int result;
+    if (!f) return stbi__err("can't fopen", "Unable to open file");
+    result = stbi_is_16_bit_from_file(f);
+    fclose(f);
+    return result;
+}
+
+STBIDEF int stbi_is_16_bit_from_file(FILE *f)
+{
+   int r;
+   stbi__context s;
+   long pos = ftell(f);
+   stbi__start_file(&s, f);
+   r = stbi__is_16_main(&s);
+   fseek(f,pos,SEEK_SET);
+   return r;
+}
+#endif // !STBI_NO_STDIO
+
+STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__info_main(&s,x,y,comp);
+}
+
+STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
+{
+   stbi__context s;
+   stbi__start_mem(&s,buffer,len);
+   return stbi__is_16_main(&s);
+}
+
+STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)
+{
+   stbi__context s;
+   stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
+   return stbi__is_16_main(&s);
+}
+
+#endif // STB_IMAGE_IMPLEMENTATION
+
+/*
+   revision history:
+      2.20  (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs
+      2.19  (2018-02-11) fix warning
+      2.18  (2018-01-30) fix warnings
+      2.17  (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug
+                         1-bit BMP
+                         *_is_16_bit api
+                         avoid warnings
+      2.16  (2017-07-23) all functions have 16-bit variants;
+                         STBI_NO_STDIO works again;
+                         compilation fixes;
+                         fix rounding in unpremultiply;
+                         optimize vertical flip;
+                         disable raw_len validation;
+                         documentation fixes
+      2.15  (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;
+                         warning fixes; disable run-time SSE detection on gcc;
+                         uniform handling of optional "return" values;
+                         thread-safe initialization of zlib tables
+      2.14  (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs
+      2.13  (2016-11-29) add 16-bit API, only supported for PNG right now
+      2.12  (2016-04-02) fix typo in 2.11 PSD fix that caused crashes
+      2.11  (2016-04-02) allocate large structures on the stack
+                         remove white matting for transparent PSD
+                         fix reported channel count for PNG & BMP
+                         re-enable SSE2 in non-gcc 64-bit
+                         support RGB-formatted JPEG
+                         read 16-bit PNGs (only as 8-bit)
+      2.10  (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED
+      2.09  (2016-01-16) allow comments in PNM files
+                         16-bit-per-pixel TGA (not bit-per-component)
+                         info() for TGA could break due to .hdr handling
+                         info() for BMP to shares code instead of sloppy parse
+                         can use STBI_REALLOC_SIZED if allocator doesn't support realloc
+                         code cleanup
+      2.08  (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA
+      2.07  (2015-09-13) fix compiler warnings
+                         partial animated GIF support
+                         limited 16-bpc PSD support
+                         #ifdef unused functions
+                         bug with < 92 byte PIC,PNM,HDR,TGA
+      2.06  (2015-04-19) fix bug where PSD returns wrong '*comp' value
+      2.05  (2015-04-19) fix bug in progressive JPEG handling, fix warning
+      2.04  (2015-04-15) try to re-enable SIMD on MinGW 64-bit
+      2.03  (2015-04-12) extra corruption checking (mmozeiko)
+                         stbi_set_flip_vertically_on_load (nguillemot)
+                         fix NEON support; fix mingw support
+      2.02  (2015-01-19) fix incorrect assert, fix warning
+      2.01  (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2
+      2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG
+      2.00  (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)
+                         progressive JPEG (stb)
+                         PGM/PPM support (Ken Miller)
+                         STBI_MALLOC,STBI_REALLOC,STBI_FREE
+                         GIF bugfix -- seemingly never worked
+                         STBI_NO_*, STBI_ONLY_*
+      1.48  (2014-12-14) fix incorrectly-named assert()
+      1.47  (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)
+                         optimize PNG (ryg)
+                         fix bug in interlaced PNG with user-specified channel count (stb)
+      1.46  (2014-08-26)
+              fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG
+      1.45  (2014-08-16)
+              fix MSVC-ARM internal compiler error by wrapping malloc
+      1.44  (2014-08-07)
+              various warning fixes from Ronny Chevalier
+      1.43  (2014-07-15)
+              fix MSVC-only compiler problem in code changed in 1.42
+      1.42  (2014-07-09)
+              don't define _CRT_SECURE_NO_WARNINGS (affects user code)
+              fixes to stbi__cleanup_jpeg path
+              added STBI_ASSERT to avoid requiring assert.h
+      1.41  (2014-06-25)
+              fix search&replace from 1.36 that messed up comments/error messages
+      1.40  (2014-06-22)
+              fix gcc struct-initialization warning
+      1.39  (2014-06-15)
+              fix to TGA optimization when req_comp != number of components in TGA;
+              fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)
+              add support for BMP version 5 (more ignored fields)
+      1.38  (2014-06-06)
+              suppress MSVC warnings on integer casts truncating values
+              fix accidental rename of 'skip' field of I/O
+      1.37  (2014-06-04)
+              remove duplicate typedef
+      1.36  (2014-06-03)
+              convert to header file single-file library
+              if de-iphone isn't set, load iphone images color-swapped instead of returning NULL
+      1.35  (2014-05-27)
+              various warnings
+              fix broken STBI_SIMD path
+              fix bug where stbi_load_from_file no longer left file pointer in correct place
+              fix broken non-easy path for 32-bit BMP (possibly never used)
+              TGA optimization by Arseny Kapoulkine
+      1.34  (unknown)
+              use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case
+      1.33  (2011-07-14)
+              make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements
+      1.32  (2011-07-13)
+              support for "info" function for all supported filetypes (SpartanJ)
+      1.31  (2011-06-20)
+              a few more leak fixes, bug in PNG handling (SpartanJ)
+      1.30  (2011-06-11)
+              added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)
+              removed deprecated format-specific test/load functions
+              removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway
+              error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)
+              fix inefficiency in decoding 32-bit BMP (David Woo)
+      1.29  (2010-08-16)
+              various warning fixes from Aurelien Pocheville
+      1.28  (2010-08-01)
+              fix bug in GIF palette transparency (SpartanJ)
+      1.27  (2010-08-01)
+              cast-to-stbi_uc to fix warnings
+      1.26  (2010-07-24)
+              fix bug in file buffering for PNG reported by SpartanJ
+      1.25  (2010-07-17)
+              refix trans_data warning (Won Chun)
+      1.24  (2010-07-12)
+              perf improvements reading from files on platforms with lock-heavy fgetc()
+              minor perf improvements for jpeg
+              deprecated type-specific functions so we'll get feedback if they're needed
+              attempt to fix trans_data warning (Won Chun)
+      1.23    fixed bug in iPhone support
+      1.22  (2010-07-10)
+              removed image *writing* support
+              stbi_info support from Jetro Lauha
+              GIF support from Jean-Marc Lienher
+              iPhone PNG-extensions from James Brown
+              warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)
+      1.21    fix use of 'stbi_uc' in header (reported by jon blow)
+      1.20    added support for Softimage PIC, by Tom Seddon
+      1.19    bug in interlaced PNG corruption check (found by ryg)
+      1.18  (2008-08-02)
+              fix a threading bug (local mutable static)
+      1.17    support interlaced PNG
+      1.16    major bugfix - stbi__convert_format converted one too many pixels
+      1.15    initialize some fields for thread safety
+      1.14    fix threadsafe conversion bug
+              header-file-only version (#define STBI_HEADER_FILE_ONLY before including)
+      1.13    threadsafe
+      1.12    const qualifiers in the API
+      1.11    Support installable IDCT, colorspace conversion routines
+      1.10    Fixes for 64-bit (don't use "unsigned long")
+              optimized upsampling by Fabian "ryg" Giesen
+      1.09    Fix format-conversion for PSD code (bad global variables!)
+      1.08    Thatcher Ulrich's PSD code integrated by Nicolas Schulz
+      1.07    attempt to fix C++ warning/errors again
+      1.06    attempt to fix C++ warning/errors again
+      1.05    fix TGA loading to return correct *comp and use good luminance calc
+      1.04    default float alpha is 1, not 255; use 'void *' for stbi_image_free
+      1.03    bugfixes to STBI_NO_STDIO, STBI_NO_HDR
+      1.02    support for (subset of) HDR files, float interface for preferred access to them
+      1.01    fix bug: possible bug in handling right-side up bmps... not sure
+              fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all
+      1.00    interface to zlib that skips zlib header
+      0.99    correct handling of alpha in palette
+      0.98    TGA loader by lonesock; dynamically add loaders (untested)
+      0.97    jpeg errors on too large a file; also catch another malloc failure
+      0.96    fix detection of invalid v value - particleman@mollyrocket forum
+      0.95    during header scan, seek to markers in case of padding
+      0.94    STBI_NO_STDIO to disable stdio usage; rename all #defines the same
+      0.93    handle jpegtran output; verbose errors
+      0.92    read 4,8,16,24,32-bit BMP files of several formats
+      0.91    output 24-bit Windows 3.0 BMP files
+      0.90    fix a few more warnings; bump version number to approach 1.0
+      0.61    bugfixes due to Marc LeBlanc, Christopher Lloyd
+      0.60    fix compiling as c++
+      0.59    fix warnings: merge Dave Moore's -Wall fixes
+      0.58    fix bug: zlib uncompressed mode len/nlen was wrong endian
+      0.57    fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available
+      0.56    fix bug: zlib uncompressed mode len vs. nlen
+      0.55    fix bug: restart_interval not initialized to 0
+      0.54    allow NULL for 'int *comp'
+      0.53    fix bug in png 3->4; speedup png decoding
+      0.52    png handles req_comp=3,4 directly; minor cleanup; jpeg comments
+      0.51    obey req_comp requests, 1-component jpegs return as 1-component,
+              on 'test' only check type, not whether we support this variant
+      0.50  (2006-11-19)
+              first released version
+*/
+
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file
diff --git a/stb_image_resize.h b/stb_image_resize.h
new file mode 100644
index 0000000..c8a2567
--- /dev/null
+++ b/stb_image_resize.h
@@ -0,0 +1,2634 @@
+/* stb_image_resize - v0.97 - public domain image resizing
+   by Jorge L Rodriguez (@VinoBS) - 2014
+   http://github.com/nothings/stb
+
+   Written with emphasis on usability, portability, and efficiency. (No
+   SIMD or threads, so it be easily outperformed by libs that use those.)
+   Only scaling and translation is supported, no rotations or shears.
+   Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation.
+
+   COMPILING & LINKING
+      In one C/C++ file that #includes this file, do this:
+         #define STB_IMAGE_RESIZE_IMPLEMENTATION
+      before the #include. That will create the implementation in that file.
+
+   QUICKSTART
+      stbir_resize_uint8(      input_pixels , in_w , in_h , 0,
+                               output_pixels, out_w, out_h, 0, num_channels)
+      stbir_resize_float(...)
+      stbir_resize_uint8_srgb( input_pixels , in_w , in_h , 0,
+                               output_pixels, out_w, out_h, 0,
+                               num_channels , alpha_chan  , 0)
+      stbir_resize_uint8_srgb_edgemode(
+                               input_pixels , in_w , in_h , 0,
+                               output_pixels, out_w, out_h, 0,
+                               num_channels , alpha_chan  , 0, STBIR_EDGE_CLAMP)
+                                                            // WRAP/REFLECT/ZERO
+
+   FULL API
+      See the "header file" section of the source for API documentation.
+
+   ADDITIONAL DOCUMENTATION
+
+      SRGB & FLOATING POINT REPRESENTATION
+         The sRGB functions presume IEEE floating point. If you do not have
+         IEEE floating point, define STBIR_NON_IEEE_FLOAT. This will use
+         a slower implementation.
+
+      MEMORY ALLOCATION
+         The resize functions here perform a single memory allocation using
+         malloc. To control the memory allocation, before the #include that
+         triggers the implementation, do:
+
+            #define STBIR_MALLOC(size,context) ...
+            #define STBIR_FREE(ptr,context)   ...
+
+         Each resize function makes exactly one call to malloc/free, so to use
+         temp memory, store the temp memory in the context and return that.
+
+      ASSERT
+         Define STBIR_ASSERT(boolval) to override assert() and not use assert.h
+
+      OPTIMIZATION
+         Define STBIR_SATURATE_INT to compute clamp values in-range using
+         integer operations instead of float operations. This may be faster
+         on some platforms.
+
+      DEFAULT FILTERS
+         For functions which don't provide explicit control over what filters
+         to use, you can change the compile-time defaults with
+
+            #define STBIR_DEFAULT_FILTER_UPSAMPLE     STBIR_FILTER_something
+            #define STBIR_DEFAULT_FILTER_DOWNSAMPLE   STBIR_FILTER_something
+
+         See stbir_filter in the header-file section for the list of filters.
+
+      NEW FILTERS
+         A number of 1D filter kernels are used. For a list of
+         supported filters see the stbir_filter enum. To add a new filter,
+         write a filter function and add it to stbir__filter_info_table.
+
+      PROGRESS
+         For interactive use with slow resize operations, you can install
+         a progress-report callback:
+
+            #define STBIR_PROGRESS_REPORT(val)   some_func(val)
+
+         The parameter val is a float which goes from 0 to 1 as progress is made.
+
+         For example:
+
+            static void my_progress_report(float progress);
+            #define STBIR_PROGRESS_REPORT(val) my_progress_report(val)
+
+            #define STB_IMAGE_RESIZE_IMPLEMENTATION
+            #include "stb_image_resize.h"
+
+            static void my_progress_report(float progress)
+            {
+               printf("Progress: %f%%\n", progress*100);
+            }
+
+      MAX CHANNELS
+         If your image has more than 64 channels, define STBIR_MAX_CHANNELS
+         to the max you'll have.
+
+      ALPHA CHANNEL
+         Most of the resizing functions provide the ability to control how
+         the alpha channel of an image is processed. The important things
+         to know about this:
+
+         1. The best mathematically-behaved version of alpha to use is
+         called "premultiplied alpha", in which the other color channels
+         have had the alpha value multiplied in. If you use premultiplied
+         alpha, linear filtering (such as image resampling done by this
+         library, or performed in texture units on GPUs) does the "right
+         thing". While premultiplied alpha is standard in the movie CGI
+         industry, it is still uncommon in the videogame/real-time world.
+
+         If you linearly filter non-premultiplied alpha, strange effects
+         occur. (For example, the 50/50 average of 99% transparent bright green
+         and 1% transparent black produces 50% transparent dark green when
+         non-premultiplied, whereas premultiplied it produces 50%
+         transparent near-black. The former introduces green energy
+         that doesn't exist in the source image.)
+
+         2. Artists should not edit premultiplied-alpha images; artists
+         want non-premultiplied alpha images. Thus, art tools generally output
+         non-premultiplied alpha images.
+
+         3. You will get best results in most cases by converting images
+         to premultiplied alpha before processing them mathematically.
+
+         4. If you pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED, the
+         resizer does not do anything special for the alpha channel;
+         it is resampled identically to other channels. This produces
+         the correct results for premultiplied-alpha images, but produces
+         less-than-ideal results for non-premultiplied-alpha images.
+
+         5. If you do not pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED,
+         then the resizer weights the contribution of input pixels
+         based on their alpha values, or, equivalently, it multiplies
+         the alpha value into the color channels, resamples, then divides
+         by the resultant alpha value. Input pixels which have alpha=0 do
+         not contribute at all to output pixels unless _all_ of the input
+         pixels affecting that output pixel have alpha=0, in which case
+         the result for that pixel is the same as it would be without
+         STBIR_FLAG_ALPHA_PREMULTIPLIED. However, this is only true for
+         input images in integer formats. For input images in float format,
+         input pixels with alpha=0 have no effect, and output pixels
+         which have alpha=0 will be 0 in all channels. (For float images,
+         you can manually achieve the same result by adding a tiny epsilon
+         value to the alpha channel of every image, and then subtracting
+         or clamping it at the end.)
+
+         6. You can suppress the behavior described in #5 and make
+         all-0-alpha pixels have 0 in all channels by #defining
+         STBIR_NO_ALPHA_EPSILON.
+
+         7. You can separately control whether the alpha channel is
+         interpreted as linear or affected by the colorspace. By default
+         it is linear; you almost never want to apply the colorspace.
+         (For example, graphics hardware does not apply sRGB conversion
+         to the alpha channel.)
+
+   CONTRIBUTORS
+      Jorge L Rodriguez: Implementation
+      Sean Barrett: API design, optimizations
+      Aras Pranckevicius: bugfix
+      Nathan Reed: warning fixes
+
+   REVISIONS
+      0.97 (2020-02-02) fixed warning
+      0.96 (2019-03-04) fixed warnings
+      0.95 (2017-07-23) fixed warnings
+      0.94 (2017-03-18) fixed warnings
+      0.93 (2017-03-03) fixed bug with certain combinations of heights
+      0.92 (2017-01-02) fix integer overflow on large (>2GB) images
+      0.91 (2016-04-02) fix warnings; fix handling of subpixel regions
+      0.90 (2014-09-17) first released version
+
+   LICENSE
+     See end of file for license information.
+
+   TODO
+      Don't decode all of the image data when only processing a partial tile
+      Don't use full-width decode buffers when only processing a partial tile
+      When processing wide images, break processing into tiles so data fits in L1 cache
+      Installable filters?
+      Resize that respects alpha test coverage
+         (Reference code: FloatImage::alphaTestCoverage and FloatImage::scaleAlphaToCoverage:
+         https://code.google.com/p/nvidia-texture-tools/source/browse/trunk/src/nvimage/FloatImage.cpp )
+*/
+
+#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE_H
+#define STBIR_INCLUDE_STB_IMAGE_RESIZE_H
+
+#ifdef _MSC_VER
+typedef unsigned char  stbir_uint8;
+typedef unsigned short stbir_uint16;
+typedef unsigned int   stbir_uint32;
+#else
+#include <stdint.h>
+typedef uint8_t  stbir_uint8;
+typedef uint16_t stbir_uint16;
+typedef uint32_t stbir_uint32;
+#endif
+
+#ifndef STBIRDEF
+#ifdef STB_IMAGE_RESIZE_STATIC
+#define STBIRDEF static
+#else
+#ifdef __cplusplus
+#define STBIRDEF extern "C"
+#else
+#define STBIRDEF extern
+#endif
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Easy-to-use API:
+//
+//     * "input pixels" points to an array of image data with 'num_channels' channels (e.g. RGB=3, RGBA=4)
+//     * input_w is input image width (x-axis), input_h is input image height (y-axis)
+//     * stride is the offset between successive rows of image data in memory, in bytes. you can
+//       specify 0 to mean packed continuously in memory
+//     * alpha channel is treated identically to other channels.
+//     * colorspace is linear or sRGB as specified by function name
+//     * returned result is 1 for success or 0 in case of an error.
+//       #define STBIR_ASSERT() to trigger an assert on parameter validation errors.
+//     * Memory required grows approximately linearly with input and output size, but with
+//       discontinuities at input_w == output_w and input_h == output_h.
+//     * These functions use a "default" resampling filter defined at compile time. To change the filter,
+//       you can change the compile-time defaults by #defining STBIR_DEFAULT_FILTER_UPSAMPLE
+//       and STBIR_DEFAULT_FILTER_DOWNSAMPLE, or you can use the medium-complexity API.
+
+STBIRDEF int stbir_resize_uint8(     const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels);
+
+STBIRDEF int stbir_resize_float(     const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels);
+
+
+// The following functions interpret image data as gamma-corrected sRGB.
+// Specify STBIR_ALPHA_CHANNEL_NONE if you have no alpha channel,
+// or otherwise provide the index of the alpha channel. Flags value
+// of 0 will probably do the right thing if you're not sure what
+// the flags mean.
+
+#define STBIR_ALPHA_CHANNEL_NONE       -1
+
+// Set this flag if your texture has premultiplied alpha. Otherwise, stbir will
+// use alpha-weighted resampling (effectively premultiplying, resampling,
+// then unpremultiplying).
+#define STBIR_FLAG_ALPHA_PREMULTIPLIED    (1 << 0)
+// The specified alpha channel should be handled as gamma-corrected value even
+// when doing sRGB operations.
+#define STBIR_FLAG_ALPHA_USES_COLORSPACE  (1 << 1)
+
+STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels, int alpha_channel, int flags);
+
+
+typedef enum
+{
+    STBIR_EDGE_CLAMP   = 1,
+    STBIR_EDGE_REFLECT = 2,
+    STBIR_EDGE_WRAP    = 3,
+    STBIR_EDGE_ZERO    = 4,
+} stbir_edge;
+
+// This function adds the ability to specify how requests to sample off the edge of the image are handled.
+STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                                    unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                              int num_channels, int alpha_channel, int flags,
+                                              stbir_edge edge_wrap_mode);
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Medium-complexity API
+//
+// This extends the easy-to-use API as follows:
+//
+//     * Alpha-channel can be processed separately
+//       * If alpha_channel is not STBIR_ALPHA_CHANNEL_NONE
+//         * Alpha channel will not be gamma corrected (unless flags&STBIR_FLAG_GAMMA_CORRECT)
+//         * Filters will be weighted by alpha channel (unless flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)
+//     * Filter can be selected explicitly
+//     * uint16 image type
+//     * sRGB colorspace available for all types
+//     * context parameter for passing to STBIR_MALLOC
+
+typedef enum
+{
+    STBIR_FILTER_DEFAULT      = 0,  // use same filter type that easy-to-use API chooses
+    STBIR_FILTER_BOX          = 1,  // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios
+    STBIR_FILTER_TRIANGLE     = 2,  // On upsampling, produces same results as bilinear texture filtering
+    STBIR_FILTER_CUBICBSPLINE = 3,  // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque
+    STBIR_FILTER_CATMULLROM   = 4,  // An interpolating cubic spline
+    STBIR_FILTER_MITCHELL     = 5,  // Mitchell-Netrevalli filter with B=1/3, C=1/3
+} stbir_filter;
+
+typedef enum
+{
+    STBIR_COLORSPACE_LINEAR,
+    STBIR_COLORSPACE_SRGB,
+
+    STBIR_MAX_COLORSPACES,
+} stbir_colorspace;
+
+// The following functions are all identical except for the type of the image data
+
+STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                               unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context);
+
+STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels  , int input_w , int input_h , int input_stride_in_bytes,
+                                               stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context);
+
+STBIRDEF int stbir_resize_float_generic( const float *input_pixels         , int input_w , int input_h , int input_stride_in_bytes,
+                                               float *output_pixels        , int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context);
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Full-complexity API
+//
+// This extends the medium API as follows:
+//
+//       * uint32 image type
+//     * not typesafe
+//     * separate filter types for each axis
+//     * separate edge modes for each axis
+//     * can specify scale explicitly for subpixel correctness
+//     * can specify image source tile using texture coordinates
+
+typedef enum
+{
+    STBIR_TYPE_UINT8 ,
+    STBIR_TYPE_UINT16,
+    STBIR_TYPE_UINT32,
+    STBIR_TYPE_FLOAT ,
+
+    STBIR_MAX_TYPES
+} stbir_datatype;
+
+STBIRDEF int stbir_resize(         const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context);
+
+STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context,
+                                   float x_scale, float y_scale,
+                                   float x_offset, float y_offset);
+
+STBIRDEF int stbir_resize_region(  const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context,
+                                   float s0, float t0, float s1, float t1);
+// (s0, t0) & (s1, t1) are the top-left and bottom right corner (uv addressing style: [0, 1]x[0, 1]) of a region of the input image to use.
+
+//
+//
+////   end header file   /////////////////////////////////////////////////////
+#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE_H
+
+
+
+
+
+#ifdef STB_IMAGE_RESIZE_IMPLEMENTATION
+
+#ifndef STBIR_ASSERT
+#include <assert.h>
+#define STBIR_ASSERT(x) assert(x)
+#endif
+
+// For memset
+#include <string.h>
+
+#include <math.h>
+
+#ifndef STBIR_MALLOC
+#include <stdlib.h>
+// use comma operator to evaluate c, to avoid "unused parameter" warnings
+#define STBIR_MALLOC(size,c) ((void)(c), malloc(size))
+#define STBIR_FREE(ptr,c)    ((void)(c), free(ptr))
+#endif
+
+#ifndef _MSC_VER
+#ifdef __cplusplus
+#define stbir__inline inline
+#else
+#define stbir__inline
+#endif
+#else
+#define stbir__inline __forceinline
+#endif
+
+
+// should produce compiler error if size is wrong
+typedef unsigned char stbir__validate_uint32[sizeof(stbir_uint32) == 4 ? 1 : -1];
+
+#ifdef _MSC_VER
+#define STBIR__NOTUSED(v)  (void)(v)
+#else
+#define STBIR__NOTUSED(v)  (void)sizeof(v)
+#endif
+
+#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))
+
+#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE
+#define STBIR_DEFAULT_FILTER_UPSAMPLE    STBIR_FILTER_CATMULLROM
+#endif
+
+#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE
+#define STBIR_DEFAULT_FILTER_DOWNSAMPLE  STBIR_FILTER_MITCHELL
+#endif
+
+#ifndef STBIR_PROGRESS_REPORT
+#define STBIR_PROGRESS_REPORT(float_0_to_1)
+#endif
+
+#ifndef STBIR_MAX_CHANNELS
+#define STBIR_MAX_CHANNELS 64
+#endif
+
+#if STBIR_MAX_CHANNELS > 65536
+#error "Too many channels; STBIR_MAX_CHANNELS must be no more than 65536."
+// because we store the indices in 16-bit variables
+#endif
+
+// This value is added to alpha just before premultiplication to avoid
+// zeroing out color values. It is equivalent to 2^-80. If you don't want
+// that behavior (it may interfere if you have floating point images with
+// very small alpha values) then you can define STBIR_NO_ALPHA_EPSILON to
+// disable it.
+#ifndef STBIR_ALPHA_EPSILON
+#define STBIR_ALPHA_EPSILON ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20))
+#endif
+
+
+
+#ifdef _MSC_VER
+#define STBIR__UNUSED_PARAM(v)  (void)(v)
+#else
+#define STBIR__UNUSED_PARAM(v)  (void)sizeof(v)
+#endif
+
+// must match stbir_datatype
+static unsigned char stbir__type_size[] = {
+    1, // STBIR_TYPE_UINT8
+    2, // STBIR_TYPE_UINT16
+    4, // STBIR_TYPE_UINT32
+    4, // STBIR_TYPE_FLOAT
+};
+
+// Kernel function centered at 0
+typedef float (stbir__kernel_fn)(float x, float scale);
+typedef float (stbir__support_fn)(float scale);
+
+typedef struct
+{
+    stbir__kernel_fn* kernel;
+    stbir__support_fn* support;
+} stbir__filter_info;
+
+// When upsampling, the contributors are which source pixels contribute.
+// When downsampling, the contributors are which destination pixels are contributed to.
+typedef struct
+{
+    int n0; // First contributing pixel
+    int n1; // Last contributing pixel
+} stbir__contributors;
+
+typedef struct
+{
+    const void* input_data;
+    int input_w;
+    int input_h;
+    int input_stride_bytes;
+
+    void* output_data;
+    int output_w;
+    int output_h;
+    int output_stride_bytes;
+
+    float s0, t0, s1, t1;
+
+    float horizontal_shift; // Units: output pixels
+    float vertical_shift;   // Units: output pixels
+    float horizontal_scale;
+    float vertical_scale;
+
+    int channels;
+    int alpha_channel;
+    stbir_uint32 flags;
+    stbir_datatype type;
+    stbir_filter horizontal_filter;
+    stbir_filter vertical_filter;
+    stbir_edge edge_horizontal;
+    stbir_edge edge_vertical;
+    stbir_colorspace colorspace;
+
+    stbir__contributors* horizontal_contributors;
+    float* horizontal_coefficients;
+
+    stbir__contributors* vertical_contributors;
+    float* vertical_coefficients;
+
+    int decode_buffer_pixels;
+    float* decode_buffer;
+
+    float* horizontal_buffer;
+
+    // cache these because ceil/floor are inexplicably showing up in profile
+    int horizontal_coefficient_width;
+    int vertical_coefficient_width;
+    int horizontal_filter_pixel_width;
+    int vertical_filter_pixel_width;
+    int horizontal_filter_pixel_margin;
+    int vertical_filter_pixel_margin;
+    int horizontal_num_contributors;
+    int vertical_num_contributors;
+
+    int ring_buffer_length_bytes;   // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter)
+    int ring_buffer_num_entries;    // Total number of entries in the ring buffer.
+    int ring_buffer_first_scanline;
+    int ring_buffer_last_scanline;
+    int ring_buffer_begin_index;    // first_scanline is at this index in the ring buffer
+    float* ring_buffer;
+
+    float* encode_buffer; // A temporary buffer to store floats so we don't lose precision while we do multiply-adds.
+
+    int horizontal_contributors_size;
+    int horizontal_coefficients_size;
+    int vertical_contributors_size;
+    int vertical_coefficients_size;
+    int decode_buffer_size;
+    int horizontal_buffer_size;
+    int ring_buffer_size;
+    int encode_buffer_size;
+} stbir__info;
+
+
+static const float stbir__max_uint8_as_float  = 255.0f;
+static const float stbir__max_uint16_as_float = 65535.0f;
+static const double stbir__max_uint32_as_float = 4294967295.0;
+
+
+static stbir__inline int stbir__min(int a, int b)
+{
+    return a < b ? a : b;
+}
+
+static stbir__inline float stbir__saturate(float x)
+{
+    if (x < 0)
+        return 0;
+
+    if (x > 1)
+        return 1;
+
+    return x;
+}
+
+#ifdef STBIR_SATURATE_INT
+static stbir__inline stbir_uint8 stbir__saturate8(int x)
+{
+    if ((unsigned int) x <= 255)
+        return x;
+
+    if (x < 0)
+        return 0;
+
+    return 255;
+}
+
+static stbir__inline stbir_uint16 stbir__saturate16(int x)
+{
+    if ((unsigned int) x <= 65535)
+        return x;
+
+    if (x < 0)
+        return 0;
+
+    return 65535;
+}
+#endif
+
+static float stbir__srgb_uchar_to_linear_float[256] = {
+    0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f,
+    0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f,
+    0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f,
+    0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f,
+    0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f,
+    0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f,
+    0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f,
+    0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f,
+    0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f,
+    0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f,
+    0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f,
+    0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f,
+    0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f,
+    0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f,
+    0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f,
+    0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f,
+    0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f,
+    0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f,
+    0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f,
+    0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f,
+    0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f,
+    0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f,
+    0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f,
+    0.982251f, 0.991102f, 1.0f
+};
+
+static float stbir__srgb_to_linear(float f)
+{
+    if (f <= 0.04045f)
+        return f / 12.92f;
+    else
+        return (float)pow((f + 0.055f) / 1.055f, 2.4f);
+}
+
+static float stbir__linear_to_srgb(float f)
+{
+    if (f <= 0.0031308f)
+        return f * 12.92f;
+    else
+        return 1.055f * (float)pow(f, 1 / 2.4f) - 0.055f;
+}
+
+#ifndef STBIR_NON_IEEE_FLOAT
+// From https://gist.github.com/rygorous/2203834
+
+typedef union
+{
+    stbir_uint32 u;
+    float f;
+} stbir__FP32;
+
+static const stbir_uint32 fp32_to_srgb8_tab4[104] = {
+    0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d,
+    0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a,
+    0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033,
+    0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067,
+    0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5,
+    0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2,
+    0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143,
+    0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af,
+    0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240,
+    0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300,
+    0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401,
+    0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559,
+    0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723,
+};
+
+static stbir_uint8 stbir__linear_to_srgb_uchar(float in)
+{
+    static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps
+    static const stbir__FP32 minval = { (127-13) << 23 };
+    stbir_uint32 tab,bias,scale,t;
+    stbir__FP32 f;
+
+    // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively.
+    // The tests are carefully written so that NaNs map to 0, same as in the reference
+    // implementation.
+    if (!(in > minval.f)) // written this way to catch NaNs
+        in = minval.f;
+    if (in > almostone.f)
+        in = almostone.f;
+
+    // Do the table lookup and unpack bias, scale
+    f.f = in;
+    tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20];
+    bias = (tab >> 16) << 9;
+    scale = tab & 0xffff;
+
+    // Grab next-highest mantissa bits and perform linear interpolation
+    t = (f.u >> 12) & 0xff;
+    return (unsigned char) ((bias + scale*t) >> 16);
+}
+
+#else
+// sRGB transition values, scaled by 1<<28
+static int stbir__srgb_offset_to_linear_scaled[256] =
+{
+            0,     40738,    122216,    203693,    285170,    366648,    448125,    529603,
+       611080,    692557,    774035,    855852,    942009,   1033024,   1128971,   1229926,
+      1335959,   1447142,   1563542,   1685229,   1812268,   1944725,   2082664,   2226148,
+      2375238,   2529996,   2690481,   2856753,   3028870,   3206888,   3390865,   3580856,
+      3776916,   3979100,   4187460,   4402049,   4622919,   4850123,   5083710,   5323731,
+      5570236,   5823273,   6082892,   6349140,   6622065,   6901714,   7188133,   7481369,
+      7781466,   8088471,   8402427,   8723380,   9051372,   9386448,   9728650,  10078021,
+     10434603,  10798439,  11169569,  11548036,  11933879,  12327139,  12727857,  13136073,
+     13551826,  13975156,  14406100,  14844697,  15290987,  15745007,  16206795,  16676389,
+     17153826,  17639142,  18132374,  18633560,  19142734,  19659934,  20185196,  20718552,
+     21260042,  21809696,  22367554,  22933648,  23508010,  24090680,  24681686,  25281066,
+     25888850,  26505076,  27129772,  27762974,  28404716,  29055026,  29713942,  30381490,
+     31057708,  31742624,  32436272,  33138682,  33849884,  34569912,  35298800,  36036568,
+     36783260,  37538896,  38303512,  39077136,  39859796,  40651528,  41452360,  42262316,
+     43081432,  43909732,  44747252,  45594016,  46450052,  47315392,  48190064,  49074096,
+     49967516,  50870356,  51782636,  52704392,  53635648,  54576432,  55526772,  56486700,
+     57456236,  58435408,  59424248,  60422780,  61431036,  62449032,  63476804,  64514376,
+     65561776,  66619028,  67686160,  68763192,  69850160,  70947088,  72053992,  73170912,
+     74297864,  75434880,  76581976,  77739184,  78906536,  80084040,  81271736,  82469648,
+     83677792,  84896192,  86124888,  87363888,  88613232,  89872928,  91143016,  92423512,
+     93714432,  95015816,  96327688,  97650056,  98982952, 100326408, 101680440, 103045072,
+    104420320, 105806224, 107202800, 108610064, 110028048, 111456776, 112896264, 114346544,
+    115807632, 117279552, 118762328, 120255976, 121760536, 123276016, 124802440, 126339832,
+    127888216, 129447616, 131018048, 132599544, 134192112, 135795792, 137410592, 139036528,
+    140673648, 142321952, 143981456, 145652208, 147334208, 149027488, 150732064, 152447968,
+    154175200, 155913792, 157663776, 159425168, 161197984, 162982240, 164777968, 166585184,
+    168403904, 170234160, 172075968, 173929344, 175794320, 177670896, 179559120, 181458992,
+    183370528, 185293776, 187228736, 189175424, 191133888, 193104112, 195086128, 197079968,
+    199085648, 201103184, 203132592, 205173888, 207227120, 209292272, 211369392, 213458480,
+    215559568, 217672656, 219797792, 221934976, 224084240, 226245600, 228419056, 230604656,
+    232802400, 235012320, 237234432, 239468736, 241715280, 243974080, 246245120, 248528464,
+    250824112, 253132064, 255452368, 257785040, 260130080, 262487520, 264857376, 267239664,
+};
+
+static stbir_uint8 stbir__linear_to_srgb_uchar(float f)
+{
+    int x = (int) (f * (1 << 28)); // has headroom so you don't need to clamp
+    int v = 0;
+    int i;
+
+    // Refine the guess with a short binary search.
+    i = v + 128; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +  64; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +  32; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +  16; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +   8; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +   4; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +   2; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+    i = v +   1; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i;
+
+    return (stbir_uint8) v;
+}
+#endif
+
+static float stbir__filter_trapezoid(float x, float scale)
+{
+    float halfscale = scale / 2;
+    float t = 0.5f + halfscale;
+    STBIR_ASSERT(scale <= 1);
+
+    x = (float)fabs(x);
+
+    if (x >= t)
+        return 0;
+    else
+    {
+        float r = 0.5f - halfscale;
+        if (x <= r)
+            return 1;
+        else
+            return (t - x) / scale;
+    }
+}
+
+static float stbir__support_trapezoid(float scale)
+{
+    STBIR_ASSERT(scale <= 1);
+    return 0.5f + scale / 2;
+}
+
+static float stbir__filter_triangle(float x, float s)
+{
+    STBIR__UNUSED_PARAM(s);
+
+    x = (float)fabs(x);
+
+    if (x <= 1.0f)
+        return 1 - x;
+    else
+        return 0;
+}
+
+static float stbir__filter_cubic(float x, float s)
+{
+    STBIR__UNUSED_PARAM(s);
+
+    x = (float)fabs(x);
+
+    if (x < 1.0f)
+        return (4 + x*x*(3*x - 6))/6;
+    else if (x < 2.0f)
+        return (8 + x*(-12 + x*(6 - x)))/6;
+
+    return (0.0f);
+}
+
+static float stbir__filter_catmullrom(float x, float s)
+{
+    STBIR__UNUSED_PARAM(s);
+
+    x = (float)fabs(x);
+
+    if (x < 1.0f)
+        return 1 - x*x*(2.5f - 1.5f*x);
+    else if (x < 2.0f)
+        return 2 - x*(4 + x*(0.5f*x - 2.5f));
+
+    return (0.0f);
+}
+
+static float stbir__filter_mitchell(float x, float s)
+{
+    STBIR__UNUSED_PARAM(s);
+
+    x = (float)fabs(x);
+
+    if (x < 1.0f)
+        return (16 + x*x*(21 * x - 36))/18;
+    else if (x < 2.0f)
+        return (32 + x*(-60 + x*(36 - 7*x)))/18;
+
+    return (0.0f);
+}
+
+static float stbir__support_zero(float s)
+{
+    STBIR__UNUSED_PARAM(s);
+    return 0;
+}
+
+static float stbir__support_one(float s)
+{
+    STBIR__UNUSED_PARAM(s);
+    return 1;
+}
+
+static float stbir__support_two(float s)
+{
+    STBIR__UNUSED_PARAM(s);
+    return 2;
+}
+
+static stbir__filter_info stbir__filter_info_table[] = {
+        { NULL,                     stbir__support_zero },
+        { stbir__filter_trapezoid,  stbir__support_trapezoid },
+        { stbir__filter_triangle,   stbir__support_one },
+        { stbir__filter_cubic,      stbir__support_two },
+        { stbir__filter_catmullrom, stbir__support_two },
+        { stbir__filter_mitchell,   stbir__support_two },
+};
+
+stbir__inline static int stbir__use_upsampling(float ratio)
+{
+    return ratio > 1;
+}
+
+stbir__inline static int stbir__use_width_upsampling(stbir__info* stbir_info)
+{
+    return stbir__use_upsampling(stbir_info->horizontal_scale);
+}
+
+stbir__inline static int stbir__use_height_upsampling(stbir__info* stbir_info)
+{
+    return stbir__use_upsampling(stbir_info->vertical_scale);
+}
+
+// This is the maximum number of input samples that can affect an output sample
+// with the given filter
+static int stbir__get_filter_pixel_width(stbir_filter filter, float scale)
+{
+    STBIR_ASSERT(filter != 0);
+    STBIR_ASSERT(filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
+
+    if (stbir__use_upsampling(scale))
+        return (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2);
+    else
+        return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2 / scale);
+}
+
+// This is how much to expand buffers to account for filters seeking outside
+// the image boundaries.
+static int stbir__get_filter_pixel_margin(stbir_filter filter, float scale)
+{
+    return stbir__get_filter_pixel_width(filter, scale) / 2;
+}
+
+static int stbir__get_coefficient_width(stbir_filter filter, float scale)
+{
+    if (stbir__use_upsampling(scale))
+        return (int)ceil(stbir__filter_info_table[filter].support(1 / scale) * 2);
+    else
+        return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2);
+}
+
+static int stbir__get_contributors(float scale, stbir_filter filter, int input_size, int output_size)
+{
+    if (stbir__use_upsampling(scale))
+        return output_size;
+    else
+        return (input_size + stbir__get_filter_pixel_margin(filter, scale) * 2);
+}
+
+static int stbir__get_total_horizontal_coefficients(stbir__info* info)
+{
+    return info->horizontal_num_contributors
+         * stbir__get_coefficient_width      (info->horizontal_filter, info->horizontal_scale);
+}
+
+static int stbir__get_total_vertical_coefficients(stbir__info* info)
+{
+    return info->vertical_num_contributors
+         * stbir__get_coefficient_width      (info->vertical_filter, info->vertical_scale);
+}
+
+static stbir__contributors* stbir__get_contributor(stbir__contributors* contributors, int n)
+{
+    return &contributors[n];
+}
+
+// For perf reasons this code is duplicated in stbir__resample_horizontal_upsample/downsample,
+// if you change it here change it there too.
+static float* stbir__get_coefficient(float* coefficients, stbir_filter filter, float scale, int n, int c)
+{
+    int width = stbir__get_coefficient_width(filter, scale);
+    return &coefficients[width*n + c];
+}
+
+static int stbir__edge_wrap_slow(stbir_edge edge, int n, int max)
+{
+    switch (edge)
+    {
+    case STBIR_EDGE_ZERO:
+        return 0; // we'll decode the wrong pixel here, and then overwrite with 0s later
+
+    case STBIR_EDGE_CLAMP:
+        if (n < 0)
+            return 0;
+
+        if (n >= max)
+            return max - 1;
+
+        return n; // NOTREACHED
+
+    case STBIR_EDGE_REFLECT:
+    {
+        if (n < 0)
+        {
+            if (n < max)
+                return -n;
+            else
+                return max - 1;
+        }
+
+        if (n >= max)
+        {
+            int max2 = max * 2;
+            if (n >= max2)
+                return 0;
+            else
+                return max2 - n - 1;
+        }
+
+        return n; // NOTREACHED
+    }
+
+    case STBIR_EDGE_WRAP:
+        if (n >= 0)
+            return (n % max);
+        else
+        {
+            int m = (-n) % max;
+
+            if (m != 0)
+                m = max - m;
+
+            return (m);
+        }
+        // NOTREACHED
+
+    default:
+        STBIR_ASSERT(!"Unimplemented edge type");
+        return 0;
+    }
+}
+
+stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)
+{
+    // avoid per-pixel switch
+    if (n >= 0 && n < max)
+        return n;
+    return stbir__edge_wrap_slow(edge, n, max);
+}
+
+// What input pixels contribute to this output pixel?
+static void stbir__calculate_sample_range_upsample(int n, float out_filter_radius, float scale_ratio, float out_shift, int* in_first_pixel, int* in_last_pixel, float* in_center_of_out)
+{
+    float out_pixel_center = (float)n + 0.5f;
+    float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius;
+    float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius;
+
+    float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) / scale_ratio;
+    float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) / scale_ratio;
+
+    *in_center_of_out = (out_pixel_center + out_shift) / scale_ratio;
+    *in_first_pixel = (int)(floor(in_pixel_influence_lowerbound + 0.5));
+    *in_last_pixel = (int)(floor(in_pixel_influence_upperbound - 0.5));
+}
+
+// What output pixels does this input pixel contribute to?
+static void stbir__calculate_sample_range_downsample(int n, float in_pixels_radius, float scale_ratio, float out_shift, int* out_first_pixel, int* out_last_pixel, float* out_center_of_in)
+{
+    float in_pixel_center = (float)n + 0.5f;
+    float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius;
+    float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius;
+
+    float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale_ratio - out_shift;
+    float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale_ratio - out_shift;
+
+    *out_center_of_in = in_pixel_center * scale_ratio - out_shift;
+    *out_first_pixel = (int)(floor(out_pixel_influence_lowerbound + 0.5));
+    *out_last_pixel = (int)(floor(out_pixel_influence_upperbound - 0.5));
+}
+
+static void stbir__calculate_coefficients_upsample(stbir_filter filter, float scale, int in_first_pixel, int in_last_pixel, float in_center_of_out, stbir__contributors* contributor, float* coefficient_group)
+{
+    int i;
+    float total_filter = 0;
+    float filter_scale;
+
+    STBIR_ASSERT(in_last_pixel - in_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.
+
+    contributor->n0 = in_first_pixel;
+    contributor->n1 = in_last_pixel;
+
+    STBIR_ASSERT(contributor->n1 >= contributor->n0);
+
+    for (i = 0; i <= in_last_pixel - in_first_pixel; i++)
+    {
+        float in_pixel_center = (float)(i + in_first_pixel) + 0.5f;
+        coefficient_group[i] = stbir__filter_info_table[filter].kernel(in_center_of_out - in_pixel_center, 1 / scale);
+
+        // If the coefficient is zero, skip it. (Don't do the <0 check here, we want the influence of those outside pixels.)
+        if (i == 0 && !coefficient_group[i])
+        {
+            contributor->n0 = ++in_first_pixel;
+            i--;
+            continue;
+        }
+
+        total_filter += coefficient_group[i];
+    }
+
+    // NOTE(fg): Not actually true in general, nor is there any reason to expect it should be.
+    // It would be true in exact math but is at best approximately true in floating-point math,
+    // and it would not make sense to try and put actual bounds on this here because it depends
+    // on the image aspect ratio which can get pretty extreme.
+    //STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(in_last_pixel + 1) + 0.5f - in_center_of_out, 1/scale) == 0);
+
+    STBIR_ASSERT(total_filter > 0.9);
+    STBIR_ASSERT(total_filter < 1.1f); // Make sure it's not way off.
+
+    // Make sure the sum of all coefficients is 1.
+    filter_scale = 1 / total_filter;
+
+    for (i = 0; i <= in_last_pixel - in_first_pixel; i++)
+        coefficient_group[i] *= filter_scale;
+
+    for (i = in_last_pixel - in_first_pixel; i >= 0; i--)
+    {
+        if (coefficient_group[i])
+            break;
+
+        // This line has no weight. We can skip it.
+        contributor->n1 = contributor->n0 + i - 1;
+    }
+}
+
+static void stbir__calculate_coefficients_downsample(stbir_filter filter, float scale_ratio, int out_first_pixel, int out_last_pixel, float out_center_of_in, stbir__contributors* contributor, float* coefficient_group)
+{
+    int i;
+
+    STBIR_ASSERT(out_last_pixel - out_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(scale_ratio) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical.
+
+    contributor->n0 = out_first_pixel;
+    contributor->n1 = out_last_pixel;
+
+    STBIR_ASSERT(contributor->n1 >= contributor->n0);
+
+    for (i = 0; i <= out_last_pixel - out_first_pixel; i++)
+    {
+        float out_pixel_center = (float)(i + out_first_pixel) + 0.5f;
+        float x = out_pixel_center - out_center_of_in;
+        coefficient_group[i] = stbir__filter_info_table[filter].kernel(x, scale_ratio) * scale_ratio;
+    }
+
+    // NOTE(fg): Not actually true in general, nor is there any reason to expect it should be.
+    // It would be true in exact math but is at best approximately true in floating-point math,
+    // and it would not make sense to try and put actual bounds on this here because it depends
+    // on the image aspect ratio which can get pretty extreme.
+    //STBIR_ASSERT(stbir__filter_info_table[filter].kernel((float)(out_last_pixel + 1) + 0.5f - out_center_of_in, scale_ratio) == 0);
+
+    for (i = out_last_pixel - out_first_pixel; i >= 0; i--)
+    {
+        if (coefficient_group[i])
+            break;
+
+        // This line has no weight. We can skip it.
+        contributor->n1 = contributor->n0 + i - 1;
+    }
+}
+
+static void stbir__normalize_downsample_coefficients(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, int input_size, int output_size)
+{
+    int num_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);
+    int num_coefficients = stbir__get_coefficient_width(filter, scale_ratio);
+    int i, j;
+    int skip;
+
+    for (i = 0; i < output_size; i++)
+    {
+        float scale;
+        float total = 0;
+
+        for (j = 0; j < num_contributors; j++)
+        {
+            if (i >= contributors[j].n0 && i <= contributors[j].n1)
+            {
+                float coefficient = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0);
+                total += coefficient;
+            }
+            else if (i < contributors[j].n0)
+                break;
+        }
+
+        STBIR_ASSERT(total > 0.9f);
+        STBIR_ASSERT(total < 1.1f);
+
+        scale = 1 / total;
+
+        for (j = 0; j < num_contributors; j++)
+        {
+            if (i >= contributors[j].n0 && i <= contributors[j].n1)
+                *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0) *= scale;
+            else if (i < contributors[j].n0)
+                break;
+        }
+    }
+
+    // Optimize: Skip zero coefficients and contributions outside of image bounds.
+    // Do this after normalizing because normalization depends on the n0/n1 values.
+    for (j = 0; j < num_contributors; j++)
+    {
+        int range, max, width;
+
+        skip = 0;
+        while (*stbir__get_coefficient(coefficients, filter, scale_ratio, j, skip) == 0)
+            skip++;
+
+        contributors[j].n0 += skip;
+
+        while (contributors[j].n0 < 0)
+        {
+            contributors[j].n0++;
+            skip++;
+        }
+
+        range = contributors[j].n1 - contributors[j].n0 + 1;
+        max = stbir__min(num_coefficients, range);
+
+        width = stbir__get_coefficient_width(filter, scale_ratio);
+        for (i = 0; i < max; i++)
+        {
+            if (i + skip >= width)
+                break;
+
+            *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i) = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i + skip);
+        }
+
+        continue;
+    }
+
+    // Using min to avoid writing into invalid pixels.
+    for (i = 0; i < num_contributors; i++)
+        contributors[i].n1 = stbir__min(contributors[i].n1, output_size - 1);
+}
+
+// Each scan line uses the same kernel values so we should calculate the kernel
+// values once and then we can use them for every scan line.
+static void stbir__calculate_filters(stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, float shift, int input_size, int output_size)
+{
+    int n;
+    int total_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size);
+
+    if (stbir__use_upsampling(scale_ratio))
+    {
+        float out_pixels_radius = stbir__filter_info_table[filter].support(1 / scale_ratio) * scale_ratio;
+
+        // Looping through out pixels
+        for (n = 0; n < total_contributors; n++)
+        {
+            float in_center_of_out; // Center of the current out pixel in the in pixel space
+            int in_first_pixel, in_last_pixel;
+
+            stbir__calculate_sample_range_upsample(n, out_pixels_radius, scale_ratio, shift, &in_first_pixel, &in_last_pixel, &in_center_of_out);
+
+            stbir__calculate_coefficients_upsample(filter, scale_ratio, in_first_pixel, in_last_pixel, in_center_of_out, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));
+        }
+    }
+    else
+    {
+        float in_pixels_radius = stbir__filter_info_table[filter].support(scale_ratio) / scale_ratio;
+
+        // Looping through in pixels
+        for (n = 0; n < total_contributors; n++)
+        {
+            float out_center_of_in; // Center of the current out pixel in the in pixel space
+            int out_first_pixel, out_last_pixel;
+            int n_adjusted = n - stbir__get_filter_pixel_margin(filter, scale_ratio);
+
+            stbir__calculate_sample_range_downsample(n_adjusted, in_pixels_radius, scale_ratio, shift, &out_first_pixel, &out_last_pixel, &out_center_of_in);
+
+            stbir__calculate_coefficients_downsample(filter, scale_ratio, out_first_pixel, out_last_pixel, out_center_of_in, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0));
+        }
+
+        stbir__normalize_downsample_coefficients(contributors, coefficients, filter, scale_ratio, input_size, output_size);
+    }
+}
+
+static float* stbir__get_decode_buffer(stbir__info* stbir_info)
+{
+    // The 0 index of the decode buffer starts after the margin. This makes
+    // it okay to use negative indexes on the decode buffer.
+    return &stbir_info->decode_buffer[stbir_info->horizontal_filter_pixel_margin * stbir_info->channels];
+}
+
+#define STBIR__DECODE(type, colorspace) ((int)(type) * (STBIR_MAX_COLORSPACES) + (int)(colorspace))
+
+static void stbir__decode_scanline(stbir__info* stbir_info, int n)
+{
+    int c;
+    int channels = stbir_info->channels;
+    int alpha_channel = stbir_info->alpha_channel;
+    int type = stbir_info->type;
+    int colorspace = stbir_info->colorspace;
+    int input_w = stbir_info->input_w;
+    size_t input_stride_bytes = stbir_info->input_stride_bytes;
+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);
+    stbir_edge edge_horizontal = stbir_info->edge_horizontal;
+    stbir_edge edge_vertical = stbir_info->edge_vertical;
+    size_t in_buffer_row_offset = stbir__edge_wrap(edge_vertical, n, stbir_info->input_h) * input_stride_bytes;
+    const void* input_data = (char *) stbir_info->input_data + in_buffer_row_offset;
+    int max_x = input_w + stbir_info->horizontal_filter_pixel_margin;
+    int decode = STBIR__DECODE(type, colorspace);
+
+    int x = -stbir_info->horizontal_filter_pixel_margin;
+
+    // special handling for STBIR_EDGE_ZERO because it needs to return an item that doesn't appear in the input,
+    // and we want to avoid paying overhead on every pixel if not STBIR_EDGE_ZERO
+    if (edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->input_h))
+    {
+        for (; x < max_x; x++)
+            for (c = 0; c < channels; c++)
+                decode_buffer[x*channels + c] = 0;
+        return;
+    }
+
+    switch (decode)
+    {
+    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned char*)input_data)[input_pixel_index + c]) / stbir__max_uint8_as_float;
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = stbir__srgb_uchar_to_linear_float[((const unsigned char*)input_data)[input_pixel_index + c]];
+
+            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned char*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint8_as_float;
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = ((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float;
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((float)((const unsigned short*)input_data)[input_pixel_index + c]) / stbir__max_uint16_as_float);
+
+            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned short*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint16_as_float;
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float);
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear((float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / stbir__max_uint32_as_float));
+
+            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                decode_buffer[decode_pixel_index + alpha_channel] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + alpha_channel]) / stbir__max_uint32_as_float);
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = ((const float*)input_data)[input_pixel_index + c];
+        }
+        break;
+
+    case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):
+        for (; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+            int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels;
+            for (c = 0; c < channels; c++)
+                decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((const float*)input_data)[input_pixel_index + c]);
+
+            if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                decode_buffer[decode_pixel_index + alpha_channel] = ((const float*)input_data)[input_pixel_index + alpha_channel];
+        }
+
+        break;
+
+    default:
+        STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");
+        break;
+    }
+
+    if (!(stbir_info->flags & STBIR_FLAG_ALPHA_PREMULTIPLIED))
+    {
+        for (x = -stbir_info->horizontal_filter_pixel_margin; x < max_x; x++)
+        {
+            int decode_pixel_index = x * channels;
+
+            // If the alpha value is 0 it will clobber the color values. Make sure it's not.
+            float alpha = decode_buffer[decode_pixel_index + alpha_channel];
+#ifndef STBIR_NO_ALPHA_EPSILON
+            if (stbir_info->type != STBIR_TYPE_FLOAT) {
+                alpha += STBIR_ALPHA_EPSILON;
+                decode_buffer[decode_pixel_index + alpha_channel] = alpha;
+            }
+#endif
+            for (c = 0; c < channels; c++)
+            {
+                if (c == alpha_channel)
+                    continue;
+
+                decode_buffer[decode_pixel_index + c] *= alpha;
+            }
+        }
+    }
+
+    if (edge_horizontal == STBIR_EDGE_ZERO)
+    {
+        for (x = -stbir_info->horizontal_filter_pixel_margin; x < 0; x++)
+        {
+            for (c = 0; c < channels; c++)
+                decode_buffer[x*channels + c] = 0;
+        }
+        for (x = input_w; x < max_x; x++)
+        {
+            for (c = 0; c < channels; c++)
+                decode_buffer[x*channels + c] = 0;
+        }
+    }
+}
+
+static float* stbir__get_ring_buffer_entry(float* ring_buffer, int index, int ring_buffer_length)
+{
+    return &ring_buffer[index * ring_buffer_length];
+}
+
+static float* stbir__add_empty_ring_buffer_entry(stbir__info* stbir_info, int n)
+{
+    int ring_buffer_index;
+    float* ring_buffer;
+
+    stbir_info->ring_buffer_last_scanline = n;
+
+    if (stbir_info->ring_buffer_begin_index < 0)
+    {
+        ring_buffer_index = stbir_info->ring_buffer_begin_index = 0;
+        stbir_info->ring_buffer_first_scanline = n;
+    }
+    else
+    {
+        ring_buffer_index = (stbir_info->ring_buffer_begin_index + (stbir_info->ring_buffer_last_scanline - stbir_info->ring_buffer_first_scanline)) % stbir_info->ring_buffer_num_entries;
+        STBIR_ASSERT(ring_buffer_index != stbir_info->ring_buffer_begin_index);
+    }
+
+    ring_buffer = stbir__get_ring_buffer_entry(stbir_info->ring_buffer, ring_buffer_index, stbir_info->ring_buffer_length_bytes / sizeof(float));
+    memset(ring_buffer, 0, stbir_info->ring_buffer_length_bytes);
+
+    return ring_buffer;
+}
+
+
+static void stbir__resample_horizontal_upsample(stbir__info* stbir_info, float* output_buffer)
+{
+    int x, k;
+    int output_w = stbir_info->output_w;
+    int channels = stbir_info->channels;
+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);
+    stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;
+    float* horizontal_coefficients = stbir_info->horizontal_coefficients;
+    int coefficient_width = stbir_info->horizontal_coefficient_width;
+
+    for (x = 0; x < output_w; x++)
+    {
+        int n0 = horizontal_contributors[x].n0;
+        int n1 = horizontal_contributors[x].n1;
+
+        int out_pixel_index = x * channels;
+        int coefficient_group = coefficient_width * x;
+        int coefficient_counter = 0;
+
+        STBIR_ASSERT(n1 >= n0);
+        STBIR_ASSERT(n0 >= -stbir_info->horizontal_filter_pixel_margin);
+        STBIR_ASSERT(n1 >= -stbir_info->horizontal_filter_pixel_margin);
+        STBIR_ASSERT(n0 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);
+        STBIR_ASSERT(n1 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin);
+
+        switch (channels) {
+            case 1:
+                for (k = n0; k <= n1; k++)
+                {
+                    int in_pixel_index = k * 1;
+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
+                    STBIR_ASSERT(coefficient != 0);
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                }
+                break;
+            case 2:
+                for (k = n0; k <= n1; k++)
+                {
+                    int in_pixel_index = k * 2;
+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
+                    STBIR_ASSERT(coefficient != 0);
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                }
+                break;
+            case 3:
+                for (k = n0; k <= n1; k++)
+                {
+                    int in_pixel_index = k * 3;
+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
+                    STBIR_ASSERT(coefficient != 0);
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
+                }
+                break;
+            case 4:
+                for (k = n0; k <= n1; k++)
+                {
+                    int in_pixel_index = k * 4;
+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
+                    STBIR_ASSERT(coefficient != 0);
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
+                    output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;
+                }
+                break;
+            default:
+                for (k = n0; k <= n1; k++)
+                {
+                    int in_pixel_index = k * channels;
+                    float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++];
+                    int c;
+                    STBIR_ASSERT(coefficient != 0);
+                    for (c = 0; c < channels; c++)
+                        output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;
+                }
+                break;
+        }
+    }
+}
+
+static void stbir__resample_horizontal_downsample(stbir__info* stbir_info, float* output_buffer)
+{
+    int x, k;
+    int input_w = stbir_info->input_w;
+    int channels = stbir_info->channels;
+    float* decode_buffer = stbir__get_decode_buffer(stbir_info);
+    stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors;
+    float* horizontal_coefficients = stbir_info->horizontal_coefficients;
+    int coefficient_width = stbir_info->horizontal_coefficient_width;
+    int filter_pixel_margin = stbir_info->horizontal_filter_pixel_margin;
+    int max_x = input_w + filter_pixel_margin * 2;
+
+    STBIR_ASSERT(!stbir__use_width_upsampling(stbir_info));
+
+    switch (channels) {
+        case 1:
+            for (x = 0; x < max_x; x++)
+            {
+                int n0 = horizontal_contributors[x].n0;
+                int n1 = horizontal_contributors[x].n1;
+
+                int in_x = x - filter_pixel_margin;
+                int in_pixel_index = in_x * 1;
+                int max_n = n1;
+                int coefficient_group = coefficient_width * x;
+
+                for (k = n0; k <= max_n; k++)
+                {
+                    int out_pixel_index = k * 1;
+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                }
+            }
+            break;
+
+        case 2:
+            for (x = 0; x < max_x; x++)
+            {
+                int n0 = horizontal_contributors[x].n0;
+                int n1 = horizontal_contributors[x].n1;
+
+                int in_x = x - filter_pixel_margin;
+                int in_pixel_index = in_x * 2;
+                int max_n = n1;
+                int coefficient_group = coefficient_width * x;
+
+                for (k = n0; k <= max_n; k++)
+                {
+                    int out_pixel_index = k * 2;
+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                }
+            }
+            break;
+
+        case 3:
+            for (x = 0; x < max_x; x++)
+            {
+                int n0 = horizontal_contributors[x].n0;
+                int n1 = horizontal_contributors[x].n1;
+
+                int in_x = x - filter_pixel_margin;
+                int in_pixel_index = in_x * 3;
+                int max_n = n1;
+                int coefficient_group = coefficient_width * x;
+
+                for (k = n0; k <= max_n; k++)
+                {
+                    int out_pixel_index = k * 3;
+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
+                }
+            }
+            break;
+
+        case 4:
+            for (x = 0; x < max_x; x++)
+            {
+                int n0 = horizontal_contributors[x].n0;
+                int n1 = horizontal_contributors[x].n1;
+
+                int in_x = x - filter_pixel_margin;
+                int in_pixel_index = in_x * 4;
+                int max_n = n1;
+                int coefficient_group = coefficient_width * x;
+
+                for (k = n0; k <= max_n; k++)
+                {
+                    int out_pixel_index = k * 4;
+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];
+                    output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient;
+                    output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient;
+                    output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient;
+                    output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient;
+                }
+            }
+            break;
+
+        default:
+            for (x = 0; x < max_x; x++)
+            {
+                int n0 = horizontal_contributors[x].n0;
+                int n1 = horizontal_contributors[x].n1;
+
+                int in_x = x - filter_pixel_margin;
+                int in_pixel_index = in_x * channels;
+                int max_n = n1;
+                int coefficient_group = coefficient_width * x;
+
+                for (k = n0; k <= max_n; k++)
+                {
+                    int c;
+                    int out_pixel_index = k * channels;
+                    float coefficient = horizontal_coefficients[coefficient_group + k - n0];
+                    for (c = 0; c < channels; c++)
+                        output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient;
+                }
+            }
+            break;
+    }
+}
+
+static void stbir__decode_and_resample_upsample(stbir__info* stbir_info, int n)
+{
+    // Decode the nth scanline from the source image into the decode buffer.
+    stbir__decode_scanline(stbir_info, n);
+
+    // Now resample it into the ring buffer.
+    if (stbir__use_width_upsampling(stbir_info))
+        stbir__resample_horizontal_upsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));
+    else
+        stbir__resample_horizontal_downsample(stbir_info, stbir__add_empty_ring_buffer_entry(stbir_info, n));
+
+    // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling.
+}
+
+static void stbir__decode_and_resample_downsample(stbir__info* stbir_info, int n)
+{
+    // Decode the nth scanline from the source image into the decode buffer.
+    stbir__decode_scanline(stbir_info, n);
+
+    memset(stbir_info->horizontal_buffer, 0, stbir_info->output_w * stbir_info->channels * sizeof(float));
+
+    // Now resample it into the horizontal buffer.
+    if (stbir__use_width_upsampling(stbir_info))
+        stbir__resample_horizontal_upsample(stbir_info, stbir_info->horizontal_buffer);
+    else
+        stbir__resample_horizontal_downsample(stbir_info, stbir_info->horizontal_buffer);
+
+    // Now it's sitting in the horizontal buffer ready to be distributed into the ring buffers.
+}
+
+// Get the specified scan line from the ring buffer.
+static float* stbir__get_ring_buffer_scanline(int get_scanline, float* ring_buffer, int begin_index, int first_scanline, int ring_buffer_num_entries, int ring_buffer_length)
+{
+    int ring_buffer_index = (begin_index + (get_scanline - first_scanline)) % ring_buffer_num_entries;
+    return stbir__get_ring_buffer_entry(ring_buffer, ring_buffer_index, ring_buffer_length);
+}
+
+
+static void stbir__encode_scanline(stbir__info* stbir_info, int num_pixels, void *output_buffer, float *encode_buffer, int channels, int alpha_channel, int decode)
+{
+    int x;
+    int n;
+    int num_nonalpha;
+    stbir_uint16 nonalpha[STBIR_MAX_CHANNELS];
+
+    if (!(stbir_info->flags&STBIR_FLAG_ALPHA_PREMULTIPLIED))
+    {
+        for (x=0; x < num_pixels; ++x)
+        {
+            int pixel_index = x*channels;
+
+            float alpha = encode_buffer[pixel_index + alpha_channel];
+            float reciprocal_alpha = alpha ? 1.0f / alpha : 0;
+
+            // unrolling this produced a 1% slowdown upscaling a large RGBA linear-space image on my machine - stb
+            for (n = 0; n < channels; n++)
+                if (n != alpha_channel)
+                    encode_buffer[pixel_index + n] *= reciprocal_alpha;
+
+            // We added in a small epsilon to prevent the color channel from being deleted with zero alpha.
+            // Because we only add it for integer types, it will automatically be discarded on integer
+            // conversion, so we don't need to subtract it back out (which would be problematic for
+            // numeric precision reasons).
+        }
+    }
+
+    // build a table of all channels that need colorspace correction, so
+    // we don't perform colorspace correction on channels that don't need it.
+    for (x = 0, num_nonalpha = 0; x < channels; ++x)
+    {
+        if (x != alpha_channel || (stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))
+        {
+            nonalpha[num_nonalpha++] = (stbir_uint16)x;
+        }
+    }
+
+    #define STBIR__ROUND_INT(f)    ((int)          ((f)+0.5))
+    #define STBIR__ROUND_UINT(f)   ((stbir_uint32) ((f)+0.5))
+
+    #ifdef STBIR__SATURATE_INT
+    #define STBIR__ENCODE_LINEAR8(f)   stbir__saturate8 (STBIR__ROUND_INT((f) * stbir__max_uint8_as_float ))
+    #define STBIR__ENCODE_LINEAR16(f)  stbir__saturate16(STBIR__ROUND_INT((f) * stbir__max_uint16_as_float))
+    #else
+    #define STBIR__ENCODE_LINEAR8(f)   (unsigned char ) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint8_as_float )
+    #define STBIR__ENCODE_LINEAR16(f)  (unsigned short) STBIR__ROUND_INT(stbir__saturate(f) * stbir__max_uint16_as_float)
+    #endif
+
+    switch (decode)
+    {
+        case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < channels; n++)
+                {
+                    int index = pixel_index + n;
+                    ((unsigned char*)output_buffer)[index] = STBIR__ENCODE_LINEAR8(encode_buffer[index]);
+                }
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < num_nonalpha; n++)
+                {
+                    int index = pixel_index + nonalpha[n];
+                    ((unsigned char*)output_buffer)[index] = stbir__linear_to_srgb_uchar(encode_buffer[index]);
+                }
+
+                if (!(stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                    ((unsigned char *)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR8(encode_buffer[pixel_index+alpha_channel]);
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < channels; n++)
+                {
+                    int index = pixel_index + n;
+                    ((unsigned short*)output_buffer)[index] = STBIR__ENCODE_LINEAR16(encode_buffer[index]);
+                }
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < num_nonalpha; n++)
+                {
+                    int index = pixel_index + nonalpha[n];
+                    ((unsigned short*)output_buffer)[index] = (unsigned short)STBIR__ROUND_INT(stbir__linear_to_srgb(stbir__saturate(encode_buffer[index])) * stbir__max_uint16_as_float);
+                }
+
+                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                    ((unsigned short*)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR16(encode_buffer[pixel_index + alpha_channel]);
+            }
+
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < channels; n++)
+                {
+                    int index = pixel_index + n;
+                    ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__saturate(encode_buffer[index])) * stbir__max_uint32_as_float);
+                }
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < num_nonalpha; n++)
+                {
+                    int index = pixel_index + nonalpha[n];
+                    ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__linear_to_srgb(stbir__saturate(encode_buffer[index]))) * stbir__max_uint32_as_float);
+                }
+
+                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                    ((unsigned int*)output_buffer)[pixel_index + alpha_channel] = (unsigned int)STBIR__ROUND_INT(((double)stbir__saturate(encode_buffer[pixel_index + alpha_channel])) * stbir__max_uint32_as_float);
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < channels; n++)
+                {
+                    int index = pixel_index + n;
+                    ((float*)output_buffer)[index] = encode_buffer[index];
+                }
+            }
+            break;
+
+        case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB):
+            for (x=0; x < num_pixels; ++x)
+            {
+                int pixel_index = x*channels;
+
+                for (n = 0; n < num_nonalpha; n++)
+                {
+                    int index = pixel_index + nonalpha[n];
+                    ((float*)output_buffer)[index] = stbir__linear_to_srgb(encode_buffer[index]);
+                }
+
+                if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE))
+                    ((float*)output_buffer)[pixel_index + alpha_channel] = encode_buffer[pixel_index + alpha_channel];
+            }
+            break;
+
+        default:
+            STBIR_ASSERT(!"Unknown type/colorspace/channels combination.");
+            break;
+    }
+}
+
+static void stbir__resample_vertical_upsample(stbir__info* stbir_info, int n)
+{
+    int x, k;
+    int output_w = stbir_info->output_w;
+    stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;
+    float* vertical_coefficients = stbir_info->vertical_coefficients;
+    int channels = stbir_info->channels;
+    int alpha_channel = stbir_info->alpha_channel;
+    int type = stbir_info->type;
+    int colorspace = stbir_info->colorspace;
+    int ring_buffer_entries = stbir_info->ring_buffer_num_entries;
+    void* output_data = stbir_info->output_data;
+    float* encode_buffer = stbir_info->encode_buffer;
+    int decode = STBIR__DECODE(type, colorspace);
+    int coefficient_width = stbir_info->vertical_coefficient_width;
+    int coefficient_counter;
+    int contributor = n;
+
+    float* ring_buffer = stbir_info->ring_buffer;
+    int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;
+    int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;
+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
+
+    int n0,n1, output_row_start;
+    int coefficient_group = coefficient_width * contributor;
+
+    n0 = vertical_contributors[contributor].n0;
+    n1 = vertical_contributors[contributor].n1;
+
+    output_row_start = n * stbir_info->output_stride_bytes;
+
+    STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));
+
+    memset(encode_buffer, 0, output_w * sizeof(float) * channels);
+
+    // I tried reblocking this for better cache usage of encode_buffer
+    // (using x_outer, k, x_inner), but it lost speed. -- stb
+
+    coefficient_counter = 0;
+    switch (channels) {
+        case 1:
+            for (k = n0; k <= n1; k++)
+            {
+                int coefficient_index = coefficient_counter++;
+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+                for (x = 0; x < output_w; ++x)
+                {
+                    int in_pixel_index = x * 1;
+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
+                }
+            }
+            break;
+        case 2:
+            for (k = n0; k <= n1; k++)
+            {
+                int coefficient_index = coefficient_counter++;
+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+                for (x = 0; x < output_w; ++x)
+                {
+                    int in_pixel_index = x * 2;
+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
+                }
+            }
+            break;
+        case 3:
+            for (k = n0; k <= n1; k++)
+            {
+                int coefficient_index = coefficient_counter++;
+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+                for (x = 0; x < output_w; ++x)
+                {
+                    int in_pixel_index = x * 3;
+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
+                    encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;
+                }
+            }
+            break;
+        case 4:
+            for (k = n0; k <= n1; k++)
+            {
+                int coefficient_index = coefficient_counter++;
+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+                for (x = 0; x < output_w; ++x)
+                {
+                    int in_pixel_index = x * 4;
+                    encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient;
+                    encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient;
+                    encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient;
+                    encode_buffer[in_pixel_index + 3] += ring_buffer_entry[in_pixel_index + 3] * coefficient;
+                }
+            }
+            break;
+        default:
+            for (k = n0; k <= n1; k++)
+            {
+                int coefficient_index = coefficient_counter++;
+                float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+                float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+                for (x = 0; x < output_w; ++x)
+                {
+                    int in_pixel_index = x * channels;
+                    int c;
+                    for (c = 0; c < channels; c++)
+                        encode_buffer[in_pixel_index + c] += ring_buffer_entry[in_pixel_index + c] * coefficient;
+                }
+            }
+            break;
+    }
+    stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, encode_buffer, channels, alpha_channel, decode);
+}
+
+static void stbir__resample_vertical_downsample(stbir__info* stbir_info, int n)
+{
+    int x, k;
+    int output_w = stbir_info->output_w;
+    stbir__contributors* vertical_contributors = stbir_info->vertical_contributors;
+    float* vertical_coefficients = stbir_info->vertical_coefficients;
+    int channels = stbir_info->channels;
+    int ring_buffer_entries = stbir_info->ring_buffer_num_entries;
+    float* horizontal_buffer = stbir_info->horizontal_buffer;
+    int coefficient_width = stbir_info->vertical_coefficient_width;
+    int contributor = n + stbir_info->vertical_filter_pixel_margin;
+
+    float* ring_buffer = stbir_info->ring_buffer;
+    int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index;
+    int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline;
+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
+    int n0,n1;
+
+    n0 = vertical_contributors[contributor].n0;
+    n1 = vertical_contributors[contributor].n1;
+
+    STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));
+
+    for (k = n0; k <= n1; k++)
+    {
+        int coefficient_index = k - n0;
+        int coefficient_group = coefficient_width * contributor;
+        float coefficient = vertical_coefficients[coefficient_group + coefficient_index];
+
+        float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, ring_buffer_entries, ring_buffer_length);
+
+        switch (channels) {
+            case 1:
+                for (x = 0; x < output_w; x++)
+                {
+                    int in_pixel_index = x * 1;
+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
+                }
+                break;
+            case 2:
+                for (x = 0; x < output_w; x++)
+                {
+                    int in_pixel_index = x * 2;
+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
+                }
+                break;
+            case 3:
+                for (x = 0; x < output_w; x++)
+                {
+                    int in_pixel_index = x * 3;
+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;
+                }
+                break;
+            case 4:
+                for (x = 0; x < output_w; x++)
+                {
+                    int in_pixel_index = x * 4;
+                    ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient;
+                    ring_buffer_entry[in_pixel_index + 3] += horizontal_buffer[in_pixel_index + 3] * coefficient;
+                }
+                break;
+            default:
+                for (x = 0; x < output_w; x++)
+                {
+                    int in_pixel_index = x * channels;
+
+                    int c;
+                    for (c = 0; c < channels; c++)
+                        ring_buffer_entry[in_pixel_index + c] += horizontal_buffer[in_pixel_index + c] * coefficient;
+                }
+                break;
+        }
+    }
+}
+
+static void stbir__buffer_loop_upsample(stbir__info* stbir_info)
+{
+    int y;
+    float scale_ratio = stbir_info->vertical_scale;
+    float out_scanlines_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(1/scale_ratio) * scale_ratio;
+
+    STBIR_ASSERT(stbir__use_height_upsampling(stbir_info));
+
+    for (y = 0; y < stbir_info->output_h; y++)
+    {
+        float in_center_of_out = 0; // Center of the current out scanline in the in scanline space
+        int in_first_scanline = 0, in_last_scanline = 0;
+
+        stbir__calculate_sample_range_upsample(y, out_scanlines_radius, scale_ratio, stbir_info->vertical_shift, &in_first_scanline, &in_last_scanline, &in_center_of_out);
+
+        STBIR_ASSERT(in_last_scanline - in_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);
+
+        if (stbir_info->ring_buffer_begin_index >= 0)
+        {
+            // Get rid of whatever we don't need anymore.
+            while (in_first_scanline > stbir_info->ring_buffer_first_scanline)
+            {
+                if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)
+                {
+                    // We just popped the last scanline off the ring buffer.
+                    // Reset it to the empty state.
+                    stbir_info->ring_buffer_begin_index = -1;
+                    stbir_info->ring_buffer_first_scanline = 0;
+                    stbir_info->ring_buffer_last_scanline = 0;
+                    break;
+                }
+                else
+                {
+                    stbir_info->ring_buffer_first_scanline++;
+                    stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;
+                }
+            }
+        }
+
+        // Load in new ones.
+        if (stbir_info->ring_buffer_begin_index < 0)
+            stbir__decode_and_resample_upsample(stbir_info, in_first_scanline);
+
+        while (in_last_scanline > stbir_info->ring_buffer_last_scanline)
+            stbir__decode_and_resample_upsample(stbir_info, stbir_info->ring_buffer_last_scanline + 1);
+
+        // Now all buffers should be ready to write a row of vertical sampling.
+        stbir__resample_vertical_upsample(stbir_info, y);
+
+        STBIR_PROGRESS_REPORT((float)y / stbir_info->output_h);
+    }
+}
+
+static void stbir__empty_ring_buffer(stbir__info* stbir_info, int first_necessary_scanline)
+{
+    int output_stride_bytes = stbir_info->output_stride_bytes;
+    int channels = stbir_info->channels;
+    int alpha_channel = stbir_info->alpha_channel;
+    int type = stbir_info->type;
+    int colorspace = stbir_info->colorspace;
+    int output_w = stbir_info->output_w;
+    void* output_data = stbir_info->output_data;
+    int decode = STBIR__DECODE(type, colorspace);
+
+    float* ring_buffer = stbir_info->ring_buffer;
+    int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float);
+
+    if (stbir_info->ring_buffer_begin_index >= 0)
+    {
+        // Get rid of whatever we don't need anymore.
+        while (first_necessary_scanline > stbir_info->ring_buffer_first_scanline)
+        {
+            if (stbir_info->ring_buffer_first_scanline >= 0 && stbir_info->ring_buffer_first_scanline < stbir_info->output_h)
+            {
+                int output_row_start = stbir_info->ring_buffer_first_scanline * output_stride_bytes;
+                float* ring_buffer_entry = stbir__get_ring_buffer_entry(ring_buffer, stbir_info->ring_buffer_begin_index, ring_buffer_length);
+                stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, ring_buffer_entry, channels, alpha_channel, decode);
+                STBIR_PROGRESS_REPORT((float)stbir_info->ring_buffer_first_scanline / stbir_info->output_h);
+            }
+
+            if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline)
+            {
+                // We just popped the last scanline off the ring buffer.
+                // Reset it to the empty state.
+                stbir_info->ring_buffer_begin_index = -1;
+                stbir_info->ring_buffer_first_scanline = 0;
+                stbir_info->ring_buffer_last_scanline = 0;
+                break;
+            }
+            else
+            {
+                stbir_info->ring_buffer_first_scanline++;
+                stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->ring_buffer_num_entries;
+            }
+        }
+    }
+}
+
+static void stbir__buffer_loop_downsample(stbir__info* stbir_info)
+{
+    int y;
+    float scale_ratio = stbir_info->vertical_scale;
+    int output_h = stbir_info->output_h;
+    float in_pixels_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(scale_ratio) / scale_ratio;
+    int pixel_margin = stbir_info->vertical_filter_pixel_margin;
+    int max_y = stbir_info->input_h + pixel_margin;
+
+    STBIR_ASSERT(!stbir__use_height_upsampling(stbir_info));
+
+    for (y = -pixel_margin; y < max_y; y++)
+    {
+        float out_center_of_in; // Center of the current out scanline in the in scanline space
+        int out_first_scanline, out_last_scanline;
+
+        stbir__calculate_sample_range_downsample(y, in_pixels_radius, scale_ratio, stbir_info->vertical_shift, &out_first_scanline, &out_last_scanline, &out_center_of_in);
+
+        STBIR_ASSERT(out_last_scanline - out_first_scanline + 1 <= stbir_info->ring_buffer_num_entries);
+
+        if (out_last_scanline < 0 || out_first_scanline >= output_h)
+            continue;
+
+        stbir__empty_ring_buffer(stbir_info, out_first_scanline);
+
+        stbir__decode_and_resample_downsample(stbir_info, y);
+
+        // Load in new ones.
+        if (stbir_info->ring_buffer_begin_index < 0)
+            stbir__add_empty_ring_buffer_entry(stbir_info, out_first_scanline);
+
+        while (out_last_scanline > stbir_info->ring_buffer_last_scanline)
+            stbir__add_empty_ring_buffer_entry(stbir_info, stbir_info->ring_buffer_last_scanline + 1);
+
+        // Now the horizontal buffer is ready to write to all ring buffer rows.
+        stbir__resample_vertical_downsample(stbir_info, y);
+    }
+
+    stbir__empty_ring_buffer(stbir_info, stbir_info->output_h);
+}
+
+static void stbir__setup(stbir__info *info, int input_w, int input_h, int output_w, int output_h, int channels)
+{
+    info->input_w = input_w;
+    info->input_h = input_h;
+    info->output_w = output_w;
+    info->output_h = output_h;
+    info->channels = channels;
+}
+
+static void stbir__calculate_transform(stbir__info *info, float s0, float t0, float s1, float t1, float *transform)
+{
+    info->s0 = s0;
+    info->t0 = t0;
+    info->s1 = s1;
+    info->t1 = t1;
+
+    if (transform)
+    {
+        info->horizontal_scale = transform[0];
+        info->vertical_scale   = transform[1];
+        info->horizontal_shift = transform[2];
+        info->vertical_shift   = transform[3];
+    }
+    else
+    {
+        info->horizontal_scale = ((float)info->output_w / info->input_w) / (s1 - s0);
+        info->vertical_scale = ((float)info->output_h / info->input_h) / (t1 - t0);
+
+        info->horizontal_shift = s0 * info->output_w / (s1 - s0);
+        info->vertical_shift = t0 * info->output_h / (t1 - t0);
+    }
+}
+
+static void stbir__choose_filter(stbir__info *info, stbir_filter h_filter, stbir_filter v_filter)
+{
+    if (h_filter == 0)
+        h_filter = stbir__use_upsampling(info->horizontal_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
+    if (v_filter == 0)
+        v_filter = stbir__use_upsampling(info->vertical_scale)   ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE;
+    info->horizontal_filter = h_filter;
+    info->vertical_filter = v_filter;
+}
+
+static stbir_uint32 stbir__calculate_memory(stbir__info *info)
+{
+    int pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);
+    int filter_height = stbir__get_filter_pixel_width(info->vertical_filter, info->vertical_scale);
+
+    info->horizontal_num_contributors = stbir__get_contributors(info->horizontal_scale, info->horizontal_filter, info->input_w, info->output_w);
+    info->vertical_num_contributors   = stbir__get_contributors(info->vertical_scale  , info->vertical_filter  , info->input_h, info->output_h);
+
+    // One extra entry because floating point precision problems sometimes cause an extra to be necessary.
+    info->ring_buffer_num_entries = filter_height + 1;
+
+    info->horizontal_contributors_size = info->horizontal_num_contributors * sizeof(stbir__contributors);
+    info->horizontal_coefficients_size = stbir__get_total_horizontal_coefficients(info) * sizeof(float);
+    info->vertical_contributors_size = info->vertical_num_contributors * sizeof(stbir__contributors);
+    info->vertical_coefficients_size = stbir__get_total_vertical_coefficients(info) * sizeof(float);
+    info->decode_buffer_size = (info->input_w + pixel_margin * 2) * info->channels * sizeof(float);
+    info->horizontal_buffer_size = info->output_w * info->channels * sizeof(float);
+    info->ring_buffer_size = info->output_w * info->channels * info->ring_buffer_num_entries * sizeof(float);
+    info->encode_buffer_size = info->output_w * info->channels * sizeof(float);
+
+    STBIR_ASSERT(info->horizontal_filter != 0);
+    STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late
+    STBIR_ASSERT(info->vertical_filter != 0);
+    STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late
+
+    if (stbir__use_height_upsampling(info))
+        // The horizontal buffer is for when we're downsampling the height and we
+        // can't output the result of sampling the decode buffer directly into the
+        // ring buffers.
+        info->horizontal_buffer_size = 0;
+    else
+        // The encode buffer is to retain precision in the height upsampling method
+        // and isn't used when height downsampling.
+        info->encode_buffer_size = 0;
+
+    return info->horizontal_contributors_size + info->horizontal_coefficients_size
+        + info->vertical_contributors_size + info->vertical_coefficients_size
+        + info->decode_buffer_size + info->horizontal_buffer_size
+        + info->ring_buffer_size + info->encode_buffer_size;
+}
+
+static int stbir__resize_allocated(stbir__info *info,
+    const void* input_data, int input_stride_in_bytes,
+    void* output_data, int output_stride_in_bytes,
+    int alpha_channel, stbir_uint32 flags, stbir_datatype type,
+    stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace,
+    void* tempmem, size_t tempmem_size_in_bytes)
+{
+    size_t memory_required = stbir__calculate_memory(info);
+
+    int width_stride_input = input_stride_in_bytes ? input_stride_in_bytes : info->channels * info->input_w * stbir__type_size[type];
+    int width_stride_output = output_stride_in_bytes ? output_stride_in_bytes : info->channels * info->output_w * stbir__type_size[type];
+
+#ifdef STBIR_DEBUG_OVERWRITE_TEST
+#define OVERWRITE_ARRAY_SIZE 8
+    unsigned char overwrite_output_before_pre[OVERWRITE_ARRAY_SIZE];
+    unsigned char overwrite_tempmem_before_pre[OVERWRITE_ARRAY_SIZE];
+    unsigned char overwrite_output_after_pre[OVERWRITE_ARRAY_SIZE];
+    unsigned char overwrite_tempmem_after_pre[OVERWRITE_ARRAY_SIZE];
+
+    size_t begin_forbidden = width_stride_output * (info->output_h - 1) + info->output_w * info->channels * stbir__type_size[type];
+    memcpy(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);
+    memcpy(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE);
+    memcpy(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE);
+    memcpy(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE);
+#endif
+
+    STBIR_ASSERT(info->channels >= 0);
+    STBIR_ASSERT(info->channels <= STBIR_MAX_CHANNELS);
+
+    if (info->channels < 0 || info->channels > STBIR_MAX_CHANNELS)
+        return 0;
+
+    STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
+    STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table));
+
+    if (info->horizontal_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))
+        return 0;
+    if (info->vertical_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table))
+        return 0;
+
+    if (alpha_channel < 0)
+        flags |= STBIR_FLAG_ALPHA_USES_COLORSPACE | STBIR_FLAG_ALPHA_PREMULTIPLIED;
+
+    if (!(flags&STBIR_FLAG_ALPHA_USES_COLORSPACE) || !(flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)) {
+        STBIR_ASSERT(alpha_channel >= 0 && alpha_channel < info->channels);
+    }
+
+    if (alpha_channel >= info->channels)
+        return 0;
+
+    STBIR_ASSERT(tempmem);
+
+    if (!tempmem)
+        return 0;
+
+    STBIR_ASSERT(tempmem_size_in_bytes >= memory_required);
+
+    if (tempmem_size_in_bytes < memory_required)
+        return 0;
+
+    memset(tempmem, 0, tempmem_size_in_bytes);
+
+    info->input_data = input_data;
+    info->input_stride_bytes = width_stride_input;
+
+    info->output_data = output_data;
+    info->output_stride_bytes = width_stride_output;
+
+    info->alpha_channel = alpha_channel;
+    info->flags = flags;
+    info->type = type;
+    info->edge_horizontal = edge_horizontal;
+    info->edge_vertical = edge_vertical;
+    info->colorspace = colorspace;
+
+    info->horizontal_coefficient_width   = stbir__get_coefficient_width  (info->horizontal_filter, info->horizontal_scale);
+    info->vertical_coefficient_width     = stbir__get_coefficient_width  (info->vertical_filter  , info->vertical_scale  );
+    info->horizontal_filter_pixel_width  = stbir__get_filter_pixel_width (info->horizontal_filter, info->horizontal_scale);
+    info->vertical_filter_pixel_width    = stbir__get_filter_pixel_width (info->vertical_filter  , info->vertical_scale  );
+    info->horizontal_filter_pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale);
+    info->vertical_filter_pixel_margin   = stbir__get_filter_pixel_margin(info->vertical_filter  , info->vertical_scale  );
+
+    info->ring_buffer_length_bytes = info->output_w * info->channels * sizeof(float);
+    info->decode_buffer_pixels = info->input_w + info->horizontal_filter_pixel_margin * 2;
+
+#define STBIR__NEXT_MEMPTR(current, newtype) (newtype*)(((unsigned char*)current) + current##_size)
+
+    info->horizontal_contributors = (stbir__contributors *) tempmem;
+    info->horizontal_coefficients = STBIR__NEXT_MEMPTR(info->horizontal_contributors, float);
+    info->vertical_contributors = STBIR__NEXT_MEMPTR(info->horizontal_coefficients, stbir__contributors);
+    info->vertical_coefficients = STBIR__NEXT_MEMPTR(info->vertical_contributors, float);
+    info->decode_buffer = STBIR__NEXT_MEMPTR(info->vertical_coefficients, float);
+
+    if (stbir__use_height_upsampling(info))
+    {
+        info->horizontal_buffer = NULL;
+        info->ring_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);
+        info->encode_buffer = STBIR__NEXT_MEMPTR(info->ring_buffer, float);
+
+        STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->encode_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);
+    }
+    else
+    {
+        info->horizontal_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float);
+        info->ring_buffer = STBIR__NEXT_MEMPTR(info->horizontal_buffer, float);
+        info->encode_buffer = NULL;
+
+        STBIR_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->ring_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes);
+    }
+
+#undef STBIR__NEXT_MEMPTR
+
+    // This signals that the ring buffer is empty
+    info->ring_buffer_begin_index = -1;
+
+    stbir__calculate_filters(info->horizontal_contributors, info->horizontal_coefficients, info->horizontal_filter, info->horizontal_scale, info->horizontal_shift, info->input_w, info->output_w);
+    stbir__calculate_filters(info->vertical_contributors, info->vertical_coefficients, info->vertical_filter, info->vertical_scale, info->vertical_shift, info->input_h, info->output_h);
+
+    STBIR_PROGRESS_REPORT(0);
+
+    if (stbir__use_height_upsampling(info))
+        stbir__buffer_loop_upsample(info);
+    else
+        stbir__buffer_loop_downsample(info);
+
+    STBIR_PROGRESS_REPORT(1);
+
+#ifdef STBIR_DEBUG_OVERWRITE_TEST
+    STBIR_ASSERT(memcmp(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);
+    STBIR_ASSERT(memcmp(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0);
+    STBIR_ASSERT(memcmp(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0);
+    STBIR_ASSERT(memcmp(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE) == 0);
+#endif
+
+    return 1;
+}
+
+
+static int stbir__resize_arbitrary(
+    void *alloc_context,
+    const void* input_data, int input_w, int input_h, int input_stride_in_bytes,
+    void* output_data, int output_w, int output_h, int output_stride_in_bytes,
+    float s0, float t0, float s1, float t1, float *transform,
+    int channels, int alpha_channel, stbir_uint32 flags, stbir_datatype type,
+    stbir_filter h_filter, stbir_filter v_filter,
+    stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace)
+{
+    stbir__info info;
+    int result;
+    size_t memory_required;
+    void* extra_memory;
+
+    stbir__setup(&info, input_w, input_h, output_w, output_h, channels);
+    stbir__calculate_transform(&info, s0,t0,s1,t1,transform);
+    stbir__choose_filter(&info, h_filter, v_filter);
+    memory_required = stbir__calculate_memory(&info);
+    extra_memory = STBIR_MALLOC(memory_required, alloc_context);
+
+    if (!extra_memory)
+        return 0;
+
+    result = stbir__resize_allocated(&info, input_data, input_stride_in_bytes,
+                                            output_data, output_stride_in_bytes,
+                                            alpha_channel, flags, type,
+                                            edge_horizontal, edge_vertical,
+                                            colorspace, extra_memory, memory_required);
+
+    STBIR_FREE(extra_memory, alloc_context);
+
+    return result;
+}
+
+STBIRDEF int stbir_resize_uint8(     const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels)
+{
+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);
+}
+
+STBIRDEF int stbir_resize_float(     const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           float *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels)
+{
+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_FLOAT, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR);
+}
+
+STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                           unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                     int num_channels, int alpha_channel, int flags)
+{
+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
+        STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_SRGB);
+}
+
+STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                                    unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                              int num_channels, int alpha_channel, int flags,
+                                              stbir_edge edge_wrap_mode)
+{
+    return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT,
+        edge_wrap_mode, edge_wrap_mode, STBIR_COLORSPACE_SRGB);
+}
+
+STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                               unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context)
+{
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, filter, filter,
+        edge_wrap_mode, edge_wrap_mode, space);
+}
+
+STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels  , int input_w , int input_h , int input_stride_in_bytes,
+                                               stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context)
+{
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT16, filter, filter,
+        edge_wrap_mode, edge_wrap_mode, space);
+}
+
+
+STBIRDEF int stbir_resize_float_generic( const float *input_pixels         , int input_w , int input_h , int input_stride_in_bytes,
+                                               float *output_pixels        , int output_w, int output_h, int output_stride_in_bytes,
+                                         int num_channels, int alpha_channel, int flags,
+                                         stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space,
+                                         void *alloc_context)
+{
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_FLOAT, filter, filter,
+        edge_wrap_mode, edge_wrap_mode, space);
+}
+
+
+STBIRDEF int stbir_resize(         const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context)
+{
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
+        edge_mode_horizontal, edge_mode_vertical, space);
+}
+
+
+STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context,
+                                   float x_scale, float y_scale,
+                                   float x_offset, float y_offset)
+{
+    float transform[4];
+    transform[0] = x_scale;
+    transform[1] = y_scale;
+    transform[2] = x_offset;
+    transform[3] = y_offset;
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        0,0,1,1,transform,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
+        edge_mode_horizontal, edge_mode_vertical, space);
+}
+
+STBIRDEF int stbir_resize_region(  const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+                                         void *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+                                   stbir_datatype datatype,
+                                   int num_channels, int alpha_channel, int flags,
+                                   stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical,
+                                   stbir_filter filter_horizontal,  stbir_filter filter_vertical,
+                                   stbir_colorspace space, void *alloc_context,
+                                   float s0, float t0, float s1, float t1)
+{
+    return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes,
+        output_pixels, output_w, output_h, output_stride_in_bytes,
+        s0,t0,s1,t1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical,
+        edge_mode_horizontal, edge_mode_vertical, space);
+}
+
+#endif // STB_IMAGE_RESIZE_IMPLEMENTATION
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file
diff --git a/test 2.zip b/test 2.zip
new file mode 100644
index 0000000..5b01c83
Binary files /dev/null and b/test 2.zip differ
diff --git a/test/.DS_Store b/test/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/test/.DS_Store differ
diff --git a/test/car.jpg b/test/car.jpg
new file mode 100644
index 0000000..b73ea27
Binary files /dev/null and b/test/car.jpg differ
diff --git a/test/convert_image_to_webp.js b/test/convert_image_to_webp.js
new file mode 100644
index 0000000..8ce1137
--- /dev/null
+++ b/test/convert_image_to_webp.js
@@ -0,0 +1 @@
+var Module=typeof Module!="undefined"?Module:{};var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");var nodePath=require("path");if(ENVIRONMENT_IS_WORKER){scriptDirectory=nodePath.dirname(scriptDirectory)+"/"}else{scriptDirectory=__dirname+"/"}read_=(filename,binary)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);return fs.readFileSync(filename,binary?undefined:"utf8")};readBinary=filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}return ret};readAsync=(filename,onload,onerror,binary=true)=>{filename=isFileURI(filename)?new URL(filename):nodePath.normalize(filename);fs.readFile(filename,binary?undefined:"utf8",(err,data)=>{if(err)onerror(err);else onload(binary?data.buffer:data)})};if(!Module["thisProgram"]&&process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);if(typeof module!="undefined"){module["exports"]=Module}process.on("uncaughtException",ex=>{if(ex!=="unwind"&&!(ex instanceof ExitStatus)&&!(ex.context instanceof ExitStatus)){throw ex}});quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var wasmMemory;var ABORT=false;var EXITSTATUS;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var isFileURI=filename=>filename.startsWith("file://");var wasmBinaryFile;wasmBinaryFile="convert_image_to_webp.wasm";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}function getBinaryPromise(binaryFile){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch=="function"&&!isFileURI(binaryFile)){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{if(!response["ok"]){throw`failed to load wasm binary file at '${binaryFile}'`}return response["arrayBuffer"]()}).catch(()=>getBinarySync(binaryFile))}else if(readAsync){return new Promise((resolve,reject)=>{readAsync(binaryFile,response=>resolve(new Uint8Array(response)),reject)})}}return Promise.resolve().then(()=>getBinarySync(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}return instantiateArrayBuffer(binaryFile,imports,callback)}function createWasm(){var info={"a":wasmImports};function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["f"];updateMemoryViews();addOnInit(wasmExports["g"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);return false}}instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult);return{}}function ExitStatus(status){this.name="ExitStatus";this.message=`Program terminated with exit(${status})`;this.status=status}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr];case"i8":return HEAP8[ptr];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":abort("to do getValue(i64) use WASM_BIGINT");case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=Module["noExitRuntime"]||true;var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;var UTF8ArrayToString=(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var ___assert_fail=(condition,filename,line,func)=>{abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"])};var getHeapMax=()=>268435456;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var _fd_close=fd=>52;var convertI32PairToI53Checked=(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN;function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);return 70}var printCharBuffers=[null,[],[]];var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}};var SYSCALLS={varargs:undefined,get(){var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret},getp(){return SYSCALLS.get()},getStr(ptr){var ret=UTF8ToString(ptr);return ret}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={"string":str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},"array":arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};var wasmImports={a:___assert_fail,d:_emscripten_resize_heap,e:_fd_close,c:_fd_seek,b:_fd_write};var wasmExports=createWasm();var ___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports["g"])();var _malloc=Module["_malloc"]=a0=>(_malloc=Module["_malloc"]=wasmExports["h"])(a0);var _free=Module["_free"]=a0=>(_free=Module["_free"]=wasmExports["i"])(a0);var _convert_image_to_webp=Module["_convert_image_to_webp"]=(a0,a1,a2,a3,a4,a5)=>(_convert_image_to_webp=Module["_convert_image_to_webp"]=wasmExports["j"])(a0,a1,a2,a3,a4,a5);var stackSave=()=>(stackSave=wasmExports["l"])();var stackRestore=a0=>(stackRestore=wasmExports["m"])(a0);var stackAlloc=a0=>(stackAlloc=wasmExports["n"])(a0);Module["cwrap"]=cwrap;Module["getValue"]=getValue;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();
diff --git a/test/convert_image_to_webp.wasm b/test/convert_image_to_webp.wasm
new file mode 100755
index 0000000..5e531d2
Binary files /dev/null and b/test/convert_image_to_webp.wasm differ
diff --git a/test/image.png b/test/image.png
new file mode 100644
index 0000000..2f46cf5
Binary files /dev/null and b/test/image.png differ
diff --git a/test/index.html b/test/index.html
new file mode 100644
index 0000000..deccb79
--- /dev/null
+++ b/test/index.html
@@ -0,0 +1,92 @@
+<body>
+   
+    base64图：
+    <img id="base64Image"
+        src="data:image/jpeg;base64,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"
+        alt="Base64 Image">
+    <span>base64 图片大小：<span id="base64Size"></span></span>
+
+    WebP 图：
+    <img id="webpImage" alt="WebP Image">
+    <br>
+    <span>WebP 缩略图片大小：<span id="webpSize"></span></span>
+    <br>
+</body>
+
+<script>
+    function base64ToArrayBuffer(base64) {
+        var binaryString = atob(base64);
+        var len = binaryString.length;
+        var bytes = new Uint8Array(len);
+        for (var i = 0; i < len; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        // 返回 ArrayBuffer
+        return bytes.buffer;
+    }
+    // 将 WASM 生成的二进制数据转换成 Base64
+    function arrayBufferToBase64(buffer) {
+        let binary = '';
+        let len = buffer.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(buffer[i]);
+        }
+        return btoa(binary);  // 使用 JavaScript 的 btoa() 函数
+    }
+
+    // 初始化 WebAssembly 模块
+    var Module = {
+        onRuntimeInitialized: function () {
+       
+        //    let baseData= document.getElementById("base64Image").src;
+        //    baseData=baseData.split(",")[1];
+        //    let buffer = base64ToArrayBuffer(baseData);
+        //        decodeToWebpp(buffer);
+
+           fetch('./car.jpg').then(response => response.arrayBuffer()).then(buffer => {
+               decodeToWebpp(buffer);
+               
+           })
+        }
+    };
+
+    function decodeToWebpp(buffer) {
+        // 显示原始图片大小
+        document.getElementById("base64Size").textContent = (buffer.byteLength / 1024).toFixed(2) + " KB";
+
+        // 转换图像为 Uint8Array
+        var inputData = new Uint8Array(buffer);
+
+        // 分配内存以存储输出 WebP 大小
+        var outputSizePtr = Module._malloc(4); // 存储输出大小的指针
+
+        // 设置目标宽高和质量因子
+        var targetWidth = 60;  // 目标宽度
+        var targetHeight = 133; // 目标高度
+        var qualityFactor = 5 // 压缩质量 (0 - 100)
+        var inputDataPtr = Module._malloc(inputData.length);
+        Module.HEAPU8.set(inputData, inputDataPtr);
+
+        // 调用 WebAssembly 函数进行图像转换，返回 WebP 数据指针
+        var webpPtr = Module._convert_image_to_webp(inputDataPtr, inputData.length, targetWidth, targetHeight, qualityFactor, outputSizePtr);
+
+        // 获取 WebP 数据大小
+        var outputSize = Module.getValue(outputSizePtr, 'i32');
+
+        // 从 WebAssembly 内存中读取 WebP 数据
+        var webpData = new Uint8Array(Module.HEAPU8.buffer, webpPtr, outputSize);
+
+        // 显示 WebP 图片大小
+        document.getElementById("webpSize").textContent = (outputSize / 1024).toFixed(2) + " KB";
+
+        // 将 WebP 数据转换为 base64，并显示
+        let img = document.getElementById("webpImage");
+        img.src = "data:image/webp;base64," + arrayBufferToBase64(webpData);
+
+        // 使用完成后释放内存
+        Module._free(outputSizePtr);
+        Module._free(webpPtr);
+        Module._free(inputDataPtr);
+    }
+</script>
+<script src="convert_image_to_webp.js"></script>
\ No newline at end of file
diff --git a/test/test.jpg b/test/test.jpg
new file mode 100644
index 0000000..195fe62
Binary files /dev/null and b/test/test.jpg differ
diff --git a/webp/config.h b/webp/config.h
new file mode 100644
index 0000000..ed3c69d
--- /dev/null
+++ b/webp/config.h
@@ -0,0 +1,150 @@
+/* Adapted from the autotools src/webp/config.h.in.  */
+
+/* Define if building universal (internal helper macro) */
+/* TODO: handle properly in CMake */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* Set to 1 if __builtin_bswap16 is available */
+/* #undef HAVE_BUILTIN_BSWAP16 */
+
+/* Set to 1 if __builtin_bswap32 is available */
+/* #undef HAVE_BUILTIN_BSWAP32 */
+
+/* Set to 1 if __builtin_bswap64 is available */
+/* #undef HAVE_BUILTIN_BSWAP64 */
+
+/* Define to 1 if you have the <cpu-features.h> header file. */
+/* #undef HAVE_CPU_FEATURES_H */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+/* #undef HAVE_DLFCN_H */
+
+/* Define to 1 if you have the <GLUT/glut.h> header file. */
+/* #undef HAVE_GLUT_GLUT_H */
+
+/* Define to 1 if you have the <GL/glut.h> header file. */
+/* #undef HAVE_GL_GLUT_H */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the <OpenGL/glut.h> header file. */
+/* #undef HAVE_OPENGL_GLUT_H */
+
+/* Have PTHREAD_PRIO_INHERIT. */
+/* #undef HAVE_PTHREAD_PRIO_INHERIT */
+
+/* Define to 1 if you have the <shlwapi.h> header file. */
+#define HAVE_SHLWAPI_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+/* #undef HAVE_STRINGS_H */
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+ #undef HAVE_UNISTD_H 
+
+/* Define to 1 if you have the <wincodec.h> header file. */
+//#define HAVE_WINCODEC_H 1
+
+/* Define to 1 if you have the <windows.h> header file. */
+//#define HAVE_WINDOWS_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+/* TODO: handle properly in CMake */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "WebP"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://bugs.chromium.org/p/webp"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "WebP"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "WebP 1.2.4"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "WebP"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://developers.google.com/speed/webp"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.2.4"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "1.2.4"
+
+/* Set to 1 if GIF library is installed */
+ //#undef WEBP_HAVE_GIF 
+
+/* Set to 1 if OpenGL is supported */
+#define WEBP_HAVE_GL 1
+
+/* Set to 1 if JPEG library is installed */
+ //#undef WEBP_HAVE_JPEG 
+
+/* Set to 1 if NEON is supported */
+/* #undef WEBP_HAVE_NEON */
+
+/* Set to 1 if runtime detection of NEON is enabled */
+/* TODO: handle properly in CMake */
+/* #undef WEBP_HAVE_NEON_RTCD */
+
+/* Set to 1 if PNG library is installed */
+//#undef WEBP_HAVE_PNG 
+//#define WEBP_HAVE_PNG
+
+/* Set to 1 if SDL library is installed */
+ //#undef WEBP_HAVE_SDL 
+
+/* Set to 1 if SSE2 is supported */
+#define WEBP_HAVE_SSE2 1
+
+/* Set to 1 if SSE4.1 is supported */
+#define WEBP_HAVE_SSE41 1
+
+/* Set to 1 if TIFF library is installed */
+ #undef WEBP_HAVE_TIFF 
+
+/* Enable near lossless encoding */
+#define WEBP_NEAR_LOSSLESS 1
+
+/* Undefine this to disable thread support. */
+#define WEBP_USE_THREAD 1
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+#  undef WORDS_BIGENDIAN
+# endif
+#endif
diff --git a/webp/decode.h b/webp/decode.h
new file mode 100644
index 0000000..d982475
--- /dev/null
+++ b/webp/decode.h
@@ -0,0 +1,503 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//  Main decoding functions for WebP images.
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_DECODE_H_
+#define WEBP_WEBP_DECODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DECODER_ABI_VERSION 0x0209    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum VP8StatusCode VP8StatusCode;
+// typedef enum WEBP_CSP_MODE WEBP_CSP_MODE;
+typedef struct WebPRGBABuffer WebPRGBABuffer;
+typedef struct WebPYUVABuffer WebPYUVABuffer;
+typedef struct WebPDecBuffer WebPDecBuffer;
+typedef struct WebPIDecoder WebPIDecoder;
+typedef struct WebPBitstreamFeatures WebPBitstreamFeatures;
+typedef struct WebPDecoderOptions WebPDecoderOptions;
+typedef struct WebPDecoderConfig WebPDecoderConfig;
+
+// Return the decoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN int WebPGetDecoderVersion(void);
+
+// Retrieve basic header information: width, height.
+// This function will also validate the header, returning true on success,
+// false otherwise. '*width' and '*height' are only valid on successful return.
+// Pointers 'width' and 'height' can be passed NULL if deemed irrelevant.
+// Note: The following chunk sequences (before the raw VP8/VP8L data) are
+// considered valid by this function:
+// RIFF + VP8(L)
+// RIFF + VP8X + (optional chunks) + VP8(L)
+// ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose.
+// VP8(L)     <-- Not a valid WebP format: only allowed for internal purpose.
+WEBP_EXTERN int WebPGetInfo(const uint8_t* data, size_t data_size,
+                            int* width, int* height);
+
+// Decodes WebP images pointed to by 'data' and returns RGBA samples, along
+// with the dimensions in *width and *height. The ordering of samples in
+// memory is R, G, B, A, R, G, B, A... in scan order (endian-independent).
+// The returned pointer should be deleted calling WebPFree().
+// Returns NULL in case of error.
+WEBP_EXTERN uint8_t* WebPDecodeRGBA(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning A, R, G, B, A, R, G, B... ordered data.
+WEBP_EXTERN uint8_t* WebPDecodeARGB(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning B, G, R, A, B, G, R, A... ordered data.
+WEBP_EXTERN uint8_t* WebPDecodeBGRA(const uint8_t* data, size_t data_size,
+                                    int* width, int* height);
+
+// Same as WebPDecodeRGBA, but returning R, G, B, R, G, B... ordered data.
+// If the bitstream contains transparency, it is ignored.
+WEBP_EXTERN uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size,
+                                   int* width, int* height);
+
+// Same as WebPDecodeRGB, but returning B, G, R, B, G, R... ordered data.
+WEBP_EXTERN uint8_t* WebPDecodeBGR(const uint8_t* data, size_t data_size,
+                                   int* width, int* height);
+
+
+// Decode WebP images pointed to by 'data' to Y'UV format(*). The pointer
+// returned is the Y samples buffer. Upon return, *u and *v will point to
+// the U and V chroma data. These U and V buffers need NOT be passed to
+// WebPFree(), unlike the returned Y luma one. The dimension of the U and V
+// planes are both (*width + 1) / 2 and (*height + 1)/ 2.
+// Upon return, the Y buffer has a stride returned as '*stride', while U and V
+// have a common stride returned as '*uv_stride'.
+// Return NULL in case of error.
+// (*) Also named Y'CbCr. See: https://en.wikipedia.org/wiki/YCbCr
+WEBP_EXTERN uint8_t* WebPDecodeYUV(const uint8_t* data, size_t data_size,
+                                   int* width, int* height,
+                                   uint8_t** u, uint8_t** v,
+                                   int* stride, int* uv_stride);
+
+// These five functions are variants of the above ones, that decode the image
+// directly into a pre-allocated buffer 'output_buffer'. The maximum storage
+// available in this buffer is indicated by 'output_buffer_size'. If this
+// storage is not sufficient (or an error occurred), NULL is returned.
+// Otherwise, output_buffer is returned, for convenience.
+// The parameter 'output_stride' specifies the distance (in bytes)
+// between scanlines. Hence, output_buffer_size is expected to be at least
+// output_stride x picture-height.
+WEBP_EXTERN uint8_t* WebPDecodeRGBAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN uint8_t* WebPDecodeARGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN uint8_t* WebPDecodeBGRAInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// RGB and BGR variants. Here too the transparency information, if present,
+// will be dropped and ignored.
+WEBP_EXTERN uint8_t* WebPDecodeRGBInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+WEBP_EXTERN uint8_t* WebPDecodeBGRInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// WebPDecodeYUVInto() is a variant of WebPDecodeYUV() that operates directly
+// into pre-allocated luma/chroma plane buffers. This function requires the
+// strides to be passed: one for the luma plane and one for each of the
+// chroma ones. The size of each plane buffer is passed as 'luma_size',
+// 'u_size' and 'v_size' respectively.
+// Pointer to the luma plane ('*luma') is returned or NULL if an error occurred
+// during decoding (or because some buffers were found to be too small).
+WEBP_EXTERN uint8_t* WebPDecodeYUVInto(
+    const uint8_t* data, size_t data_size,
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+//------------------------------------------------------------------------------
+// Output colorspaces and buffer
+
+// Colorspaces
+// Note: the naming describes the byte-ordering of packed samples in memory.
+// For instance, MODE_BGRA relates to samples ordered as B,G,R,A,B,G,R,A,...
+// Non-capital names (e.g.:MODE_Argb) relates to pre-multiplied RGB channels.
+// RGBA-4444 and RGB-565 colorspaces are represented by following byte-order:
+// RGBA-4444: [r3 r2 r1 r0 g3 g2 g1 g0], [b3 b2 b1 b0 a3 a2 a1 a0], ...
+// RGB-565: [r4 r3 r2 r1 r0 g5 g4 g3], [g2 g1 g0 b4 b3 b2 b1 b0], ...
+// In the case WEBP_SWAP_16BITS_CSP is defined, the bytes are swapped for
+// these two modes:
+// RGBA-4444: [b3 b2 b1 b0 a3 a2 a1 a0], [r3 r2 r1 r0 g3 g2 g1 g0], ...
+// RGB-565: [g2 g1 g0 b4 b3 b2 b1 b0], [r4 r3 r2 r1 r0 g5 g4 g3], ...
+
+typedef enum WEBP_CSP_MODE {
+  MODE_RGB = 0, MODE_RGBA = 1,
+  MODE_BGR = 2, MODE_BGRA = 3,
+  MODE_ARGB = 4, MODE_RGBA_4444 = 5,
+  MODE_RGB_565 = 6,
+  // RGB-premultiplied transparent modes (alpha value is preserved)
+  MODE_rgbA = 7,
+  MODE_bgrA = 8,
+  MODE_Argb = 9,
+  MODE_rgbA_4444 = 10,
+  // YUV modes must come after RGB ones.
+  MODE_YUV = 11, MODE_YUVA = 12,  // yuv 4:2:0
+  MODE_LAST = 13
+} WEBP_CSP_MODE;
+
+// Some useful macros:
+static WEBP_INLINE int WebPIsPremultipliedMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_rgbA || mode == MODE_bgrA || mode == MODE_Argb ||
+          mode == MODE_rgbA_4444);
+}
+
+static WEBP_INLINE int WebPIsAlphaMode(WEBP_CSP_MODE mode) {
+  return (mode == MODE_RGBA || mode == MODE_BGRA || mode == MODE_ARGB ||
+          mode == MODE_RGBA_4444 || mode == MODE_YUVA ||
+          WebPIsPremultipliedMode(mode));
+}
+
+static WEBP_INLINE int WebPIsRGBMode(WEBP_CSP_MODE mode) {
+  return (mode < MODE_YUV);
+}
+
+//------------------------------------------------------------------------------
+// WebPDecBuffer: Generic structure for describing the output sample buffer.
+
+struct WebPRGBABuffer {    // view as RGBA
+  uint8_t* rgba;    // pointer to RGBA samples
+  int stride;       // stride in bytes from one scanline to the next.
+  size_t size;      // total size of the *rgba buffer.
+};
+
+struct WebPYUVABuffer {              // view as YUVA
+  uint8_t* y, *u, *v, *a;     // pointer to luma, chroma U/V, alpha samples
+  int y_stride;               // luma stride
+  int u_stride, v_stride;     // chroma strides
+  int a_stride;               // alpha stride
+  size_t y_size;              // luma plane size
+  size_t u_size, v_size;      // chroma planes size
+  size_t a_size;              // alpha-plane size
+};
+
+// Output buffer
+struct WebPDecBuffer {
+  WEBP_CSP_MODE colorspace;  // Colorspace.
+  int width, height;         // Dimensions.
+  int is_external_memory;    // If non-zero, 'internal_memory' pointer is not
+                             // used. If value is '2' or more, the external
+                             // memory is considered 'slow' and multiple
+                             // read/write will be avoided.
+  union {
+    WebPRGBABuffer RGBA;
+    WebPYUVABuffer YUVA;
+  } u;                       // Nameless union of buffer parameters.
+  uint32_t       pad[4];     // padding for later use
+
+  uint8_t* private_memory;   // Internally allocated memory (only when
+                             // is_external_memory is 0). Should not be used
+                             // externally, but accessed via the buffer union.
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN int WebPInitDecBufferInternal(WebPDecBuffer*, int);
+
+// Initialize the structure as empty. Must be called before any other use.
+// Returns false in case of version mismatch
+static WEBP_INLINE int WebPInitDecBuffer(WebPDecBuffer* buffer) {
+  return WebPInitDecBufferInternal(buffer, WEBP_DECODER_ABI_VERSION);
+}
+
+// Free any memory associated with the buffer. Must always be called last.
+// Note: doesn't free the 'buffer' structure itself.
+WEBP_EXTERN void WebPFreeDecBuffer(WebPDecBuffer* buffer);
+
+//------------------------------------------------------------------------------
+// Enumeration of the status codes
+
+typedef enum VP8StatusCode {
+  VP8_STATUS_OK = 0,
+  VP8_STATUS_OUT_OF_MEMORY,
+  VP8_STATUS_INVALID_PARAM,
+  VP8_STATUS_BITSTREAM_ERROR,
+  VP8_STATUS_UNSUPPORTED_FEATURE,
+  VP8_STATUS_SUSPENDED,
+  VP8_STATUS_USER_ABORT,
+  VP8_STATUS_NOT_ENOUGH_DATA
+} VP8StatusCode;
+
+//------------------------------------------------------------------------------
+// Incremental decoding
+//
+// This API allows streamlined decoding of partial data.
+// Picture can be incrementally decoded as data become available thanks to the
+// WebPIDecoder object. This object can be left in a SUSPENDED state if the
+// picture is only partially decoded, pending additional input.
+// Code example:
+//
+//   WebPInitDecBuffer(&output_buffer);
+//   output_buffer.colorspace = mode;
+//   ...
+//   WebPIDecoder* idec = WebPINewDecoder(&output_buffer);
+//   while (additional_data_is_available) {
+//     // ... (get additional data in some new_data[] buffer)
+//     status = WebPIAppend(idec, new_data, new_data_size);
+//     if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED) {
+//       break;    // an error occurred.
+//     }
+//
+//     // The above call decodes the current available buffer.
+//     // Part of the image can now be refreshed by calling
+//     // WebPIDecGetRGB()/WebPIDecGetYUVA() etc.
+//   }
+//   WebPIDelete(idec);
+
+// Creates a new incremental decoder with the supplied buffer parameter.
+// This output_buffer can be passed NULL, in which case a default output buffer
+// is used (with MODE_RGB). Otherwise, an internal reference to 'output_buffer'
+// is kept, which means that the lifespan of 'output_buffer' must be larger than
+// that of the returned WebPIDecoder object.
+// The supplied 'output_buffer' content MUST NOT be changed between calls to
+// WebPIAppend() or WebPIUpdate() unless 'output_buffer.is_external_memory' is
+// not set to 0. In such a case, it is allowed to modify the pointers, size and
+// stride of output_buffer.u.RGBA or output_buffer.u.YUVA, provided they remain
+// within valid bounds.
+// All other fields of WebPDecBuffer MUST remain constant between calls.
+// Returns NULL if the allocation failed.
+WEBP_EXTERN WebPIDecoder* WebPINewDecoder(WebPDecBuffer* output_buffer);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the RGB/A samples specified by 'csp' into a preallocated
+// buffer 'output_buffer'. The size of this buffer is at least
+// 'output_buffer_size' and the stride (distance in bytes between two scanlines)
+// is specified by 'output_stride'.
+// Additionally, output_buffer can be passed NULL in which case the output
+// buffer will be allocated automatically when the decoding starts. The
+// colorspace 'csp' is taken into account for allocating this buffer. All other
+// parameters are ignored.
+// Returns NULL if the allocation failed, or if some parameters are invalid.
+WEBP_EXTERN WebPIDecoder* WebPINewRGB(
+    WEBP_CSP_MODE csp,
+    uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
+
+// This function allocates and initializes an incremental-decoder object, which
+// will output the raw luma/chroma samples into a preallocated planes if
+// supplied. The luma plane is specified by its pointer 'luma', its size
+// 'luma_size' and its stride 'luma_stride'. Similarly, the chroma-u plane
+// is specified by the 'u', 'u_size' and 'u_stride' parameters, and the chroma-v
+// plane by 'v' and 'v_size'. And same for the alpha-plane. The 'a' pointer
+// can be pass NULL in case one is not interested in the transparency plane.
+// Conversely, 'luma' can be passed NULL if no preallocated planes are supplied.
+// In this case, the output buffer will be automatically allocated (using
+// MODE_YUVA) when decoding starts. All parameters are then ignored.
+// Returns NULL if the allocation failed or if a parameter is invalid.
+WEBP_EXTERN WebPIDecoder* WebPINewYUVA(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride,
+    uint8_t* a, size_t a_size, int a_stride);
+
+// Deprecated version of the above, without the alpha plane.
+// Kept for backward compatibility.
+WEBP_EXTERN WebPIDecoder* WebPINewYUV(
+    uint8_t* luma, size_t luma_size, int luma_stride,
+    uint8_t* u, size_t u_size, int u_stride,
+    uint8_t* v, size_t v_size, int v_stride);
+
+// Deletes the WebPIDecoder object and associated memory. Must always be called
+// if WebPINewDecoder, WebPINewRGB or WebPINewYUV succeeded.
+WEBP_EXTERN void WebPIDelete(WebPIDecoder* idec);
+
+// Copies and decodes the next available data. Returns VP8_STATUS_OK when
+// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more
+// data is expected. Returns error in other cases.
+WEBP_EXTERN VP8StatusCode WebPIAppend(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// A variant of the above function to be used when data buffer contains
+// partial data from the beginning. In this case data buffer is not copied
+// to the internal memory.
+// Note that the value of the 'data' pointer can change between calls to
+// WebPIUpdate, for instance when the data buffer is resized to fit larger data.
+WEBP_EXTERN VP8StatusCode WebPIUpdate(
+    WebPIDecoder* idec, const uint8_t* data, size_t data_size);
+
+// Returns the RGB/A image decoded so far. Returns NULL if output params
+// are not initialized yet. The RGB/A output type corresponds to the colorspace
+// specified during call to WebPINewDecoder() or WebPINewRGB().
+// *last_y is the index of last decoded row in raster scan order. Some pointers
+// (*last_y, *width etc.) can be NULL if corresponding information is not
+// needed. The values in these pointers are only valid on successful (non-NULL)
+// return.
+WEBP_EXTERN uint8_t* WebPIDecGetRGB(
+    const WebPIDecoder* idec, int* last_y,
+    int* width, int* height, int* stride);
+
+// Same as above function to get a YUVA image. Returns pointer to the luma
+// plane or NULL in case of error. If there is no alpha information
+// the alpha pointer '*a' will be returned NULL.
+WEBP_EXTERN uint8_t* WebPIDecGetYUVA(
+    const WebPIDecoder* idec, int* last_y,
+    uint8_t** u, uint8_t** v, uint8_t** a,
+    int* width, int* height, int* stride, int* uv_stride, int* a_stride);
+
+// Deprecated alpha-less version of WebPIDecGetYUVA(): it will ignore the
+// alpha information (if present). Kept for backward compatibility.
+static WEBP_INLINE uint8_t* WebPIDecGetYUV(
+    const WebPIDecoder* idec, int* last_y, uint8_t** u, uint8_t** v,
+    int* width, int* height, int* stride, int* uv_stride) {
+  return WebPIDecGetYUVA(idec, last_y, u, v, NULL, width, height,
+                         stride, uv_stride, NULL);
+}
+
+// Generic call to retrieve information about the displayable area.
+// If non NULL, the left/right/width/height pointers are filled with the visible
+// rectangular area so far.
+// Returns NULL in case the incremental decoder object is in an invalid state.
+// Otherwise returns the pointer to the internal representation. This structure
+// is read-only, tied to WebPIDecoder's lifespan and should not be modified.
+WEBP_EXTERN const WebPDecBuffer* WebPIDecodedArea(
+    const WebPIDecoder* idec, int* left, int* top, int* width, int* height);
+
+//------------------------------------------------------------------------------
+// Advanced decoding parametrization
+//
+//  Code sample for using the advanced decoding API
+/*
+     // A) Init a configuration object
+     WebPDecoderConfig config;
+     CHECK(WebPInitDecoderConfig(&config));
+
+     // B) optional: retrieve the bitstream's features.
+     CHECK(WebPGetFeatures(data, data_size, &config.input) == VP8_STATUS_OK);
+
+     // C) Adjust 'config', if needed
+     config.no_fancy_upsampling = 1;
+     config.output.colorspace = MODE_BGRA;
+     // etc.
+
+     // Note that you can also make config.output point to an externally
+     // supplied memory buffer, provided it's big enough to store the decoded
+     // picture. Otherwise, config.output will just be used to allocate memory
+     // and store the decoded picture.
+
+     // D) Decode!
+     CHECK(WebPDecode(data, data_size, &config) == VP8_STATUS_OK);
+
+     // E) Decoded image is now in config.output (and config.output.u.RGBA)
+
+     // F) Reclaim memory allocated in config's object. It's safe to call
+     // this function even if the memory is external and wasn't allocated
+     // by WebPDecode().
+     WebPFreeDecBuffer(&config.output);
+*/
+
+// Features gathered from the bitstream
+struct WebPBitstreamFeatures {
+  int width;          // Width in pixels, as read from the bitstream.
+  int height;         // Height in pixels, as read from the bitstream.
+  int has_alpha;      // True if the bitstream contains an alpha channel.
+  int has_animation;  // True if the bitstream is an animation.
+  int format;         // 0 = undefined (/mixed), 1 = lossy, 2 = lossless
+
+  uint32_t pad[5];    // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN VP8StatusCode WebPGetFeaturesInternal(
+    const uint8_t*, size_t, WebPBitstreamFeatures*, int);
+
+// Retrieve features from the bitstream. The *features structure is filled
+// with information gathered from the bitstream.
+// Returns VP8_STATUS_OK when the features are successfully retrieved. Returns
+// VP8_STATUS_NOT_ENOUGH_DATA when more data is needed to retrieve the
+// features from headers. Returns error in other cases.
+// Note: The following chunk sequences (before the raw VP8/VP8L data) are
+// considered valid by this function:
+// RIFF + VP8(L)
+// RIFF + VP8X + (optional chunks) + VP8(L)
+// ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose.
+// VP8(L)     <-- Not a valid WebP format: only allowed for internal purpose.
+static WEBP_INLINE VP8StatusCode WebPGetFeatures(
+    const uint8_t* data, size_t data_size,
+    WebPBitstreamFeatures* features) {
+  return WebPGetFeaturesInternal(data, data_size, features,
+                                 WEBP_DECODER_ABI_VERSION);
+}
+
+// Decoding options
+struct WebPDecoderOptions {
+  int bypass_filtering;               // if true, skip the in-loop filtering
+  int no_fancy_upsampling;            // if true, use faster pointwise upsampler
+  int use_cropping;                   // if true, cropping is applied _first_
+  int crop_left, crop_top;            // top-left position for cropping.
+                                      // Will be snapped to even values.
+  int crop_width, crop_height;        // dimension of the cropping area
+  int use_scaling;                    // if true, scaling is applied _afterward_
+  int scaled_width, scaled_height;    // final resolution
+  int use_threads;                    // if true, use multi-threaded decoding
+  int dithering_strength;             // dithering strength (0=Off, 100=full)
+  int flip;                           // if true, flip output vertically
+  int alpha_dithering_strength;       // alpha dithering strength in [0..100]
+
+  uint32_t pad[5];                    // padding for later use
+};
+
+// Main object storing the configuration for advanced decoding.
+struct WebPDecoderConfig {
+  WebPBitstreamFeatures input;  // Immutable bitstream features (optional)
+  WebPDecBuffer output;         // Output buffer (can point to external mem)
+  WebPDecoderOptions options;   // Decoding options
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN int WebPInitDecoderConfigInternal(WebPDecoderConfig*, int);
+
+// Initialize the configuration as empty. This function must always be
+// called first, unless WebPGetFeatures() is to be called.
+// Returns false in case of mismatched version.
+static WEBP_INLINE int WebPInitDecoderConfig(WebPDecoderConfig* config) {
+  return WebPInitDecoderConfigInternal(config, WEBP_DECODER_ABI_VERSION);
+}
+
+// Instantiate a new incremental decoder object with the requested
+// configuration. The bitstream can be passed using 'data' and 'data_size'
+// parameter, in which case the features will be parsed and stored into
+// config->input. Otherwise, 'data' can be NULL and no parsing will occur.
+// Note that 'config' can be NULL too, in which case a default configuration
+// is used. If 'config' is not NULL, it must outlive the WebPIDecoder object
+// as some references to its fields will be used. No internal copy of 'config'
+// is made.
+// The return WebPIDecoder object must always be deleted calling WebPIDelete().
+// Returns NULL in case of error (and config->status will then reflect
+// the error condition, if available).
+WEBP_EXTERN WebPIDecoder* WebPIDecode(const uint8_t* data, size_t data_size,
+                                      WebPDecoderConfig* config);
+
+// Non-incremental version. This version decodes the full data at once, taking
+// 'config' into account. Returns decoding status (which should be VP8_STATUS_OK
+// if the decoding was successful). Note that 'config' cannot be NULL.
+WEBP_EXTERN VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size,
+                                     WebPDecoderConfig* config);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_DECODE_H_
diff --git a/webp/demux.h b/webp/demux.h
new file mode 100644
index 0000000..846eeb1
--- /dev/null
+++ b/webp/demux.h
@@ -0,0 +1,363 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+// Demux API.
+// Enables extraction of image and extended format data from WebP files.
+
+// Code Example: Demuxing WebP data to extract all the frames, ICC profile
+// and EXIF/XMP metadata.
+/*
+  WebPDemuxer* demux = WebPDemux(&webp_data);
+
+  uint32_t width = WebPDemuxGetI(demux, WEBP_FF_CANVAS_WIDTH);
+  uint32_t height = WebPDemuxGetI(demux, WEBP_FF_CANVAS_HEIGHT);
+  // ... (Get information about the features present in the WebP file).
+  uint32_t flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS);
+
+  // ... (Iterate over all frames).
+  WebPIterator iter;
+  if (WebPDemuxGetFrame(demux, 1, &iter)) {
+    do {
+      // ... (Consume 'iter'; e.g. Decode 'iter.fragment' with WebPDecode(),
+      // ... and get other frame properties like width, height, offsets etc.
+      // ... see 'struct WebPIterator' below for more info).
+    } while (WebPDemuxNextFrame(&iter));
+    WebPDemuxReleaseIterator(&iter);
+  }
+
+  // ... (Extract metadata).
+  WebPChunkIterator chunk_iter;
+  if (flags & ICCP_FLAG) WebPDemuxGetChunk(demux, "ICCP", 1, &chunk_iter);
+  // ... (Consume the ICC profile in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  if (flags & EXIF_FLAG) WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter);
+  // ... (Consume the EXIF metadata in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  if (flags & XMP_FLAG) WebPDemuxGetChunk(demux, "XMP ", 1, &chunk_iter);
+  // ... (Consume the XMP metadata in 'chunk_iter.chunk').
+  WebPDemuxReleaseChunkIterator(&chunk_iter);
+  WebPDemuxDelete(demux);
+*/
+
+#ifndef WEBP_WEBP_DEMUX_H_
+#define WEBP_WEBP_DEMUX_H_
+
+#include "./decode.h"     // for WEBP_CSP_MODE
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_DEMUX_ABI_VERSION 0x0107    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPDemuxState WebPDemuxState;
+// typedef enum WebPFormatFeature WebPFormatFeature;
+typedef struct WebPDemuxer WebPDemuxer;
+typedef struct WebPIterator WebPIterator;
+typedef struct WebPChunkIterator WebPChunkIterator;
+typedef struct WebPAnimInfo WebPAnimInfo;
+typedef struct WebPAnimDecoderOptions WebPAnimDecoderOptions;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the demux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN int WebPGetDemuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Demux object
+
+typedef enum WebPDemuxState {
+  WEBP_DEMUX_PARSE_ERROR    = -1,  // An error occurred while parsing.
+  WEBP_DEMUX_PARSING_HEADER =  0,  // Not enough data to parse full header.
+  WEBP_DEMUX_PARSED_HEADER  =  1,  // Header parsing complete,
+                                   // data may be available.
+  WEBP_DEMUX_DONE           =  2   // Entire file has been parsed.
+} WebPDemuxState;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN WebPDemuxer* WebPDemuxInternal(
+    const WebPData*, int, WebPDemuxState*, int);
+
+// Parses the full WebP file given by 'data'. For single images the WebP file
+// header alone or the file header and the chunk header may be absent.
+// Returns a WebPDemuxer object on successful parse, NULL otherwise.
+static WEBP_INLINE WebPDemuxer* WebPDemux(const WebPData* data) {
+  return WebPDemuxInternal(data, 0, NULL, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Parses the possibly incomplete WebP file given by 'data'.
+// If 'state' is non-NULL it will be set to indicate the status of the demuxer.
+// Returns NULL in case of error or if there isn't enough data to start parsing;
+// and a WebPDemuxer object on successful parse.
+// Note that WebPDemuxer keeps internal pointers to 'data' memory segment.
+// If this data is volatile, the demuxer object should be deleted (by calling
+// WebPDemuxDelete()) and WebPDemuxPartial() called again on the new data.
+// This is usually an inexpensive operation.
+static WEBP_INLINE WebPDemuxer* WebPDemuxPartial(
+    const WebPData* data, WebPDemuxState* state) {
+  return WebPDemuxInternal(data, 1, state, WEBP_DEMUX_ABI_VERSION);
+}
+
+// Frees memory associated with 'dmux'.
+WEBP_EXTERN void WebPDemuxDelete(WebPDemuxer* dmux);
+
+//------------------------------------------------------------------------------
+// Data/information extraction.
+
+typedef enum WebPFormatFeature {
+  WEBP_FF_FORMAT_FLAGS,      // bit-wise combination of WebPFeatureFlags
+                             // corresponding to the 'VP8X' chunk (if present).
+  WEBP_FF_CANVAS_WIDTH,
+  WEBP_FF_CANVAS_HEIGHT,
+  WEBP_FF_LOOP_COUNT,        // only relevant for animated file
+  WEBP_FF_BACKGROUND_COLOR,  // idem.
+  WEBP_FF_FRAME_COUNT        // Number of frames present in the demux object.
+                             // In case of a partial demux, this is the number
+                             // of frames seen so far, with the last frame
+                             // possibly being partial.
+} WebPFormatFeature;
+
+// Get the 'feature' value from the 'dmux'.
+// NOTE: values are only valid if WebPDemux() was used or WebPDemuxPartial()
+// returned a state > WEBP_DEMUX_PARSING_HEADER.
+// If 'feature' is WEBP_FF_FORMAT_FLAGS, the returned value is a bit-wise
+// combination of WebPFeatureFlags values.
+// If 'feature' is WEBP_FF_LOOP_COUNT, WEBP_FF_BACKGROUND_COLOR, the returned
+// value is only meaningful if the bitstream is animated.
+WEBP_EXTERN uint32_t WebPDemuxGetI(
+    const WebPDemuxer* dmux, WebPFormatFeature feature);
+
+//------------------------------------------------------------------------------
+// Frame iteration.
+
+struct WebPIterator {
+  int frame_num;
+  int num_frames;          // equivalent to WEBP_FF_FRAME_COUNT.
+  int x_offset, y_offset;  // offset relative to the canvas.
+  int width, height;       // dimensions of this frame.
+  int duration;            // display duration in milliseconds.
+  WebPMuxAnimDispose dispose_method;  // dispose method for the frame.
+  int complete;   // true if 'fragment' contains a full frame. partial images
+                  // may still be decoded with the WebP incremental decoder.
+  WebPData fragment;  // The frame given by 'frame_num'. Note for historical
+                      // reasons this is called a fragment.
+  int has_alpha;      // True if the frame contains transparency.
+  WebPMuxAnimBlend blend_method;  // Blend operation for the frame.
+
+  uint32_t pad[2];         // padding for later use.
+  void* private_;          // for internal use only.
+};
+
+// Retrieves frame 'frame_number' from 'dmux'.
+// 'iter->fragment' points to the frame on return from this function.
+// Setting 'frame_number' equal to 0 will return the last frame of the image.
+// Returns false if 'dmux' is NULL or frame 'frame_number' is not present.
+// Call WebPDemuxReleaseIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of 'iter'.
+WEBP_EXTERN int WebPDemuxGetFrame(
+    const WebPDemuxer* dmux, int frame_number, WebPIterator* iter);
+
+// Sets 'iter->fragment' to point to the next ('iter->frame_num' + 1) or
+// previous ('iter->frame_num' - 1) frame. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN int WebPDemuxNextFrame(WebPIterator* iter);
+WEBP_EXTERN int WebPDemuxPrevFrame(WebPIterator* iter);
+
+// Releases any memory associated with 'iter'.
+// Must be called before any subsequent calls to WebPDemuxGetChunk() on the same
+// iter. Also, must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN void WebPDemuxReleaseIterator(WebPIterator* iter);
+
+//------------------------------------------------------------------------------
+// Chunk iteration.
+
+struct WebPChunkIterator {
+  // The current and total number of chunks with the fourcc given to
+  // WebPDemuxGetChunk().
+  int chunk_num;
+  int num_chunks;
+  WebPData chunk;    // The payload of the chunk.
+
+  uint32_t pad[6];   // padding for later use
+  void* private_;
+};
+
+// Retrieves the 'chunk_number' instance of the chunk with id 'fourcc' from
+// 'dmux'.
+// 'fourcc' is a character array containing the fourcc of the chunk to return,
+// e.g., "ICCP", "XMP ", "EXIF", etc.
+// Setting 'chunk_number' equal to 0 will return the last chunk in a set.
+// Returns true if the chunk is found, false otherwise. Image related chunk
+// payloads are accessed through WebPDemuxGetFrame() and related functions.
+// Call WebPDemuxReleaseChunkIterator() when use of the iterator is complete.
+// NOTE: 'dmux' must persist for the lifetime of the iterator.
+WEBP_EXTERN int WebPDemuxGetChunk(const WebPDemuxer* dmux,
+                                  const char fourcc[4], int chunk_number,
+                                  WebPChunkIterator* iter);
+
+// Sets 'iter->chunk' to point to the next ('iter->chunk_num' + 1) or previous
+// ('iter->chunk_num' - 1) chunk. These functions do not loop.
+// Returns true on success, false otherwise.
+WEBP_EXTERN int WebPDemuxNextChunk(WebPChunkIterator* iter);
+WEBP_EXTERN int WebPDemuxPrevChunk(WebPChunkIterator* iter);
+
+// Releases any memory associated with 'iter'.
+// Must be called before destroying the associated WebPDemuxer with
+// WebPDemuxDelete().
+WEBP_EXTERN void WebPDemuxReleaseChunkIterator(WebPChunkIterator* iter);
+
+//------------------------------------------------------------------------------
+// WebPAnimDecoder API
+//
+// This API allows decoding (possibly) animated WebP images.
+//
+// Code Example:
+/*
+  WebPAnimDecoderOptions dec_options;
+  WebPAnimDecoderOptionsInit(&dec_options);
+  // Tune 'dec_options' as needed.
+  WebPAnimDecoder* dec = WebPAnimDecoderNew(webp_data, &dec_options);
+  WebPAnimInfo anim_info;
+  WebPAnimDecoderGetInfo(dec, &anim_info);
+  for (uint32_t i = 0; i < anim_info.loop_count; ++i) {
+    while (WebPAnimDecoderHasMoreFrames(dec)) {
+      uint8_t* buf;
+      int timestamp;
+      WebPAnimDecoderGetNext(dec, &buf, &timestamp);
+      // ... (Render 'buf' based on 'timestamp').
+      // ... (Do NOT free 'buf', as it is owned by 'dec').
+    }
+    WebPAnimDecoderReset(dec);
+  }
+  const WebPDemuxer* demuxer = WebPAnimDecoderGetDemuxer(dec);
+  // ... (Do something using 'demuxer'; e.g. get EXIF/XMP/ICC data).
+  WebPAnimDecoderDelete(dec);
+*/
+
+typedef struct WebPAnimDecoder WebPAnimDecoder;  // Main opaque object.
+
+// Global options.
+struct WebPAnimDecoderOptions {
+  // Output colorspace. Only the following modes are supported:
+  // MODE_RGBA, MODE_BGRA, MODE_rgbA and MODE_bgrA.
+  WEBP_CSP_MODE color_mode;
+  int use_threads;           // If true, use multi-threaded decoding.
+  uint32_t padding[7];       // Padding for later use.
+};
+
+// Internal, version-checked, entry point.
+WEBP_EXTERN int WebPAnimDecoderOptionsInitInternal(
+    WebPAnimDecoderOptions*, int);
+
+// Should always be called, to initialize a fresh WebPAnimDecoderOptions
+// structure before modification. Returns false in case of version mismatch.
+// WebPAnimDecoderOptionsInit() must have succeeded before using the
+// 'dec_options' object.
+static WEBP_INLINE int WebPAnimDecoderOptionsInit(
+    WebPAnimDecoderOptions* dec_options) {
+  return WebPAnimDecoderOptionsInitInternal(dec_options,
+                                            WEBP_DEMUX_ABI_VERSION);
+}
+
+// Internal, version-checked, entry point.
+WEBP_EXTERN WebPAnimDecoder* WebPAnimDecoderNewInternal(
+    const WebPData*, const WebPAnimDecoderOptions*, int);
+
+// Creates and initializes a WebPAnimDecoder object.
+// Parameters:
+//   webp_data - (in) WebP bitstream. This should remain unchanged during the
+//                    lifetime of the output WebPAnimDecoder object.
+//   dec_options - (in) decoding options. Can be passed NULL to choose
+//                      reasonable defaults (in particular, color mode MODE_RGBA
+//                      will be picked).
+// Returns:
+//   A pointer to the newly created WebPAnimDecoder object, or NULL in case of
+//   parsing error, invalid option or memory error.
+static WEBP_INLINE WebPAnimDecoder* WebPAnimDecoderNew(
+    const WebPData* webp_data, const WebPAnimDecoderOptions* dec_options) {
+  return WebPAnimDecoderNewInternal(webp_data, dec_options,
+                                    WEBP_DEMUX_ABI_VERSION);
+}
+
+// Global information about the animation..
+struct WebPAnimInfo {
+  uint32_t canvas_width;
+  uint32_t canvas_height;
+  uint32_t loop_count;
+  uint32_t bgcolor;
+  uint32_t frame_count;
+  uint32_t pad[4];   // padding for later use
+};
+
+// Get global information about the animation.
+// Parameters:
+//   dec - (in) decoder instance to get information from.
+//   info - (out) global information fetched from the animation.
+// Returns:
+//   True on success.
+WEBP_EXTERN int WebPAnimDecoderGetInfo(const WebPAnimDecoder* dec,
+                                       WebPAnimInfo* info);
+
+// Fetch the next frame from 'dec' based on options supplied to
+// WebPAnimDecoderNew(). This will be a fully reconstructed canvas of size
+// 'canvas_width * 4 * canvas_height', and not just the frame sub-rectangle. The
+// returned buffer 'buf' is valid only until the next call to
+// WebPAnimDecoderGetNext(), WebPAnimDecoderReset() or WebPAnimDecoderDelete().
+// Parameters:
+//   dec - (in/out) decoder instance from which the next frame is to be fetched.
+//   buf - (out) decoded frame.
+//   timestamp - (out) timestamp of the frame in milliseconds.
+// Returns:
+//   False if any of the arguments are NULL, or if there is a parsing or
+//   decoding error, or if there are no more frames. Otherwise, returns true.
+WEBP_EXTERN int WebPAnimDecoderGetNext(WebPAnimDecoder* dec,
+                                       uint8_t** buf, int* timestamp);
+
+// Check if there are more frames left to decode.
+// Parameters:
+//   dec - (in) decoder instance to be checked.
+// Returns:
+//   True if 'dec' is not NULL and some frames are yet to be decoded.
+//   Otherwise, returns false.
+WEBP_EXTERN int WebPAnimDecoderHasMoreFrames(const WebPAnimDecoder* dec);
+
+// Resets the WebPAnimDecoder object, so that next call to
+// WebPAnimDecoderGetNext() will restart decoding from 1st frame. This would be
+// helpful when all frames need to be decoded multiple times (e.g.
+// info.loop_count times) without destroying and recreating the 'dec' object.
+// Parameters:
+//   dec - (in/out) decoder instance to be reset
+WEBP_EXTERN void WebPAnimDecoderReset(WebPAnimDecoder* dec);
+
+// Grab the internal demuxer object.
+// Getting the demuxer object can be useful if one wants to use operations only
+// available through demuxer; e.g. to get XMP/EXIF/ICC metadata. The returned
+// demuxer object is owned by 'dec' and is valid only until the next call to
+// WebPAnimDecoderDelete().
+//
+// Parameters:
+//   dec - (in) decoder instance from which the demuxer object is to be fetched.
+WEBP_EXTERN const WebPDemuxer* WebPAnimDecoderGetDemuxer(
+    const WebPAnimDecoder* dec);
+
+// Deletes the WebPAnimDecoder object.
+// Parameters:
+//   dec - (in/out) decoder instance to be deleted
+WEBP_EXTERN void WebPAnimDecoderDelete(WebPAnimDecoder* dec);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_DEMUX_H_
diff --git a/webp/encode.h b/webp/encode.h
new file mode 100644
index 0000000..56b68e2
--- /dev/null
+++ b/webp/encode.h
@@ -0,0 +1,552 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//   WebP encoder: main interface
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_ENCODE_H_
+#define WEBP_WEBP_ENCODE_H_
+
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_ENCODER_ABI_VERSION 0x020f    // MAJOR(8b) + MINOR(8b)
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPImageHint WebPImageHint;
+// typedef enum WebPEncCSP WebPEncCSP;
+// typedef enum WebPPreset WebPPreset;
+// typedef enum WebPEncodingError WebPEncodingError;
+typedef struct WebPConfig WebPConfig;
+typedef struct WebPPicture WebPPicture;   // main structure for I/O
+typedef struct WebPAuxStats WebPAuxStats;
+typedef struct WebPMemoryWriter WebPMemoryWriter;
+
+// Return the encoder's version number, packed in hexadecimal using 8bits for
+// each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN int WebPGetEncoderVersion(void);
+
+//------------------------------------------------------------------------------
+// One-stop-shop call! No questions asked:
+
+// Returns the size of the compressed data (pointed to by *output), or 0 if
+// an error occurred. The compressed data must be released by the caller
+// using the call 'WebPFree(*output)'.
+// These functions compress using the lossy format, and the quality_factor
+// can go from 0 (smaller output, lower quality) to 100 (best quality,
+// larger output).
+WEBP_EXTERN size_t WebPEncodeRGB(const uint8_t* rgb,
+                                 int width, int height, int stride,
+                                 float quality_factor, uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeBGR(const uint8_t* bgr,
+                                 int width, int height, int stride,
+                                 float quality_factor, uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeRGBA(const uint8_t* rgba,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeBGRA(const uint8_t* bgra,
+                                  int width, int height, int stride,
+                                  float quality_factor, uint8_t** output);
+
+// These functions are the equivalent of the above, but compressing in a
+// lossless manner. Files are usually larger than lossy format, but will
+// not suffer any compression loss.
+// Note these functions, like the lossy versions, use the library's default
+// settings. For lossless this means 'exact' is disabled. RGB values in
+// transparent areas will be modified to improve compression. To avoid this,
+// use WebPEncode() and set WebPConfig::exact to 1.
+WEBP_EXTERN size_t WebPEncodeLosslessRGB(const uint8_t* rgb,
+                                         int width, int height, int stride,
+                                         uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeLosslessBGR(const uint8_t* bgr,
+                                         int width, int height, int stride,
+                                         uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeLosslessRGBA(const uint8_t* rgba,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+WEBP_EXTERN size_t WebPEncodeLosslessBGRA(const uint8_t* bgra,
+                                          int width, int height, int stride,
+                                          uint8_t** output);
+
+//------------------------------------------------------------------------------
+// Coding parameters
+
+// Image characteristics hint for the underlying encoder.
+typedef enum WebPImageHint {
+  WEBP_HINT_DEFAULT = 0,  // default preset.
+  WEBP_HINT_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_HINT_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_HINT_GRAPH,        // Discrete tone image (graph, map-tile etc).
+  WEBP_HINT_LAST
+} WebPImageHint;
+
+// Compression parameters.
+struct WebPConfig {
+  int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+  float quality;          // between 0 and 100. For lossy, 0 gives the smallest
+                          // size and 100 the largest. For lossless, this
+                          // parameter is the amount of effort put into the
+                          // compression: 0 is the fastest but gives larger
+                          // files compared to the slowest, but best, 100.
+  int method;             // quality/speed trade-off (0=fast, 6=slower-better)
+
+  WebPImageHint image_hint;  // Hint for image type (lossless only for now).
+
+  int target_size;        // if non-zero, set the desired target size in bytes.
+                          // Takes precedence over the 'compression' parameter.
+  float target_PSNR;      // if non-zero, specifies the minimal distortion to
+                          // try to achieve. Takes precedence over target_size.
+  int segments;           // maximum number of segments to use, in [1..4]
+  int sns_strength;       // Spatial Noise Shaping. 0=off, 100=maximum.
+  int filter_strength;    // range: [0 = off .. 100 = strongest]
+  int filter_sharpness;   // range: [0 = off .. 7 = least sharp]
+  int filter_type;        // filtering type: 0 = simple, 1 = strong (only used
+                          // if filter_strength > 0 or autofilter > 0)
+  int autofilter;         // Auto adjust filter's strength [0 = off, 1 = on]
+  int alpha_compression;  // Algorithm for encoding the alpha plane (0 = none,
+                          // 1 = compressed with WebP lossless). Default is 1.
+  int alpha_filtering;    // Predictive filtering method for alpha plane.
+                          //  0: none, 1: fast, 2: best. Default if 1.
+  int alpha_quality;      // Between 0 (smallest size) and 100 (lossless).
+                          // Default is 100.
+  int pass;               // number of entropy-analysis passes (in [1..10]).
+
+  int show_compressed;    // if true, export the compressed picture back.
+                          // In-loop filtering is not applied.
+  int preprocessing;      // preprocessing filter:
+                          // 0=none, 1=segment-smooth, 2=pseudo-random dithering
+  int partitions;         // log2(number of token partitions) in [0..3]. Default
+                          // is set to 0 for easier progressive decoding.
+  int partition_limit;    // quality degradation allowed to fit the 512k limit
+                          // on prediction modes coding (0: no degradation,
+                          // 100: maximum possible degradation).
+  int emulate_jpeg_size;  // If true, compression parameters will be remapped
+                          // to better match the expected output size from
+                          // JPEG compression. Generally, the output size will
+                          // be similar but the degradation will be lower.
+  int thread_level;       // If non-zero, try and use multi-threaded encoding.
+  int low_memory;         // If set, reduce memory usage (but increase CPU use).
+
+  int near_lossless;      // Near lossless encoding [0 = max loss .. 100 = off
+                          // (default)].
+  int exact;              // if non-zero, preserve the exact RGB values under
+                          // transparent area. Otherwise, discard this invisible
+                          // RGB information for better compression. The default
+                          // value is 0.
+
+  int use_delta_palette;  // reserved for future lossless feature
+  int use_sharp_yuv;      // if needed, use sharp (and slow) RGB->YUV conversion
+
+  int qmin;               // minimum permissible quality factor
+  int qmax;               // maximum permissible quality factor
+};
+
+// Enumerate some predefined settings for WebPConfig, depending on the type
+// of source picture. These presets are used when calling WebPConfigPreset().
+typedef enum WebPPreset {
+  WEBP_PRESET_DEFAULT = 0,  // default preset.
+  WEBP_PRESET_PICTURE,      // digital picture, like portrait, inner shot
+  WEBP_PRESET_PHOTO,        // outdoor photograph, with natural lighting
+  WEBP_PRESET_DRAWING,      // hand or line drawing, with high-contrast details
+  WEBP_PRESET_ICON,         // small-sized colorful images
+  WEBP_PRESET_TEXT          // text-like
+} WebPPreset;
+
+// Internal, version-checked, entry point
+WEBP_EXTERN int WebPConfigInitInternal(WebPConfig*, WebPPreset, float, int);
+
+// Should always be called, to initialize a fresh WebPConfig structure before
+// modification. Returns false in case of version mismatch. WebPConfigInit()
+// must have succeeded before using the 'config' object.
+// Note that the default values are lossless=0 and quality=75.
+static WEBP_INLINE int WebPConfigInit(WebPConfig* config) {
+  return WebPConfigInitInternal(config, WEBP_PRESET_DEFAULT, 75.f,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+// This function will initialize the configuration according to a predefined
+// set of parameters (referred to by 'preset') and a given quality factor.
+// This function can be called as a replacement to WebPConfigInit(). Will
+// return false in case of error.
+static WEBP_INLINE int WebPConfigPreset(WebPConfig* config,
+                                        WebPPreset preset, float quality) {
+  return WebPConfigInitInternal(config, preset, quality,
+                                WEBP_ENCODER_ABI_VERSION);
+}
+
+// Activate the lossless compression mode with the desired efficiency level
+// between 0 (fastest, lowest compression) and 9 (slower, best compression).
+// A good default level is '6', providing a fair tradeoff between compression
+// speed and final compressed size.
+// This function will overwrite several fields from config: 'method', 'quality'
+// and 'lossless'. Returns false in case of parameter error.
+WEBP_EXTERN int WebPConfigLosslessPreset(WebPConfig* config, int level);
+
+// Returns true if 'config' is non-NULL and all configuration parameters are
+// within their valid ranges.
+WEBP_EXTERN int WebPValidateConfig(const WebPConfig* config);
+
+//------------------------------------------------------------------------------
+// Input / Output
+// Structure for storing auxiliary statistics.
+
+struct WebPAuxStats {
+  int coded_size;         // final size
+
+  float PSNR[5];          // peak-signal-to-noise ratio for Y/U/V/All/Alpha
+  int block_count[3];     // number of intra4/intra16/skipped macroblocks
+  int header_bytes[2];    // approximate number of bytes spent for header
+                          // and mode-partition #0
+  int residual_bytes[3][4];  // approximate number of bytes spent for
+                             // DC/AC/uv coefficients for each (0..3) segments.
+  int segment_size[4];    // number of macroblocks in each segments
+  int segment_quant[4];   // quantizer values for each segments
+  int segment_level[4];   // filtering strength for each segments [0..63]
+
+  int alpha_data_size;    // size of the transparency data
+  int layer_data_size;    // size of the enhancement layer data
+
+  // lossless encoder statistics
+  uint32_t lossless_features;  // bit0:predictor bit1:cross-color transform
+                               // bit2:subtract-green bit3:color indexing
+  int histogram_bits;          // number of precision bits of histogram
+  int transform_bits;          // precision bits for transform
+  int cache_bits;              // number of bits for color cache lookup
+  int palette_size;            // number of color in palette, if used
+  int lossless_size;           // final lossless size
+  int lossless_hdr_size;       // lossless header (transform, huffman etc) size
+  int lossless_data_size;      // lossless image data size
+
+  uint32_t pad[2];        // padding for later use
+};
+
+// Signature for output function. Should return true if writing was successful.
+// data/data_size is the segment of data to write, and 'picture' is for
+// reference (and so one can make use of picture->custom_ptr).
+typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size,
+                                  const WebPPicture* picture);
+
+// WebPMemoryWrite: a special WebPWriterFunction that writes to memory using
+// the following WebPMemoryWriter object (to be set as a custom_ptr).
+struct WebPMemoryWriter {
+  uint8_t* mem;       // final buffer (of size 'max_size', larger than 'size').
+  size_t   size;      // final size
+  size_t   max_size;  // total capacity
+  uint32_t pad[1];    // padding for later use
+};
+
+// The following must be called first before any use.
+WEBP_EXTERN void WebPMemoryWriterInit(WebPMemoryWriter* writer);
+
+// The following must be called to deallocate writer->mem memory. The 'writer'
+// object itself is not deallocated.
+WEBP_EXTERN void WebPMemoryWriterClear(WebPMemoryWriter* writer);
+// The custom writer to be used with WebPMemoryWriter as custom_ptr. Upon
+// completion, writer.mem and writer.size will hold the coded data.
+// writer.mem must be freed by calling WebPMemoryWriterClear.
+WEBP_EXTERN int WebPMemoryWrite(const uint8_t* data, size_t data_size,
+                                const WebPPicture* picture);
+
+// Progress hook, called from time to time to report progress. It can return
+// false to request an abort of the encoding process, or true otherwise if
+// everything is OK.
+typedef int (*WebPProgressHook)(int percent, const WebPPicture* picture);
+
+// Color spaces.
+typedef enum WebPEncCSP {
+  // chroma sampling
+  WEBP_YUV420  = 0,        // 4:2:0
+  WEBP_YUV420A = 4,        // alpha channel variant
+  WEBP_CSP_UV_MASK = 3,    // bit-mask to get the UV sampling factors
+  WEBP_CSP_ALPHA_BIT = 4   // bit that is set if alpha is present
+} WebPEncCSP;
+
+// Encoding error conditions.
+typedef enum WebPEncodingError {
+  VP8_ENC_OK = 0,
+  VP8_ENC_ERROR_OUT_OF_MEMORY,            // memory error allocating objects
+  VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY,  // memory error while flushing bits
+  VP8_ENC_ERROR_NULL_PARAMETER,           // a pointer parameter is NULL
+  VP8_ENC_ERROR_INVALID_CONFIGURATION,    // configuration is invalid
+  VP8_ENC_ERROR_BAD_DIMENSION,            // picture has invalid width/height
+  VP8_ENC_ERROR_PARTITION0_OVERFLOW,      // partition is bigger than 512k
+  VP8_ENC_ERROR_PARTITION_OVERFLOW,       // partition is bigger than 16M
+  VP8_ENC_ERROR_BAD_WRITE,                // error while flushing bytes
+  VP8_ENC_ERROR_FILE_TOO_BIG,             // file is bigger than 4G
+  VP8_ENC_ERROR_USER_ABORT,               // abort request by user
+  VP8_ENC_ERROR_LAST                      // list terminator. always last.
+} WebPEncodingError;
+
+// maximum width/height allowed (inclusive), in pixels
+#define WEBP_MAX_DIMENSION 16383
+
+// Main exchange structure (input samples, output bytes, statistics)
+//
+// Once WebPPictureInit() has been called, it's ok to make all the INPUT fields
+// (use_argb, y/u/v, argb, ...) point to user-owned data, even if
+// WebPPictureAlloc() has been called. Depending on the value use_argb,
+// it's guaranteed that either *argb or *y/*u/*v content will be kept untouched.
+struct WebPPicture {
+  //   INPUT
+  //////////////
+  // Main flag for encoder selecting between ARGB or YUV input.
+  // It is recommended to use ARGB input (*argb, argb_stride) for lossless
+  // compression, and YUV input (*y, *u, *v, etc.) for lossy compression
+  // since these are the respective native colorspace for these formats.
+  int use_argb;
+
+  // YUV input (mostly used for input to lossy compression)
+  WebPEncCSP colorspace;     // colorspace: should be YUV420 for now (=Y'CbCr).
+  int width, height;         // dimensions (less or equal to WEBP_MAX_DIMENSION)
+  uint8_t* y, *u, *v;        // pointers to luma/chroma planes.
+  int y_stride, uv_stride;   // luma/chroma strides.
+  uint8_t* a;                // pointer to the alpha plane
+  int a_stride;              // stride of the alpha plane
+  uint32_t pad1[2];          // padding for later use
+
+  // ARGB input (mostly used for input to lossless compression)
+  uint32_t* argb;            // Pointer to argb (32 bit) plane.
+  int argb_stride;           // This is stride in pixels units, not bytes.
+  uint32_t pad2[3];          // padding for later use
+
+  //   OUTPUT
+  ///////////////
+  // Byte-emission hook, to store compressed bytes as they are ready.
+  WebPWriterFunction writer;  // can be NULL
+  void* custom_ptr;           // can be used by the writer.
+
+  // map for extra information (only for lossy compression mode)
+  int extra_info_type;    // 1: intra type, 2: segment, 3: quant
+                          // 4: intra-16 prediction mode,
+                          // 5: chroma prediction mode,
+                          // 6: bit cost, 7: distortion
+  uint8_t* extra_info;    // if not NULL, points to an array of size
+                          // ((width + 15) / 16) * ((height + 15) / 16) that
+                          // will be filled with a macroblock map, depending
+                          // on extra_info_type.
+
+  //   STATS AND REPORTS
+  ///////////////////////////
+  // Pointer to side statistics (updated only if not NULL)
+  WebPAuxStats* stats;
+
+  // Error code for the latest error encountered during encoding
+  WebPEncodingError error_code;
+
+  // If not NULL, report progress during encoding.
+  WebPProgressHook progress_hook;
+
+  void* user_data;        // this field is free to be set to any value and
+                          // used during callbacks (like progress-report e.g.).
+
+  uint32_t pad3[3];       // padding for later use
+
+  // Unused for now
+  uint8_t* pad4, *pad5;
+  uint32_t pad6[8];       // padding for later use
+
+  // PRIVATE FIELDS
+  ////////////////////
+  void* memory_;          // row chunk of memory for yuva planes
+  void* memory_argb_;     // and for argb too.
+  void* pad7[2];          // padding for later use
+};
+
+// Internal, version-checked, entry point
+WEBP_EXTERN int WebPPictureInitInternal(WebPPicture*, int);
+
+// Should always be called, to initialize the structure. Returns false in case
+// of version mismatch. WebPPictureInit() must have succeeded before using the
+// 'picture' object.
+// Note that, by default, use_argb is false and colorspace is WEBP_YUV420.
+static WEBP_INLINE int WebPPictureInit(WebPPicture* picture) {
+  return WebPPictureInitInternal(picture, WEBP_ENCODER_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// WebPPicture utils
+
+// Convenience allocation / deallocation based on picture->width/height:
+// Allocate y/u/v buffers as per colorspace/width/height specification.
+// Note! This function will free the previous buffer if needed.
+// Returns false in case of memory error.
+WEBP_EXTERN int WebPPictureAlloc(WebPPicture* picture);
+
+// Release the memory allocated by WebPPictureAlloc() or WebPPictureImport*().
+// Note that this function does _not_ free the memory used by the 'picture'
+// object itself.
+// Besides memory (which is reclaimed) all other fields of 'picture' are
+// preserved.
+WEBP_EXTERN void WebPPictureFree(WebPPicture* picture);
+
+// Copy the pixels of *src into *dst, using WebPPictureAlloc. Upon return, *dst
+// will fully own the copied pixels (this is not a view). The 'dst' picture need
+// not be initialized as its content is overwritten.
+// Returns false in case of memory allocation error.
+WEBP_EXTERN int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst);
+
+// Compute the single distortion for packed planes of samples.
+// 'src' will be compared to 'ref', and the raw distortion stored into
+// '*distortion'. The refined metric (log(MSE), log(1 - ssim),...' will be
+// stored in '*result'.
+// 'x_step' is the horizontal stride (in bytes) between samples.
+// 'src/ref_stride' is the byte distance between rows.
+// Returns false in case of error (bad parameter, memory allocation error, ...).
+WEBP_EXTERN int WebPPlaneDistortion(const uint8_t* src, size_t src_stride,
+                                    const uint8_t* ref, size_t ref_stride,
+                                    int width, int height,
+                                    size_t x_step,
+                                    int type,   // 0 = PSNR, 1 = SSIM, 2 = LSIM
+                                    float* distortion, float* result);
+
+// Compute PSNR, SSIM or LSIM distortion metric between two pictures. Results
+// are in dB, stored in result[] in the B/G/R/A/All order. The distortion is
+// always performed using ARGB samples. Hence if the input is YUV(A), the
+// picture will be internally converted to ARGB (just for the measurement).
+// Warning: this function is rather CPU-intensive.
+WEBP_EXTERN int WebPPictureDistortion(
+    const WebPPicture* src, const WebPPicture* ref,
+    int metric_type,           // 0 = PSNR, 1 = SSIM, 2 = LSIM
+    float result[5]);
+
+// self-crops a picture to the rectangle defined by top/left/width/height.
+// Returns false in case of memory allocation error, or if the rectangle is
+// outside of the source picture.
+// The rectangle for the view is defined by the top-left corner pixel
+// coordinates (left, top) as well as its width and height. This rectangle
+// must be fully be comprised inside the 'src' source picture. If the source
+// picture uses the YUV420 colorspace, the top and left coordinates will be
+// snapped to even values.
+WEBP_EXTERN int WebPPictureCrop(WebPPicture* picture,
+                                int left, int top, int width, int height);
+
+// Extracts a view from 'src' picture into 'dst'. The rectangle for the view
+// is defined by the top-left corner pixel coordinates (left, top) as well
+// as its width and height. This rectangle must be fully be comprised inside
+// the 'src' source picture. If the source picture uses the YUV420 colorspace,
+// the top and left coordinates will be snapped to even values.
+// Picture 'src' must out-live 'dst' picture. Self-extraction of view is allowed
+// ('src' equal to 'dst') as a mean of fast-cropping (but note that doing so,
+// the original dimension will be lost). Picture 'dst' need not be initialized
+// with WebPPictureInit() if it is different from 'src', since its content will
+// be overwritten.
+// Returns false in case of invalid parameters.
+WEBP_EXTERN int WebPPictureView(const WebPPicture* src,
+                                int left, int top, int width, int height,
+                                WebPPicture* dst);
+
+// Returns true if the 'picture' is actually a view and therefore does
+// not own the memory for pixels.
+WEBP_EXTERN int WebPPictureIsView(const WebPPicture* picture);
+
+// Rescale a picture to new dimension width x height.
+// If either 'width' or 'height' (but not both) is 0 the corresponding
+// dimension will be calculated preserving the aspect ratio.
+// No gamma correction is applied.
+// Returns false in case of error (invalid parameter or insufficient memory).
+WEBP_EXTERN int WebPPictureRescale(WebPPicture* picture, int width, int height);
+
+// Colorspace conversion function to import RGB samples.
+// Previous buffer will be free'd, if any.
+// *rgb buffer should have a size of at least height * rgb_stride.
+// Returns false in case of memory error.
+WEBP_EXTERN int WebPPictureImportRGB(
+    WebPPicture* picture, const uint8_t* rgb, int rgb_stride);
+// Same, but for RGBA buffer.
+WEBP_EXTERN int WebPPictureImportRGBA(
+    WebPPicture* picture, const uint8_t* rgba, int rgba_stride);
+// Same, but for RGBA buffer. Imports the RGB direct from the 32-bit format
+// input buffer ignoring the alpha channel. Avoids needing to copy the data
+// to a temporary 24-bit RGB buffer to import the RGB only.
+WEBP_EXTERN int WebPPictureImportRGBX(
+    WebPPicture* picture, const uint8_t* rgbx, int rgbx_stride);
+
+// Variants of the above, but taking BGR(A|X) input.
+WEBP_EXTERN int WebPPictureImportBGR(
+    WebPPicture* picture, const uint8_t* bgr, int bgr_stride);
+WEBP_EXTERN int WebPPictureImportBGRA(
+    WebPPicture* picture, const uint8_t* bgra, int bgra_stride);
+WEBP_EXTERN int WebPPictureImportBGRX(
+    WebPPicture* picture, const uint8_t* bgrx, int bgrx_stride);
+
+// Converts picture->argb data to the YUV420A format. The 'colorspace'
+// parameter is deprecated and should be equal to WEBP_YUV420.
+// Upon return, picture->use_argb is set to false. The presence of real
+// non-opaque transparent values is detected, and 'colorspace' will be
+// adjusted accordingly. Note that this method is lossy.
+// Returns false in case of error.
+WEBP_EXTERN int WebPPictureARGBToYUVA(WebPPicture* picture,
+                                      WebPEncCSP /*colorspace = WEBP_YUV420*/);
+
+// Same as WebPPictureARGBToYUVA(), but the conversion is done using
+// pseudo-random dithering with a strength 'dithering' between
+// 0.0 (no dithering) and 1.0 (maximum dithering). This is useful
+// for photographic picture.
+WEBP_EXTERN int WebPPictureARGBToYUVADithered(
+    WebPPicture* picture, WebPEncCSP colorspace, float dithering);
+
+// Performs 'sharp' RGBA->YUVA420 downsampling and colorspace conversion.
+// Downsampling is handled with extra care in case of color clipping. This
+// method is roughly 2x slower than WebPPictureARGBToYUVA() but produces better
+// and sharper YUV representation.
+// Returns false in case of error.
+WEBP_EXTERN int WebPPictureSharpARGBToYUVA(WebPPicture* picture);
+// kept for backward compatibility:
+WEBP_EXTERN int WebPPictureSmartARGBToYUVA(WebPPicture* picture);
+
+// Converts picture->yuv to picture->argb and sets picture->use_argb to true.
+// The input format must be YUV_420 or YUV_420A. The conversion from YUV420 to
+// ARGB incurs a small loss too.
+// Note that the use of this colorspace is discouraged if one has access to the
+// raw ARGB samples, since using YUV420 is comparatively lossy.
+// Returns false in case of error.
+WEBP_EXTERN int WebPPictureYUVAToARGB(WebPPicture* picture);
+
+// Helper function: given a width x height plane of RGBA or YUV(A) samples
+// clean-up or smoothen the YUV or RGB samples under fully transparent area,
+// to help compressibility (no guarantee, though).
+WEBP_EXTERN void WebPCleanupTransparentArea(WebPPicture* picture);
+
+// Scan the picture 'picture' for the presence of non fully opaque alpha values.
+// Returns true in such case. Otherwise returns false (indicating that the
+// alpha plane can be ignored altogether e.g.).
+WEBP_EXTERN int WebPPictureHasTransparency(const WebPPicture* picture);
+
+// Remove the transparency information (if present) by blending the color with
+// the background color 'background_rgb' (specified as 24bit RGB triplet).
+// After this call, all alpha values are reset to 0xff.
+WEBP_EXTERN void WebPBlendAlpha(WebPPicture* picture, uint32_t background_rgb);
+
+//------------------------------------------------------------------------------
+// Main call
+
+// Main encoding call, after config and picture have been initialized.
+// 'picture' must be less than 16384x16384 in dimension (cf WEBP_MAX_DIMENSION),
+// and the 'config' object must be a valid one.
+// Returns false in case of error, true otherwise.
+// In case of error, picture->error_code is updated accordingly.
+// 'picture' can hold the source samples in both YUV(A) or ARGB input, depending
+// on the value of 'picture->use_argb'. It is highly recommended to use
+// the former for lossy encoding, and the latter for lossless encoding
+// (when config.lossless is true). Automatic conversion from one format to
+// another is provided but they both incur some loss.
+WEBP_EXTERN int WebPEncode(const WebPConfig* config, WebPPicture* picture);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_ENCODE_H_
diff --git a/webp/format_constants.h b/webp/format_constants.h
new file mode 100644
index 0000000..eca6981
--- /dev/null
+++ b/webp/format_constants.h
@@ -0,0 +1,87 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//  Internal header for constants related to WebP file format.
+//
+// Author: Urvang (urvang@google.com)
+
+#ifndef WEBP_WEBP_FORMAT_CONSTANTS_H_
+#define WEBP_WEBP_FORMAT_CONSTANTS_H_
+
+// Create fourcc of the chunk from the chunk tag characters.
+#define MKFOURCC(a, b, c, d) ((a) | (b) << 8 | (c) << 16 | (uint32_t)(d) << 24)
+
+// VP8 related constants.
+#define VP8_SIGNATURE 0x9d012a              // Signature in VP8 data.
+#define VP8_MAX_PARTITION0_SIZE (1 << 19)   // max size of mode partition
+#define VP8_MAX_PARTITION_SIZE  (1 << 24)   // max size for token partition
+#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
+
+// VP8L related constants.
+#define VP8L_SIGNATURE_SIZE          1      // VP8L signature size.
+#define VP8L_MAGIC_BYTE              0x2f   // VP8L signature byte.
+#define VP8L_IMAGE_SIZE_BITS         14     // Number of bits used to store
+                                            // width and height.
+#define VP8L_VERSION_BITS            3      // 3 bits reserved for version.
+#define VP8L_VERSION                 0      // version 0
+#define VP8L_FRAME_HEADER_SIZE       5      // Size of the VP8L frame header.
+
+#define MAX_PALETTE_SIZE             256
+#define MAX_CACHE_BITS               11
+#define HUFFMAN_CODES_PER_META_CODE  5
+#define ARGB_BLACK                   0xff000000
+
+#define DEFAULT_CODE_LENGTH          8
+#define MAX_ALLOWED_CODE_LENGTH      15
+
+#define NUM_LITERAL_CODES            256
+#define NUM_LENGTH_CODES             24
+#define NUM_DISTANCE_CODES           40
+#define CODE_LENGTH_CODES            19
+
+#define MIN_HUFFMAN_BITS             2  // min number of Huffman bits
+#define MAX_HUFFMAN_BITS             9  // max number of Huffman bits
+
+#define TRANSFORM_PRESENT            1  // The bit to be written when next data
+                                        // to be read is a transform.
+#define NUM_TRANSFORMS               4  // Maximum number of allowed transform
+                                        // in a bitstream.
+typedef enum {
+  PREDICTOR_TRANSFORM      = 0,
+  CROSS_COLOR_TRANSFORM    = 1,
+  SUBTRACT_GREEN           = 2,
+  COLOR_INDEXING_TRANSFORM = 3
+} VP8LImageTransformType;
+
+// Alpha related constants.
+#define ALPHA_HEADER_LEN            1
+#define ALPHA_NO_COMPRESSION        0
+#define ALPHA_LOSSLESS_COMPRESSION  1
+#define ALPHA_PREPROCESSED_LEVELS   1
+
+// Mux related constants.
+#define TAG_SIZE           4     // Size of a chunk tag (e.g. "VP8L").
+#define CHUNK_SIZE_BYTES   4     // Size needed to store chunk's size.
+#define CHUNK_HEADER_SIZE  8     // Size of a chunk header.
+#define RIFF_HEADER_SIZE   12    // Size of the RIFF header ("RIFFnnnnWEBP").
+#define ANMF_CHUNK_SIZE    16    // Size of an ANMF chunk.
+#define ANIM_CHUNK_SIZE    6     // Size of an ANIM chunk.
+#define VP8X_CHUNK_SIZE    10    // Size of a VP8X chunk.
+
+#define MAX_CANVAS_SIZE     (1 << 24)     // 24-bit max for VP8X width/height.
+#define MAX_IMAGE_AREA      (1ULL << 32)  // 32-bit max for width x height.
+#define MAX_LOOP_COUNT      (1 << 16)     // maximum value for loop-count
+#define MAX_DURATION        (1 << 24)     // maximum duration
+#define MAX_POSITION_OFFSET (1 << 24)     // maximum frame x/y offset
+
+// Maximum chunk payload is such that adding the header and padding won't
+// overflow a uint32_t.
+#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
+
+#endif  // WEBP_WEBP_FORMAT_CONSTANTS_H_
diff --git a/webp/mux.h b/webp/mux.h
new file mode 100644
index 0000000..7d27489
--- /dev/null
+++ b/webp/mux.h
@@ -0,0 +1,530 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//  RIFF container manipulation and encoding for WebP images.
+//
+// Authors: Urvang (urvang@google.com)
+//          Vikas (vikasa@google.com)
+
+#ifndef WEBP_WEBP_MUX_H_
+#define WEBP_WEBP_MUX_H_
+
+#include "./mux_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WEBP_MUX_ABI_VERSION 0x0108        // MAJOR(8b) + MINOR(8b)
+
+//------------------------------------------------------------------------------
+// Mux API
+//
+// This API allows manipulation of WebP container images containing features
+// like color profile, metadata, animation.
+//
+// Code Example#1: Create a WebPMux object with image data, color profile and
+// XMP metadata.
+/*
+  int copy_data = 0;
+  WebPMux* mux = WebPMuxNew();
+  // ... (Prepare image data).
+  WebPMuxSetImage(mux, &image, copy_data);
+  // ... (Prepare ICCP color profile data).
+  WebPMuxSetChunk(mux, "ICCP", &icc_profile, copy_data);
+  // ... (Prepare XMP metadata).
+  WebPMuxSetChunk(mux, "XMP ", &xmp, copy_data);
+  // Get data from mux in WebP RIFF format.
+  WebPMuxAssemble(mux, &output_data);
+  WebPMuxDelete(mux);
+  // ... (Consume output_data; e.g. write output_data.bytes to file).
+  WebPDataClear(&output_data);
+*/
+
+// Code Example#2: Get image and color profile data from a WebP file.
+/*
+  int copy_data = 0;
+  // ... (Read data from file).
+  WebPMux* mux = WebPMuxCreate(&data, copy_data);
+  WebPMuxGetFrame(mux, 1, &image);
+  // ... (Consume image; e.g. call WebPDecode() to decode the data).
+  WebPMuxGetChunk(mux, "ICCP", &icc_profile);
+  // ... (Consume icc_data).
+  WebPMuxDelete(mux);
+  WebPFree(data);
+*/
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPMuxError WebPMuxError;
+// typedef enum WebPChunkId WebPChunkId;
+typedef struct WebPMux WebPMux;   // main opaque object.
+typedef struct WebPMuxFrameInfo WebPMuxFrameInfo;
+typedef struct WebPMuxAnimParams WebPMuxAnimParams;
+typedef struct WebPAnimEncoderOptions WebPAnimEncoderOptions;
+
+// Error codes
+typedef enum WebPMuxError {
+  WEBP_MUX_OK                 =  1,
+  WEBP_MUX_NOT_FOUND          =  0,
+  WEBP_MUX_INVALID_ARGUMENT   = -1,
+  WEBP_MUX_BAD_DATA           = -2,
+  WEBP_MUX_MEMORY_ERROR       = -3,
+  WEBP_MUX_NOT_ENOUGH_DATA    = -4
+} WebPMuxError;
+
+// IDs for different types of chunks.
+typedef enum WebPChunkId {
+  WEBP_CHUNK_VP8X,        // VP8X
+  WEBP_CHUNK_ICCP,        // ICCP
+  WEBP_CHUNK_ANIM,        // ANIM
+  WEBP_CHUNK_ANMF,        // ANMF
+  WEBP_CHUNK_DEPRECATED,  // (deprecated from FRGM)
+  WEBP_CHUNK_ALPHA,       // ALPH
+  WEBP_CHUNK_IMAGE,       // VP8/VP8L
+  WEBP_CHUNK_EXIF,        // EXIF
+  WEBP_CHUNK_XMP,         // XMP
+  WEBP_CHUNK_UNKNOWN,     // Other chunks.
+  WEBP_CHUNK_NIL
+} WebPChunkId;
+
+//------------------------------------------------------------------------------
+
+// Returns the version number of the mux library, packed in hexadecimal using
+// 8bits for each of major/minor/revision. E.g: v2.5.7 is 0x020507.
+WEBP_EXTERN int WebPGetMuxVersion(void);
+
+//------------------------------------------------------------------------------
+// Life of a Mux object
+
+// Internal, version-checked, entry point
+WEBP_EXTERN WebPMux* WebPNewInternal(int);
+
+// Creates an empty mux object.
+// Returns:
+//   A pointer to the newly created empty mux object.
+//   Or NULL in case of memory error.
+static WEBP_INLINE WebPMux* WebPMuxNew(void) {
+  return WebPNewInternal(WEBP_MUX_ABI_VERSION);
+}
+
+// Deletes the mux object.
+// Parameters:
+//   mux - (in/out) object to be deleted
+WEBP_EXTERN void WebPMuxDelete(WebPMux* mux);
+
+//------------------------------------------------------------------------------
+// Mux creation.
+
+// Internal, version-checked, entry point
+WEBP_EXTERN WebPMux* WebPMuxCreateInternal(const WebPData*, int, int);
+
+// Creates a mux object from raw data given in WebP RIFF format.
+// Parameters:
+//   bitstream - (in) the bitstream data in WebP RIFF format
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   A pointer to the mux object created from given data - on success.
+//   NULL - In case of invalid data or memory error.
+static WEBP_INLINE WebPMux* WebPMuxCreate(const WebPData* bitstream,
+                                          int copy_data) {
+  return WebPMuxCreateInternal(bitstream, copy_data, WEBP_MUX_ABI_VERSION);
+}
+
+//------------------------------------------------------------------------------
+// Non-image chunks.
+
+// Note: Only non-image related chunks should be managed through chunk APIs.
+// (Image related chunks are: "ANMF", "VP8 ", "VP8L" and "ALPH").
+// To add, get and delete images, use WebPMuxSetImage(), WebPMuxPushFrame(),
+// WebPMuxGetFrame() and WebPMuxDeleteFrame().
+
+// Adds a chunk with id 'fourcc' and data 'chunk_data' in the mux object.
+// Any existing chunk(s) with the same id will be removed.
+// Parameters:
+//   mux - (in/out) object to which the chunk is to be added
+//   fourcc - (in) a character array containing the fourcc of the given chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (in) the chunk data to be added
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxSetChunk(
+    WebPMux* mux, const char fourcc[4], const WebPData* chunk_data,
+    int copy_data);
+
+// Gets a reference to the data of the chunk with id 'fourcc' in the mux object.
+// The caller should NOT free the returned data.
+// Parameters:
+//   mux - (in) object from which the chunk data is to be fetched
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+//   chunk_data - (out) returned chunk data
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, fourcc or chunk_data is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given id.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxGetChunk(
+    const WebPMux* mux, const char fourcc[4], WebPData* chunk_data);
+
+// Deletes the chunk with the given 'fourcc' from the mux object.
+// Parameters:
+//   mux - (in/out) object from which the chunk is to be deleted
+//   fourcc - (in) a character array containing the fourcc of the chunk;
+//                 e.g., "ICCP", "XMP ", "EXIF" etc.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or fourcc is NULL
+//                               or if fourcc corresponds to an image chunk.
+//   WEBP_MUX_NOT_FOUND - If mux does not contain a chunk with the given fourcc.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxDeleteChunk(
+    WebPMux* mux, const char fourcc[4]);
+
+//------------------------------------------------------------------------------
+// Images.
+
+// Encapsulates data about a single frame.
+struct WebPMuxFrameInfo {
+  WebPData    bitstream;  // image data: can be a raw VP8/VP8L bitstream
+                          // or a single-image WebP file.
+  int         x_offset;   // x-offset of the frame.
+  int         y_offset;   // y-offset of the frame.
+  int         duration;   // duration of the frame (in milliseconds).
+
+  WebPChunkId id;         // frame type: should be one of WEBP_CHUNK_ANMF
+                          // or WEBP_CHUNK_IMAGE
+  WebPMuxAnimDispose dispose_method;  // Disposal method for the frame.
+  WebPMuxAnimBlend   blend_method;    // Blend operation for the frame.
+  uint32_t    pad[1];     // padding for later use
+};
+
+// Sets the (non-animated) image in the mux object.
+// Note: Any existing images (including frames) will be removed.
+// Parameters:
+//   mux - (in/out) object in which the image is to be set
+//   bitstream - (in) can be a raw VP8/VP8L bitstream or a single-image
+//               WebP file (non-animated)
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL or bitstream is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxSetImage(
+    WebPMux* mux, const WebPData* bitstream, int copy_data);
+
+// Adds a frame at the end of the mux object.
+// Notes: (1) frame.id should be WEBP_CHUNK_ANMF
+//        (2) For setting a non-animated image, use WebPMuxSetImage() instead.
+//        (3) Type of frame being pushed must be same as the frames in mux.
+//        (4) As WebP only supports even offsets, any odd offset will be snapped
+//            to an even location using: offset &= ~1
+// Parameters:
+//   mux - (in/out) object to which the frame is to be added
+//   frame - (in) frame data.
+//   copy_data - (in) value 1 indicates given data WILL be copied to the mux
+//               object and value 0 indicates data will NOT be copied.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL
+//                               or if content of 'frame' is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxPushFrame(
+    WebPMux* mux, const WebPMuxFrameInfo* frame, int copy_data);
+
+// Gets the nth frame from the mux object.
+// The content of 'frame->bitstream' is allocated using WebPMalloc(), and NOT
+// owned by the 'mux' object. It MUST be deallocated by the caller by calling
+// WebPDataClear().
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   nth - (in) index of the frame in the mux object
+//   frame - (out) data of the returned frame
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or frame is NULL.
+//   WEBP_MUX_NOT_FOUND - if there are less than nth frames in the mux object.
+//   WEBP_MUX_BAD_DATA - if nth frame chunk in mux is invalid.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxGetFrame(
+    const WebPMux* mux, uint32_t nth, WebPMuxFrameInfo* frame);
+
+// Deletes a frame from the mux object.
+// nth=0 has a special meaning - last position.
+// Parameters:
+//   mux - (in/out) object from which a frame is to be deleted
+//   nth - (in) The position from which the frame is to be deleted
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL.
+//   WEBP_MUX_NOT_FOUND - If there are less than nth frames in the mux object
+//                        before deletion.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxDeleteFrame(WebPMux* mux, uint32_t nth);
+
+//------------------------------------------------------------------------------
+// Animation.
+
+// Animation parameters.
+struct WebPMuxAnimParams {
+  uint32_t bgcolor;  // Background color of the canvas stored (in MSB order) as:
+                     // Bits 00 to 07: Alpha.
+                     // Bits 08 to 15: Red.
+                     // Bits 16 to 23: Green.
+                     // Bits 24 to 31: Blue.
+  int loop_count;    // Number of times to repeat the animation [0 = infinite].
+};
+
+// Sets the animation parameters in the mux object. Any existing ANIM chunks
+// will be removed.
+// Parameters:
+//   mux - (in/out) object in which ANIM chunk is to be set/added
+//   params - (in) animation parameters.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxSetAnimationParams(
+    WebPMux* mux, const WebPMuxAnimParams* params);
+
+// Gets the animation parameters from the mux object.
+// Parameters:
+//   mux - (in) object from which the animation parameters to be fetched
+//   params - (out) animation parameters extracted from the ANIM chunk
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or params is NULL.
+//   WEBP_MUX_NOT_FOUND - if ANIM chunk is not present in mux object.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxGetAnimationParams(
+    const WebPMux* mux, WebPMuxAnimParams* params);
+
+//------------------------------------------------------------------------------
+// Misc Utilities.
+
+// Sets the canvas size for the mux object. The width and height can be
+// specified explicitly or left as zero (0, 0).
+// * When width and height are specified explicitly, then this frame bound is
+//   enforced during subsequent calls to WebPMuxAssemble() and an error is
+//   reported if any animated frame does not completely fit within the canvas.
+// * When unspecified (0, 0), the constructed canvas will get the frame bounds
+//   from the bounding-box over all frames after calling WebPMuxAssemble().
+// Parameters:
+//   mux - (in) object to which the canvas size is to be set
+//   width - (in) canvas width
+//   height - (in) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux is NULL; or
+//                               width or height are invalid or out of bounds
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxSetCanvasSize(WebPMux* mux,
+                                              int width, int height);
+
+// Gets the canvas size from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the canvas size is to be fetched
+//   width - (out) canvas width
+//   height - (out) canvas height
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, width or height is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxGetCanvasSize(const WebPMux* mux,
+                                              int* width, int* height);
+
+// Gets the feature flags from the mux object.
+// Note: This method assumes that the VP8X chunk, if present, is up-to-date.
+// That is, the mux object hasn't been modified since the last call to
+// WebPMuxAssemble() or WebPMuxCreate().
+// Parameters:
+//   mux - (in) object from which the features are to be fetched
+//   flags - (out) the flags specifying which features are present in the
+//           mux object. This will be an OR of various flag values.
+//           Enum 'WebPFeatureFlags' can be used to test individual flag values.
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or flags is NULL.
+//   WEBP_MUX_BAD_DATA - if VP8X/VP8/VP8L chunk or canvas size is invalid.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxGetFeatures(const WebPMux* mux,
+                                            uint32_t* flags);
+
+// Gets number of chunks with the given 'id' in the mux object.
+// Parameters:
+//   mux - (in) object from which the info is to be fetched
+//   id - (in) chunk id specifying the type of chunk
+//   num_elements - (out) number of chunks with the given chunk id
+// Returns:
+//   WEBP_MUX_INVALID_ARGUMENT - if mux, or num_elements is NULL.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxNumChunks(const WebPMux* mux,
+                                          WebPChunkId id, int* num_elements);
+
+// Assembles all chunks in WebP RIFF format and returns in 'assembled_data'.
+// This function also validates the mux object.
+// Note: The content of 'assembled_data' will be ignored and overwritten.
+// Also, the content of 'assembled_data' is allocated using WebPMalloc(), and
+// NOT owned by the 'mux' object. It MUST be deallocated by the caller by
+// calling WebPDataClear(). It's always safe to call WebPDataClear() upon
+// return, even in case of error.
+// Parameters:
+//   mux - (in/out) object whose chunks are to be assembled
+//   assembled_data - (out) assembled WebP data
+// Returns:
+//   WEBP_MUX_BAD_DATA - if mux object is invalid.
+//   WEBP_MUX_INVALID_ARGUMENT - if mux or assembled_data is NULL.
+//   WEBP_MUX_MEMORY_ERROR - on memory allocation error.
+//   WEBP_MUX_OK - on success.
+WEBP_EXTERN WebPMuxError WebPMuxAssemble(WebPMux* mux,
+                                         WebPData* assembled_data);
+
+//------------------------------------------------------------------------------
+// WebPAnimEncoder API
+//
+// This API allows encoding (possibly) animated WebP images.
+//
+// Code Example:
+/*
+  WebPAnimEncoderOptions enc_options;
+  WebPAnimEncoderOptionsInit(&enc_options);
+  // Tune 'enc_options' as needed.
+  WebPAnimEncoder* enc = WebPAnimEncoderNew(width, height, &enc_options);
+  while(<there are more frames>) {
+    WebPConfig config;
+    WebPConfigInit(&config);
+    // Tune 'config' as needed.
+    WebPAnimEncoderAdd(enc, frame, timestamp_ms, &config);
+  }
+  WebPAnimEncoderAdd(enc, NULL, timestamp_ms, NULL);
+  WebPAnimEncoderAssemble(enc, webp_data);
+  WebPAnimEncoderDelete(enc);
+  // Write the 'webp_data' to a file, or re-mux it further.
+*/
+
+typedef struct WebPAnimEncoder WebPAnimEncoder;  // Main opaque object.
+
+// Forward declarations. Defined in encode.h.
+struct WebPPicture;
+struct WebPConfig;
+
+// Global options.
+struct WebPAnimEncoderOptions {
+  WebPMuxAnimParams anim_params;  // Animation parameters.
+  int minimize_size;    // If true, minimize the output size (slow). Implicitly
+                        // disables key-frame insertion.
+  int kmin;
+  int kmax;             // Minimum and maximum distance between consecutive key
+                        // frames in the output. The library may insert some key
+                        // frames as needed to satisfy this criteria.
+                        // Note that these conditions should hold: kmax > kmin
+                        // and kmin >= kmax / 2 + 1. Also, if kmax <= 0, then
+                        // key-frame insertion is disabled; and if kmax == 1,
+                        // then all frames will be key-frames (kmin value does
+                        // not matter for these special cases).
+  int allow_mixed;      // If true, use mixed compression mode; may choose
+                        // either lossy and lossless for each frame.
+  int verbose;          // If true, print info and warning messages to stderr.
+
+  uint32_t padding[4];  // Padding for later use.
+};
+
+// Internal, version-checked, entry point.
+WEBP_EXTERN int WebPAnimEncoderOptionsInitInternal(
+    WebPAnimEncoderOptions*, int);
+
+// Should always be called, to initialize a fresh WebPAnimEncoderOptions
+// structure before modification. Returns false in case of version mismatch.
+// WebPAnimEncoderOptionsInit() must have succeeded before using the
+// 'enc_options' object.
+static WEBP_INLINE int WebPAnimEncoderOptionsInit(
+    WebPAnimEncoderOptions* enc_options) {
+  return WebPAnimEncoderOptionsInitInternal(enc_options, WEBP_MUX_ABI_VERSION);
+}
+
+// Internal, version-checked, entry point.
+WEBP_EXTERN WebPAnimEncoder* WebPAnimEncoderNewInternal(
+    int, int, const WebPAnimEncoderOptions*, int);
+
+// Creates and initializes a WebPAnimEncoder object.
+// Parameters:
+//   width/height - (in) canvas width and height of the animation.
+//   enc_options - (in) encoding options; can be passed NULL to pick
+//                      reasonable defaults.
+// Returns:
+//   A pointer to the newly created WebPAnimEncoder object.
+//   Or NULL in case of memory error.
+static WEBP_INLINE WebPAnimEncoder* WebPAnimEncoderNew(
+    int width, int height, const WebPAnimEncoderOptions* enc_options) {
+  return WebPAnimEncoderNewInternal(width, height, enc_options,
+                                    WEBP_MUX_ABI_VERSION);
+}
+
+// Optimize the given frame for WebP, encode it and add it to the
+// WebPAnimEncoder object.
+// The last call to 'WebPAnimEncoderAdd' should be with frame = NULL, which
+// indicates that no more frames are to be added. This call is also used to
+// determine the duration of the last frame.
+// Parameters:
+//   enc - (in/out) object to which the frame is to be added.
+//   frame - (in/out) frame data in ARGB or YUV(A) format. If it is in YUV(A)
+//           format, it will be converted to ARGB, which incurs a small loss.
+//   timestamp_ms - (in) timestamp of this frame in milliseconds.
+//                       Duration of a frame would be calculated as
+//                       "timestamp of next frame - timestamp of this frame".
+//                       Hence, timestamps should be in non-decreasing order.
+//   config - (in) encoding options; can be passed NULL to pick
+//            reasonable defaults.
+// Returns:
+//   On error, returns false and frame->error_code is set appropriately.
+//   Otherwise, returns true.
+WEBP_EXTERN int WebPAnimEncoderAdd(
+    WebPAnimEncoder* enc, struct WebPPicture* frame, int timestamp_ms,
+    const struct WebPConfig* config);
+
+// Assemble all frames added so far into a WebP bitstream.
+// This call should be preceded by  a call to 'WebPAnimEncoderAdd' with
+// frame = NULL; if not, the duration of the last frame will be internally
+// estimated.
+// Parameters:
+//   enc - (in/out) object from which the frames are to be assembled.
+//   webp_data - (out) generated WebP bitstream.
+// Returns:
+//   True on success.
+WEBP_EXTERN int WebPAnimEncoderAssemble(WebPAnimEncoder* enc,
+                                        WebPData* webp_data);
+
+// Get error string corresponding to the most recent call using 'enc'. The
+// returned string is owned by 'enc' and is valid only until the next call to
+// WebPAnimEncoderAdd() or WebPAnimEncoderAssemble() or WebPAnimEncoderDelete().
+// Parameters:
+//   enc - (in/out) object from which the error string is to be fetched.
+// Returns:
+//   NULL if 'enc' is NULL. Otherwise, returns the error string if the last call
+//   to 'enc' had an error, or an empty string if the last call was a success.
+WEBP_EXTERN const char* WebPAnimEncoderGetError(WebPAnimEncoder* enc);
+
+// Deletes the WebPAnimEncoder object.
+// Parameters:
+//   enc - (in/out) object to be deleted
+WEBP_EXTERN void WebPAnimEncoderDelete(WebPAnimEncoder* enc);
+
+//------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_MUX_H_
diff --git a/webp/mux_types.h b/webp/mux_types.h
new file mode 100644
index 0000000..2fe8195
--- /dev/null
+++ b/webp/mux_types.h
@@ -0,0 +1,98 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+// Data-types common to the mux and demux libraries.
+//
+// Author: Urvang (urvang@google.com)
+
+#ifndef WEBP_WEBP_MUX_TYPES_H_
+#define WEBP_WEBP_MUX_TYPES_H_
+
+#include <string.h>  // memset()
+#include "./types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Note: forward declaring enumerations is not allowed in (strict) C and C++,
+// the types are left here for reference.
+// typedef enum WebPFeatureFlags WebPFeatureFlags;
+// typedef enum WebPMuxAnimDispose WebPMuxAnimDispose;
+// typedef enum WebPMuxAnimBlend WebPMuxAnimBlend;
+typedef struct WebPData WebPData;
+
+// VP8X Feature Flags.
+typedef enum WebPFeatureFlags {
+  ANIMATION_FLAG  = 0x00000002,
+  XMP_FLAG        = 0x00000004,
+  EXIF_FLAG       = 0x00000008,
+  ALPHA_FLAG      = 0x00000010,
+  ICCP_FLAG       = 0x00000020,
+
+  ALL_VALID_FLAGS = 0x0000003e
+} WebPFeatureFlags;
+
+// Dispose method (animation only). Indicates how the area used by the current
+// frame is to be treated before rendering the next frame on the canvas.
+typedef enum WebPMuxAnimDispose {
+  WEBP_MUX_DISPOSE_NONE,       // Do not dispose.
+  WEBP_MUX_DISPOSE_BACKGROUND  // Dispose to background color.
+} WebPMuxAnimDispose;
+
+// Blend operation (animation only). Indicates how transparent pixels of the
+// current frame are blended with those of the previous canvas.
+typedef enum WebPMuxAnimBlend {
+  WEBP_MUX_BLEND,              // Blend.
+  WEBP_MUX_NO_BLEND            // Do not blend.
+} WebPMuxAnimBlend;
+
+// Data type used to describe 'raw' data, e.g., chunk data
+// (ICC profile, metadata) and WebP compressed image data.
+// 'bytes' memory must be allocated using WebPMalloc() and such.
+struct WebPData {
+  const uint8_t* bytes;
+  size_t size;
+};
+
+// Initializes the contents of the 'webp_data' object with default values.
+static WEBP_INLINE void WebPDataInit(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    memset(webp_data, 0, sizeof(*webp_data));
+  }
+}
+
+// Clears the contents of the 'webp_data' object by calling WebPFree().
+// Does not deallocate the object itself.
+static WEBP_INLINE void WebPDataClear(WebPData* webp_data) {
+  if (webp_data != NULL) {
+    WebPFree((void*)webp_data->bytes);
+    WebPDataInit(webp_data);
+  }
+}
+
+// Allocates necessary storage for 'dst' and copies the contents of 'src'.
+// Returns true on success.
+static WEBP_INLINE int WebPDataCopy(const WebPData* src, WebPData* dst) {
+  if (src == NULL || dst == NULL) return 0;
+  WebPDataInit(dst);
+  if (src->bytes != NULL && src->size != 0) {
+    dst->bytes = (uint8_t*)WebPMalloc(src->size);
+    if (dst->bytes == NULL) return 0;
+    memcpy((void*)dst->bytes, src->bytes, src->size);
+    dst->size = src->size;
+  }
+  return 1;
+}
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_MUX_TYPES_H_
diff --git a/webp/types.h b/webp/types.h
new file mode 100644
index 0000000..47f7f2b
--- /dev/null
+++ b/webp/types.h
@@ -0,0 +1,68 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+//  Common types + memory wrappers
+//
+// Author: Skal (pascal.massimino@gmail.com)
+
+#ifndef WEBP_WEBP_TYPES_H_
+#define WEBP_WEBP_TYPES_H_
+
+#include <stddef.h>  // for size_t
+
+#ifndef _MSC_VER
+#include <inttypes.h>
+#if defined(__cplusplus) || !defined(__STRICT_ANSI__) || \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
+#define WEBP_INLINE inline
+#else
+#define WEBP_INLINE
+#endif
+#else
+typedef signed   char int8_t;
+typedef unsigned char uint8_t;
+typedef signed   short int16_t;
+typedef unsigned short uint16_t;
+typedef signed   int int32_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long int uint64_t;
+typedef long long int int64_t;
+#define WEBP_INLINE __forceinline
+#endif  /* _MSC_VER */
+
+#ifndef WEBP_EXTERN
+// This explicitly marks library functions and allows for changing the
+// signature for e.g., Windows DLL builds.
+# if defined(__GNUC__) && __GNUC__ >= 4
+#  define WEBP_EXTERN extern __attribute__ ((visibility ("default")))
+# else
+#  define WEBP_EXTERN extern
+# endif  /* __GNUC__ >= 4 */
+#endif  /* WEBP_EXTERN */
+
+// Macro to check ABI compatibility (same major revision number)
+#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Allocates 'size' bytes of memory. Returns NULL upon error. Memory
+// must be deallocated by calling WebPFree(). This function is made available
+// by the core 'libwebp' library.
+WEBP_EXTERN void* WebPMalloc(size_t size);
+
+// Releases memory returned by the WebPDecode*() functions (from decode.h).
+WEBP_EXTERN void WebPFree(void* ptr);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif
+
+#endif  // WEBP_WEBP_TYPES_H_
diff --git a/webp/unicode.h b/webp/unicode.h
new file mode 100644
index 0000000..0831e23
--- /dev/null
+++ b/webp/unicode.h
@@ -0,0 +1,116 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the COPYING file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS. All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+// -----------------------------------------------------------------------------
+//
+// Unicode support for Windows. The main idea is to maintain an array of Unicode
+// arguments (wargv) and use it only for file paths. The regular argv is used
+// for everything else.
+//
+// Author: Yannis Guyon (yguyon@google.com)
+
+#ifndef WEBP_EXAMPLES_UNICODE_H_
+#define WEBP_EXAMPLES_UNICODE_H_
+
+#include <stdio.h>
+
+#if defined(_WIN32) && defined(_UNICODE)
+
+// wchar_t is used instead of TCHAR because we only perform additional work when
+// Unicode is enabled and because the output of CommandLineToArgvW() is wchar_t.
+
+#include <fcntl.h>
+#include <io.h>
+#include <wchar.h>
+#include <windows.h>
+#include <shellapi.h>
+
+// Create a wchar_t array containing Unicode parameters.
+#define INIT_WARGV(ARGC, ARGV)                                                \
+  int wargc;                                                                  \
+  const W_CHAR** const wargv =                                                \
+      (const W_CHAR**)CommandLineToArgvW(GetCommandLineW(), &wargc);          \
+  do {                                                                        \
+    if (wargv == NULL || wargc != (ARGC)) {                                   \
+      fprintf(stderr, "Error: Unable to get Unicode arguments.\n");           \
+      FREE_WARGV_AND_RETURN(-1);                                              \
+    }                                                                         \
+  } while (0)
+
+// Use this to get a Unicode argument (e.g. file path).
+#define GET_WARGV(UNUSED, C) wargv[C]
+// For cases where argv is shifted by one compared to wargv.
+#define GET_WARGV_SHIFTED(UNUSED, C) wargv[(C) + 1]
+#define GET_WARGV_OR_NULL() wargv
+
+// Release resources. LocalFree() is needed after CommandLineToArgvW().
+#define FREE_WARGV() LOCAL_FREE((W_CHAR** const)wargv)
+#define LOCAL_FREE(WARGV)                  \
+  do {                                     \
+    if ((WARGV) != NULL) LocalFree(WARGV); \
+  } while (0)
+
+#define W_CHAR wchar_t  // WCHAR without underscore might already be defined.
+#define TO_W_CHAR(STR) (L##STR)
+
+#define WFOPEN(ARG, OPT) _wfopen((const W_CHAR*)ARG, TO_W_CHAR(OPT))
+
+#define WFPRINTF(STREAM, STR, ...)                    \
+  do {                                                \
+    int prev_mode;                                    \
+    fflush(STREAM);                                   \
+    prev_mode = _setmode(_fileno(STREAM), _O_U8TEXT); \
+    fwprintf(STREAM, TO_W_CHAR(STR), __VA_ARGS__);    \
+    fflush(STREAM);                                   \
+    (void)_setmode(_fileno(STREAM), prev_mode);       \
+  } while (0)
+#define WPRINTF(STR, ...) WFPRINTF(stdout, STR, __VA_ARGS__)
+
+#define WSTRLEN(FILENAME) wcslen((const W_CHAR*)FILENAME)
+#define WSTRCMP(FILENAME, STR) wcscmp((const W_CHAR*)FILENAME, TO_W_CHAR(STR))
+#define WSTRRCHR(FILENAME, STR) wcsrchr((const W_CHAR*)FILENAME, TO_W_CHAR(STR))
+#define WSNPRINTF(A, B, STR, ...) _snwprintf(A, B, TO_W_CHAR(STR), __VA_ARGS__)
+
+#else
+
+#include <string.h>
+
+// Unicode file paths work as is on Unix platforms, and no extra work is done on
+// Windows either if Unicode is disabled.
+
+#define INIT_WARGV(ARGC, ARGV)
+
+#define GET_WARGV(ARGV, C) (ARGV)[C]
+#define GET_WARGV_SHIFTED(ARGV, C) (ARGV)[C]
+#define GET_WARGV_OR_NULL() NULL
+
+#define FREE_WARGV()
+#define LOCAL_FREE(WARGV)
+
+#define W_CHAR char
+#define TO_W_CHAR(STR) (STR)
+
+#define WFOPEN(ARG, OPT) fopen(ARG, OPT)
+
+#define WPRINTF(STR, ...) printf(STR, __VA_ARGS__)
+#define WFPRINTF(STREAM, STR, ...) fprintf(STREAM, STR, __VA_ARGS__)
+
+#define WSTRLEN(FILENAME) strlen(FILENAME)
+#define WSTRCMP(FILENAME, STR) strcmp(FILENAME, STR)
+#define WSTRRCHR(FILENAME, STR) strrchr(FILENAME, STR)
+#define WSNPRINTF(A, B, STR, ...) snprintf(A, B, STR, __VA_ARGS__)
+
+#endif  // defined(_WIN32) && defined(_UNICODE)
+
+// Don't forget to free wargv before returning (e.g. from main).
+#define FREE_WARGV_AND_RETURN(VALUE) \
+  do {                               \
+    FREE_WARGV();                    \
+    return (VALUE);                  \
+  } while (0)
+
+#endif  // WEBP_EXAMPLES_UNICODE_H_
diff --git a/yarn.lock b/yarn.lock
new file mode 100644
index 0000000..61280ec
--- /dev/null
+++ b/yarn.lock
@@ -0,0 +1,314 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@esbuild/aix-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f"
+  integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==
+
+"@esbuild/android-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052"
+  integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==
+
+"@esbuild/android-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28"
+  integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==
+
+"@esbuild/android-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e"
+  integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==
+
+"@esbuild/darwin-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a"
+  integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==
+
+"@esbuild/darwin-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22"
+  integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==
+
+"@esbuild/freebsd-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e"
+  integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==
+
+"@esbuild/freebsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261"
+  integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==
+
+"@esbuild/linux-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b"
+  integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==
+
+"@esbuild/linux-arm@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9"
+  integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==
+
+"@esbuild/linux-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2"
+  integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==
+
+"@esbuild/linux-loong64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df"
+  integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==
+
+"@esbuild/linux-mips64el@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe"
+  integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==
+
+"@esbuild/linux-ppc64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4"
+  integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==
+
+"@esbuild/linux-riscv64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc"
+  integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==
+
+"@esbuild/linux-s390x@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de"
+  integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==
+
+"@esbuild/linux-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0"
+  integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==
+
+"@esbuild/netbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047"
+  integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==
+
+"@esbuild/openbsd-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70"
+  integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==
+
+"@esbuild/sunos-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b"
+  integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==
+
+"@esbuild/win32-arm64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d"
+  integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==
+
+"@esbuild/win32-ia32@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b"
+  integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==
+
+"@esbuild/win32-x64@0.21.5":
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c"
+  integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==
+
+"@ffmpeg/ffmpeg@^0.12.10":
+  version "0.12.10"
+  resolved "https://registry.yarnpkg.com/@ffmpeg/ffmpeg/-/ffmpeg-0.12.10.tgz#e3cce21f21f11f33dfc1ec1d5ad5694f4a3073c9"
+  integrity sha512-lVtk8PW8e+NUzGZhPTWj2P1J4/NyuCrbDD3O9IGpSeLYtUZKBqZO8CNj1WYGghep/MXoM8e1qVY1GztTkf8YYQ==
+  dependencies:
+    "@ffmpeg/types" "^0.12.2"
+
+"@ffmpeg/types@^0.12.2":
+  version "0.12.2"
+  resolved "https://registry.yarnpkg.com/@ffmpeg/types/-/types-0.12.2.tgz#bc7eef321ae50225c247091f1f23fd3087c6aa1d"
+  integrity sha512-NJtxwPoLb60/z1Klv0ueshguWQ/7mNm106qdHkB4HL49LXszjhjCCiL+ldHJGQ9ai2Igx0s4F24ghigy//ERdA==
+
+"@ffmpeg/util@^0.12.1":
+  version "0.12.1"
+  resolved "https://registry.yarnpkg.com/@ffmpeg/util/-/util-0.12.1.tgz#98afa20d7b4c0821eebdb205ddcfa5d07b0a4f53"
+  integrity sha512-10jjfAKWaDyb8+nAkijcsi9wgz/y26LOc1NKJradNMyCIl6usQcBbhkjX5qhALrSBcOy6TOeksunTYa+a03qNQ==
+
+"@rollup/rollup-android-arm-eabi@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.24.0.tgz#1661ff5ea9beb362795304cb916049aba7ac9c54"
+  integrity sha512-Q6HJd7Y6xdB48x8ZNVDOqsbh2uByBhgK8PiQgPhwkIw/HC/YX5Ghq2mQY5sRMZWHb3VsFkWooUVOZHKr7DmDIA==
+
+"@rollup/rollup-android-arm64@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.24.0.tgz#2ffaa91f1b55a0082b8a722525741aadcbd3971e"
+  integrity sha512-ijLnS1qFId8xhKjT81uBHuuJp2lU4x2yxa4ctFPtG+MqEE6+C5f/+X/bStmxapgmwLwiL3ih122xv8kVARNAZA==
+
+"@rollup/rollup-darwin-arm64@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.24.0.tgz#627007221b24b8cc3063703eee0b9177edf49c1f"
+  integrity sha512-bIv+X9xeSs1XCk6DVvkO+S/z8/2AMt/2lMqdQbMrmVpgFvXlmde9mLcbQpztXm1tajC3raFDqegsH18HQPMYtA==
+
+"@rollup/rollup-darwin-x64@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.24.0.tgz#0605506142b9e796c370d59c5984ae95b9758724"
+  integrity sha512-X6/nOwoFN7RT2svEQWUsW/5C/fYMBe4fnLK9DQk4SX4mgVBiTA9h64kjUYPvGQ0F/9xwJ5U5UfTbl6BEjaQdBQ==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.24.0.tgz#62dfd196d4b10c0c2db833897164d2d319ee0cbb"
+  integrity sha512-0KXvIJQMOImLCVCz9uvvdPgfyWo93aHHp8ui3FrtOP57svqrF/roSSR5pjqL2hcMp0ljeGlU4q9o/rQaAQ3AYA==
+
+"@rollup/rollup-linux-arm-musleabihf@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.24.0.tgz#53ce72aeb982f1f34b58b380baafaf6a240fddb3"
+  integrity sha512-it2BW6kKFVh8xk/BnHfakEeoLPv8STIISekpoF+nBgWM4d55CZKc7T4Dx1pEbTnYm/xEKMgy1MNtYuoA8RFIWw==
+
+"@rollup/rollup-linux-arm64-gnu@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.24.0.tgz#1632990f62a75c74f43e4b14ab3597d7ed416496"
+  integrity sha512-i0xTLXjqap2eRfulFVlSnM5dEbTVque/3Pi4g2y7cxrs7+a9De42z4XxKLYJ7+OhE3IgxvfQM7vQc43bwTgPwA==
+
+"@rollup/rollup-linux-arm64-musl@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.24.0.tgz#8c03a996efb41e257b414b2e0560b7a21f2d9065"
+  integrity sha512-9E6MKUJhDuDh604Qco5yP/3qn3y7SLXYuiC0Rpr89aMScS2UAmK1wHP2b7KAa1nSjWJc/f/Lc0Wl1L47qjiyQw==
+
+"@rollup/rollup-linux-powerpc64le-gnu@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.24.0.tgz#5b98729628d5bcc8f7f37b58b04d6845f85c7b5d"
+  integrity sha512-2XFFPJ2XMEiF5Zi2EBf4h73oR1V/lycirxZxHZNc93SqDN/IWhYYSYj8I9381ikUFXZrz2v7r2tOVk2NBwxrWw==
+
+"@rollup/rollup-linux-riscv64-gnu@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.24.0.tgz#48e42e41f4cabf3573cfefcb448599c512e22983"
+  integrity sha512-M3Dg4hlwuntUCdzU7KjYqbbd+BLq3JMAOhCKdBE3TcMGMZbKkDdJ5ivNdehOssMCIokNHFOsv7DO4rlEOfyKpg==
+
+"@rollup/rollup-linux-s390x-gnu@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.24.0.tgz#e0b4f9a966872cb7d3e21b9e412a4b7efd7f0b58"
+  integrity sha512-mjBaoo4ocxJppTorZVKWFpy1bfFj9FeCMJqzlMQGjpNPY9JwQi7OuS1axzNIk0nMX6jSgy6ZURDZ2w0QW6D56g==
+
+"@rollup/rollup-linux-x64-gnu@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.24.0.tgz#78144741993100f47bd3da72fce215e077ae036b"
+  integrity sha512-ZXFk7M72R0YYFN5q13niV0B7G8/5dcQ9JDp8keJSfr3GoZeXEoMHP/HlvqROA3OMbMdfr19IjCeNAnPUG93b6A==
+
+"@rollup/rollup-linux-x64-musl@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.24.0.tgz#d9fe32971883cd1bd858336bd33a1c3ca6146127"
+  integrity sha512-w1i+L7kAXZNdYl+vFvzSZy8Y1arS7vMgIy8wusXJzRrPyof5LAb02KGr1PD2EkRcl73kHulIID0M501lN+vobQ==
+
+"@rollup/rollup-win32-arm64-msvc@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.24.0.tgz#71fa3ea369316db703a909c790743972e98afae5"
+  integrity sha512-VXBrnPWgBpVDCVY6XF3LEW0pOU51KbaHhccHw6AS6vBWIC60eqsH19DAeeObl+g8nKAz04QFdl/Cefta0xQtUQ==
+
+"@rollup/rollup-win32-ia32-msvc@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.24.0.tgz#653f5989a60658e17d7576a3996deb3902e342e2"
+  integrity sha512-xrNcGDU0OxVcPTH/8n/ShH4UevZxKIO6HJFK0e15XItZP2UcaiLFd5kiX7hJnqCbSztUF8Qot+JWBC/QXRPYWQ==
+
+"@rollup/rollup-win32-x64-msvc@4.24.0":
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.24.0.tgz#0574d7e87b44ee8511d08cc7f914bcb802b70818"
+  integrity sha512-fbMkAF7fufku0N2dE5TBXcNlg0pt0cJue4xBRE2Qc5Vqikxr4VCgKj/ht6SMdFcOacVA9rqF70APJ8RN/4vMJw==
+
+"@types/estree@1.0.6":
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.6.tgz#628effeeae2064a1b4e79f78e81d87b7e5fc7b50"
+  integrity sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==
+
+esbuild@^0.21.3:
+  version "0.21.5"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d"
+  integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==
+  optionalDependencies:
+    "@esbuild/aix-ppc64" "0.21.5"
+    "@esbuild/android-arm" "0.21.5"
+    "@esbuild/android-arm64" "0.21.5"
+    "@esbuild/android-x64" "0.21.5"
+    "@esbuild/darwin-arm64" "0.21.5"
+    "@esbuild/darwin-x64" "0.21.5"
+    "@esbuild/freebsd-arm64" "0.21.5"
+    "@esbuild/freebsd-x64" "0.21.5"
+    "@esbuild/linux-arm" "0.21.5"
+    "@esbuild/linux-arm64" "0.21.5"
+    "@esbuild/linux-ia32" "0.21.5"
+    "@esbuild/linux-loong64" "0.21.5"
+    "@esbuild/linux-mips64el" "0.21.5"
+    "@esbuild/linux-ppc64" "0.21.5"
+    "@esbuild/linux-riscv64" "0.21.5"
+    "@esbuild/linux-s390x" "0.21.5"
+    "@esbuild/linux-x64" "0.21.5"
+    "@esbuild/netbsd-x64" "0.21.5"
+    "@esbuild/openbsd-x64" "0.21.5"
+    "@esbuild/sunos-x64" "0.21.5"
+    "@esbuild/win32-arm64" "0.21.5"
+    "@esbuild/win32-ia32" "0.21.5"
+    "@esbuild/win32-x64" "0.21.5"
+
+fsevents@~2.3.2, fsevents@~2.3.3:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
+
+nanoid@^3.3.7:
+  version "3.3.7"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8"
+  integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==
+
+picocolors@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.0.tgz#5358b76a78cde483ba5cef6a9dc9671440b27d59"
+  integrity sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==
+
+postcss@^8.4.43:
+  version "8.4.47"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.47.tgz#5bf6c9a010f3e724c503bf03ef7947dcb0fea365"
+  integrity sha512-56rxCq7G/XfB4EkXq9Egn5GCqugWvDFjafDOThIdMBsI15iqPqR5r15TfSr1YPYeEI19YeaXMCbY6u88Y76GLQ==
+  dependencies:
+    nanoid "^3.3.7"
+    picocolors "^1.1.0"
+    source-map-js "^1.2.1"
+
+rollup@^4.20.0:
+  version "4.24.0"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.24.0.tgz#c14a3576f20622ea6a5c9cad7caca5e6e9555d05"
+  integrity sha512-DOmrlGSXNk1DM0ljiQA+i+o0rSLhtii1je5wgk60j49d1jHT5YYttBv1iWOnYSTG+fZZESUOSNiAl89SIet+Cg==
+  dependencies:
+    "@types/estree" "1.0.6"
+  optionalDependencies:
+    "@rollup/rollup-android-arm-eabi" "4.24.0"
+    "@rollup/rollup-android-arm64" "4.24.0"
+    "@rollup/rollup-darwin-arm64" "4.24.0"
+    "@rollup/rollup-darwin-x64" "4.24.0"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.24.0"
+    "@rollup/rollup-linux-arm-musleabihf" "4.24.0"
+    "@rollup/rollup-linux-arm64-gnu" "4.24.0"
+    "@rollup/rollup-linux-arm64-musl" "4.24.0"
+    "@rollup/rollup-linux-powerpc64le-gnu" "4.24.0"
+    "@rollup/rollup-linux-riscv64-gnu" "4.24.0"
+    "@rollup/rollup-linux-s390x-gnu" "4.24.0"
+    "@rollup/rollup-linux-x64-gnu" "4.24.0"
+    "@rollup/rollup-linux-x64-musl" "4.24.0"
+    "@rollup/rollup-win32-arm64-msvc" "4.24.0"
+    "@rollup/rollup-win32-ia32-msvc" "4.24.0"
+    "@rollup/rollup-win32-x64-msvc" "4.24.0"
+    fsevents "~2.3.2"
+
+source-map-js@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46"
+  integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
+
+vite@^5.4.8:
+  version "5.4.8"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.8.tgz#af548ce1c211b2785478d3ba3e8da51e39a287e8"
+  integrity sha512-FqrItQ4DT1NC4zCUqMB4c4AZORMKIa0m8/URVCZ77OZ/QSNeJ54bU1vrFADbDsuwfIPcgknRkmqakQcgnL4GiQ==
+  dependencies:
+    esbuild "^0.21.3"
+    postcss "^8.4.43"
+    rollup "^4.20.0"
+  optionalDependencies:
+    fsevents "~2.3.3"
diff --git a/生成 b/生成
new file mode 100644
index 0000000..cb7a0b8
--- /dev/null
+++ b/生成
@@ -0,0 +1,4 @@
+docker run --rm -v $(pwd):/src emscripten/emsdk emcc convert_image_to_webp.cpp stb_image.c libwebp.a libsharpyuv.a libwebpdecoder.a libwebpdemux.a libwebpmux.a -o ./test/convert_image_to_webp.js -s WASM=1 -s INITIAL_MEMORY=34340864 -s EXPORTED_FUNCTIONS="['_free','_malloc','_convert_image_to_webp']" -s EXTRA_EXPORTED_RUNTIME_METHODS='["cwrap", "getValue"]'
+
+
+docker run --rm -v $(pwd):/src emscripten/emsdk emcc convert_image_to_webp.cpp stb_image.c libwebp.a libsharpyuv.a -o ./test/convert_image_to_webp.js -s WASM=1 -s NO_FILESYSTEM=1 -s INITIAL_MEMORY=34340864 -s ALLOW_MEMORY_GROWTH=1 -s MAXIMUM_MEMORY=268435456 -s EXPORTED_FUNCTIONS="['_free','_malloc','_convert_image_to_webp']" -s EXTRA_EXPORTED_RUNTIME_METHODS='["cwrap", "getValue"]' -Oz
\ No newline at end of file