diff --git a/.changeset/new-shirts-reply.md b/.changeset/new-shirts-reply.md
new file mode 100644
index 0000000000..ab4ce1b307
--- /dev/null
+++ b/.changeset/new-shirts-reply.md
@@ -0,0 +1,10 @@
+---
+"llamaindex": patch
+"@llamaindex/env": patch
+---
+
+refactor: remove `defaultFS` from parameters
+
+We don't accept passing fs in the parameter since it's unnecessary for a determined JS environment.
+
+This was a polyfill way for the non-Node.js environment, but now we use another way to polyfill APIs.
diff --git a/packages/core/src/embeddings/utils.ts b/packages/core/src/embeddings/utils.ts
index d0ec09e69e..80fa61e822 100644
--- a/packages/core/src/embeddings/utils.ts
+++ b/packages/core/src/embeddings/utils.ts
@@ -1,4 +1,4 @@
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import _ from "lodash";
 import { filetypemime } from "magic-bytes.js";
 import type { ImageType } from "../Node.js";
@@ -243,7 +243,7 @@ export async function imageToDataUrl(input: ImageType): Promise<string> {
     _.isString(input)
   ) {
     // string or file URL
-    const dataBuffer = await defaultFS.readFile(
+    const dataBuffer = await fs.readFile(
       input instanceof URL ? input.pathname : input,
     );
     input = new Blob([dataBuffer]);
diff --git a/packages/core/src/readers/CSVReader.ts b/packages/core/src/readers/CSVReader.ts
index 3b1583a675..4844b5f1df 100644
--- a/packages/core/src/readers/CSVReader.ts
+++ b/packages/core/src/readers/CSVReader.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import type { ParseConfig } from "papaparse";
 import Papa from "papaparse";
 import { Document } from "../Node.js";
@@ -40,11 +39,8 @@ export class PapaCSVReader implements FileReader {
    * @param {GenericFileSystem} [fs=DEFAULT_FS] - The file system to use for reading the file.
    * @returns {Promise<Document[]>}
    */
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const fileContent = await fs.readFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const fileContent = await fs.readFile(file, "utf-8");
     const result = Papa.parse(fileContent, this.papaConfig);
     const textList = result.data.map((row: any) => {
       // Compatible with header row mode
diff --git a/packages/core/src/readers/DocxReader.ts b/packages/core/src/readers/DocxReader.ts
index dfef05caa7..0f79aa90aa 100644
--- a/packages/core/src/readers/DocxReader.ts
+++ b/packages/core/src/readers/DocxReader.ts
@@ -1,16 +1,12 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import mammoth from "mammoth";
 import { Document } from "../Node.js";
 import type { FileReader } from "./type.js";
 
 export class DocxReader implements FileReader {
   /** DocxParser */
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const dataBuffer = await fs.readRawFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const dataBuffer = await fs.readFile(file);
     const { value } = await mammoth.extractRawText({ buffer: dataBuffer });
     return [new Document({ text: value, id_: file })];
   }
diff --git a/packages/core/src/readers/HTMLReader.ts b/packages/core/src/readers/HTMLReader.ts
index a05530b747..5b16c55569 100644
--- a/packages/core/src/readers/HTMLReader.ts
+++ b/packages/core/src/readers/HTMLReader.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import { Document } from "../Node.js";
 import type { FileReader } from "./type.js";
 
@@ -15,14 +14,10 @@ export class HTMLReader implements FileReader {
    * Public method for this reader.
    * Required by BaseReader interface.
    * @param file Path/name of the file to be loaded.
-   * @param fs fs wrapper interface for getting the file content.
    * @returns Promise<Document[]> A Promise object, eventually yielding zero or one Document parsed from the HTML content of the specified file.
    */
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const dataBuffer = await fs.readFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const dataBuffer = await fs.readFile(file, "utf-8");
     const htmlOptions = this.getOptions();
     const content = await this.parseContent(dataBuffer, htmlOptions);
     return [new Document({ text: content, id_: file })];
diff --git a/packages/core/src/readers/ImageReader.ts b/packages/core/src/readers/ImageReader.ts
index 9be135691b..6a3d70b4c8 100644
--- a/packages/core/src/readers/ImageReader.ts
+++ b/packages/core/src/readers/ImageReader.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import type { Document } from "../Node.js";
 import { ImageDocument } from "../Node.js";
 import type { FileReader } from "./type.js";
@@ -15,11 +14,8 @@ export class ImageReader implements FileReader {
    * @param fs fs wrapper interface for getting the file content.
    * @returns Promise<Document[]> A Promise object, eventually yielding zero or one ImageDocument of the specified file.
    */
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const dataBuffer = await fs.readRawFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const dataBuffer = await fs.readFile(file);
     const blob = new Blob([dataBuffer]);
     return [new ImageDocument({ image: blob, id_: file })];
   }
diff --git a/packages/core/src/readers/LlamaParseReader.ts b/packages/core/src/readers/LlamaParseReader.ts
index 327878c4c1..2996a589e4 100644
--- a/packages/core/src/readers/LlamaParseReader.ts
+++ b/packages/core/src/readers/LlamaParseReader.ts
@@ -1,4 +1,4 @@
-import { defaultFS, getEnv, type GenericFileSystem } from "@llamaindex/env";
+import { fs, getEnv } from "@llamaindex/env";
 import { filetypemime } from "magic-bytes.js";
 import { Document } from "../Node.js";
 import type { FileReader, Language, ResultType } from "./type.js";
@@ -79,14 +79,11 @@ export class LlamaParseReader implements FileReader {
     this.apiKey = params.apiKey;
   }
 
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
+  async loadData(file: string): Promise<Document[]> {
     const metadata = { file_path: file };
 
     // Load data, set the mime type
-    const data = await fs.readRawFile(file);
+    const data = await fs.readFile(file);
     const mimeType = await this.getMimeType(data);
 
     const body = new FormData();
diff --git a/packages/core/src/readers/MarkdownReader.ts b/packages/core/src/readers/MarkdownReader.ts
index a747497b8a..7814986fb9 100644
--- a/packages/core/src/readers/MarkdownReader.ts
+++ b/packages/core/src/readers/MarkdownReader.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import { Document } from "../Node.js";
 import type { FileReader } from "./type.js";
 
@@ -88,11 +87,8 @@ export class MarkdownReader implements FileReader {
     return this.markdownToTups(modifiedContent);
   }
 
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const content = await fs.readFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const content = await fs.readFile(file, "utf-8");
     const tups = this.parseTups(content);
     const results: Document[] = [];
     let counter = 0;
diff --git a/packages/core/src/readers/PDFReader.ts b/packages/core/src/readers/PDFReader.ts
index 659ed51346..982ca1ced9 100644
--- a/packages/core/src/readers/PDFReader.ts
+++ b/packages/core/src/readers/PDFReader.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import { Document } from "../Node.js";
 import type { BaseReader } from "./type.js";
 
@@ -7,11 +6,8 @@ import type { BaseReader } from "./type.js";
  * Read the text of a PDF
  */
 export class PDFReader implements BaseReader {
-  async loadData(
-    file: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const content = await fs.readRawFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const content = await fs.readFile(file);
     const pages = await readPDF(content);
     return pages.map((text, page) => {
       const id_ = `${file}_${page + 1}`;
diff --git a/packages/core/src/readers/SimpleDirectoryReader.edge.ts b/packages/core/src/readers/SimpleDirectoryReader.edge.ts
index 70123b153d..a26eae4f96 100644
--- a/packages/core/src/readers/SimpleDirectoryReader.edge.ts
+++ b/packages/core/src/readers/SimpleDirectoryReader.edge.ts
@@ -1,5 +1,4 @@
-import type { CompleteFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
+import { fs, path } from "@llamaindex/env";
 import { Document, type Metadata } from "../Node.js";
 import { walk } from "../storage/FileSystem.js";
 import { TextFileReader } from "./TextFileReader.js";
@@ -19,7 +18,6 @@ enum ReaderStatus {
 
 export type SimpleDirectoryReaderLoadDataParams = {
   directoryPath: string;
-  fs?: CompleteFileSystem;
   defaultReader?: BaseReader | null;
   fileExtToReader?: Record<string, BaseReader>;
 };
@@ -45,7 +43,6 @@ export class SimpleDirectoryReader implements BaseReader {
 
     const {
       directoryPath,
-      fs = defaultFS,
       defaultReader = new TextFileReader(),
       fileExtToReader,
     } = params;
@@ -58,7 +55,7 @@ export class SimpleDirectoryReader implements BaseReader {
     }
 
     const docs: Document[] = [];
-    for await (const filePath of walk(fs, directoryPath)) {
+    for await (const filePath of walk(directoryPath)) {
       try {
         const fileExt = path.extname(filePath).slice(1).toLowerCase();
 
diff --git a/packages/core/src/readers/TextFileReader.ts b/packages/core/src/readers/TextFileReader.ts
index 9a3b6b8efa..7d51ac53b8 100644
--- a/packages/core/src/readers/TextFileReader.ts
+++ b/packages/core/src/readers/TextFileReader.ts
@@ -1,5 +1,4 @@
-import type { CompleteFileSystem } from "@llamaindex/env";
-import { defaultFS } from "@llamaindex/env";
+import { fs } from "@llamaindex/env";
 import { Document } from "../Node.js";
 import type { BaseReader } from "./type.js";
 
@@ -8,11 +7,8 @@ import type { BaseReader } from "./type.js";
  */
 
 export class TextFileReader implements BaseReader {
-  async loadData(
-    file: string,
-    fs: CompleteFileSystem = defaultFS,
-  ): Promise<Document[]> {
-    const dataBuffer = await fs.readFile(file);
+  async loadData(file: string): Promise<Document[]> {
+    const dataBuffer = await fs.readFile(file, "utf-8");
     return [new Document({ text: dataBuffer, id_: file })];
   }
 }
diff --git a/packages/core/src/readers/type.ts b/packages/core/src/readers/type.ts
index 5912896212..233375963a 100644
--- a/packages/core/src/readers/type.ts
+++ b/packages/core/src/readers/type.ts
@@ -1,4 +1,3 @@
-import type { CompleteFileSystem } from "@llamaindex/env";
 import type { Document } from "../Node.js";
 
 /**
@@ -12,7 +11,7 @@ export interface BaseReader {
  * A reader takes file paths and imports data into Document objects.
  */
 export interface FileReader extends BaseReader {
-  loadData(filePath: string, fs?: CompleteFileSystem): Promise<Document[]>;
+  loadData(filePath: string): Promise<Document[]>;
 }
 
 // For LlamaParseReader.ts
diff --git a/packages/core/src/storage/FileSystem.ts b/packages/core/src/storage/FileSystem.ts
index 1c685b4763..a268cfffb0 100644
--- a/packages/core/src/storage/FileSystem.ts
+++ b/packages/core/src/storage/FileSystem.ts
@@ -1,5 +1,6 @@
-import type { GenericFileSystem, WalkableFileSystem } from "@llamaindex/env";
-// FS utility functions
+// FS utility helpers
+
+import { fs } from "@llamaindex/env";
 
 /**
  * Checks if a file exists.
@@ -8,10 +9,7 @@ import type { GenericFileSystem, WalkableFileSystem } from "@llamaindex/env";
  * @param path The path to the file to check.
  * @returns A promise that resolves to true if the file exists, false otherwise.
  */
-export async function exists(
-  fs: GenericFileSystem,
-  path: string,
-): Promise<boolean> {
+export async function exists(path: string): Promise<boolean> {
   try {
     await fs.access(path);
     return true;
@@ -22,19 +20,15 @@ export async function exists(
 
 /**
  * Recursively traverses a directory and yields all the paths to the files in it.
- * @param fs The filesystem to use.
  * @param dirPath The path to the directory to traverse.
  */
-export async function* walk(
-  fs: WalkableFileSystem,
-  dirPath: string,
-): AsyncIterable<string> {
+export async function* walk(dirPath: string): AsyncIterable<string> {
   const entries = await fs.readdir(dirPath);
   for (const entry of entries) {
     const fullPath = `${dirPath}/${entry}`;
     const stats = await fs.stat(fullPath);
     if (stats.isDirectory()) {
-      yield* walk(fs, fullPath);
+      yield* walk(fullPath);
     } else {
       yield fullPath;
     }
diff --git a/packages/core/src/storage/StorageContext.ts b/packages/core/src/storage/StorageContext.ts
index a32ae573d2..8872a67c59 100644
--- a/packages/core/src/storage/StorageContext.ts
+++ b/packages/core/src/storage/StorageContext.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
+import { path } from "@llamaindex/env";
 import {
   DEFAULT_IMAGE_VECTOR_NAMESPACE,
   DEFAULT_NAMESPACE,
@@ -25,7 +24,6 @@ export type BuilderParams = {
   imageVectorStore: VectorStore;
   storeImages: boolean;
   persistDir: string;
-  fs: GenericFileSystem;
 };
 
 export async function storageContextFromDefaults({
@@ -35,7 +33,6 @@ export async function storageContextFromDefaults({
   imageVectorStore,
   storeImages,
   persistDir,
-  fs,
 }: Partial<BuilderParams>): Promise<StorageContext> {
   if (!persistDir) {
     docStore = docStore || new SimpleDocumentStore();
@@ -43,22 +40,16 @@ export async function storageContextFromDefaults({
     vectorStore = vectorStore || new SimpleVectorStore();
     imageVectorStore = storeImages ? new SimpleVectorStore() : imageVectorStore;
   } else {
-    fs = fs || defaultFS;
     docStore =
       docStore ||
-      (await SimpleDocumentStore.fromPersistDir(
-        persistDir,
-        DEFAULT_NAMESPACE,
-        fs,
-      ));
+      (await SimpleDocumentStore.fromPersistDir(persistDir, DEFAULT_NAMESPACE));
     indexStore =
-      indexStore || (await SimpleIndexStore.fromPersistDir(persistDir, fs));
+      indexStore || (await SimpleIndexStore.fromPersistDir(persistDir));
     vectorStore =
-      vectorStore || (await SimpleVectorStore.fromPersistDir(persistDir, fs));
+      vectorStore || (await SimpleVectorStore.fromPersistDir(persistDir));
     imageVectorStore = storeImages
       ? await SimpleVectorStore.fromPersistDir(
           path.join(persistDir, DEFAULT_IMAGE_VECTOR_NAMESPACE),
-          fs,
         )
       : imageVectorStore;
   }
diff --git a/packages/core/src/storage/docStore/SimpleDocumentStore.ts b/packages/core/src/storage/docStore/SimpleDocumentStore.ts
index 5c97cf4df3..710b72d297 100644
--- a/packages/core/src/storage/docStore/SimpleDocumentStore.ts
+++ b/packages/core/src/storage/docStore/SimpleDocumentStore.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
+import { path } from "@llamaindex/env";
 import _ from "lodash";
 import {
   DEFAULT_DOC_STORE_PERSIST_FILENAME,
@@ -25,26 +24,19 @@ export class SimpleDocumentStore extends KVDocumentStore {
   static async fromPersistDir(
     persistDir: string = DEFAULT_PERSIST_DIR,
     namespace?: string,
-    fsModule?: GenericFileSystem,
   ): Promise<SimpleDocumentStore> {
     const persistPath = path.join(
       persistDir,
       DEFAULT_DOC_STORE_PERSIST_FILENAME,
     );
-    return await SimpleDocumentStore.fromPersistPath(
-      persistPath,
-      namespace,
-      fsModule,
-    );
+    return await SimpleDocumentStore.fromPersistPath(persistPath, namespace);
   }
 
   static async fromPersistPath(
     persistPath: string,
     namespace?: string,
-    fs?: GenericFileSystem,
   ): Promise<SimpleDocumentStore> {
-    fs = fs || defaultFS;
-    const simpleKVStore = await SimpleKVStore.fromPersistPath(persistPath, fs);
+    const simpleKVStore = await SimpleKVStore.fromPersistPath(persistPath);
     return new SimpleDocumentStore(simpleKVStore, namespace);
   }
 
@@ -53,14 +45,12 @@ export class SimpleDocumentStore extends KVDocumentStore {
       DEFAULT_PERSIST_DIR,
       DEFAULT_DOC_STORE_PERSIST_FILENAME,
     ),
-    fs?: GenericFileSystem,
   ): Promise<void> {
-    fs = fs || defaultFS;
     if (
       _.isObject(this.kvStore) &&
       this.kvStore instanceof BaseInMemoryKVStore
     ) {
-      await this.kvStore.persist(persistPath, fs);
+      await this.kvStore.persist(persistPath);
     }
   }
 
diff --git a/packages/core/src/storage/docStore/types.ts b/packages/core/src/storage/docStore/types.ts
index 119ca2449c..f5206b9e43 100644
--- a/packages/core/src/storage/docStore/types.ts
+++ b/packages/core/src/storage/docStore/types.ts
@@ -1,4 +1,3 @@
-import type { GenericFileSystem } from "@llamaindex/env";
 import { BaseNode } from "../../Node.js";
 import {
   DEFAULT_DOC_STORE_PERSIST_FILENAME,
@@ -14,10 +13,7 @@ export interface RefDocInfo {
 
 export abstract class BaseDocumentStore {
   // Save/load
-  persist(
-    persistPath: string = defaultPersistPath,
-    fs?: GenericFileSystem,
-  ): void {
+  persist(persistPath: string = defaultPersistPath): void {
     // Persist the docstore to a file.
   }
 
diff --git a/packages/core/src/storage/indexStore/SimpleIndexStore.ts b/packages/core/src/storage/indexStore/SimpleIndexStore.ts
index 48a5579b9b..5447b5638f 100644
--- a/packages/core/src/storage/indexStore/SimpleIndexStore.ts
+++ b/packages/core/src/storage/indexStore/SimpleIndexStore.ts
@@ -1,5 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
+import { path } from "@llamaindex/env";
 import {
   DEFAULT_INDEX_STORE_PERSIST_FILENAME,
   DEFAULT_PERSIST_DIR,
@@ -20,28 +19,21 @@ export class SimpleIndexStore extends KVIndexStore {
 
   static async fromPersistDir(
     persistDir: string = DEFAULT_PERSIST_DIR,
-    fs: GenericFileSystem = defaultFS,
   ): Promise<SimpleIndexStore> {
     const persistPath = path.join(
       persistDir,
       DEFAULT_INDEX_STORE_PERSIST_FILENAME,
     );
-    return this.fromPersistPath(persistPath, fs);
+    return this.fromPersistPath(persistPath);
   }
 
-  static async fromPersistPath(
-    persistPath: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<SimpleIndexStore> {
-    const simpleKVStore = await SimpleKVStore.fromPersistPath(persistPath, fs);
+  static async fromPersistPath(persistPath: string): Promise<SimpleIndexStore> {
+    const simpleKVStore = await SimpleKVStore.fromPersistPath(persistPath);
     return new SimpleIndexStore(simpleKVStore);
   }
 
-  async persist(
-    persistPath: string = DEFAULT_PERSIST_DIR,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<void> {
-    await this.kvStore.persist(persistPath, fs);
+  async persist(persistPath: string = DEFAULT_PERSIST_DIR): Promise<void> {
+    this.kvStore.persist(persistPath);
   }
 
   static fromDict(saveDict: DataType): SimpleIndexStore {
diff --git a/packages/core/src/storage/indexStore/types.ts b/packages/core/src/storage/indexStore/types.ts
index 343c1f738d..e503af83c2 100644
--- a/packages/core/src/storage/indexStore/types.ts
+++ b/packages/core/src/storage/indexStore/types.ts
@@ -1,4 +1,3 @@
-import type { GenericFileSystem } from "@llamaindex/env";
 import type { IndexStruct } from "../../indices/IndexStruct.js";
 import {
   DEFAULT_INDEX_STORE_PERSIST_FILENAME,
@@ -16,10 +15,7 @@ export abstract class BaseIndexStore {
 
   abstract getIndexStruct(structId?: string): Promise<IndexStruct | undefined>;
 
-  async persist(
-    persistPath: string = defaultPersistPath,
-    fs?: GenericFileSystem,
-  ): Promise<void> {
+  async persist(persistPath: string = defaultPersistPath): Promise<void> {
     // Persist the index store to disk.
   }
 }
diff --git a/packages/core/src/storage/kvStore/SimpleKVStore.ts b/packages/core/src/storage/kvStore/SimpleKVStore.ts
index 5af9d719ae..07c3a696e3 100644
--- a/packages/core/src/storage/kvStore/SimpleKVStore.ts
+++ b/packages/core/src/storage/kvStore/SimpleKVStore.ts
@@ -1,6 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
-import _ from "lodash";
+import { fs, path } from "@llamaindex/env";
 import { exists } from "../FileSystem.js";
 import { DEFAULT_COLLECTION } from "../constants.js";
 import { BaseKVStore } from "./types.js";
@@ -9,7 +7,6 @@ export type DataType = Record<string, Record<string, any>>;
 
 export class SimpleKVStore extends BaseKVStore {
   private persistPath: string | undefined;
-  private fs: GenericFileSystem | undefined;
 
   constructor(private data: DataType = {}) {
     super();
@@ -23,10 +20,10 @@ export class SimpleKVStore extends BaseKVStore {
     if (!(collection in this.data)) {
       this.data[collection] = {};
     }
-    this.data[collection][key] = _.clone(val); // Creating a shallow copy of the object
+    this.data[collection][key] = structuredClone(val); // Creating a shallow copy of the object
 
     if (this.persistPath) {
-      await this.persist(this.persistPath, this.fs);
+      await this.persist(this.persistPath);
     }
   }
 
@@ -35,17 +32,17 @@ export class SimpleKVStore extends BaseKVStore {
     collection: string = DEFAULT_COLLECTION,
   ): Promise<any> {
     const collectionData = this.data[collection];
-    if (_.isNil(collectionData)) {
+    if (collectionData == null) {
       return null;
     }
     if (!(key in collectionData)) {
       return null;
     }
-    return _.clone(collectionData[key]); // Creating a shallow copy of the object
+    return structuredClone(collectionData[key]); // Creating a shallow copy of the object
   }
 
   async getAll(collection: string = DEFAULT_COLLECTION): Promise<DataType> {
-    return _.clone(this.data[collection]); // Creating a shallow copy of the object
+    return structuredClone(this.data[collection]); // Creating a shallow copy of the object
   }
 
   async delete(
@@ -55,31 +52,25 @@ export class SimpleKVStore extends BaseKVStore {
     if (key in this.data[collection]) {
       delete this.data[collection][key];
       if (this.persistPath) {
-        await this.persist(this.persistPath, this.fs);
+        await this.persist(this.persistPath);
       }
       return true;
     }
     return false;
   }
 
-  async persist(
-    persistPath: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<void> {
+  async persist(persistPath: string): Promise<void> {
     // TODO: decide on a way to polyfill path
     const dirPath = path.dirname(persistPath);
-    if (!(await exists(fs, dirPath))) {
+    if (!(await exists(dirPath))) {
       await fs.mkdir(dirPath);
     }
     await fs.writeFile(persistPath, JSON.stringify(this.data));
   }
 
-  static async fromPersistPath(
-    persistPath: string,
-    fs: GenericFileSystem = defaultFS,
-  ): Promise<SimpleKVStore> {
+  static async fromPersistPath(persistPath: string): Promise<SimpleKVStore> {
     const dirPath = path.dirname(persistPath);
-    if (!(await exists(fs, dirPath))) {
+    if (!(await exists(dirPath))) {
       await fs.mkdir(dirPath);
     }
 
@@ -95,7 +86,6 @@ export class SimpleKVStore extends BaseKVStore {
 
     const store = new SimpleKVStore(data);
     store.persistPath = persistPath;
-    store.fs = fs;
     return store;
   }
 
diff --git a/packages/core/src/storage/kvStore/types.ts b/packages/core/src/storage/kvStore/types.ts
index 8e9ca21093..c7a8b5137e 100644
--- a/packages/core/src/storage/kvStore/types.ts
+++ b/packages/core/src/storage/kvStore/types.ts
@@ -1,4 +1,3 @@
-import type { GenericFileSystem } from "@llamaindex/env";
 const defaultCollection = "data";
 
 type StoredValue = Record<string, any> | null;
@@ -15,7 +14,7 @@ export abstract class BaseKVStore {
 }
 
 export abstract class BaseInMemoryKVStore extends BaseKVStore {
-  abstract persist(persistPath: string, fs?: GenericFileSystem): void;
+  abstract persist(persistPath: string): void;
   static fromPersistPath(persistPath: string): BaseInMemoryKVStore {
     throw new Error("Method not implemented.");
   }
diff --git a/packages/core/src/storage/vectorStore/PGVectorStore.ts b/packages/core/src/storage/vectorStore/PGVectorStore.ts
index 3109d9d37c..b46a2a7b16 100644
--- a/packages/core/src/storage/vectorStore/PGVectorStore.ts
+++ b/packages/core/src/storage/vectorStore/PGVectorStore.ts
@@ -6,7 +6,6 @@ import type {
   VectorStoreQueryResult,
 } from "./types.js";
 
-import type { GenericFileSystem } from "@llamaindex/env";
 import type { BaseNode, Metadata } from "../../Node.js";
 import { Document, MetadataMode } from "../../Node.js";
 
@@ -307,10 +306,7 @@ export class PGVectorStore implements VectorStore {
    * @param fs
    * @returns Resolved Promise.
    */
-  persist(
-    persistPath: string,
-    fs?: GenericFileSystem | undefined,
-  ): Promise<void> {
+  persist(persistPath: string): Promise<void> {
     return Promise.resolve();
   }
 }
diff --git a/packages/core/src/storage/vectorStore/PineconeVectorStore.ts b/packages/core/src/storage/vectorStore/PineconeVectorStore.ts
index e537ca2341..cf5f789ac2 100644
--- a/packages/core/src/storage/vectorStore/PineconeVectorStore.ts
+++ b/packages/core/src/storage/vectorStore/PineconeVectorStore.ts
@@ -6,7 +6,7 @@ import type {
   VectorStoreQueryResult,
 } from "./types.js";
 
-import { getEnv, type GenericFileSystem } from "@llamaindex/env";
+import { getEnv } from "@llamaindex/env";
 import type {
   FetchResponse,
   Index,
@@ -188,10 +188,7 @@ export class PineconeVectorStore implements VectorStore {
    * @param fs
    * @returns Resolved Promise.
    */
-  persist(
-    persistPath: string,
-    fs?: GenericFileSystem | undefined,
-  ): Promise<void> {
+  persist(persistPath: string): Promise<void> {
     return Promise.resolve();
   }
 
diff --git a/packages/core/src/storage/vectorStore/SimpleVectorStore.ts b/packages/core/src/storage/vectorStore/SimpleVectorStore.ts
index 6caa439f4a..0652c3214c 100644
--- a/packages/core/src/storage/vectorStore/SimpleVectorStore.ts
+++ b/packages/core/src/storage/vectorStore/SimpleVectorStore.ts
@@ -1,6 +1,4 @@
-import type { GenericFileSystem } from "@llamaindex/env";
-import { defaultFS, path } from "@llamaindex/env";
-import _ from "lodash";
+import { fs, path } from "@llamaindex/env";
 import type { BaseNode } from "../../Node.js";
 import {
   getTopKEmbeddings,
@@ -32,20 +30,17 @@ class SimpleVectorStoreData {
 export class SimpleVectorStore implements VectorStore {
   storesText: boolean = false;
   private data: SimpleVectorStoreData = new SimpleVectorStoreData();
-  private fs: GenericFileSystem = defaultFS;
   private persistPath: string | undefined;
 
-  constructor(data?: SimpleVectorStoreData, fs?: GenericFileSystem) {
+  constructor(data?: SimpleVectorStoreData) {
     this.data = data || new SimpleVectorStoreData();
-    this.fs = fs || defaultFS;
   }
 
   static async fromPersistDir(
     persistDir: string = DEFAULT_PERSIST_DIR,
-    fs: GenericFileSystem = defaultFS,
   ): Promise<SimpleVectorStore> {
-    const persistPath = `${persistDir}/vector_store.json`;
-    return await SimpleVectorStore.fromPersistPath(persistPath, fs);
+    const persistPath = path.join(persistDir, "vector_store.json");
+    return await SimpleVectorStore.fromPersistPath(persistPath);
   }
 
   get client(): any {
@@ -68,7 +63,7 @@ export class SimpleVectorStore implements VectorStore {
     }
 
     if (this.persistPath) {
-      await this.persist(this.persistPath, this.fs);
+      await this.persist(this.persistPath);
     }
 
     return embeddingResults.map((result) => result.id_);
@@ -83,13 +78,13 @@ export class SimpleVectorStore implements VectorStore {
       delete this.data.textIdToRefDocId[textId];
     }
     if (this.persistPath) {
-      await this.persist(this.persistPath, this.fs);
+      await this.persist(this.persistPath);
     }
     return Promise.resolve();
   }
 
   async query(query: VectorStoreQuery): Promise<VectorStoreQueryResult> {
-    if (!_.isNil(query.filters)) {
+    if (!(query.filters == null)) {
       throw new Error(
         "Metadata filters not implemented for SimpleVectorStore yet.",
       );
@@ -147,12 +142,10 @@ export class SimpleVectorStore implements VectorStore {
   }
 
   async persist(
-    persistPath: string = `${DEFAULT_PERSIST_DIR}/vector_store.json`,
-    fs?: GenericFileSystem,
+    persistPath: string = path.join(DEFAULT_PERSIST_DIR, "vector_store.json"),
   ): Promise<void> {
-    fs = fs || this.fs;
     const dirPath = path.dirname(persistPath);
-    if (!(await exists(fs, dirPath))) {
+    if (!(await exists(dirPath))) {
       await fs.mkdir(dirPath);
     }
 
@@ -161,10 +154,9 @@ export class SimpleVectorStore implements VectorStore {
 
   static async fromPersistPath(
     persistPath: string,
-    fs: GenericFileSystem = defaultFS,
   ): Promise<SimpleVectorStore> {
     const dirPath = path.dirname(persistPath);
-    if (!(await exists(fs, dirPath))) {
+    if (!(await exists(dirPath))) {
       await fs.mkdir(dirPath, { recursive: true });
     }
 
@@ -183,7 +175,6 @@ export class SimpleVectorStore implements VectorStore {
     data.textIdToRefDocId = dataDict.textIdToRefDocId ?? {};
     const store = new SimpleVectorStore(data);
     store.persistPath = persistPath;
-    store.fs = fs;
     return store;
   }
 
diff --git a/packages/env/package.json b/packages/env/package.json
index 75a986dc75..5bcaf7dcec 100644
--- a/packages/env/package.json
+++ b/packages/env/package.json
@@ -33,8 +33,8 @@
         "default": "./dist/index.workerd.js"
       },
       "edge-light": {
-        "types": "./dist/type/index.polyfill.d.ts",
-        "default": "./dist/index.polyfill.js"
+        "types": "./dist/type/index.edge-light.d.ts",
+        "default": "./dist/index.edge-light.js"
       },
       "import": {
         "types": "./dist/type/index.d.ts",
@@ -44,16 +44,6 @@
         "types": "./dist/type/index.d.ts",
         "default": "./dist/cjs/index.js"
       }
-    },
-    "./*": {
-      "import": {
-        "types": "./dist/type/*.d.ts",
-        "default": "./dist/*.js"
-      },
-      "require": {
-        "types": "./dist/type/*.d.ts",
-        "default": "./dist/cjs/*.js"
-      }
     }
   },
   "files": [
@@ -71,7 +61,8 @@
     "build:cjs": "swc src -d dist/cjs --strip-leading-paths --config-file ../../.cjs.swcrc",
     "build:type": "tsc -p tsconfig.json",
     "postbuild": "node -e \"require('fs').writeFileSync('./dist/cjs/package.json', JSON.stringify({ type: 'commonjs' }))\"",
-    "dev": "concurrently \"pnpm run build:esm --watch\" \"pnpm run build:cjs --watch\" \"pnpm run build:type --watch\""
+    "dev": "concurrently \"pnpm run build:esm --watch\" \"pnpm run build:cjs --watch\" \"pnpm run build:type --watch\"",
+    "test": "vitest"
   },
   "devDependencies": {
     "@aws-crypto/sha256-js": "^5.2.0",
@@ -79,7 +70,8 @@
     "@swc/core": "^1.5.5",
     "concurrently": "^8.2.2",
     "pathe": "^1.1.2",
-    "readable-stream": "^4.5.2"
+    "readable-stream": "^4.5.2",
+    "vitest": "^1.6.0"
   },
   "dependencies": {
     "@types/lodash": "^4.17.1",
diff --git a/packages/env/src/fs/memfs/README.md b/packages/env/src/fs/memfs/README.md
new file mode 100644
index 0000000000..0fe784f9c4
--- /dev/null
+++ b/packages/env/src/fs/memfs/README.md
@@ -0,0 +1 @@
+Copy from https://github.com/bundled-es-modules/memfs/blob/main/index-esm.js
diff --git a/packages/env/src/fs/memfs/index.js b/packages/env/src/fs/memfs/index.js
new file mode 100644
index 0000000000..53b84dfca1
--- /dev/null
+++ b/packages/env/src/fs/memfs/index.js
@@ -0,0 +1,12665 @@
+var process = {};
+var cachedSetTimeout;
+var cachedClearTimeout;
+function defaultSetTimout() {
+  throw new Error("setTimeout has not been defined");
+}
+function defaultClearTimeout() {
+  throw new Error("clearTimeout has not been defined");
+}
+(function () {
+  try {
+    if (typeof setTimeout === "function") {
+      cachedSetTimeout = setTimeout;
+    } else {
+      cachedSetTimeout = defaultSetTimout;
+    }
+  } catch (e) {
+    cachedSetTimeout = defaultSetTimout;
+  }
+  try {
+    if (typeof clearTimeout === "function") {
+      cachedClearTimeout = clearTimeout;
+    } else {
+      cachedClearTimeout = defaultClearTimeout;
+    }
+  } catch (e) {
+    cachedClearTimeout = defaultClearTimeout;
+  }
+})();
+function runTimeout(fun) {
+  if (cachedSetTimeout === setTimeout) {
+    return setTimeout(fun, 0);
+  }
+  if (
+    (cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) &&
+    setTimeout
+  ) {
+    cachedSetTimeout = setTimeout;
+    return setTimeout(fun, 0);
+  }
+  try {
+    return cachedSetTimeout(fun, 0);
+  } catch (e) {
+    try {
+      return cachedSetTimeout.call(null, fun, 0);
+    } catch (e2) {
+      return cachedSetTimeout.call(this, fun, 0);
+    }
+  }
+}
+function runClearTimeout(marker) {
+  if (cachedClearTimeout === clearTimeout) {
+    return clearTimeout(marker);
+  }
+  if (
+    (cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) &&
+    clearTimeout
+  ) {
+    cachedClearTimeout = clearTimeout;
+    return clearTimeout(marker);
+  }
+  try {
+    return cachedClearTimeout(marker);
+  } catch (e) {
+    try {
+      return cachedClearTimeout.call(null, marker);
+    } catch (e2) {
+      return cachedClearTimeout.call(this, marker);
+    }
+  }
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+function cleanUpNextTick() {
+  if (!draining || !currentQueue) {
+    return;
+  }
+  draining = false;
+  if (currentQueue.length) {
+    queue = currentQueue.concat(queue);
+  } else {
+    queueIndex = -1;
+  }
+  if (queue.length) {
+    drainQueue();
+  }
+}
+function drainQueue() {
+  if (draining) {
+    return;
+  }
+  var timeout = runTimeout(cleanUpNextTick);
+  draining = true;
+  var len = queue.length;
+  while (len) {
+    currentQueue = queue;
+    queue = [];
+    while (++queueIndex < len) {
+      if (currentQueue) {
+        currentQueue[queueIndex].run();
+      }
+    }
+    queueIndex = -1;
+    len = queue.length;
+  }
+  currentQueue = null;
+  draining = false;
+  runClearTimeout(timeout);
+}
+process.nextTick = function (fun) {
+  var args = new Array(arguments.length - 1);
+  if (arguments.length > 1) {
+    for (var i = 1; i < arguments.length; i++) {
+      args[i - 1] = arguments[i];
+    }
+  }
+  queue.push(new Item(fun, args));
+  if (queue.length === 1 && !draining) {
+    runTimeout(drainQueue);
+  }
+};
+function Item(fun, array) {
+  this.fun = fun;
+  this.array = array;
+}
+Item.prototype.run = function () {
+  this.fun.apply(null, this.array);
+};
+process.title = "browser";
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = "";
+process.versions = {};
+function noop() {}
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+process.listeners = function (name) {
+  return [];
+};
+process.binding = function (name) {
+  throw new Error("process.binding is not supported");
+};
+process.cwd = function () {
+  return "/";
+};
+process.chdir = function (dir) {
+  throw new Error("process.chdir is not supported");
+};
+process.umask = function () {
+  return 0;
+};
+
+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 __require = /* @__PURE__ */ ((x) =>
+  typeof require !== "undefined"
+    ? require
+    : typeof Proxy !== "undefined"
+      ? new Proxy(x, {
+          get: (a, b) => (typeof require !== "undefined" ? require : a)[b],
+        })
+      : x)(function (x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) =>
+  function __require2() {
+    return (
+      mod ||
+        (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod),
+      mod.exports
+    );
+  };
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (const 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,
+  )
+);
+
+// node_modules/memfs/lib/constants.js
+var require_constants = __commonJS({
+  "node_modules/memfs/lib/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.constants = void 0;
+    exports.constants = {
+      O_RDONLY: 0,
+      O_WRONLY: 1,
+      O_RDWR: 2,
+      S_IFMT: 61440,
+      S_IFREG: 32768,
+      S_IFDIR: 16384,
+      S_IFCHR: 8192,
+      S_IFBLK: 24576,
+      S_IFIFO: 4096,
+      S_IFLNK: 40960,
+      S_IFSOCK: 49152,
+      O_CREAT: 64,
+      O_EXCL: 128,
+      O_NOCTTY: 256,
+      O_TRUNC: 512,
+      O_APPEND: 1024,
+      O_DIRECTORY: 65536,
+      O_NOATIME: 262144,
+      O_NOFOLLOW: 131072,
+      O_SYNC: 1052672,
+      O_SYMLINK: 2097152,
+      O_DIRECT: 16384,
+      O_NONBLOCK: 2048,
+      S_IRWXU: 448,
+      S_IRUSR: 256,
+      S_IWUSR: 128,
+      S_IXUSR: 64,
+      S_IRWXG: 56,
+      S_IRGRP: 32,
+      S_IWGRP: 16,
+      S_IXGRP: 8,
+      S_IRWXO: 7,
+      S_IROTH: 4,
+      S_IWOTH: 2,
+      S_IXOTH: 1,
+      F_OK: 0,
+      R_OK: 4,
+      W_OK: 2,
+      X_OK: 1,
+      UV_FS_SYMLINK_DIR: 1,
+      UV_FS_SYMLINK_JUNCTION: 2,
+      UV_FS_COPYFILE_EXCL: 1,
+      UV_FS_COPYFILE_FICLONE: 2,
+      UV_FS_COPYFILE_FICLONE_FORCE: 4,
+      COPYFILE_EXCL: 1,
+      COPYFILE_FICLONE: 2,
+      COPYFILE_FICLONE_FORCE: 4,
+    };
+  },
+});
+
+// node_modules/memfs/lib/Stats.js
+var require_Stats = __commonJS({
+  "node_modules/memfs/lib/Stats.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Stats = void 0;
+    var constants_1 = require_constants();
+    var {
+      S_IFMT,
+      S_IFDIR,
+      S_IFREG,
+      S_IFBLK,
+      S_IFCHR,
+      S_IFLNK,
+      S_IFIFO,
+      S_IFSOCK,
+    } = constants_1.constants;
+    var Stats = class _Stats {
+      static build(node, bigint = false) {
+        const stats = new _Stats();
+        const { uid, gid, atime, mtime, ctime } = node;
+        const getStatNumber = !bigint
+          ? (number) => number
+          : (number) => BigInt(number);
+        stats.uid = getStatNumber(uid);
+        stats.gid = getStatNumber(gid);
+        stats.rdev = getStatNumber(0);
+        stats.blksize = getStatNumber(4096);
+        stats.ino = getStatNumber(node.ino);
+        stats.size = getStatNumber(node.getSize());
+        stats.blocks = getStatNumber(1);
+        stats.atime = atime;
+        stats.mtime = mtime;
+        stats.ctime = ctime;
+        stats.birthtime = ctime;
+        stats.atimeMs = getStatNumber(atime.getTime());
+        stats.mtimeMs = getStatNumber(mtime.getTime());
+        const ctimeMs = getStatNumber(ctime.getTime());
+        stats.ctimeMs = ctimeMs;
+        stats.birthtimeMs = ctimeMs;
+        if (bigint) {
+          stats.atimeNs = BigInt(atime.getTime()) * BigInt(1e6);
+          stats.mtimeNs = BigInt(mtime.getTime()) * BigInt(1e6);
+          const ctimeNs = BigInt(ctime.getTime()) * BigInt(1e6);
+          stats.ctimeNs = ctimeNs;
+          stats.birthtimeNs = ctimeNs;
+        }
+        stats.dev = getStatNumber(0);
+        stats.mode = getStatNumber(node.mode);
+        stats.nlink = getStatNumber(node.nlink);
+        return stats;
+      }
+      _checkModeProperty(property) {
+        return (Number(this.mode) & S_IFMT) === property;
+      }
+      isDirectory() {
+        return this._checkModeProperty(S_IFDIR);
+      }
+      isFile() {
+        return this._checkModeProperty(S_IFREG);
+      }
+      isBlockDevice() {
+        return this._checkModeProperty(S_IFBLK);
+      }
+      isCharacterDevice() {
+        return this._checkModeProperty(S_IFCHR);
+      }
+      isSymbolicLink() {
+        return this._checkModeProperty(S_IFLNK);
+      }
+      isFIFO() {
+        return this._checkModeProperty(S_IFIFO);
+      }
+      isSocket() {
+        return this._checkModeProperty(S_IFSOCK);
+      }
+    };
+    exports.Stats = Stats;
+    exports.default = Stats;
+  },
+});
+
+// node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code.length; i < len; ++i) {
+      lookup[i] = code[i];
+      revLookup[code.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1) validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - (validLen % 4);
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var i2;
+      for (i2 = 0; i2 < len2; i2 += 4) {
+        tmp =
+          (revLookup[b64.charCodeAt(i2)] << 18) |
+          (revLookup[b64.charCodeAt(i2 + 1)] << 12) |
+          (revLookup[b64.charCodeAt(i2 + 2)] << 6) |
+          revLookup[b64.charCodeAt(i2 + 3)];
+        arr[curByte++] = (tmp >> 16) & 255;
+        arr[curByte++] = (tmp >> 8) & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 2) {
+        tmp =
+          (revLookup[b64.charCodeAt(i2)] << 2) |
+          (revLookup[b64.charCodeAt(i2 + 1)] >> 4);
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 1) {
+        tmp =
+          (revLookup[b64.charCodeAt(i2)] << 10) |
+          (revLookup[b64.charCodeAt(i2 + 1)] << 4) |
+          (revLookup[b64.charCodeAt(i2 + 2)] >> 2);
+        arr[curByte++] = (tmp >> 8) & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    function tripletToBase64(num) {
+      return (
+        lookup[(num >> 18) & 63] +
+        lookup[(num >> 12) & 63] +
+        lookup[(num >> 6) & 63] +
+        lookup[num & 63]
+      );
+    }
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var output = [];
+      for (var i2 = start; i2 < end; i2 += 3) {
+        tmp =
+          ((uint8[i2] << 16) & 16711680) +
+          ((uint8[i2 + 1] << 8) & 65280) +
+          (uint8[i2 + 2] & 255);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      var extraBytes = len2 % 3;
+      var parts = [];
+      var maxChunkLength = 16383;
+      for (
+        var i2 = 0, len22 = len2 - extraBytes;
+        i2 < len22;
+        i2 += maxChunkLength
+      ) {
+        parts.push(
+          encodeChunk(
+            uint8,
+            i2,
+            i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength,
+          ),
+        );
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 1];
+        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 63] + "==");
+      } else if (extraBytes === 2) {
+        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+        parts.push(
+          lookup[tmp >> 10] +
+            lookup[(tmp >> 4) & 63] +
+            lookup[(tmp << 2) & 63] +
+            "=",
+        );
+      }
+      return parts.join("");
+    }
+  },
+});
+
+// node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "node_modules/ieee754/index.js"(exports) {
+    exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var s = buffer[offset + i];
+      i += d;
+      e = s & ((1 << -nBits) - 1);
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+      m = e & ((1 << -nBits) - 1);
+      e >>= -nBits;
+      nBits += mLen;
+      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+      var i = isLE ? 0 : nBytes - 1;
+      var d = isLE ? 1 : -1;
+      var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (
+        ;
+        mLen >= 8;
+        buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8
+      ) {}
+      e = (e << mLen) | m;
+      eLen += mLen;
+      for (
+        ;
+        eLen > 0;
+        buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8
+      ) {}
+      buffer[offset + i - d] |= s * 128;
+    };
+  },
+});
+
+// node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "node_modules/buffer/index.js"(exports) {
+    "use strict";
+    var base64 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol =
+      typeof Symbol === "function" && typeof Symbol["for"] === "function"
+        ? Symbol["for"]("nodejs.util.inspect.custom")
+        : null;
+    exports.Buffer = Buffer2;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (
+      !Buffer2.TYPED_ARRAY_SUPPORT &&
+      typeof console !== "undefined" &&
+      typeof console.error === "function"
+    ) {
+      console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.",
+      );
+    }
+    function typedArraySupport() {
+      try {
+        const arr = new Uint8Array(1);
+        const proto = {
+          foo: function () {
+            return 42;
+          },
+        };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    Object.defineProperty(Buffer2.prototype, "parent", {
+      enumerable: true,
+      get: function () {
+        if (!Buffer2.isBuffer(this)) return void 0;
+        return this.buffer;
+      },
+    });
+    Object.defineProperty(Buffer2.prototype, "offset", {
+      enumerable: true,
+      get: function () {
+        if (!Buffer2.isBuffer(this)) return void 0;
+        return this.byteOffset;
+      },
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError(
+          'The value "' + length + '" is invalid for option "size"',
+        );
+      }
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer2.prototype);
+      return buf;
+    }
+    function Buffer2(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError(
+            'The "string" argument must be of type string. Received type number',
+          );
+        }
+        return allocUnsafe(arg);
+      }
+      return from(arg, encodingOrOffset, length);
+    }
+    Buffer2.poolSize = 8192;
+    function from(value, encodingOrOffset, length) {
+      if (typeof value === "string") {
+        return fromString(value, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
+      }
+      if (value == null) {
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
+            typeof value,
+        );
+      }
+      if (
+        isInstance(value, ArrayBuffer) ||
+        (value && isInstance(value.buffer, ArrayBuffer))
+      ) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (
+        typeof SharedArrayBuffer !== "undefined" &&
+        (isInstance(value, SharedArrayBuffer) ||
+          (value && isInstance(value.buffer, SharedArrayBuffer)))
+      ) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof value === "number") {
+        throw new TypeError(
+          'The "value" argument must not be of type number. Received type number',
+        );
+      }
+      const valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer2.from(valueOf, encodingOrOffset, length);
+      }
+      const b = fromObject(value);
+      if (b) return b;
+      if (
+        typeof Symbol !== "undefined" &&
+        Symbol.toPrimitive != null &&
+        typeof value[Symbol.toPrimitive] === "function"
+      ) {
+        return Buffer2.from(
+          value[Symbol.toPrimitive]("string"),
+          encodingOrOffset,
+          length,
+        );
+      }
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
+          typeof value,
+      );
+    }
+    Buffer2.from = function (value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer2, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError(
+          'The value "' + size + '" is invalid for option "size"',
+        );
+      }
+    }
+    function alloc(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string"
+          ? createBuffer(size).fill(fill, encoding)
+          : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    Buffer2.alloc = function (size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer2.allocUnsafe = function (size) {
+      return allocUnsafe(size);
+    };
+    Buffer2.allocUnsafeSlow = function (size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer2.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    function fromArrayLike(array) {
+      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+      const buf = createBuffer(length);
+      for (let i = 0; i < length; i += 1) {
+        buf[i] = array[i] & 255;
+      }
+      return buf;
+    }
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    function fromArrayBuffer(array, byteOffset, length) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      let buf;
+      if (byteOffset === void 0 && length === void 0) {
+        buf = new Uint8Array(array);
+      } else if (length === void 0) {
+        buf = new Uint8Array(array, byteOffset);
+      } else {
+        buf = new Uint8Array(array, byteOffset, length);
+      }
+      Object.setPrototypeOf(buf, Buffer2.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer2.isBuffer(obj)) {
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
+        if (buf.length === 0) {
+          return buf;
+        }
+        obj.copy(buf, 0, 0, len);
+        return buf;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike(obj.data);
+      }
+    }
+    function checked(length) {
+      if (length >= K_MAX_LENGTH) {
+        throw new RangeError(
+          "Attempt to allocate Buffer larger than maximum size: 0x" +
+            K_MAX_LENGTH.toString(16) +
+            " bytes",
+        );
+      }
+      return length | 0;
+    }
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer2.alloc(+length);
+    }
+    Buffer2.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+    };
+    Buffer2.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array))
+        a = Buffer2.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array))
+        b = Buffer2.from(b, b.offset, b.byteLength);
+      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+        throw new TypeError(
+          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array',
+        );
+      }
+      if (a === b) return 0;
+      let x = a.length;
+      let y = b.length;
+      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    Buffer2.isEncoding = function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    };
+    Buffer2.concat = function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer2.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer2.allocUnsafe(length);
+      let pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        let buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(buffer, buf, pos);
+          }
+        } else if (!Buffer2.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    };
+    function byteLength(string, encoding) {
+      if (Buffer2.isBuffer(string)) {
+        return string.length;
+      }
+      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+        return string.byteLength;
+      }
+      if (typeof string !== "string") {
+        throw new TypeError(
+          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' +
+            typeof string,
+        );
+      }
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0) return 0;
+      let loweredCase = false;
+      for (;;) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes(string).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes(string).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes(string).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer2.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      let loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding) encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer2.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    Buffer2.prototype.swap16 = function swap16() {
+      const len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (let i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    };
+    Buffer2.prototype.swap32 = function swap32() {
+      const len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (let i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    };
+    Buffer2.prototype.swap64 = function swap64() {
+      const len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      for (let i = 0; i < len; i += 8) {
+        swap(this, i, i + 7);
+        swap(this, i + 1, i + 6);
+        swap(this, i + 2, i + 5);
+        swap(this, i + 3, i + 4);
+      }
+      return this;
+    };
+    Buffer2.prototype.toString = function toString() {
+      const length = this.length;
+      if (length === 0) return "";
+      if (arguments.length === 0) return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    };
+    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+    Buffer2.prototype.equals = function equals(b) {
+      if (!Buffer2.isBuffer(b))
+        throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer2.compare(this, b) === 0;
+    };
+    Buffer2.prototype.inspect = function inspect() {
+      let str = "";
+      const max = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max)
+        .replace(/(.{2})/g, "$1 ")
+        .trim();
+      if (this.length > max) str += " ... ";
+      return "<Buffer " + str + ">";
+    };
+    if (customInspectSymbol) {
+      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+    }
+    Buffer2.prototype.compare = function compare(
+      target,
+      start,
+      end,
+      thisStart,
+      thisEnd,
+    ) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer2.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer2.isBuffer(target)) {
+        throw new TypeError(
+          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' +
+            typeof target,
+        );
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (
+        start < 0 ||
+        end > target.length ||
+        thisStart < 0 ||
+        thisEnd > this.length
+      ) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target) return 0;
+      let x = thisEnd - thisStart;
+      let y = end - start;
+      const len = Math.min(x, y);
+      const thisCopy = this.slice(thisStart, thisEnd);
+      const targetCopy = target.slice(start, end);
+      for (let i = 0; i < len; ++i) {
+        if (thisCopy[i] !== targetCopy[i]) {
+          x = thisCopy[i];
+          y = targetCopy[i];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+      if (buffer.length === 0) return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+      if (byteOffset >= buffer.length) {
+        if (dir) return -1;
+        else byteOffset = buffer.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir) byteOffset = 0;
+        else return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer2.from(val, encoding);
+      }
+      if (Buffer2.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(
+              buffer,
+              val,
+              byteOffset,
+            );
+          }
+        }
+        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (
+          encoding === "ucs2" ||
+          encoding === "ucs-2" ||
+          encoding === "utf16le" ||
+          encoding === "utf-16le"
+        ) {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read(buf, i2) {
+        if (indexSize === 1) {
+          return buf[i2];
+        } else {
+          return buf.readUInt16BE(i2 * indexSize);
+        }
+      }
+      let i;
+      if (dir) {
+        let foundIndex = -1;
+        for (i = byteOffset; i < arrLength; i++) {
+          if (
+            read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)
+          ) {
+            if (foundIndex === -1) foundIndex = i;
+            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+          } else {
+            if (foundIndex !== -1) i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength)
+          byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer2.prototype.lastIndexOf = function lastIndexOf(
+      val,
+      byteOffset,
+      encoding,
+    ) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    };
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      const remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      const strLen = string.length;
+      if (length > strLen / 2) {
+        length = strLen / 2;
+      }
+      let i;
+      for (i = 0; i < length; ++i) {
+        const parsed = parseInt(string.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed)) return i;
+        buf[offset + i] = parsed;
+      }
+      return i;
+    }
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(
+        utf8ToBytes(string, buf.length - offset),
+        buf,
+        offset,
+        length,
+      );
+    }
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(
+        utf16leToBytes(string, buf.length - offset),
+        buf,
+        offset,
+        length,
+      );
+    }
+    Buffer2.prototype.write = function write(string, offset, length, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length = this.length;
+        offset = 0;
+      } else if (length === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length)) {
+          length = length >>> 0;
+          if (encoding === void 0) encoding = "utf8";
+        } else {
+          encoding = length;
+          length = void 0;
+        }
+      } else {
+        throw new Error(
+          "Buffer.write(string, encoding, offset[, length]) is no longer supported",
+        );
+      }
+      const remaining = this.length - offset;
+      if (length === void 0 || length > remaining) length = remaining;
+      if (
+        (string.length > 0 && (length < 0 || offset < 0)) ||
+        offset > this.length
+      ) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding) encoding = "utf8";
+      let loweredCase = false;
+      for (;;) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string, offset, length);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string, offset, length);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string, offset, length);
+          case "base64":
+            return base64Write(this, string, offset, length);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string, offset, length);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    };
+    Buffer2.prototype.toJSON = function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0),
+      };
+    };
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      const res = [];
+      let i = start;
+      while (i < end) {
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence =
+          firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = ((firstByte & 31) << 6) | (secondByte & 63);
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint =
+                  ((firstByte & 15) << 12) |
+                  ((secondByte & 63) << 6) |
+                  (thirdByte & 63);
+                if (
+                  tempCodePoint > 2047 &&
+                  (tempCodePoint < 55296 || tempCodePoint > 57343)
+                ) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              fourthByte = buf[i + 3];
+              if (
+                (secondByte & 192) === 128 &&
+                (thirdByte & 192) === 128 &&
+                (fourthByte & 192) === 128
+              ) {
+                tempCodePoint =
+                  ((firstByte & 15) << 18) |
+                  ((secondByte & 63) << 12) |
+                  ((thirdByte & 63) << 6) |
+                  (fourthByte & 63);
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(((codePoint >>> 10) & 1023) | 55296);
+          codePoint = 56320 | (codePoint & 1023);
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray(res);
+    }
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      const len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      let res = "";
+      let i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(
+          String,
+          codePoints.slice(i, (i += MAX_ARGUMENTS_LENGTH)),
+        );
+      }
+      return res;
+    }
+    function asciiSlice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i] & 127);
+      }
+      return ret;
+    }
+    function latin1Slice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i]);
+      }
+      return ret;
+    }
+    function hexSlice(buf, start, end) {
+      const len = buf.length;
+      if (!start || start < 0) start = 0;
+      if (!end || end < 0 || end > len) end = len;
+      let out = "";
+      for (let i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf[i]];
+      }
+      return out;
+    }
+    function utf16leSlice(buf, start, end) {
+      const bytes = buf.slice(start, end);
+      let res = "";
+      for (let i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    Buffer2.prototype.slice = function slice(start, end) {
+      const len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0) start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0) end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start) end = start;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer2.prototype);
+      return newBuf;
+    };
+    function checkOffset(offset, ext, length) {
+      if (offset % 1 !== 0 || offset < 0)
+        throw new RangeError("offset is not uint");
+      if (offset + ext > length)
+        throw new RangeError("Trying to access beyond buffer length");
+    }
+    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE =
+      function readUIntLE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) checkOffset(offset, byteLength2, this.length);
+        let val = this[offset];
+        let mul = 1;
+        let i = 0;
+        while (++i < byteLength2 && (mul *= 256)) {
+          val += this[offset + i] * mul;
+        }
+        return val;
+      };
+    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE =
+      function readUIntBE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          checkOffset(offset, byteLength2, this.length);
+        }
+        let val = this[offset + --byteLength2];
+        let mul = 1;
+        while (byteLength2 > 0 && (mul *= 256)) {
+          val += this[offset + --byteLength2] * mul;
+        }
+        return val;
+      };
+    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 =
+      function readUInt8(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert) checkOffset(offset, 1, this.length);
+        return this[offset];
+      };
+    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE =
+      function readUInt16LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert) checkOffset(offset, 2, this.length);
+        return this[offset] | (this[offset + 1] << 8);
+      };
+    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE =
+      function readUInt16BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert) checkOffset(offset, 2, this.length);
+        return (this[offset] << 8) | this[offset + 1];
+      };
+    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE =
+      function readUInt32LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert) checkOffset(offset, 4, this.length);
+        return (
+          (this[offset] | (this[offset + 1] << 8) | (this[offset + 2] << 16)) +
+          this[offset + 3] * 16777216
+        );
+      };
+    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE =
+      function readUInt32BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert) checkOffset(offset, 4, this.length);
+        return (
+          this[offset] * 16777216 +
+          ((this[offset + 1] << 16) |
+            (this[offset + 2] << 8) |
+            this[offset + 3])
+        );
+      };
+    Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(
+      function readBigUInt64LE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const lo =
+          first +
+          this[++offset] * 2 ** 8 +
+          this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 24;
+        const hi =
+          this[++offset] +
+          this[++offset] * 2 ** 8 +
+          this[++offset] * 2 ** 16 +
+          last * 2 ** 24;
+        return BigInt(lo) + (BigInt(hi) << BigInt(32));
+      },
+    );
+    Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(
+      function readBigUInt64BE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const hi =
+          first * 2 ** 24 +
+          this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 +
+          this[++offset];
+        const lo =
+          this[++offset] * 2 ** 24 +
+          this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 +
+          last;
+        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+      },
+    );
+    Buffer2.prototype.readIntLE = function readIntLE(
+      offset,
+      byteLength2,
+      noAssert,
+    ) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer2.prototype.readIntBE = function readIntBE(
+      offset,
+      byteLength2,
+      noAssert,
+    ) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let i = byteLength2;
+      let mul = 1;
+      let val = this[offset + --i];
+      while (i > 0 && (mul *= 256)) {
+        val += this[offset + --i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128)) return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    };
+    Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset] | (this[offset + 1] << 8);
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset + 1] | (this[offset] << 8);
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return (
+        this[offset] |
+        (this[offset + 1] << 8) |
+        (this[offset + 2] << 16) |
+        (this[offset + 3] << 24)
+      );
+    };
+    Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return (
+        (this[offset] << 24) |
+        (this[offset + 1] << 16) |
+        (this[offset + 2] << 8) |
+        this[offset + 3]
+      );
+    };
+    Buffer2.prototype.readBigInt64LE = defineBigIntMethod(
+      function readBigInt64LE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const val =
+          this[offset + 4] +
+          this[offset + 5] * 2 ** 8 +
+          this[offset + 6] * 2 ** 16 +
+          (last << 24);
+        return (
+          (BigInt(val) << BigInt(32)) +
+          BigInt(
+            first +
+              this[++offset] * 2 ** 8 +
+              this[++offset] * 2 ** 16 +
+              this[++offset] * 2 ** 24,
+          )
+        );
+      },
+    );
+    Buffer2.prototype.readBigInt64BE = defineBigIntMethod(
+      function readBigInt64BE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const val =
+          (first << 24) + // Overflow
+          this[++offset] * 2 ** 16 +
+          this[++offset] * 2 ** 8 +
+          this[++offset];
+        return (
+          (BigInt(val) << BigInt(32)) +
+          BigInt(
+            this[++offset] * 2 ** 24 +
+              this[++offset] * 2 ** 16 +
+              this[++offset] * 2 ** 8 +
+              last,
+          )
+        );
+      },
+    );
+    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    };
+    function checkInt(buf, value, offset, ext, max, min) {
+      if (!Buffer2.isBuffer(buf))
+        throw new TypeError('"buffer" argument must be a Buffer instance');
+      if (value > max || value < min)
+        throw new RangeError('"value" argument is out of bounds');
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+    }
+    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE =
+      function writeUIntLE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 0);
+        }
+        let mul = 1;
+        let i = 0;
+        this[offset] = value & 255;
+        while (++i < byteLength2 && (mul *= 256)) {
+          this[offset + i] = (value / mul) & 255;
+        }
+        return offset + byteLength2;
+      };
+    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE =
+      function writeUIntBE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 0);
+        }
+        let i = byteLength2 - 1;
+        let mul = 1;
+        this[offset + i] = value & 255;
+        while (--i >= 0 && (mul *= 256)) {
+          this[offset + i] = (value / mul) & 255;
+        }
+        return offset + byteLength2;
+      };
+    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 =
+      function writeUInt8(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+        this[offset] = value & 255;
+        return offset + 1;
+      };
+    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE =
+      function writeUInt16LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        return offset + 2;
+      };
+    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE =
+      function writeUInt16BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value >>> 8;
+        this[offset + 1] = value & 255;
+        return offset + 2;
+      };
+    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE =
+      function writeUInt32LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset + 3] = value >>> 24;
+        this[offset + 2] = value >>> 16;
+        this[offset + 1] = value >>> 8;
+        this[offset] = value & 255;
+        return offset + 4;
+      };
+    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE =
+      function writeUInt32BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset] = value >>> 24;
+        this[offset + 1] = value >>> 16;
+        this[offset + 2] = value >>> 8;
+        this[offset + 3] = value & 255;
+        return offset + 4;
+      };
+    function wrtBigUInt64LE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      let hi = Number((value >> BigInt(32)) & BigInt(4294967295));
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      return offset;
+    }
+    function wrtBigUInt64BE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset + 7] = lo;
+      lo = lo >> 8;
+      buf[offset + 6] = lo;
+      lo = lo >> 8;
+      buf[offset + 5] = lo;
+      lo = lo >> 8;
+      buf[offset + 4] = lo;
+      let hi = Number((value >> BigInt(32)) & BigInt(4294967295));
+      buf[offset + 3] = hi;
+      hi = hi >> 8;
+      buf[offset + 2] = hi;
+      hi = hi >> 8;
+      buf[offset + 1] = hi;
+      hi = hi >> 8;
+      buf[offset] = hi;
+      return offset + 8;
+    }
+    Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(
+      function writeBigUInt64LE(value, offset = 0) {
+        return wrtBigUInt64LE(
+          this,
+          value,
+          offset,
+          BigInt(0),
+          BigInt("0xffffffffffffffff"),
+        );
+      },
+    );
+    Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(
+      function writeBigUInt64BE(value, offset = 0) {
+        return wrtBigUInt64BE(
+          this,
+          value,
+          offset,
+          BigInt(0),
+          BigInt("0xffffffffffffffff"),
+        );
+      },
+    );
+    Buffer2.prototype.writeIntLE = function writeIntLE(
+      value,
+      offset,
+      byteLength2,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = 0;
+      let mul = 1;
+      let sub = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (((value / mul) >> 0) - sub) & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeIntBE = function writeIntBE(
+      value,
+      offset,
+      byteLength2,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      let sub = 0;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (((value / mul) >> 0) - sub) & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0) value = 255 + value + 1;
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer2.prototype.writeInt16LE = function writeInt16LE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeInt16BE = function writeInt16BE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeInt32LE = function writeInt32LE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
+      return offset + 4;
+    };
+    Buffer2.prototype.writeInt32BE = function writeInt32BE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0) value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(
+      function writeBigInt64LE(value, offset = 0) {
+        return wrtBigUInt64LE(
+          this,
+          value,
+          offset,
+          -BigInt("0x8000000000000000"),
+          BigInt("0x7fffffffffffffff"),
+        );
+      },
+    );
+    Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(
+      function writeBigInt64BE(value, offset = 0) {
+        return wrtBigUInt64BE(
+          this,
+          value,
+          offset,
+          -BigInt("0x8000000000000000"),
+          BigInt("0x7fffffffffffffff"),
+        );
+      },
+    );
+    function checkIEEE754(buf, value, offset, ext, max, min) {
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+      if (offset < 0) throw new RangeError("Index out of range");
+    }
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(
+          buf,
+          value,
+          offset,
+          4,
+          34028234663852886e22,
+          -34028234663852886e22,
+        );
+      }
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    Buffer2.prototype.writeFloatLE = function writeFloatLE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      return writeFloat(this, value, offset, true, noAssert);
+    };
+    Buffer2.prototype.writeFloatBE = function writeFloatBE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      return writeFloat(this, value, offset, false, noAssert);
+    };
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(
+          buf,
+          value,
+          offset,
+          8,
+          17976931348623157e292,
+          -17976931348623157e292,
+        );
+      }
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      return writeDouble(this, value, offset, true, noAssert);
+    };
+    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(
+      value,
+      offset,
+      noAssert,
+    ) {
+      return writeDouble(this, value, offset, false, noAssert);
+    };
+    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer2.isBuffer(target))
+        throw new TypeError("argument should be a Buffer");
+      if (!start) start = 0;
+      if (!end && end !== 0) end = this.length;
+      if (targetStart >= target.length) targetStart = target.length;
+      if (!targetStart) targetStart = 0;
+      if (end > 0 && end < start) end = start;
+      if (end === start) return 0;
+      if (target.length === 0 || this.length === 0) return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length)
+        throw new RangeError("Index out of range");
+      if (end < 0) throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length) end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      const len = end - start;
+      if (
+        this === target &&
+        typeof Uint8Array.prototype.copyWithin === "function"
+      ) {
+        this.copyWithin(targetStart, start, end);
+      } else {
+        Uint8Array.prototype.set.call(
+          target,
+          this.subarray(start, end),
+          targetStart,
+        );
+      }
+      return len;
+    };
+    Buffer2.prototype.fill = function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          const code = val.charCodeAt(0);
+          if ((encoding === "utf8" && code < 128) || encoding === "latin1") {
+            val = code;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val) val = 0;
+      let i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+        const len = bytes.length;
+        if (len === 0) {
+          throw new TypeError(
+            'The value "' + val + '" is invalid for argument "value"',
+          );
+        }
+        for (i = 0; i < end - start; ++i) {
+          this[i + start] = bytes[i % len];
+        }
+      }
+      return this;
+    };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[sym] = class NodeError extends Base {
+        constructor() {
+          super();
+          Object.defineProperty(this, "message", {
+            value: getMessage.apply(this, arguments),
+            writable: true,
+            configurable: true,
+          });
+          this.name = `${this.name} [${sym}]`;
+          this.stack;
+          delete this.name;
+        }
+        get code() {
+          return sym;
+        }
+        set code(value) {
+          Object.defineProperty(this, "code", {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true,
+          });
+        }
+        toString() {
+          return `${this.name} [${sym}]: ${this.message}`;
+        }
+      };
+    }
+    E(
+      "ERR_BUFFER_OUT_OF_BOUNDS",
+      function (name) {
+        if (name) {
+          return `${name} is outside of buffer bounds`;
+        }
+        return "Attempt to access memory outside buffer bounds";
+      },
+      RangeError,
+    );
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      function (name, actual) {
+        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+      },
+      TypeError,
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      function (str, range, input) {
+        let msg = `The value of "${str}" is out of range.`;
+        let received = input;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          if (
+            input > BigInt(2) ** BigInt(32) ||
+            input < -(BigInt(2) ** BigInt(32))
+          ) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        }
+        msg += ` It must be ${range}. Received ${received}`;
+        return msg;
+      },
+      RangeError,
+    );
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const start = val[0] === "-" ? 1 : 0;
+      for (; i >= start + 4; i -= 3) {
+        res = `_${val.slice(i - 3, i)}${res}`;
+      }
+      return `${val.slice(0, i)}${res}`;
+    }
+    function checkBounds(buf, offset, byteLength2) {
+      validateNumber(offset, "offset");
+      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+        boundsError(offset, buf.length - (byteLength2 + 1));
+      }
+    }
+    function checkIntBI(value, min, max, buf, offset, byteLength2) {
+      if (value > max || value < min) {
+        const n = typeof min === "bigint" ? "n" : "";
+        let range;
+        if (byteLength2 > 3) {
+          if (min === 0 || min === BigInt(0)) {
+            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+          } else {
+            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+          }
+        } else {
+          range = `>= ${min}${n} and <= ${max}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+    }
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(
+          type || "offset",
+          "an integer",
+          value,
+        );
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value,
+      );
+    }
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2) return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes = [];
+      for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        if (codePoint > 55295 && codePoint < 57344) {
+          if (!leadSurrogate) {
+            if (codePoint > 56319) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            } else if (i + 1 === length) {
+              if ((units -= 3) > -1) bytes.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1) bytes.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint =
+            (((leadSurrogate - 55296) << 10) | (codePoint - 56320)) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1) bytes.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0) break;
+          bytes.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0) break;
+          bytes.push((codePoint >> 6) | 192, (codePoint & 63) | 128);
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0) break;
+          bytes.push(
+            (codePoint >> 12) | 224,
+            ((codePoint >> 6) & 63) | 128,
+            (codePoint & 63) | 128,
+          );
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0) break;
+          bytes.push(
+            (codePoint >> 18) | 240,
+            ((codePoint >> 12) & 63) | 128,
+            ((codePoint >> 6) & 63) | 128,
+            (codePoint & 63) | 128,
+          );
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes;
+    }
+    function asciiToBytes(str) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    function utf16leToBytes(str, units) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0) break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    function base64ToBytes(str) {
+      return base64.toByteArray(base64clean(str));
+    }
+    function blitBuffer(src, dst, offset, length) {
+      let i;
+      for (i = 0; i < length; ++i) {
+        if (i + offset >= dst.length || i >= src.length) break;
+        dst[i + offset] = src[i];
+      }
+      return i;
+    }
+    function isInstance(obj, type) {
+      return (
+        obj instanceof type ||
+        (obj != null &&
+          obj.constructor != null &&
+          obj.constructor.name != null &&
+          obj.constructor.name === type.name)
+      );
+    }
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    var hexSliceLookupTable = (function () {
+      const alphabet = "0123456789abcdef";
+      const table = new Array(256);
+      for (let i = 0; i < 16; ++i) {
+        const i16 = i * 16;
+        for (let j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table;
+    })();
+    function defineBigIntMethod(fn) {
+      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+    }
+    function BufferBigIntNotDefined() {
+      throw new Error("BigInt not supported");
+    }
+  },
+});
+
+// node_modules/memfs/lib/internal/buffer.js
+var require_buffer2 = __commonJS({
+  "node_modules/memfs/lib/internal/buffer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bufferFrom = exports.bufferAllocUnsafe = exports.Buffer = void 0;
+    var buffer_1 = require_buffer();
+    Object.defineProperty(exports, "Buffer", {
+      enumerable: true,
+      get: function () {
+        return buffer_1.Buffer;
+      },
+    });
+    function bufferV0P12Ponyfill(arg0, ...args) {
+      return new buffer_1.Buffer(arg0, ...args);
+    }
+    var bufferAllocUnsafe = buffer_1.Buffer.allocUnsafe || bufferV0P12Ponyfill;
+    exports.bufferAllocUnsafe = bufferAllocUnsafe;
+    var bufferFrom = buffer_1.Buffer.from || bufferV0P12Ponyfill;
+    exports.bufferFrom = bufferFrom;
+  },
+});
+
+// node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "node_modules/has-symbols/shams.js"(exports, module) {
+    "use strict";
+    module.exports = function hasSymbols() {
+      if (
+        typeof Symbol !== "function" ||
+        typeof Object.getOwnPropertySymbols !== "function"
+      ) {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (sym in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (
+        typeof Object.getOwnPropertyNames === "function" &&
+        Object.getOwnPropertyNames(obj).length !== 0
+      ) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  },
+});
+
+// node_modules/has-tostringtag/shams.js
+var require_shams2 = __commonJS({
+  "node_modules/has-tostringtag/shams.js"(exports, module) {
+    "use strict";
+    var hasSymbols = require_shams();
+    module.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  },
+});
+
+// node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "node_modules/has-symbols/index.js"(exports, module) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  },
+});
+
+// node_modules/has-proto/index.js
+var require_has_proto = __commonJS({
+  "node_modules/has-proto/index.js"(exports, module) {
+    "use strict";
+    var test = {
+      foo: {},
+    };
+    var $Object = Object;
+    module.exports = function hasProto() {
+      return (
+        { __proto__: test }.foo === test.foo &&
+        !({ __proto__: null } instanceof $Object)
+      );
+    };
+  },
+});
+
+// node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "node_modules/function-bind/implementation.js"(exports, module) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var slice = Array.prototype.slice;
+    var toStr = Object.prototype.toString;
+    var funcType = "[object Function]";
+    module.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slice.call(arguments, 1);
+      var bound;
+      var binder = function () {
+        if (this instanceof bound) {
+          var result = target.apply(this, args.concat(slice.call(arguments)));
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        } else {
+          return target.apply(that, args.concat(slice.call(arguments)));
+        }
+      };
+      var boundLength = Math.max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs.push("$" + i);
+      }
+      bound = Function(
+        "binder",
+        "return function (" +
+          boundArgs.join(",") +
+          "){ return binder.apply(this,arguments); }",
+      )(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  },
+});
+
+// node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "node_modules/function-bind/index.js"(exports, module) {
+    "use strict";
+    var implementation = require_implementation();
+    module.exports = Function.prototype.bind || implementation;
+  },
+});
+
+// node_modules/has/src/index.js
+var require_src = __commonJS({
+  "node_modules/has/src/index.js"(exports, module) {
+    "use strict";
+    var bind = require_function_bind();
+    module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
+  },
+});
+
+// node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "node_modules/get-intrinsic/index.js"(exports, module) {
+    "use strict";
+    var undefined2;
+    var $SyntaxError = SyntaxError;
+    var $Function = Function;
+    var $TypeError = TypeError;
+    var getEvalledConstructor = function (expressionSyntax) {
+      try {
+        return $Function(
+          '"use strict"; return (' + expressionSyntax + ").constructor;",
+        )();
+      } catch (e) {}
+    };
+    var $gOPD = Object.getOwnPropertyDescriptor;
+    if ($gOPD) {
+      try {
+        $gOPD({}, "");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    var throwTypeError = function () {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD
+      ? (function () {
+          try {
+            arguments.callee;
+            return throwTypeError;
+          } catch (calleeThrows) {
+            try {
+              return $gOPD(arguments, "callee").get;
+            } catch (gOPDthrows) {
+              return throwTypeError;
+            }
+          }
+        })()
+      : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var hasProto = require_has_proto()();
+    var getProto =
+      Object.getPrototypeOf ||
+      (hasProto
+        ? function (x) {
+            return x.__proto__;
+          }
+        : null);
+    var needsEval = {};
+    var TypedArray =
+      typeof Uint8Array === "undefined" || !getProto
+        ? undefined2
+        : getProto(Uint8Array);
+    var INTRINSICS = {
+      "%AggregateError%":
+        typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%":
+        typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%":
+        hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%":
+        typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%":
+        typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": EvalError,
+      "%Float32Array%":
+        typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%":
+        typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%":
+        typeof FinalizationRegistry === "undefined"
+          ? undefined2
+          : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%":
+        typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%":
+        typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%":
+        hasSymbols && getProto
+          ? getProto(getProto([][Symbol.iterator]()))
+          : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%":
+        typeof Map === "undefined" || !hasSymbols || !getProto
+          ? undefined2
+          : getProto(/* @__PURE__ */ new Map()[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": Object,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": RangeError,
+      "%ReferenceError%": ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%":
+        typeof Set === "undefined" || !hasSymbols || !getProto
+          ? undefined2
+          : getProto(/* @__PURE__ */ new Set()[Symbol.iterator]()),
+      "%SharedArrayBuffer%":
+        typeof SharedArrayBuffer === "undefined"
+          ? undefined2
+          : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%":
+        hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%":
+        typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%":
+        typeof Uint8ClampedArray === "undefined"
+          ? undefined2
+          : Uint8ClampedArray,
+      "%Uint16Array%":
+        typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%":
+        typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": [
+        "AsyncGeneratorFunction",
+        "prototype",
+        "prototype",
+      ],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"],
+    };
+    var bind = require_function_bind();
+    var hasOwn = require_src();
+    var $concat = bind.call(Function.call, Array.prototype.concat);
+    var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+    var $replace = bind.call(Function.call, String.prototype.replace);
+    var $strSlice = bind.call(Function.call, String.prototype.slice);
+    var $exec = bind.call(Function.call, RegExp.prototype.exec);
+    var rePropName =
+      /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError(
+          "invalid intrinsic syntax, expected closing `%`",
+        );
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError(
+          "invalid intrinsic syntax, expected opening `%`",
+        );
+      }
+      var result = [];
+      $replace(string, rePropName, function (match, number, quote, subString) {
+        result[result.length] = quote
+          ? $replace(subString, reEscapeChar, "$1")
+          : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError(
+            "intrinsic " +
+              name +
+              " exists, but is not available. Please file an issue!",
+          );
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value,
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError(
+          "`%` may not be present anywhere but at the beginning and end of the intrinsic name",
+        );
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic(
+        "%" + intrinsicBaseName + "%",
+        allowMissing,
+      );
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if (
+          (first === '"' ||
+            first === "'" ||
+            first === "`" ||
+            last === '"' ||
+            last === "'" ||
+            last === "`") &&
+          first !== last
+        ) {
+          throw new $SyntaxError(
+            "property names with quotes must have matching quotes",
+          );
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError(
+                "base intrinsic for " +
+                  name +
+                  " exists, but the property is not available.",
+              );
+            }
+            return void 0;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  },
+});
+
+// node_modules/call-bind/index.js
+var require_call_bind = __commonJS({
+  "node_modules/call-bind/index.js"(exports, module) {
+    "use strict";
+    var bind = require_function_bind();
+    var GetIntrinsic = require_get_intrinsic();
+    var $apply = GetIntrinsic("%Function.prototype.apply%");
+    var $call = GetIntrinsic("%Function.prototype.call%");
+    var $reflectApply =
+      GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
+    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var $max = GetIntrinsic("%Math.max%");
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = null;
+      }
+    }
+    module.exports = function callBind(originalFunction) {
+      var func = $reflectApply(bind, $call, arguments);
+      if ($gOPD && $defineProperty) {
+        var desc = $gOPD(func, "length");
+        if (desc.configurable) {
+          $defineProperty(func, "length", {
+            value:
+              1 + $max(0, originalFunction.length - (arguments.length - 1)),
+          });
+        }
+      }
+      return func;
+    };
+    var applyBind = function applyBind2() {
+      return $reflectApply(bind, $apply, arguments);
+    };
+    if ($defineProperty) {
+      $defineProperty(module.exports, "apply", { value: applyBind });
+    } else {
+      module.exports.apply = applyBind;
+    }
+  },
+});
+
+// node_modules/call-bind/callBound.js
+var require_callBound = __commonJS({
+  "node_modules/call-bind/callBound.js"(exports, module) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var callBind = require_call_bind();
+    var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+    module.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing);
+      if (
+        typeof intrinsic === "function" &&
+        $indexOf(name, ".prototype.") > -1
+      ) {
+        return callBind(intrinsic);
+      }
+      return intrinsic;
+    };
+  },
+});
+
+// node_modules/is-arguments/index.js
+var require_is_arguments = __commonJS({
+  "node_modules/is-arguments/index.js"(exports, module) {
+    "use strict";
+    var hasToStringTag = require_shams2()();
+    var callBound = require_callBound();
+    var $toString = callBound("Object.prototype.toString");
+    var isStandardArguments = function isArguments(value) {
+      if (
+        hasToStringTag &&
+        value &&
+        typeof value === "object" &&
+        Symbol.toStringTag in value
+      ) {
+        return false;
+      }
+      return $toString(value) === "[object Arguments]";
+    };
+    var isLegacyArguments = function isArguments(value) {
+      if (isStandardArguments(value)) {
+        return true;
+      }
+      return (
+        value !== null &&
+        typeof value === "object" &&
+        typeof value.length === "number" &&
+        value.length >= 0 &&
+        $toString(value) !== "[object Array]" &&
+        $toString(value.callee) === "[object Function]"
+      );
+    };
+    var supportsStandardArguments = (function () {
+      return isStandardArguments(arguments);
+    })();
+    isStandardArguments.isLegacyArguments = isLegacyArguments;
+    module.exports = supportsStandardArguments
+      ? isStandardArguments
+      : isLegacyArguments;
+  },
+});
+
+// node_modules/is-generator-function/index.js
+var require_is_generator_function = __commonJS({
+  "node_modules/is-generator-function/index.js"(exports, module) {
+    "use strict";
+    var toStr = Object.prototype.toString;
+    var fnToStr = Function.prototype.toString;
+    var isFnRegex = /^\s*(?:function)?\*/;
+    var hasToStringTag = require_shams2()();
+    var getProto = Object.getPrototypeOf;
+    var getGeneratorFunc = function () {
+      if (!hasToStringTag) {
+        return false;
+      }
+      try {
+        return Function("return function*() {}")();
+      } catch (e) {}
+    };
+    var GeneratorFunction;
+    module.exports = function isGeneratorFunction(fn) {
+      if (typeof fn !== "function") {
+        return false;
+      }
+      if (isFnRegex.test(fnToStr.call(fn))) {
+        return true;
+      }
+      if (!hasToStringTag) {
+        var str = toStr.call(fn);
+        return str === "[object GeneratorFunction]";
+      }
+      if (!getProto) {
+        return false;
+      }
+      if (typeof GeneratorFunction === "undefined") {
+        var generatorFunc = getGeneratorFunc();
+        GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
+      }
+      return getProto(fn) === GeneratorFunction;
+    };
+  },
+});
+
+// node_modules/is-callable/index.js
+var require_is_callable = __commonJS({
+  "node_modules/is-callable/index.js"(exports, module) {
+    "use strict";
+    var fnToStr = Function.prototype.toString;
+    var reflectApply =
+      typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+    var badArrayLike;
+    var isCallableMarker;
+    if (
+      typeof reflectApply === "function" &&
+      typeof Object.defineProperty === "function"
+    ) {
+      try {
+        badArrayLike = Object.defineProperty({}, "length", {
+          get: function () {
+            throw isCallableMarker;
+          },
+        });
+        isCallableMarker = {};
+        reflectApply(
+          function () {
+            throw 42;
+          },
+          null,
+          badArrayLike,
+        );
+      } catch (_) {
+        if (_ !== isCallableMarker) {
+          reflectApply = null;
+        }
+      }
+    } else {
+      reflectApply = null;
+    }
+    var constructorRegex = /^\s*class\b/;
+    var isES6ClassFn = function isES6ClassFunction(value) {
+      try {
+        var fnStr = fnToStr.call(value);
+        return constructorRegex.test(fnStr);
+      } catch (e) {
+        return false;
+      }
+    };
+    var tryFunctionObject = function tryFunctionToStr(value) {
+      try {
+        if (isES6ClassFn(value)) {
+          return false;
+        }
+        fnToStr.call(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    };
+    var toStr = Object.prototype.toString;
+    var objectClass = "[object Object]";
+    var fnClass = "[object Function]";
+    var genClass = "[object GeneratorFunction]";
+    var ddaClass = "[object HTMLAllCollection]";
+    var ddaClass2 = "[object HTML document.all class]";
+    var ddaClass3 = "[object HTMLCollection]";
+    var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
+    var isIE68 = !(0 in [,]);
+    var isDDA = function isDocumentDotAll() {
+      return false;
+    };
+    if (typeof document === "object") {
+      all = document.all;
+      if (toStr.call(all) === toStr.call(document.all)) {
+        isDDA = function isDocumentDotAll(value) {
+          if (
+            (isIE68 || !value) &&
+            (typeof value === "undefined" || typeof value === "object")
+          ) {
+            try {
+              var str = toStr.call(value);
+              return (
+                (str === ddaClass ||
+                  str === ddaClass2 ||
+                  str === ddaClass3 ||
+                  str === objectClass) &&
+                value("") == null
+              );
+            } catch (e) {}
+          }
+          return false;
+        };
+      }
+    }
+    var all;
+    module.exports = reflectApply
+      ? function isCallable(value) {
+          if (isDDA(value)) {
+            return true;
+          }
+          if (!value) {
+            return false;
+          }
+          if (typeof value !== "function" && typeof value !== "object") {
+            return false;
+          }
+          try {
+            reflectApply(value, null, badArrayLike);
+          } catch (e) {
+            if (e !== isCallableMarker) {
+              return false;
+            }
+          }
+          return !isES6ClassFn(value) && tryFunctionObject(value);
+        }
+      : function isCallable(value) {
+          if (isDDA(value)) {
+            return true;
+          }
+          if (!value) {
+            return false;
+          }
+          if (typeof value !== "function" && typeof value !== "object") {
+            return false;
+          }
+          if (hasToStringTag) {
+            return tryFunctionObject(value);
+          }
+          if (isES6ClassFn(value)) {
+            return false;
+          }
+          var strClass = toStr.call(value);
+          if (
+            strClass !== fnClass &&
+            strClass !== genClass &&
+            !/^\[object HTML/.test(strClass)
+          ) {
+            return false;
+          }
+          return tryFunctionObject(value);
+        };
+  },
+});
+
+// node_modules/for-each/index.js
+var require_for_each = __commonJS({
+  "node_modules/for-each/index.js"(exports, module) {
+    "use strict";
+    var isCallable = require_is_callable();
+    var toStr = Object.prototype.toString;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var forEachArray = function forEachArray2(array, iterator, receiver) {
+      for (var i = 0, len = array.length; i < len; i++) {
+        if (hasOwnProperty.call(array, i)) {
+          if (receiver == null) {
+            iterator(array[i], i, array);
+          } else {
+            iterator.call(receiver, array[i], i, array);
+          }
+        }
+      }
+    };
+    var forEachString = function forEachString2(string, iterator, receiver) {
+      for (var i = 0, len = string.length; i < len; i++) {
+        if (receiver == null) {
+          iterator(string.charAt(i), i, string);
+        } else {
+          iterator.call(receiver, string.charAt(i), i, string);
+        }
+      }
+    };
+    var forEachObject = function forEachObject2(object, iterator, receiver) {
+      for (var k in object) {
+        if (hasOwnProperty.call(object, k)) {
+          if (receiver == null) {
+            iterator(object[k], k, object);
+          } else {
+            iterator.call(receiver, object[k], k, object);
+          }
+        }
+      }
+    };
+    var forEach = function forEach2(list, iterator, thisArg) {
+      if (!isCallable(iterator)) {
+        throw new TypeError("iterator must be a function");
+      }
+      var receiver;
+      if (arguments.length >= 3) {
+        receiver = thisArg;
+      }
+      if (toStr.call(list) === "[object Array]") {
+        forEachArray(list, iterator, receiver);
+      } else if (typeof list === "string") {
+        forEachString(list, iterator, receiver);
+      } else {
+        forEachObject(list, iterator, receiver);
+      }
+    };
+    module.exports = forEach;
+  },
+});
+
+// node_modules/available-typed-arrays/index.js
+var require_available_typed_arrays = __commonJS({
+  "node_modules/available-typed-arrays/index.js"(exports, module) {
+    "use strict";
+    var possibleNames = [
+      "BigInt64Array",
+      "BigUint64Array",
+      "Float32Array",
+      "Float64Array",
+      "Int16Array",
+      "Int32Array",
+      "Int8Array",
+      "Uint16Array",
+      "Uint32Array",
+      "Uint8Array",
+      "Uint8ClampedArray",
+    ];
+    var g = typeof globalThis === "undefined" ? global : globalThis;
+    module.exports = function availableTypedArrays() {
+      var out = [];
+      for (var i = 0; i < possibleNames.length; i++) {
+        if (typeof g[possibleNames[i]] === "function") {
+          out[out.length] = possibleNames[i];
+        }
+      }
+      return out;
+    };
+  },
+});
+
+// node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "node_modules/gopd/index.js"(exports, module) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module.exports = $gOPD;
+  },
+});
+
+// node_modules/which-typed-array/index.js
+var require_which_typed_array = __commonJS({
+  "node_modules/which-typed-array/index.js"(exports, module) {
+    "use strict";
+    var forEach = require_for_each();
+    var availableTypedArrays = require_available_typed_arrays();
+    var callBind = require_call_bind();
+    var callBound = require_callBound();
+    var gOPD = require_gopd();
+    var $toString = callBound("Object.prototype.toString");
+    var hasToStringTag = require_shams2()();
+    var g = typeof globalThis === "undefined" ? global : globalThis;
+    var typedArrays = availableTypedArrays();
+    var $slice = callBound("String.prototype.slice");
+    var getPrototypeOf = Object.getPrototypeOf;
+    var $indexOf =
+      callBound("Array.prototype.indexOf", true) ||
+      function indexOf(array, value) {
+        for (var i = 0; i < array.length; i += 1) {
+          if (array[i] === value) {
+            return i;
+          }
+        }
+        return -1;
+      };
+    var cache = { __proto__: null };
+    if (hasToStringTag && gOPD && getPrototypeOf) {
+      forEach(typedArrays, function (typedArray) {
+        var arr = new g[typedArray]();
+        if (Symbol.toStringTag in arr) {
+          var proto = getPrototypeOf(arr);
+          var descriptor = gOPD(proto, Symbol.toStringTag);
+          if (!descriptor) {
+            var superProto = getPrototypeOf(proto);
+            descriptor = gOPD(superProto, Symbol.toStringTag);
+          }
+          cache["$" + typedArray] = callBind(descriptor.get);
+        }
+      });
+    } else {
+      forEach(typedArrays, function (typedArray) {
+        var arr = new g[typedArray]();
+        cache["$" + typedArray] = callBind(arr.slice);
+      });
+    }
+    var tryTypedArrays = function tryAllTypedArrays(value) {
+      var found = false;
+      forEach(cache, function (getter, typedArray) {
+        if (!found) {
+          try {
+            if ("$" + getter(value) === typedArray) {
+              found = $slice(typedArray, 1);
+            }
+          } catch (e) {}
+        }
+      });
+      return found;
+    };
+    var trySlices = function tryAllSlices(value) {
+      var found = false;
+      forEach(cache, function (getter, name) {
+        if (!found) {
+          try {
+            getter(value);
+            found = $slice(name, 1);
+          } catch (e) {}
+        }
+      });
+      return found;
+    };
+    module.exports = function whichTypedArray(value) {
+      if (!value || typeof value !== "object") {
+        return false;
+      }
+      if (!hasToStringTag) {
+        var tag = $slice($toString(value), 8, -1);
+        if ($indexOf(typedArrays, tag) > -1) {
+          return tag;
+        }
+        if (tag !== "Object") {
+          return false;
+        }
+        return trySlices(value);
+      }
+      if (!gOPD) {
+        return null;
+      }
+      return tryTypedArrays(value);
+    };
+  },
+});
+
+// node_modules/is-typed-array/index.js
+var require_is_typed_array = __commonJS({
+  "node_modules/is-typed-array/index.js"(exports, module) {
+    "use strict";
+    var whichTypedArray = require_which_typed_array();
+    module.exports = function isTypedArray(value) {
+      return !!whichTypedArray(value);
+    };
+  },
+});
+
+// node_modules/util/support/types.js
+var require_types = __commonJS({
+  "node_modules/util/support/types.js"(exports) {
+    "use strict";
+    var isArgumentsObject = require_is_arguments();
+    var isGeneratorFunction = require_is_generator_function();
+    var whichTypedArray = require_which_typed_array();
+    var isTypedArray = require_is_typed_array();
+    function uncurryThis(f) {
+      return f.call.bind(f);
+    }
+    var BigIntSupported = typeof BigInt !== "undefined";
+    var SymbolSupported = typeof Symbol !== "undefined";
+    var ObjectToString = uncurryThis(Object.prototype.toString);
+    var numberValue = uncurryThis(Number.prototype.valueOf);
+    var stringValue = uncurryThis(String.prototype.valueOf);
+    var booleanValue = uncurryThis(Boolean.prototype.valueOf);
+    if (BigIntSupported) {
+      bigIntValue = uncurryThis(BigInt.prototype.valueOf);
+    }
+    var bigIntValue;
+    if (SymbolSupported) {
+      symbolValue = uncurryThis(Symbol.prototype.valueOf);
+    }
+    var symbolValue;
+    function checkBoxedPrimitive(value, prototypeValueOf) {
+      if (typeof value !== "object") {
+        return false;
+      }
+      try {
+        prototypeValueOf(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    exports.isArgumentsObject = isArgumentsObject;
+    exports.isGeneratorFunction = isGeneratorFunction;
+    exports.isTypedArray = isTypedArray;
+    function isPromise(input) {
+      return (
+        (typeof Promise !== "undefined" && input instanceof Promise) ||
+        (input !== null &&
+          typeof input === "object" &&
+          typeof input.then === "function" &&
+          typeof input.catch === "function")
+      );
+    }
+    exports.isPromise = isPromise;
+    function isArrayBufferView(value) {
+      if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+        return ArrayBuffer.isView(value);
+      }
+      return isTypedArray(value) || isDataView(value);
+    }
+    exports.isArrayBufferView = isArrayBufferView;
+    function isUint8Array(value) {
+      return whichTypedArray(value) === "Uint8Array";
+    }
+    exports.isUint8Array = isUint8Array;
+    function isUint8ClampedArray(value) {
+      return whichTypedArray(value) === "Uint8ClampedArray";
+    }
+    exports.isUint8ClampedArray = isUint8ClampedArray;
+    function isUint16Array(value) {
+      return whichTypedArray(value) === "Uint16Array";
+    }
+    exports.isUint16Array = isUint16Array;
+    function isUint32Array(value) {
+      return whichTypedArray(value) === "Uint32Array";
+    }
+    exports.isUint32Array = isUint32Array;
+    function isInt8Array(value) {
+      return whichTypedArray(value) === "Int8Array";
+    }
+    exports.isInt8Array = isInt8Array;
+    function isInt16Array(value) {
+      return whichTypedArray(value) === "Int16Array";
+    }
+    exports.isInt16Array = isInt16Array;
+    function isInt32Array(value) {
+      return whichTypedArray(value) === "Int32Array";
+    }
+    exports.isInt32Array = isInt32Array;
+    function isFloat32Array(value) {
+      return whichTypedArray(value) === "Float32Array";
+    }
+    exports.isFloat32Array = isFloat32Array;
+    function isFloat64Array(value) {
+      return whichTypedArray(value) === "Float64Array";
+    }
+    exports.isFloat64Array = isFloat64Array;
+    function isBigInt64Array(value) {
+      return whichTypedArray(value) === "BigInt64Array";
+    }
+    exports.isBigInt64Array = isBigInt64Array;
+    function isBigUint64Array(value) {
+      return whichTypedArray(value) === "BigUint64Array";
+    }
+    exports.isBigUint64Array = isBigUint64Array;
+    function isMapToString(value) {
+      return ObjectToString(value) === "[object Map]";
+    }
+    isMapToString.working =
+      typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
+    function isMap(value) {
+      if (typeof Map === "undefined") {
+        return false;
+      }
+      return isMapToString.working
+        ? isMapToString(value)
+        : value instanceof Map;
+    }
+    exports.isMap = isMap;
+    function isSetToString(value) {
+      return ObjectToString(value) === "[object Set]";
+    }
+    isSetToString.working =
+      typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
+    function isSet(value) {
+      if (typeof Set === "undefined") {
+        return false;
+      }
+      return isSetToString.working
+        ? isSetToString(value)
+        : value instanceof Set;
+    }
+    exports.isSet = isSet;
+    function isWeakMapToString(value) {
+      return ObjectToString(value) === "[object WeakMap]";
+    }
+    isWeakMapToString.working =
+      typeof WeakMap !== "undefined" &&
+      isWeakMapToString(/* @__PURE__ */ new WeakMap());
+    function isWeakMap(value) {
+      if (typeof WeakMap === "undefined") {
+        return false;
+      }
+      return isWeakMapToString.working
+        ? isWeakMapToString(value)
+        : value instanceof WeakMap;
+    }
+    exports.isWeakMap = isWeakMap;
+    function isWeakSetToString(value) {
+      return ObjectToString(value) === "[object WeakSet]";
+    }
+    isWeakSetToString.working =
+      typeof WeakSet !== "undefined" &&
+      isWeakSetToString(/* @__PURE__ */ new WeakSet());
+    function isWeakSet(value) {
+      return isWeakSetToString(value);
+    }
+    exports.isWeakSet = isWeakSet;
+    function isArrayBufferToString(value) {
+      return ObjectToString(value) === "[object ArrayBuffer]";
+    }
+    isArrayBufferToString.working =
+      typeof ArrayBuffer !== "undefined" &&
+      isArrayBufferToString(new ArrayBuffer());
+    function isArrayBuffer(value) {
+      if (typeof ArrayBuffer === "undefined") {
+        return false;
+      }
+      return isArrayBufferToString.working
+        ? isArrayBufferToString(value)
+        : value instanceof ArrayBuffer;
+    }
+    exports.isArrayBuffer = isArrayBuffer;
+    function isDataViewToString(value) {
+      return ObjectToString(value) === "[object DataView]";
+    }
+    isDataViewToString.working =
+      typeof ArrayBuffer !== "undefined" &&
+      typeof DataView !== "undefined" &&
+      isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));
+    function isDataView(value) {
+      if (typeof DataView === "undefined") {
+        return false;
+      }
+      return isDataViewToString.working
+        ? isDataViewToString(value)
+        : value instanceof DataView;
+    }
+    exports.isDataView = isDataView;
+    var SharedArrayBufferCopy =
+      typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0;
+    function isSharedArrayBufferToString(value) {
+      return ObjectToString(value) === "[object SharedArrayBuffer]";
+    }
+    function isSharedArrayBuffer(value) {
+      if (typeof SharedArrayBufferCopy === "undefined") {
+        return false;
+      }
+      if (typeof isSharedArrayBufferToString.working === "undefined") {
+        isSharedArrayBufferToString.working = isSharedArrayBufferToString(
+          new SharedArrayBufferCopy(),
+        );
+      }
+      return isSharedArrayBufferToString.working
+        ? isSharedArrayBufferToString(value)
+        : value instanceof SharedArrayBufferCopy;
+    }
+    exports.isSharedArrayBuffer = isSharedArrayBuffer;
+    function isAsyncFunction(value) {
+      return ObjectToString(value) === "[object AsyncFunction]";
+    }
+    exports.isAsyncFunction = isAsyncFunction;
+    function isMapIterator(value) {
+      return ObjectToString(value) === "[object Map Iterator]";
+    }
+    exports.isMapIterator = isMapIterator;
+    function isSetIterator(value) {
+      return ObjectToString(value) === "[object Set Iterator]";
+    }
+    exports.isSetIterator = isSetIterator;
+    function isGeneratorObject(value) {
+      return ObjectToString(value) === "[object Generator]";
+    }
+    exports.isGeneratorObject = isGeneratorObject;
+    function isWebAssemblyCompiledModule(value) {
+      return ObjectToString(value) === "[object WebAssembly.Module]";
+    }
+    exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
+    function isNumberObject(value) {
+      return checkBoxedPrimitive(value, numberValue);
+    }
+    exports.isNumberObject = isNumberObject;
+    function isStringObject(value) {
+      return checkBoxedPrimitive(value, stringValue);
+    }
+    exports.isStringObject = isStringObject;
+    function isBooleanObject(value) {
+      return checkBoxedPrimitive(value, booleanValue);
+    }
+    exports.isBooleanObject = isBooleanObject;
+    function isBigIntObject(value) {
+      return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
+    }
+    exports.isBigIntObject = isBigIntObject;
+    function isSymbolObject(value) {
+      return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
+    }
+    exports.isSymbolObject = isSymbolObject;
+    function isBoxedPrimitive(value) {
+      return (
+        isNumberObject(value) ||
+        isStringObject(value) ||
+        isBooleanObject(value) ||
+        isBigIntObject(value) ||
+        isSymbolObject(value)
+      );
+    }
+    exports.isBoxedPrimitive = isBoxedPrimitive;
+    function isAnyArrayBuffer(value) {
+      return (
+        typeof Uint8Array !== "undefined" &&
+        (isArrayBuffer(value) || isSharedArrayBuffer(value))
+      );
+    }
+    exports.isAnyArrayBuffer = isAnyArrayBuffer;
+    ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(
+      function (method) {
+        Object.defineProperty(exports, method, {
+          enumerable: false,
+          value: function () {
+            throw new Error(method + " is not supported in userland");
+          },
+        });
+      },
+    );
+  },
+});
+
+// node_modules/util/support/isBufferBrowser.js
+var require_isBufferBrowser = __commonJS({
+  "node_modules/util/support/isBufferBrowser.js"(exports, module) {
+    module.exports = function isBuffer(arg) {
+      return (
+        arg &&
+        typeof arg === "object" &&
+        typeof arg.copy === "function" &&
+        typeof arg.fill === "function" &&
+        typeof arg.readUInt8 === "function"
+      );
+    };
+  },
+});
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module) {
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true,
+            },
+          });
+        }
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function () {};
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  },
+});
+
+// node_modules/util/util.js
+var require_util = __commonJS({
+  "node_modules/util/util.js"(exports) {
+    var getOwnPropertyDescriptors =
+      Object.getOwnPropertyDescriptors ||
+      function getOwnPropertyDescriptors2(obj) {
+        var keys = Object.keys(obj);
+        var descriptors = {};
+        for (var i = 0; i < keys.length; i++) {
+          descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+        }
+        return descriptors;
+      };
+    var formatRegExp = /%[sdj%]/g;
+    exports.format = function (f) {
+      if (!isString(f)) {
+        var objects = [];
+        for (var i = 0; i < arguments.length; i++) {
+          objects.push(inspect(arguments[i]));
+        }
+        return objects.join(" ");
+      }
+      var i = 1;
+      var args = arguments;
+      var len = args.length;
+      var str = String(f).replace(formatRegExp, function (x2) {
+        if (x2 === "%%") return "%";
+        if (i >= len) return x2;
+        switch (x2) {
+          case "%s":
+            return String(args[i++]);
+          case "%d":
+            return Number(args[i++]);
+          case "%j":
+            try {
+              return JSON.stringify(args[i++]);
+            } catch (_) {
+              return "[Circular]";
+            }
+          default:
+            return x2;
+        }
+      });
+      for (var x = args[i]; i < len; x = args[++i]) {
+        if (isNull(x) || !isObject(x)) {
+          str += " " + x;
+        } else {
+          str += " " + inspect(x);
+        }
+      }
+      return str;
+    };
+    exports.deprecate = function (fn, msg) {
+      if (typeof process !== "undefined" && process.noDeprecation === true) {
+        return fn;
+      }
+      if (typeof process === "undefined") {
+        return function () {
+          return exports.deprecate(fn, msg).apply(this, arguments);
+        };
+      }
+      var warned = false;
+      function deprecated() {
+        if (!warned) {
+          if (process.throwDeprecation) {
+            throw new Error(msg);
+          } else if (process.traceDeprecation) {
+            console.trace(msg);
+          } else {
+            console.error(msg);
+          }
+          warned = true;
+        }
+        return fn.apply(this, arguments);
+      }
+      return deprecated;
+    };
+    var debugs = {};
+    var debugEnvRegex = /^$/;
+    if (process.env.NODE_DEBUG) {
+      debugEnv = process.env.NODE_DEBUG;
+      debugEnv = debugEnv
+        .replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/,/g, "$|^")
+        .toUpperCase();
+      debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
+    }
+    var debugEnv;
+    exports.debuglog = function (set) {
+      set = set.toUpperCase();
+      if (!debugs[set]) {
+        if (debugEnvRegex.test(set)) {
+          var pid = process.pid;
+          debugs[set] = function () {
+            var msg = exports.format.apply(exports, arguments);
+            console.error("%s %d: %s", set, pid, msg);
+          };
+        } else {
+          debugs[set] = function () {};
+        }
+      }
+      return debugs[set];
+    };
+    function inspect(obj, opts) {
+      var ctx = {
+        seen: [],
+        stylize: stylizeNoColor,
+      };
+      if (arguments.length >= 3) ctx.depth = arguments[2];
+      if (arguments.length >= 4) ctx.colors = arguments[3];
+      if (isBoolean(opts)) {
+        ctx.showHidden = opts;
+      } else if (opts) {
+        exports._extend(ctx, opts);
+      }
+      if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+      if (isUndefined(ctx.depth)) ctx.depth = 2;
+      if (isUndefined(ctx.colors)) ctx.colors = false;
+      if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+      if (ctx.colors) ctx.stylize = stylizeWithColor;
+      return formatValue(ctx, obj, ctx.depth);
+    }
+    exports.inspect = inspect;
+    inspect.colors = {
+      bold: [1, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      white: [37, 39],
+      grey: [90, 39],
+      black: [30, 39],
+      blue: [34, 39],
+      cyan: [36, 39],
+      green: [32, 39],
+      magenta: [35, 39],
+      red: [31, 39],
+      yellow: [33, 39],
+    };
+    inspect.styles = {
+      special: "cyan",
+      number: "yellow",
+      boolean: "yellow",
+      undefined: "grey",
+      null: "bold",
+      string: "green",
+      date: "magenta",
+      // "name": intentionally not styling
+      regexp: "red",
+    };
+    function stylizeWithColor(str, styleType) {
+      var style = inspect.styles[styleType];
+      if (style) {
+        return (
+          "\x1B[" +
+          inspect.colors[style][0] +
+          "m" +
+          str +
+          "\x1B[" +
+          inspect.colors[style][1] +
+          "m"
+        );
+      } else {
+        return str;
+      }
+    }
+    function stylizeNoColor(str, styleType) {
+      return str;
+    }
+    function arrayToHash(array) {
+      var hash = {};
+      array.forEach(function (val, idx) {
+        hash[val] = true;
+      });
+      return hash;
+    }
+    function formatValue(ctx, value, recurseTimes) {
+      if (
+        ctx.customInspect &&
+        value &&
+        isFunction(value.inspect) && // Filter out the util module, it's inspect function is special
+        value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
+        !(value.constructor && value.constructor.prototype === value)
+      ) {
+        var ret = value.inspect(recurseTimes, ctx);
+        if (!isString(ret)) {
+          ret = formatValue(ctx, ret, recurseTimes);
+        }
+        return ret;
+      }
+      var primitive = formatPrimitive(ctx, value);
+      if (primitive) {
+        return primitive;
+      }
+      var keys = Object.keys(value);
+      var visibleKeys = arrayToHash(keys);
+      if (ctx.showHidden) {
+        keys = Object.getOwnPropertyNames(value);
+      }
+      if (
+        isError(value) &&
+        (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)
+      ) {
+        return formatError(value);
+      }
+      if (keys.length === 0) {
+        if (isFunction(value)) {
+          var name = value.name ? ": " + value.name : "";
+          return ctx.stylize("[Function" + name + "]", "special");
+        }
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        }
+        if (isDate(value)) {
+          return ctx.stylize(Date.prototype.toString.call(value), "date");
+        }
+        if (isError(value)) {
+          return formatError(value);
+        }
+      }
+      var base = "",
+        array = false,
+        braces = ["{", "}"];
+      if (isArray(value)) {
+        array = true;
+        braces = ["[", "]"];
+      }
+      if (isFunction(value)) {
+        var n = value.name ? ": " + value.name : "";
+        base = " [Function" + n + "]";
+      }
+      if (isRegExp(value)) {
+        base = " " + RegExp.prototype.toString.call(value);
+      }
+      if (isDate(value)) {
+        base = " " + Date.prototype.toUTCString.call(value);
+      }
+      if (isError(value)) {
+        base = " " + formatError(value);
+      }
+      if (keys.length === 0 && (!array || value.length == 0)) {
+        return braces[0] + base + braces[1];
+      }
+      if (recurseTimes < 0) {
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        } else {
+          return ctx.stylize("[Object]", "special");
+        }
+      }
+      ctx.seen.push(value);
+      var output;
+      if (array) {
+        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+      } else {
+        output = keys.map(function (key) {
+          return formatProperty(
+            ctx,
+            value,
+            recurseTimes,
+            visibleKeys,
+            key,
+            array,
+          );
+        });
+      }
+      ctx.seen.pop();
+      return reduceToSingleString(output, base, braces);
+    }
+    function formatPrimitive(ctx, value) {
+      if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
+      if (isString(value)) {
+        var simple =
+          "'" +
+          JSON.stringify(value)
+            .replace(/^"|"$/g, "")
+            .replace(/'/g, "\\'")
+            .replace(/\\"/g, '"') +
+          "'";
+        return ctx.stylize(simple, "string");
+      }
+      if (isNumber(value)) return ctx.stylize("" + value, "number");
+      if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
+      if (isNull(value)) return ctx.stylize("null", "null");
+    }
+    function formatError(value) {
+      return "[" + Error.prototype.toString.call(value) + "]";
+    }
+    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+      var output = [];
+      for (var i = 0, l = value.length; i < l; ++i) {
+        if (hasOwnProperty(value, String(i))) {
+          output.push(
+            formatProperty(
+              ctx,
+              value,
+              recurseTimes,
+              visibleKeys,
+              String(i),
+              true,
+            ),
+          );
+        } else {
+          output.push("");
+        }
+      }
+      keys.forEach(function (key) {
+        if (!key.match(/^\d+$/)) {
+          output.push(
+            formatProperty(ctx, value, recurseTimes, visibleKeys, key, true),
+          );
+        }
+      });
+      return output;
+    }
+    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+      var name, str, desc;
+      desc = Object.getOwnPropertyDescriptor(value, key) || {
+        value: value[key],
+      };
+      if (desc.get) {
+        if (desc.set) {
+          str = ctx.stylize("[Getter/Setter]", "special");
+        } else {
+          str = ctx.stylize("[Getter]", "special");
+        }
+      } else {
+        if (desc.set) {
+          str = ctx.stylize("[Setter]", "special");
+        }
+      }
+      if (!hasOwnProperty(visibleKeys, key)) {
+        name = "[" + key + "]";
+      }
+      if (!str) {
+        if (ctx.seen.indexOf(desc.value) < 0) {
+          if (isNull(recurseTimes)) {
+            str = formatValue(ctx, desc.value, null);
+          } else {
+            str = formatValue(ctx, desc.value, recurseTimes - 1);
+          }
+          if (str.indexOf("\n") > -1) {
+            if (array) {
+              str = str
+                .split("\n")
+                .map(function (line) {
+                  return "  " + line;
+                })
+                .join("\n")
+                .slice(2);
+            } else {
+              str =
+                "\n" +
+                str
+                  .split("\n")
+                  .map(function (line) {
+                    return "   " + line;
+                  })
+                  .join("\n");
+            }
+          }
+        } else {
+          str = ctx.stylize("[Circular]", "special");
+        }
+      }
+      if (isUndefined(name)) {
+        if (array && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify("" + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.slice(1, -1);
+          name = ctx.stylize(name, "name");
+        } else {
+          name = name
+            .replace(/'/g, "\\'")
+            .replace(/\\"/g, '"')
+            .replace(/(^"|"$)/g, "'");
+          name = ctx.stylize(name, "string");
+        }
+      }
+      return name + ": " + str;
+    }
+    function reduceToSingleString(output, base, braces) {
+      var numLinesEst = 0;
+      var length = output.reduce(function (prev, cur) {
+        numLinesEst++;
+        if (cur.indexOf("\n") >= 0) numLinesEst++;
+        return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0);
+      if (length > 60) {
+        return (
+          braces[0] +
+          (base === "" ? "" : base + "\n ") +
+          " " +
+          output.join(",\n  ") +
+          " " +
+          braces[1]
+        );
+      }
+      return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+    }
+    exports.types = require_types();
+    function isArray(ar) {
+      return Array.isArray(ar);
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return isObject(re) && objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    exports.types.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return isObject(d) && objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    exports.types.isDate = isDate;
+    function isError(e) {
+      return (
+        isObject(e) &&
+        (objectToString(e) === "[object Error]" || e instanceof Error)
+      );
+    }
+    exports.isError = isError;
+    exports.types.isNativeError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return (
+        arg === null ||
+        typeof arg === "boolean" ||
+        typeof arg === "number" ||
+        typeof arg === "string" ||
+        typeof arg === "symbol" || // ES6 symbol
+        typeof arg === "undefined"
+      );
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = require_isBufferBrowser();
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+    function pad(n) {
+      return n < 10 ? "0" + n.toString(10) : n.toString(10);
+    }
+    var months = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec",
+    ];
+    function timestamp() {
+      var d = /* @__PURE__ */ new Date();
+      var time = [
+        pad(d.getHours()),
+        pad(d.getMinutes()),
+        pad(d.getSeconds()),
+      ].join(":");
+      return [d.getDate(), months[d.getMonth()], time].join(" ");
+    }
+    exports.log = function () {
+      console.log(
+        "%s - %s",
+        timestamp(),
+        exports.format.apply(exports, arguments),
+      );
+    };
+    exports.inherits = require_inherits_browser();
+    exports._extend = function (origin, add) {
+      if (!add || !isObject(add)) return origin;
+      var keys = Object.keys(add);
+      var i = keys.length;
+      while (i--) {
+        origin[keys[i]] = add[keys[i]];
+      }
+      return origin;
+    };
+    function hasOwnProperty(obj, prop) {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+    var kCustomPromisifiedSymbol =
+      typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+    exports.promisify = function promisify(original) {
+      if (typeof original !== "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+        var fn = original[kCustomPromisifiedSymbol];
+        if (typeof fn !== "function") {
+          throw new TypeError(
+            'The "util.promisify.custom" argument must be of type Function',
+          );
+        }
+        Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+          value: fn,
+          enumerable: false,
+          writable: false,
+          configurable: true,
+        });
+        return fn;
+      }
+      function fn() {
+        var promiseResolve, promiseReject;
+        var promise = new Promise(function (resolve, reject) {
+          promiseResolve = resolve;
+          promiseReject = reject;
+        });
+        var args = [];
+        for (var i = 0; i < arguments.length; i++) {
+          args.push(arguments[i]);
+        }
+        args.push(function (err, value) {
+          if (err) {
+            promiseReject(err);
+          } else {
+            promiseResolve(value);
+          }
+        });
+        try {
+          original.apply(this, args);
+        } catch (err) {
+          promiseReject(err);
+        }
+        return promise;
+      }
+      Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+      if (kCustomPromisifiedSymbol)
+        Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+          value: fn,
+          enumerable: false,
+          writable: false,
+          configurable: true,
+        });
+      return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
+    };
+    exports.promisify.custom = kCustomPromisifiedSymbol;
+    function callbackifyOnRejected(reason, cb) {
+      if (!reason) {
+        var newReason = new Error("Promise was rejected with a falsy value");
+        newReason.reason = reason;
+        reason = newReason;
+      }
+      return cb(reason);
+    }
+    function callbackify(original) {
+      if (typeof original !== "function") {
+        throw new TypeError('The "original" argument must be of type Function');
+      }
+      function callbackified() {
+        var args = [];
+        for (var i = 0; i < arguments.length; i++) {
+          args.push(arguments[i]);
+        }
+        var maybeCb = args.pop();
+        if (typeof maybeCb !== "function") {
+          throw new TypeError("The last argument must be of type Function");
+        }
+        var self = this;
+        var cb = function () {
+          return maybeCb.apply(self, arguments);
+        };
+        original.apply(this, args).then(
+          function (ret) {
+            process.nextTick(cb.bind(null, null, ret));
+          },
+          function (rej) {
+            process.nextTick(callbackifyOnRejected.bind(null, rej, cb));
+          },
+        );
+      }
+      Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+      Object.defineProperties(
+        callbackified,
+        getOwnPropertyDescriptors(original),
+      );
+      return callbackified;
+    }
+    exports.callbackify = callbackify;
+  },
+});
+
+// node_modules/assert/build/internal/errors.js
+var require_errors = __commonJS({
+  "node_modules/assert/build/internal/errors.js"(exports, module) {
+    "use strict";
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 &&
+            typeof Symbol === "function" &&
+            obj2.constructor === Symbol &&
+            obj2 !== Symbol.prototype
+            ? "symbol"
+            : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      }
+      return _assertThisInitialized(self);
+    }
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError(
+          "this hasn't been initialised - super() hasn't been called",
+        );
+      }
+      return self;
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf
+        ? Object.getPrototypeOf
+        : function _getPrototypeOf2(o2) {
+            return o2.__proto__ || Object.getPrototypeOf(o2);
+          };
+      return _getPrototypeOf(o);
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError(
+          "Super expression must either be null or a function",
+        );
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: { value: subClass, writable: true, configurable: true },
+      });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf =
+        Object.setPrototypeOf ||
+        function _setPrototypeOf2(o2, p2) {
+          o2.__proto__ = p2;
+          return o2;
+        };
+      return _setPrototypeOf(o, p);
+    }
+    var codes = {};
+    var assert;
+    var util;
+    function createErrorType(code, message, Base) {
+      if (!Base) {
+        Base = Error;
+      }
+      function getMessage(arg1, arg2, arg3) {
+        if (typeof message === "string") {
+          return message;
+        } else {
+          return message(arg1, arg2, arg3);
+        }
+      }
+      var NodeError = /* @__PURE__ */ (function (_Base) {
+        _inherits(NodeError2, _Base);
+        function NodeError2(arg1, arg2, arg3) {
+          var _this;
+          _classCallCheck(this, NodeError2);
+          _this = _possibleConstructorReturn(
+            this,
+            _getPrototypeOf(NodeError2).call(
+              this,
+              getMessage(arg1, arg2, arg3),
+            ),
+          );
+          _this.code = code;
+          return _this;
+        }
+        return NodeError2;
+      })(Base);
+      codes[code] = NodeError;
+    }
+    function oneOf(expected, thing) {
+      if (Array.isArray(expected)) {
+        var len = expected.length;
+        expected = expected.map(function (i) {
+          return String(i);
+        });
+        if (len > 2) {
+          return (
+            "one of "
+              .concat(thing, " ")
+              .concat(expected.slice(0, len - 1).join(", "), ", or ") +
+            expected[len - 1]
+          );
+        } else if (len === 2) {
+          return "one of "
+            .concat(thing, " ")
+            .concat(expected[0], " or ")
+            .concat(expected[1]);
+        } else {
+          return "of ".concat(thing, " ").concat(expected[0]);
+        }
+      } else {
+        return "of ".concat(thing, " ").concat(String(expected));
+      }
+    }
+    function startsWith(str, search, pos) {
+      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+    }
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function includes(str, search, start) {
+      if (typeof start !== "number") {
+        start = 0;
+      }
+      if (start + search.length > str.length) {
+        return false;
+      } else {
+        return str.indexOf(search, start) !== -1;
+      }
+    }
+    createErrorType(
+      "ERR_AMBIGUOUS_ARGUMENT",
+      'The "%s" argument is ambiguous. %s',
+      TypeError,
+    );
+    createErrorType(
+      "ERR_INVALID_ARG_TYPE",
+      function (name, expected, actual) {
+        if (assert === void 0) assert = require_assert();
+        assert(typeof name === "string", "'name' must be a string");
+        var determiner;
+        if (typeof expected === "string" && startsWith(expected, "not ")) {
+          determiner = "must not be";
+          expected = expected.replace(/^not /, "");
+        } else {
+          determiner = "must be";
+        }
+        var msg;
+        if (endsWith(name, " argument")) {
+          msg = "The "
+            .concat(name, " ")
+            .concat(determiner, " ")
+            .concat(oneOf(expected, "type"));
+        } else {
+          var type = includes(name, ".") ? "property" : "argument";
+          msg = 'The "'
+            .concat(name, '" ')
+            .concat(type, " ")
+            .concat(determiner, " ")
+            .concat(oneOf(expected, "type"));
+        }
+        msg += ". Received type ".concat(_typeof(actual));
+        return msg;
+      },
+      TypeError,
+    );
+    createErrorType(
+      "ERR_INVALID_ARG_VALUE",
+      function (name, value) {
+        var reason =
+          arguments.length > 2 && arguments[2] !== void 0
+            ? arguments[2]
+            : "is invalid";
+        if (util === void 0) util = require_util();
+        var inspected = util.inspect(value);
+        if (inspected.length > 128) {
+          inspected = "".concat(inspected.slice(0, 128), "...");
+        }
+        return "The argument '"
+          .concat(name, "' ")
+          .concat(reason, ". Received ")
+          .concat(inspected);
+      },
+      TypeError,
+      RangeError,
+    );
+    createErrorType(
+      "ERR_INVALID_RETURN_VALUE",
+      function (input, name, value) {
+        var type;
+        if (value && value.constructor && value.constructor.name) {
+          type = "instance of ".concat(value.constructor.name);
+        } else {
+          type = "type ".concat(_typeof(value));
+        }
+        return (
+          "Expected "
+            .concat(input, ' to be returned from the "')
+            .concat(name, '"') + " function but got ".concat(type, ".")
+        );
+      },
+      TypeError,
+    );
+    createErrorType(
+      "ERR_MISSING_ARGS",
+      function () {
+        for (
+          var _len = arguments.length, args = new Array(_len), _key = 0;
+          _key < _len;
+          _key++
+        ) {
+          args[_key] = arguments[_key];
+        }
+        if (assert === void 0) assert = require_assert();
+        assert(args.length > 0, "At least one arg needs to be specified");
+        var msg = "The ";
+        var len = args.length;
+        args = args.map(function (a) {
+          return '"'.concat(a, '"');
+        });
+        switch (len) {
+          case 1:
+            msg += "".concat(args[0], " argument");
+            break;
+          case 2:
+            msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+            break;
+          default:
+            msg += args.slice(0, len - 1).join(", ");
+            msg += ", and ".concat(args[len - 1], " arguments");
+            break;
+        }
+        return "".concat(msg, " must be specified");
+      },
+      TypeError,
+    );
+    module.exports.codes = codes;
+  },
+});
+
+// node_modules/assert/build/internal/assert/assertion_error.js
+var require_assertion_error = __commonJS({
+  "node_modules/assert/build/internal/assert/assertion_error.js"(
+    exports,
+    module,
+  ) {
+    "use strict";
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+          ownKeys = ownKeys.concat(
+            Object.getOwnPropertySymbols(source).filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }),
+          );
+        }
+        ownKeys.forEach(function (key) {
+          _defineProperty(target, key, source[key]);
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, {
+          value,
+          enumerable: true,
+          configurable: true,
+          writable: true,
+        });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    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);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      return Constructor;
+    }
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      }
+      return _assertThisInitialized(self);
+    }
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError(
+          "this hasn't been initialised - super() hasn't been called",
+        );
+      }
+      return self;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError(
+          "Super expression must either be null or a function",
+        );
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: { value: subClass, writable: true, configurable: true },
+      });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    function _wrapNativeSuper(Class) {
+      var _cache =
+        typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+        if (typeof Class2 !== "function") {
+          throw new TypeError(
+            "Super expression must either be null or a function",
+          );
+        }
+        if (typeof _cache !== "undefined") {
+          if (_cache.has(Class2)) return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(
+            Class2,
+            arguments,
+            _getPrototypeOf(this).constructor,
+          );
+        }
+        Wrapper.prototype = Object.create(Class2.prototype, {
+          constructor: {
+            value: Wrapper,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+          },
+        });
+        return _setPrototypeOf(Wrapper, Class2);
+      };
+      return _wrapNativeSuper(Class);
+    }
+    function isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Date.prototype.toString.call(
+          Reflect.construct(Date, [], function () {}),
+        );
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    function _construct(Parent, args, Class) {
+      if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+      } else {
+        _construct = function _construct2(Parent2, args2, Class2) {
+          var a = [null];
+          a.push.apply(a, args2);
+          var Constructor = Function.bind.apply(Parent2, a);
+          var instance = new Constructor();
+          if (Class2) _setPrototypeOf(instance, Class2.prototype);
+          return instance;
+        };
+      }
+      return _construct.apply(null, arguments);
+    }
+    function _isNativeFunction(fn) {
+      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf =
+        Object.setPrototypeOf ||
+        function _setPrototypeOf2(o2, p2) {
+          o2.__proto__ = p2;
+          return o2;
+        };
+      return _setPrototypeOf(o, p);
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf
+        ? Object.getPrototypeOf
+        : function _getPrototypeOf2(o2) {
+            return o2.__proto__ || Object.getPrototypeOf(o2);
+          };
+      return _getPrototypeOf(o);
+    }
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 &&
+            typeof Symbol === "function" &&
+            obj2.constructor === Symbol &&
+            obj2 !== Symbol.prototype
+            ? "symbol"
+            : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    var _require = require_util();
+    var inspect = _require.inspect;
+    var _require2 = require_errors();
+    var ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function repeat(str, count) {
+      count = Math.floor(count);
+      if (str.length == 0 || count == 0) return "";
+      var maxCount = str.length * count;
+      count = Math.floor(Math.log(count) / Math.log(2));
+      while (count) {
+        str += str;
+        count--;
+      }
+      str += str.substring(0, maxCount - str.length);
+      return str;
+    }
+    var blue = "";
+    var green = "";
+    var red = "";
+    var white = "";
+    var kReadableOperator = {
+      deepStrictEqual: "Expected values to be strictly deep-equal:",
+      strictEqual: "Expected values to be strictly equal:",
+      strictEqualObject:
+        'Expected "actual" to be reference-equal to "expected":',
+      deepEqual: "Expected values to be loosely deep-equal:",
+      equal: "Expected values to be loosely equal:",
+      notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
+      notStrictEqual: 'Expected "actual" to be strictly unequal to:',
+      notStrictEqualObject:
+        'Expected "actual" not to be reference-equal to "expected":',
+      notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+      notEqual: 'Expected "actual" to be loosely unequal to:',
+      notIdentical: "Values identical but not reference-equal:",
+    };
+    var kMaxShortLength = 10;
+    function copyError(source) {
+      var keys = Object.keys(source);
+      var target = Object.create(Object.getPrototypeOf(source));
+      keys.forEach(function (key) {
+        target[key] = source[key];
+      });
+      Object.defineProperty(target, "message", {
+        value: source.message,
+      });
+      return target;
+    }
+    function inspectValue(val) {
+      return inspect(val, {
+        compact: false,
+        customInspect: false,
+        depth: 1e3,
+        maxArrayLength: Infinity,
+        // Assert compares only enumerable properties (with a few exceptions).
+        showHidden: false,
+        // Having a long line as error is better than wrapping the line for
+        // comparison for now.
+        // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
+        // have meta information about the inspected properties (i.e., know where
+        // in what line the property starts and ends).
+        breakLength: Infinity,
+        // Assert does not detect proxies currently.
+        showProxy: false,
+        sorted: true,
+        // Inspect getters as we also check them when comparing entries.
+        getters: true,
+      });
+    }
+    function createErrDiff(actual, expected, operator) {
+      var other = "";
+      var res = "";
+      var lastPos = 0;
+      var end = "";
+      var skipped = false;
+      var actualInspected = inspectValue(actual);
+      var actualLines = actualInspected.split("\n");
+      var expectedLines = inspectValue(expected).split("\n");
+      var i = 0;
+      var indicator = "";
+      if (
+        operator === "strictEqual" &&
+        _typeof(actual) === "object" &&
+        _typeof(expected) === "object" &&
+        actual !== null &&
+        expected !== null
+      ) {
+        operator = "strictEqualObject";
+      }
+      if (
+        actualLines.length === 1 &&
+        expectedLines.length === 1 &&
+        actualLines[0] !== expectedLines[0]
+      ) {
+        var inputLength = actualLines[0].length + expectedLines[0].length;
+        if (inputLength <= kMaxShortLength) {
+          if (
+            (_typeof(actual) !== "object" || actual === null) &&
+            (_typeof(expected) !== "object" || expected === null) &&
+            (actual !== 0 || expected !== 0)
+          ) {
+            return (
+              "".concat(kReadableOperator[operator], "\n\n") +
+              "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n")
+            );
+          }
+        } else if (operator !== "strictEqualObject") {
+          var maxLength =
+            process.stderr && process.stderr.isTTY
+              ? process.stderr.columns
+              : 80;
+          if (inputLength < maxLength) {
+            while (actualLines[0][i] === expectedLines[0][i]) {
+              i++;
+            }
+            if (i > 2) {
+              indicator = "\n  ".concat(repeat(" ", i), "^");
+              i = 0;
+            }
+          }
+        }
+      }
+      var a = actualLines[actualLines.length - 1];
+      var b = expectedLines[expectedLines.length - 1];
+      while (a === b) {
+        if (i++ < 2) {
+          end = "\n  ".concat(a).concat(end);
+        } else {
+          other = a;
+        }
+        actualLines.pop();
+        expectedLines.pop();
+        if (actualLines.length === 0 || expectedLines.length === 0) break;
+        a = actualLines[actualLines.length - 1];
+        b = expectedLines[expectedLines.length - 1];
+      }
+      var maxLines = Math.max(actualLines.length, expectedLines.length);
+      if (maxLines === 0) {
+        var _actualLines = actualInspected.split("\n");
+        if (_actualLines.length > 30) {
+          _actualLines[26] = "".concat(blue, "...").concat(white);
+          while (_actualLines.length > 27) {
+            _actualLines.pop();
+          }
+        }
+        return ""
+          .concat(kReadableOperator.notIdentical, "\n\n")
+          .concat(_actualLines.join("\n"), "\n");
+      }
+      if (i > 3) {
+        end = "\n".concat(blue, "...").concat(white).concat(end);
+        skipped = true;
+      }
+      if (other !== "") {
+        end = "\n  ".concat(other).concat(end);
+        other = "";
+      }
+      var printedLines = 0;
+      var msg =
+        kReadableOperator[operator] +
+        "\n"
+          .concat(green, "+ actual")
+          .concat(white, " ")
+          .concat(red, "- expected")
+          .concat(white);
+      var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+      for (i = 0; i < maxLines; i++) {
+        var cur = i - lastPos;
+        if (actualLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(expectedLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(expectedLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          other += "\n"
+            .concat(red, "-")
+            .concat(white, " ")
+            .concat(expectedLines[i]);
+          printedLines++;
+        } else if (expectedLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(actualLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(actualLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          res += "\n"
+            .concat(green, "+")
+            .concat(white, " ")
+            .concat(actualLines[i]);
+          printedLines++;
+        } else {
+          var expectedLine = expectedLines[i];
+          var actualLine = actualLines[i];
+          var divergingLines =
+            actualLine !== expectedLine &&
+            (!endsWith(actualLine, ",") ||
+              actualLine.slice(0, -1) !== expectedLine);
+          if (
+            divergingLines &&
+            endsWith(expectedLine, ",") &&
+            expectedLine.slice(0, -1) === actualLine
+          ) {
+            divergingLines = false;
+            actualLine += ",";
+          }
+          if (divergingLines) {
+            if (cur > 1 && i > 2) {
+              if (cur > 4) {
+                res += "\n".concat(blue, "...").concat(white);
+                skipped = true;
+              } else if (cur > 3) {
+                res += "\n  ".concat(actualLines[i - 2]);
+                printedLines++;
+              }
+              res += "\n  ".concat(actualLines[i - 1]);
+              printedLines++;
+            }
+            lastPos = i;
+            res += "\n"
+              .concat(green, "+")
+              .concat(white, " ")
+              .concat(actualLine);
+            other += "\n"
+              .concat(red, "-")
+              .concat(white, " ")
+              .concat(expectedLine);
+            printedLines += 2;
+          } else {
+            res += other;
+            other = "";
+            if (cur === 1 || i === 0) {
+              res += "\n  ".concat(actualLine);
+              printedLines++;
+            }
+          }
+        }
+        if (printedLines > 20 && i < maxLines - 2) {
+          return (
+            ""
+              .concat(msg)
+              .concat(skippedMsg, "\n")
+              .concat(res, "\n")
+              .concat(blue, "...")
+              .concat(white)
+              .concat(other, "\n") + "".concat(blue, "...").concat(white)
+          );
+        }
+      }
+      return ""
+        .concat(msg)
+        .concat(skipped ? skippedMsg : "", "\n")
+        .concat(res)
+        .concat(other)
+        .concat(end)
+        .concat(indicator);
+    }
+    var AssertionError = /* @__PURE__ */ (function (_Error) {
+      _inherits(AssertionError2, _Error);
+      function AssertionError2(options) {
+        var _this;
+        _classCallCheck(this, AssertionError2);
+        if (_typeof(options) !== "object" || options === null) {
+          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+        }
+        var message = options.message,
+          operator = options.operator,
+          stackStartFn = options.stackStartFn;
+        var actual = options.actual,
+          expected = options.expected;
+        var limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 0;
+        if (message != null) {
+          _this = _possibleConstructorReturn(
+            this,
+            _getPrototypeOf(AssertionError2).call(this, String(message)),
+          );
+        } else {
+          if (process.stderr && process.stderr.isTTY) {
+            if (
+              process.stderr &&
+              process.stderr.getColorDepth &&
+              process.stderr.getColorDepth() !== 1
+            ) {
+              blue = "\x1B[34m";
+              green = "\x1B[32m";
+              white = "\x1B[39m";
+              red = "\x1B[31m";
+            } else {
+              blue = "";
+              green = "";
+              white = "";
+              red = "";
+            }
+          }
+          if (
+            _typeof(actual) === "object" &&
+            actual !== null &&
+            _typeof(expected) === "object" &&
+            expected !== null &&
+            "stack" in actual &&
+            actual instanceof Error &&
+            "stack" in expected &&
+            expected instanceof Error
+          ) {
+            actual = copyError(actual);
+            expected = copyError(expected);
+          }
+          if (operator === "deepStrictEqual" || operator === "strictEqual") {
+            _this = _possibleConstructorReturn(
+              this,
+              _getPrototypeOf(AssertionError2).call(
+                this,
+                createErrDiff(actual, expected, operator),
+              ),
+            );
+          } else if (
+            operator === "notDeepStrictEqual" ||
+            operator === "notStrictEqual"
+          ) {
+            var base = kReadableOperator[operator];
+            var res = inspectValue(actual).split("\n");
+            if (
+              operator === "notStrictEqual" &&
+              _typeof(actual) === "object" &&
+              actual !== null
+            ) {
+              base = kReadableOperator.notStrictEqualObject;
+            }
+            if (res.length > 30) {
+              res[26] = "".concat(blue, "...").concat(white);
+              while (res.length > 27) {
+                res.pop();
+              }
+            }
+            if (res.length === 1) {
+              _this = _possibleConstructorReturn(
+                this,
+                _getPrototypeOf(AssertionError2).call(
+                  this,
+                  "".concat(base, " ").concat(res[0]),
+                ),
+              );
+            } else {
+              _this = _possibleConstructorReturn(
+                this,
+                _getPrototypeOf(AssertionError2).call(
+                  this,
+                  "".concat(base, "\n\n").concat(res.join("\n"), "\n"),
+                ),
+              );
+            }
+          } else {
+            var _res = inspectValue(actual);
+            var other = "";
+            var knownOperators = kReadableOperator[operator];
+            if (operator === "notDeepEqual" || operator === "notEqual") {
+              _res = ""
+                .concat(kReadableOperator[operator], "\n\n")
+                .concat(_res);
+              if (_res.length > 1024) {
+                _res = "".concat(_res.slice(0, 1021), "...");
+              }
+            } else {
+              other = "".concat(inspectValue(expected));
+              if (_res.length > 512) {
+                _res = "".concat(_res.slice(0, 509), "...");
+              }
+              if (other.length > 512) {
+                other = "".concat(other.slice(0, 509), "...");
+              }
+              if (operator === "deepEqual" || operator === "equal") {
+                _res = ""
+                  .concat(knownOperators, "\n\n")
+                  .concat(_res, "\n\nshould equal\n\n");
+              } else {
+                other = " ".concat(operator, " ").concat(other);
+              }
+            }
+            _this = _possibleConstructorReturn(
+              this,
+              _getPrototypeOf(AssertionError2).call(
+                this,
+                "".concat(_res).concat(other),
+              ),
+            );
+          }
+        }
+        Error.stackTraceLimit = limit;
+        _this.generatedMessage = !message;
+        Object.defineProperty(_assertThisInitialized(_this), "name", {
+          value: "AssertionError [ERR_ASSERTION]",
+          enumerable: false,
+          writable: true,
+          configurable: true,
+        });
+        _this.code = "ERR_ASSERTION";
+        _this.actual = actual;
+        _this.expected = expected;
+        _this.operator = operator;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+        }
+        _this.stack;
+        _this.name = "AssertionError";
+        return _possibleConstructorReturn(_this);
+      }
+      _createClass(AssertionError2, [
+        {
+          key: "toString",
+          value: function toString() {
+            return ""
+              .concat(this.name, " [")
+              .concat(this.code, "]: ")
+              .concat(this.message);
+          },
+        },
+        {
+          key: inspect.custom,
+          value: function value(recurseTimes, ctx) {
+            return inspect(
+              this,
+              _objectSpread({}, ctx, {
+                customInspect: false,
+                depth: 0,
+              }),
+            );
+          },
+        },
+      ]);
+      return AssertionError2;
+    })(_wrapNativeSuper(Error));
+    module.exports = AssertionError;
+  },
+});
+
+// node_modules/es6-object-assign/index.js
+var require_es6_object_assign = __commonJS({
+  "node_modules/es6-object-assign/index.js"(exports, module) {
+    "use strict";
+    function assign(target, firstSource) {
+      if (target === void 0 || target === null) {
+        throw new TypeError("Cannot convert first argument to object");
+      }
+      var to = Object(target);
+      for (var i = 1; i < arguments.length; i++) {
+        var nextSource = arguments[i];
+        if (nextSource === void 0 || nextSource === null) {
+          continue;
+        }
+        var keysArray = Object.keys(Object(nextSource));
+        for (
+          var nextIndex = 0, len = keysArray.length;
+          nextIndex < len;
+          nextIndex++
+        ) {
+          var nextKey = keysArray[nextIndex];
+          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+          if (desc !== void 0 && desc.enumerable) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+      return to;
+    }
+    function polyfill() {
+      if (!Object.assign) {
+        Object.defineProperty(Object, "assign", {
+          enumerable: false,
+          configurable: true,
+          writable: true,
+          value: assign,
+        });
+      }
+    }
+    module.exports = {
+      assign,
+      polyfill,
+    };
+  },
+});
+
+// node_modules/object-keys/isArguments.js
+var require_isArguments = __commonJS({
+  "node_modules/object-keys/isArguments.js"(exports, module) {
+    "use strict";
+    var toStr = Object.prototype.toString;
+    module.exports = function isArguments(value) {
+      var str = toStr.call(value);
+      var isArgs = str === "[object Arguments]";
+      if (!isArgs) {
+        isArgs =
+          str !== "[object Array]" &&
+          value !== null &&
+          typeof value === "object" &&
+          typeof value.length === "number" &&
+          value.length >= 0 &&
+          toStr.call(value.callee) === "[object Function]";
+      }
+      return isArgs;
+    };
+  },
+});
+
+// node_modules/object-keys/implementation.js
+var require_implementation2 = __commonJS({
+  "node_modules/object-keys/implementation.js"(exports, module) {
+    "use strict";
+    var keysShim;
+    if (!Object.keys) {
+      has = Object.prototype.hasOwnProperty;
+      toStr = Object.prototype.toString;
+      isArgs = require_isArguments();
+      isEnumerable = Object.prototype.propertyIsEnumerable;
+      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+      hasProtoEnumBug = isEnumerable.call(function () {}, "prototype");
+      dontEnums = [
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "constructor",
+      ];
+      equalsConstructorPrototype = function (o) {
+        var ctor = o.constructor;
+        return ctor && ctor.prototype === o;
+      };
+      excludedKeys = {
+        $applicationCache: true,
+        $console: true,
+        $external: true,
+        $frame: true,
+        $frameElement: true,
+        $frames: true,
+        $innerHeight: true,
+        $innerWidth: true,
+        $onmozfullscreenchange: true,
+        $onmozfullscreenerror: true,
+        $outerHeight: true,
+        $outerWidth: true,
+        $pageXOffset: true,
+        $pageYOffset: true,
+        $parent: true,
+        $scrollLeft: true,
+        $scrollTop: true,
+        $scrollX: true,
+        $scrollY: true,
+        $self: true,
+        $webkitIndexedDB: true,
+        $webkitStorageInfo: true,
+        $window: true,
+      };
+      hasAutomationEqualityBug = (function () {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        for (var k in window) {
+          try {
+            if (
+              !excludedKeys["$" + k] &&
+              has.call(window, k) &&
+              window[k] !== null &&
+              typeof window[k] === "object"
+            ) {
+              try {
+                equalsConstructorPrototype(window[k]);
+              } catch (e) {
+                return true;
+              }
+            }
+          } catch (e) {
+            return true;
+          }
+        }
+        return false;
+      })();
+      equalsConstructorPrototypeIfNotBuggy = function (o) {
+        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+          return equalsConstructorPrototype(o);
+        }
+        try {
+          return equalsConstructorPrototype(o);
+        } catch (e) {
+          return false;
+        }
+      };
+      keysShim = function keys(object) {
+        var isObject = object !== null && typeof object === "object";
+        var isFunction = toStr.call(object) === "[object Function]";
+        var isArguments = isArgs(object);
+        var isString = isObject && toStr.call(object) === "[object String]";
+        var theKeys = [];
+        if (!isObject && !isFunction && !isArguments) {
+          throw new TypeError("Object.keys called on a non-object");
+        }
+        var skipProto = hasProtoEnumBug && isFunction;
+        if (isString && object.length > 0 && !has.call(object, 0)) {
+          for (var i = 0; i < object.length; ++i) {
+            theKeys.push(String(i));
+          }
+        }
+        if (isArguments && object.length > 0) {
+          for (var j = 0; j < object.length; ++j) {
+            theKeys.push(String(j));
+          }
+        } else {
+          for (var name in object) {
+            if (
+              !(skipProto && name === "prototype") &&
+              has.call(object, name)
+            ) {
+              theKeys.push(String(name));
+            }
+          }
+        }
+        if (hasDontEnumBug) {
+          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+          for (var k = 0; k < dontEnums.length; ++k) {
+            if (
+              !(skipConstructor && dontEnums[k] === "constructor") &&
+              has.call(object, dontEnums[k])
+            ) {
+              theKeys.push(dontEnums[k]);
+            }
+          }
+        }
+        return theKeys;
+      };
+    }
+    var has;
+    var toStr;
+    var isArgs;
+    var isEnumerable;
+    var hasDontEnumBug;
+    var hasProtoEnumBug;
+    var dontEnums;
+    var equalsConstructorPrototype;
+    var excludedKeys;
+    var hasAutomationEqualityBug;
+    var equalsConstructorPrototypeIfNotBuggy;
+    module.exports = keysShim;
+  },
+});
+
+// node_modules/object-keys/index.js
+var require_object_keys = __commonJS({
+  "node_modules/object-keys/index.js"(exports, module) {
+    "use strict";
+    var slice = Array.prototype.slice;
+    var isArgs = require_isArguments();
+    var origKeys = Object.keys;
+    var keysShim = origKeys
+      ? function keys(o) {
+          return origKeys(o);
+        }
+      : require_implementation2();
+    var originalKeys = Object.keys;
+    keysShim.shim = function shimObjectKeys() {
+      if (Object.keys) {
+        var keysWorksWithArguments = (function () {
+          var args = Object.keys(arguments);
+          return args && args.length === arguments.length;
+        })(1, 2);
+        if (!keysWorksWithArguments) {
+          Object.keys = function keys(object) {
+            if (isArgs(object)) {
+              return originalKeys(slice.call(object));
+            }
+            return originalKeys(object);
+          };
+        }
+      } else {
+        Object.keys = keysShim;
+      }
+      return Object.keys || keysShim;
+    };
+    module.exports = keysShim;
+  },
+});
+
+// node_modules/has-property-descriptors/index.js
+var require_has_property_descriptors = __commonJS({
+  "node_modules/has-property-descriptors/index.js"(exports, module) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+      if ($defineProperty) {
+        try {
+          $defineProperty({}, "a", { value: 1 });
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    };
+    hasPropertyDescriptors.hasArrayLengthDefineBug =
+      function hasArrayLengthDefineBug() {
+        if (!hasPropertyDescriptors()) {
+          return null;
+        }
+        try {
+          return $defineProperty([], "length", { value: 1 }).length !== 1;
+        } catch (e) {
+          return true;
+        }
+      };
+    module.exports = hasPropertyDescriptors;
+  },
+});
+
+// node_modules/define-properties/index.js
+var require_define_properties = __commonJS({
+  "node_modules/define-properties/index.js"(exports, module) {
+    "use strict";
+    var keys = require_object_keys();
+    var hasSymbols =
+      typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+    var toStr = Object.prototype.toString;
+    var concat = Array.prototype.concat;
+    var origDefineProperty = Object.defineProperty;
+    var isFunction = function (fn) {
+      return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+    };
+    var hasPropertyDescriptors = require_has_property_descriptors()();
+    var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
+    var defineProperty = function (object, name, value, predicate) {
+      if (name in object) {
+        if (predicate === true) {
+          if (object[name] === value) {
+            return;
+          }
+        } else if (!isFunction(predicate) || !predicate()) {
+          return;
+        }
+      }
+      if (supportsDescriptors) {
+        origDefineProperty(object, name, {
+          configurable: true,
+          enumerable: false,
+          value,
+          writable: true,
+        });
+      } else {
+        object[name] = value;
+      }
+    };
+    var defineProperties = function (object, map) {
+      var predicates = arguments.length > 2 ? arguments[2] : {};
+      var props = keys(map);
+      if (hasSymbols) {
+        props = concat.call(props, Object.getOwnPropertySymbols(map));
+      }
+      for (var i = 0; i < props.length; i += 1) {
+        defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+      }
+    };
+    defineProperties.supportsDescriptors = !!supportsDescriptors;
+    module.exports = defineProperties;
+  },
+});
+
+// node_modules/object-is/implementation.js
+var require_implementation3 = __commonJS({
+  "node_modules/object-is/implementation.js"(exports, module) {
+    "use strict";
+    var numberIsNaN = function (value) {
+      return value !== value;
+    };
+    module.exports = function is(a, b) {
+      if (a === 0 && b === 0) {
+        return 1 / a === 1 / b;
+      }
+      if (a === b) {
+        return true;
+      }
+      if (numberIsNaN(a) && numberIsNaN(b)) {
+        return true;
+      }
+      return false;
+    };
+  },
+});
+
+// node_modules/object-is/polyfill.js
+var require_polyfill = __commonJS({
+  "node_modules/object-is/polyfill.js"(exports, module) {
+    "use strict";
+    var implementation = require_implementation3();
+    module.exports = function getPolyfill() {
+      return typeof Object.is === "function" ? Object.is : implementation;
+    };
+  },
+});
+
+// node_modules/object-is/shim.js
+var require_shim = __commonJS({
+  "node_modules/object-is/shim.js"(exports, module) {
+    "use strict";
+    var getPolyfill = require_polyfill();
+    var define = require_define_properties();
+    module.exports = function shimObjectIs() {
+      var polyfill = getPolyfill();
+      define(
+        Object,
+        { is: polyfill },
+        {
+          is: function testObjectIs() {
+            return Object.is !== polyfill;
+          },
+        },
+      );
+      return polyfill;
+    };
+  },
+});
+
+// node_modules/object-is/index.js
+var require_object_is = __commonJS({
+  "node_modules/object-is/index.js"(exports, module) {
+    "use strict";
+    var define = require_define_properties();
+    var callBind = require_call_bind();
+    var implementation = require_implementation3();
+    var getPolyfill = require_polyfill();
+    var shim = require_shim();
+    var polyfill = callBind(getPolyfill(), Object);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim,
+    });
+    module.exports = polyfill;
+  },
+});
+
+// node_modules/is-nan/implementation.js
+var require_implementation4 = __commonJS({
+  "node_modules/is-nan/implementation.js"(exports, module) {
+    "use strict";
+    module.exports = function isNaN2(value) {
+      return value !== value;
+    };
+  },
+});
+
+// node_modules/is-nan/polyfill.js
+var require_polyfill2 = __commonJS({
+  "node_modules/is-nan/polyfill.js"(exports, module) {
+    "use strict";
+    var implementation = require_implementation4();
+    module.exports = function getPolyfill() {
+      if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
+        return Number.isNaN;
+      }
+      return implementation;
+    };
+  },
+});
+
+// node_modules/is-nan/shim.js
+var require_shim2 = __commonJS({
+  "node_modules/is-nan/shim.js"(exports, module) {
+    "use strict";
+    var define = require_define_properties();
+    var getPolyfill = require_polyfill2();
+    module.exports = function shimNumberIsNaN() {
+      var polyfill = getPolyfill();
+      define(
+        Number,
+        { isNaN: polyfill },
+        {
+          isNaN: function testIsNaN() {
+            return Number.isNaN !== polyfill;
+          },
+        },
+      );
+      return polyfill;
+    };
+  },
+});
+
+// node_modules/is-nan/index.js
+var require_is_nan = __commonJS({
+  "node_modules/is-nan/index.js"(exports, module) {
+    "use strict";
+    var callBind = require_call_bind();
+    var define = require_define_properties();
+    var implementation = require_implementation4();
+    var getPolyfill = require_polyfill2();
+    var shim = require_shim2();
+    var polyfill = callBind(getPolyfill(), Number);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim,
+    });
+    module.exports = polyfill;
+  },
+});
+
+// node_modules/assert/build/internal/util/comparisons.js
+var require_comparisons = __commonJS({
+  "node_modules/assert/build/internal/util/comparisons.js"(exports, module) {
+    "use strict";
+    function _slicedToArray(arr, i) {
+      return (
+        _arrayWithHoles(arr) ||
+        _iterableToArrayLimit(arr, i) ||
+        _nonIterableRest()
+      );
+    }
+    function _nonIterableRest() {
+      throw new TypeError(
+        "Invalid attempt to destructure non-iterable instance",
+      );
+    }
+    function _iterableToArrayLimit(arr, i) {
+      var _arr = [];
+      var _n = true;
+      var _d = false;
+      var _e = void 0;
+      try {
+        for (
+          var _i = arr[Symbol.iterator](), _s;
+          !(_n = (_s = _i.next()).done);
+          _n = true
+        ) {
+          _arr.push(_s.value);
+          if (i && _arr.length === i) break;
+        }
+      } catch (err) {
+        _d = true;
+        _e = err;
+      } finally {
+        try {
+          if (!_n && _i["return"] != null) _i["return"]();
+        } finally {
+          if (_d) throw _e;
+        }
+      }
+      return _arr;
+    }
+    function _arrayWithHoles(arr) {
+      if (Array.isArray(arr)) return arr;
+    }
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 &&
+            typeof Symbol === "function" &&
+            obj2.constructor === Symbol &&
+            obj2 !== Symbol.prototype
+            ? "symbol"
+            : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    var regexFlagsSupported = /a/g.flags !== void 0;
+    var arrayFromSet = function arrayFromSet2(set) {
+      var array = [];
+      set.forEach(function (value) {
+        return array.push(value);
+      });
+      return array;
+    };
+    var arrayFromMap = function arrayFromMap2(map) {
+      var array = [];
+      map.forEach(function (value, key) {
+        return array.push([key, value]);
+      });
+      return array;
+    };
+    var objectIs = Object.is ? Object.is : require_object_is();
+    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols
+      ? Object.getOwnPropertySymbols
+      : function () {
+          return [];
+        };
+    var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();
+    function uncurryThis(f) {
+      return f.call.bind(f);
+    }
+    var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+    var propertyIsEnumerable = uncurryThis(
+      Object.prototype.propertyIsEnumerable,
+    );
+    var objectToString = uncurryThis(Object.prototype.toString);
+    var _require$types = require_util().types;
+    var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;
+    var isArrayBufferView = _require$types.isArrayBufferView;
+    var isDate = _require$types.isDate;
+    var isMap = _require$types.isMap;
+    var isRegExp = _require$types.isRegExp;
+    var isSet = _require$types.isSet;
+    var isNativeError = _require$types.isNativeError;
+    var isBoxedPrimitive = _require$types.isBoxedPrimitive;
+    var isNumberObject = _require$types.isNumberObject;
+    var isStringObject = _require$types.isStringObject;
+    var isBooleanObject = _require$types.isBooleanObject;
+    var isBigIntObject = _require$types.isBigIntObject;
+    var isSymbolObject = _require$types.isSymbolObject;
+    var isFloat32Array = _require$types.isFloat32Array;
+    var isFloat64Array = _require$types.isFloat64Array;
+    function isNonIndex(key) {
+      if (key.length === 0 || key.length > 10) return true;
+      for (var i = 0; i < key.length; i++) {
+        var code = key.charCodeAt(i);
+        if (code < 48 || code > 57) return true;
+      }
+      return key.length === 10 && key >= Math.pow(2, 32);
+    }
+    function getOwnNonIndexProperties(value) {
+      return Object.keys(value)
+        .filter(isNonIndex)
+        .concat(
+          objectGetOwnPropertySymbols(value).filter(
+            Object.prototype.propertyIsEnumerable.bind(value),
+          ),
+        );
+    }
+    function compare(a, b) {
+      if (a === b) {
+        return 0;
+      }
+      var x = a.length;
+      var y = b.length;
+      for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y) {
+        return -1;
+      }
+      if (y < x) {
+        return 1;
+      }
+      return 0;
+    }
+    var ONLY_ENUMERABLE = void 0;
+    var kStrict = true;
+    var kLoose = false;
+    var kNoIterator = 0;
+    var kIsArray = 1;
+    var kIsSet = 2;
+    var kIsMap = 3;
+    function areSimilarRegExps(a, b) {
+      return regexFlagsSupported
+        ? a.source === b.source && a.flags === b.flags
+        : RegExp.prototype.toString.call(a) ===
+            RegExp.prototype.toString.call(b);
+    }
+    function areSimilarFloatArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (var offset = 0; offset < a.byteLength; offset++) {
+        if (a[offset] !== b[offset]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function areSimilarTypedArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      return (
+        compare(
+          new Uint8Array(a.buffer, a.byteOffset, a.byteLength),
+          new Uint8Array(b.buffer, b.byteOffset, b.byteLength),
+        ) === 0
+      );
+    }
+    function areEqualArrayBuffers(buf1, buf2) {
+      return (
+        buf1.byteLength === buf2.byteLength &&
+        compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0
+      );
+    }
+    function isEqualBoxedPrimitive(val1, val2) {
+      if (isNumberObject(val1)) {
+        return (
+          isNumberObject(val2) &&
+          objectIs(
+            Number.prototype.valueOf.call(val1),
+            Number.prototype.valueOf.call(val2),
+          )
+        );
+      }
+      if (isStringObject(val1)) {
+        return (
+          isStringObject(val2) &&
+          String.prototype.valueOf.call(val1) ===
+            String.prototype.valueOf.call(val2)
+        );
+      }
+      if (isBooleanObject(val1)) {
+        return (
+          isBooleanObject(val2) &&
+          Boolean.prototype.valueOf.call(val1) ===
+            Boolean.prototype.valueOf.call(val2)
+        );
+      }
+      if (isBigIntObject(val1)) {
+        return (
+          isBigIntObject(val2) &&
+          BigInt.prototype.valueOf.call(val1) ===
+            BigInt.prototype.valueOf.call(val2)
+        );
+      }
+      return (
+        isSymbolObject(val2) &&
+        Symbol.prototype.valueOf.call(val1) ===
+          Symbol.prototype.valueOf.call(val2)
+      );
+    }
+    function innerDeepEqual(val1, val2, strict, memos) {
+      if (val1 === val2) {
+        if (val1 !== 0) return true;
+        return strict ? objectIs(val1, val2) : true;
+      }
+      if (strict) {
+        if (_typeof(val1) !== "object") {
+          return (
+            typeof val1 === "number" && numberIsNaN(val1) && numberIsNaN(val2)
+          );
+        }
+        if (_typeof(val2) !== "object" || val1 === null || val2 === null) {
+          return false;
+        }
+        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+          return false;
+        }
+      } else {
+        if (val1 === null || _typeof(val1) !== "object") {
+          if (val2 === null || _typeof(val2) !== "object") {
+            return val1 == val2;
+          }
+          return false;
+        }
+        if (val2 === null || _typeof(val2) !== "object") {
+          return false;
+        }
+      }
+      var val1Tag = objectToString(val1);
+      var val2Tag = objectToString(val2);
+      if (val1Tag !== val2Tag) {
+        return false;
+      }
+      if (Array.isArray(val1)) {
+        if (val1.length !== val2.length) {
+          return false;
+        }
+        var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (keys1.length !== keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+      }
+      if (val1Tag === "[object Object]") {
+        if ((!isMap(val1) && isMap(val2)) || (!isSet(val1) && isSet(val2))) {
+          return false;
+        }
+      }
+      if (isDate(val1)) {
+        if (
+          !isDate(val2) ||
+          Date.prototype.getTime.call(val1) !==
+            Date.prototype.getTime.call(val2)
+        ) {
+          return false;
+        }
+      } else if (isRegExp(val1)) {
+        if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+          return false;
+        }
+      } else if (isNativeError(val1) || val1 instanceof Error) {
+        if (val1.message !== val2.message || val1.name !== val2.name) {
+          return false;
+        }
+      } else if (isArrayBufferView(val1)) {
+        if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
+          if (!areSimilarFloatArrays(val1, val2)) {
+            return false;
+          }
+        } else if (!areSimilarTypedArrays(val1, val2)) {
+          return false;
+        }
+        var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (_keys.length !== _keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+      } else if (isSet(val1)) {
+        if (!isSet(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsSet);
+      } else if (isMap(val1)) {
+        if (!isMap(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsMap);
+      } else if (isAnyArrayBuffer(val1)) {
+        if (!areEqualArrayBuffers(val1, val2)) {
+          return false;
+        }
+      } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
+        return false;
+      }
+      return keyCheck(val1, val2, strict, memos, kNoIterator);
+    }
+    function getEnumerables(val, keys) {
+      return keys.filter(function (k) {
+        return propertyIsEnumerable(val, k);
+      });
+    }
+    function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+      if (arguments.length === 5) {
+        aKeys = Object.keys(val1);
+        var bKeys = Object.keys(val2);
+        if (aKeys.length !== bKeys.length) {
+          return false;
+        }
+      }
+      var i = 0;
+      for (; i < aKeys.length; i++) {
+        if (!hasOwnProperty(val2, aKeys[i])) {
+          return false;
+        }
+      }
+      if (strict && arguments.length === 5) {
+        var symbolKeysA = objectGetOwnPropertySymbols(val1);
+        if (symbolKeysA.length !== 0) {
+          var count = 0;
+          for (i = 0; i < symbolKeysA.length; i++) {
+            var key = symbolKeysA[i];
+            if (propertyIsEnumerable(val1, key)) {
+              if (!propertyIsEnumerable(val2, key)) {
+                return false;
+              }
+              aKeys.push(key);
+              count++;
+            } else if (propertyIsEnumerable(val2, key)) {
+              return false;
+            }
+          }
+          var symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (
+            symbolKeysA.length !== symbolKeysB.length &&
+            getEnumerables(val2, symbolKeysB).length !== count
+          ) {
+            return false;
+          }
+        } else {
+          var _symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (
+            _symbolKeysB.length !== 0 &&
+            getEnumerables(val2, _symbolKeysB).length !== 0
+          ) {
+            return false;
+          }
+        }
+      }
+      if (
+        aKeys.length === 0 &&
+        (iterationType === kNoIterator ||
+          (iterationType === kIsArray && val1.length === 0) ||
+          val1.size === 0)
+      ) {
+        return true;
+      }
+      if (memos === void 0) {
+        memos = {
+          val1: /* @__PURE__ */ new Map(),
+          val2: /* @__PURE__ */ new Map(),
+          position: 0,
+        };
+      } else {
+        var val2MemoA = memos.val1.get(val1);
+        if (val2MemoA !== void 0) {
+          var val2MemoB = memos.val2.get(val2);
+          if (val2MemoB !== void 0) {
+            return val2MemoA === val2MemoB;
+          }
+        }
+        memos.position++;
+      }
+      memos.val1.set(val1, memos.position);
+      memos.val2.set(val2, memos.position);
+      var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
+      memos.val1.delete(val1);
+      memos.val2.delete(val2);
+      return areEq;
+    }
+    function setHasEqualElement(set, val1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var val2 = setValues[i];
+        if (innerDeepEqual(val1, val2, strict, memo)) {
+          set.delete(val2);
+          return true;
+        }
+      }
+      return false;
+    }
+    function findLooseMatchingPrimitives(prim) {
+      switch (_typeof(prim)) {
+        case "undefined":
+          return null;
+        case "object":
+          return void 0;
+        case "symbol":
+          return false;
+        case "string":
+          prim = +prim;
+        case "number":
+          if (numberIsNaN(prim)) {
+            return false;
+          }
+      }
+      return true;
+    }
+    function setMightHaveLoosePrim(a, b, prim) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null) return altValue;
+      return b.has(altValue) && !a.has(altValue);
+    }
+    function mapMightHaveLoosePrim(a, b, prim, item, memo) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null) {
+        return altValue;
+      }
+      var curB = b.get(altValue);
+      if (
+        (curB === void 0 && !b.has(altValue)) ||
+        !innerDeepEqual(item, curB, false, memo)
+      ) {
+        return false;
+      }
+      return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
+    }
+    function setEquiv(a, b, strict, memo) {
+      var set = null;
+      var aValues = arrayFromSet(a);
+      for (var i = 0; i < aValues.length; i++) {
+        var val = aValues[i];
+        if (_typeof(val) === "object" && val !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        } else if (!b.has(val)) {
+          if (strict) return false;
+          if (!setMightHaveLoosePrim(a, b, val)) {
+            return false;
+          }
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        }
+      }
+      if (set !== null) {
+        var bValues = arrayFromSet(b);
+        for (var _i = 0; _i < bValues.length; _i++) {
+          var _val = bValues[_i];
+          if (_typeof(_val) === "object" && _val !== null) {
+            if (!setHasEqualElement(set, _val, strict, memo)) return false;
+          } else if (
+            !strict &&
+            !a.has(_val) &&
+            !setHasEqualElement(set, _val, strict, memo)
+          ) {
+            return false;
+          }
+        }
+        return set.size === 0;
+      }
+      return true;
+    }
+    function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var key2 = setValues[i];
+        if (
+          innerDeepEqual(key1, key2, strict, memo) &&
+          innerDeepEqual(item1, map.get(key2), strict, memo)
+        ) {
+          set.delete(key2);
+          return true;
+        }
+      }
+      return false;
+    }
+    function mapEquiv(a, b, strict, memo) {
+      var set = null;
+      var aEntries = arrayFromMap(a);
+      for (var i = 0; i < aEntries.length; i++) {
+        var _aEntries$i = _slicedToArray(aEntries[i], 2),
+          key = _aEntries$i[0],
+          item1 = _aEntries$i[1];
+        if (_typeof(key) === "object" && key !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(key);
+        } else {
+          var item2 = b.get(key);
+          if (
+            (item2 === void 0 && !b.has(key)) ||
+            !innerDeepEqual(item1, item2, strict, memo)
+          ) {
+            if (strict) return false;
+            if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;
+            if (set === null) {
+              set = /* @__PURE__ */ new Set();
+            }
+            set.add(key);
+          }
+        }
+      }
+      if (set !== null) {
+        var bEntries = arrayFromMap(b);
+        for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
+          var _bEntries$_i = _slicedToArray(bEntries[_i2], 2),
+            key = _bEntries$_i[0],
+            item = _bEntries$_i[1];
+          if (_typeof(key) === "object" && key !== null) {
+            if (!mapHasEqualEntry(set, a, key, item, strict, memo))
+              return false;
+          } else if (
+            !strict &&
+            (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) &&
+            !mapHasEqualEntry(set, a, key, item, false, memo)
+          ) {
+            return false;
+          }
+        }
+        return set.size === 0;
+      }
+      return true;
+    }
+    function objEquiv(a, b, strict, keys, memos, iterationType) {
+      var i = 0;
+      if (iterationType === kIsSet) {
+        if (!setEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsMap) {
+        if (!mapEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsArray) {
+        for (; i < a.length; i++) {
+          if (hasOwnProperty(a, i)) {
+            if (
+              !hasOwnProperty(b, i) ||
+              !innerDeepEqual(a[i], b[i], strict, memos)
+            ) {
+              return false;
+            }
+          } else if (hasOwnProperty(b, i)) {
+            return false;
+          } else {
+            var keysA = Object.keys(a);
+            for (; i < keysA.length; i++) {
+              var key = keysA[i];
+              if (
+                !hasOwnProperty(b, key) ||
+                !innerDeepEqual(a[key], b[key], strict, memos)
+              ) {
+                return false;
+              }
+            }
+            if (keysA.length !== Object.keys(b).length) {
+              return false;
+            }
+            return true;
+          }
+        }
+      }
+      for (i = 0; i < keys.length; i++) {
+        var _key = keys[i];
+        if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function isDeepEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kLoose);
+    }
+    function isDeepStrictEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kStrict);
+    }
+    module.exports = {
+      isDeepEqual,
+      isDeepStrictEqual,
+    };
+  },
+});
+
+// node_modules/assert/build/assert.js
+var require_assert = __commonJS({
+  "node_modules/assert/build/assert.js"(exports, module) {
+    "use strict";
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 &&
+            typeof Symbol === "function" &&
+            obj2.constructor === Symbol &&
+            obj2 !== Symbol.prototype
+            ? "symbol"
+            : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var _require = require_errors();
+    var _require$codes = _require.codes;
+    var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;
+    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+    var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;
+    var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;
+    var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+    var AssertionError = require_assertion_error();
+    var _require2 = require_util();
+    var inspect = _require2.inspect;
+    var _require$types = require_util().types;
+    var isPromise = _require$types.isPromise;
+    var isRegExp = _require$types.isRegExp;
+    var objectAssign = Object.assign
+      ? Object.assign
+      : require_es6_object_assign().assign;
+    var objectIs = Object.is ? Object.is : require_object_is();
+    var isDeepEqual;
+    var isDeepStrictEqual;
+    function lazyLoadComparison() {
+      var comparison = require_comparisons();
+      isDeepEqual = comparison.isDeepEqual;
+      isDeepStrictEqual = comparison.isDeepStrictEqual;
+    }
+    var warned = false;
+    var assert = (module.exports = ok);
+    var NO_EXCEPTION_SENTINEL = {};
+    function innerFail(obj) {
+      if (obj.message instanceof Error) throw obj.message;
+      throw new AssertionError(obj);
+    }
+    function fail(actual, expected, message, operator, stackStartFn) {
+      var argsLen = arguments.length;
+      var internalMessage;
+      if (argsLen === 0) {
+        internalMessage = "Failed";
+      } else if (argsLen === 1) {
+        message = actual;
+        actual = void 0;
+      } else {
+        if (warned === false) {
+          warned = true;
+          var warn = process.emitWarning
+            ? process.emitWarning
+            : console.warn.bind(console);
+          warn(
+            "assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.",
+            "DeprecationWarning",
+            "DEP0094",
+          );
+        }
+        if (argsLen === 2) operator = "!=";
+      }
+      if (message instanceof Error) throw message;
+      var errArgs = {
+        actual,
+        expected,
+        operator: operator === void 0 ? "fail" : operator,
+        stackStartFn: stackStartFn || fail,
+      };
+      if (message !== void 0) {
+        errArgs.message = message;
+      }
+      var err = new AssertionError(errArgs);
+      if (internalMessage) {
+        err.message = internalMessage;
+        err.generatedMessage = true;
+      }
+      throw err;
+    }
+    assert.fail = fail;
+    assert.AssertionError = AssertionError;
+    function innerOk(fn, argLen, value, message) {
+      if (!value) {
+        var generatedMessage = false;
+        if (argLen === 0) {
+          generatedMessage = true;
+          message = "No value argument passed to `assert.ok()`";
+        } else if (message instanceof Error) {
+          throw message;
+        }
+        var err = new AssertionError({
+          actual: value,
+          expected: true,
+          message,
+          operator: "==",
+          stackStartFn: fn,
+        });
+        err.generatedMessage = generatedMessage;
+        throw err;
+      }
+    }
+    function ok() {
+      for (
+        var _len = arguments.length, args = new Array(_len), _key = 0;
+        _key < _len;
+        _key++
+      ) {
+        args[_key] = arguments[_key];
+      }
+      innerOk.apply(void 0, [ok, args.length].concat(args));
+    }
+    assert.ok = ok;
+    assert.equal = function equal(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (actual != expected) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "==",
+          stackStartFn: equal,
+        });
+      }
+    };
+    assert.notEqual = function notEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (actual == expected) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "!=",
+          stackStartFn: notEqual,
+        });
+      }
+    };
+    assert.deepEqual = function deepEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (!isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepEqual",
+          stackStartFn: deepEqual,
+        });
+      }
+    };
+    assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepEqual",
+          stackStartFn: notDeepEqual,
+        });
+      }
+    };
+    assert.deepStrictEqual = function deepStrictEqual(
+      actual,
+      expected,
+      message,
+    ) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (!isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepStrictEqual",
+          stackStartFn: deepStrictEqual,
+        });
+      }
+    };
+    assert.notDeepStrictEqual = notDeepStrictEqual;
+    function notDeepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepStrictEqual",
+          stackStartFn: notDeepStrictEqual,
+        });
+      }
+    }
+    assert.strictEqual = function strictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (!objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "strictEqual",
+          stackStartFn: strictEqual,
+        });
+      }
+    };
+    assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notStrictEqual",
+          stackStartFn: notStrictEqual,
+        });
+      }
+    };
+    var Comparison = function Comparison2(obj, keys, actual) {
+      var _this = this;
+      _classCallCheck(this, Comparison2);
+      keys.forEach(function (key) {
+        if (key in obj) {
+          if (
+            actual !== void 0 &&
+            typeof actual[key] === "string" &&
+            isRegExp(obj[key]) &&
+            obj[key].test(actual[key])
+          ) {
+            _this[key] = actual[key];
+          } else {
+            _this[key] = obj[key];
+          }
+        }
+      });
+    };
+    function compareExceptionKey(actual, expected, key, message, keys, fn) {
+      if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+        if (!message) {
+          var a = new Comparison(actual, keys);
+          var b = new Comparison(expected, keys, actual);
+          var err = new AssertionError({
+            actual: a,
+            expected: b,
+            operator: "deepStrictEqual",
+            stackStartFn: fn,
+          });
+          err.actual = actual;
+          err.expected = expected;
+          err.operator = fn.name;
+          throw err;
+        }
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: fn.name,
+          stackStartFn: fn,
+        });
+      }
+    }
+    function expectedException(actual, expected, msg, fn) {
+      if (typeof expected !== "function") {
+        if (isRegExp(expected)) return expected.test(actual);
+        if (arguments.length === 2) {
+          throw new ERR_INVALID_ARG_TYPE(
+            "expected",
+            ["Function", "RegExp"],
+            expected,
+          );
+        }
+        if (_typeof(actual) !== "object" || actual === null) {
+          var err = new AssertionError({
+            actual,
+            expected,
+            message: msg,
+            operator: "deepStrictEqual",
+            stackStartFn: fn,
+          });
+          err.operator = fn.name;
+          throw err;
+        }
+        var keys = Object.keys(expected);
+        if (expected instanceof Error) {
+          keys.push("name", "message");
+        } else if (keys.length === 0) {
+          throw new ERR_INVALID_ARG_VALUE(
+            "error",
+            expected,
+            "may not be an empty object",
+          );
+        }
+        if (isDeepEqual === void 0) lazyLoadComparison();
+        keys.forEach(function (key) {
+          if (
+            typeof actual[key] === "string" &&
+            isRegExp(expected[key]) &&
+            expected[key].test(actual[key])
+          ) {
+            return;
+          }
+          compareExceptionKey(actual, expected, key, msg, keys, fn);
+        });
+        return true;
+      }
+      if (expected.prototype !== void 0 && actual instanceof expected) {
+        return true;
+      }
+      if (Error.isPrototypeOf(expected)) {
+        return false;
+      }
+      return expected.call({}, actual) === true;
+    }
+    function getActual(fn) {
+      if (typeof fn !== "function") {
+        throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+      }
+      try {
+        fn();
+      } catch (e) {
+        return e;
+      }
+      return NO_EXCEPTION_SENTINEL;
+    }
+    function checkIsPromise(obj) {
+      return (
+        isPromise(obj) ||
+        (obj !== null &&
+          _typeof(obj) === "object" &&
+          typeof obj.then === "function" &&
+          typeof obj.catch === "function")
+      );
+    }
+    function waitForActual(promiseFn) {
+      return Promise.resolve().then(function () {
+        var resultPromise;
+        if (typeof promiseFn === "function") {
+          resultPromise = promiseFn();
+          if (!checkIsPromise(resultPromise)) {
+            throw new ERR_INVALID_RETURN_VALUE(
+              "instance of Promise",
+              "promiseFn",
+              resultPromise,
+            );
+          }
+        } else if (checkIsPromise(promiseFn)) {
+          resultPromise = promiseFn;
+        } else {
+          throw new ERR_INVALID_ARG_TYPE(
+            "promiseFn",
+            ["Function", "Promise"],
+            promiseFn,
+          );
+        }
+        return Promise.resolve()
+          .then(function () {
+            return resultPromise;
+          })
+          .then(function () {
+            return NO_EXCEPTION_SENTINEL;
+          })
+          .catch(function (e) {
+            return e;
+          });
+      });
+    }
+    function expectsError(stackStartFn, actual, error, message) {
+      if (typeof error === "string") {
+        if (arguments.length === 4) {
+          throw new ERR_INVALID_ARG_TYPE(
+            "error",
+            ["Object", "Error", "Function", "RegExp"],
+            error,
+          );
+        }
+        if (_typeof(actual) === "object" && actual !== null) {
+          if (actual.message === error) {
+            throw new ERR_AMBIGUOUS_ARGUMENT(
+              "error/message",
+              'The error message "'.concat(
+                actual.message,
+                '" is identical to the message.',
+              ),
+            );
+          }
+        } else if (actual === error) {
+          throw new ERR_AMBIGUOUS_ARGUMENT(
+            "error/message",
+            'The error "'.concat(actual, '" is identical to the message.'),
+          );
+        }
+        message = error;
+        error = void 0;
+      } else if (
+        error != null &&
+        _typeof(error) !== "object" &&
+        typeof error !== "function"
+      ) {
+        throw new ERR_INVALID_ARG_TYPE(
+          "error",
+          ["Object", "Error", "Function", "RegExp"],
+          error,
+        );
+      }
+      if (actual === NO_EXCEPTION_SENTINEL) {
+        var details = "";
+        if (error && error.name) {
+          details += " (".concat(error.name, ")");
+        }
+        details += message ? ": ".concat(message) : ".";
+        var fnType =
+          stackStartFn.name === "rejects" ? "rejection" : "exception";
+        innerFail({
+          actual: void 0,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Missing expected ".concat(fnType).concat(details),
+          stackStartFn,
+        });
+      }
+      if (error && !expectedException(actual, error, message, stackStartFn)) {
+        throw actual;
+      }
+    }
+    function expectsNoError(stackStartFn, actual, error, message) {
+      if (actual === NO_EXCEPTION_SENTINEL) return;
+      if (typeof error === "string") {
+        message = error;
+        error = void 0;
+      }
+      if (!error || expectedException(actual, error)) {
+        var details = message ? ": ".concat(message) : ".";
+        var fnType =
+          stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+        innerFail({
+          actual,
+          expected: error,
+          operator: stackStartFn.name,
+          message:
+            "Got unwanted ".concat(fnType).concat(details, "\n") +
+            'Actual message: "'.concat(actual && actual.message, '"'),
+          stackStartFn,
+        });
+      }
+      throw actual;
+    }
+    assert.throws = function throws(promiseFn) {
+      for (
+        var _len2 = arguments.length,
+          args = new Array(_len2 > 1 ? _len2 - 1 : 0),
+          _key2 = 1;
+        _key2 < _len2;
+        _key2++
+      ) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
+    };
+    assert.rejects = function rejects(promiseFn) {
+      for (
+        var _len3 = arguments.length,
+          args = new Array(_len3 > 1 ? _len3 - 1 : 0),
+          _key3 = 1;
+        _key3 < _len3;
+        _key3++
+      ) {
+        args[_key3 - 1] = arguments[_key3];
+      }
+      return waitForActual(promiseFn).then(function (result) {
+        return expectsError.apply(void 0, [rejects, result].concat(args));
+      });
+    };
+    assert.doesNotThrow = function doesNotThrow(fn) {
+      for (
+        var _len4 = arguments.length,
+          args = new Array(_len4 > 1 ? _len4 - 1 : 0),
+          _key4 = 1;
+        _key4 < _len4;
+        _key4++
+      ) {
+        args[_key4 - 1] = arguments[_key4];
+      }
+      expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
+    };
+    assert.doesNotReject = function doesNotReject(fn) {
+      for (
+        var _len5 = arguments.length,
+          args = new Array(_len5 > 1 ? _len5 - 1 : 0),
+          _key5 = 1;
+        _key5 < _len5;
+        _key5++
+      ) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      return waitForActual(fn).then(function (result) {
+        return expectsNoError.apply(
+          void 0,
+          [doesNotReject, result].concat(args),
+        );
+      });
+    };
+    assert.ifError = function ifError(err) {
+      if (err !== null && err !== void 0) {
+        var message = "ifError got unwanted exception: ";
+        if (_typeof(err) === "object" && typeof err.message === "string") {
+          if (err.message.length === 0 && err.constructor) {
+            message += err.constructor.name;
+          } else {
+            message += err.message;
+          }
+        } else {
+          message += inspect(err);
+        }
+        var newErr = new AssertionError({
+          actual: err,
+          expected: null,
+          operator: "ifError",
+          message,
+          stackStartFn: ifError,
+        });
+        var origStack = err.stack;
+        if (typeof origStack === "string") {
+          var tmp2 = origStack.split("\n");
+          tmp2.shift();
+          var tmp1 = newErr.stack.split("\n");
+          for (var i = 0; i < tmp2.length; i++) {
+            var pos = tmp1.indexOf(tmp2[i]);
+            if (pos !== -1) {
+              tmp1 = tmp1.slice(0, pos);
+              break;
+            }
+          }
+          newErr.stack = ""
+            .concat(tmp1.join("\n"), "\n")
+            .concat(tmp2.join("\n"));
+        }
+        throw newErr;
+      }
+    };
+    function strict() {
+      for (
+        var _len6 = arguments.length, args = new Array(_len6), _key6 = 0;
+        _key6 < _len6;
+        _key6++
+      ) {
+        args[_key6] = arguments[_key6];
+      }
+      innerOk.apply(void 0, [strict, args.length].concat(args));
+    }
+    assert.strict = objectAssign(strict, assert, {
+      equal: assert.strictEqual,
+      deepEqual: assert.deepStrictEqual,
+      notEqual: assert.notStrictEqual,
+      notDeepEqual: assert.notDeepStrictEqual,
+    });
+    assert.strict.strict = assert.strict;
+  },
+});
+
+// node_modules/memfs/lib/internal/errors.js
+var require_errors2 = __commonJS({
+  "node_modules/memfs/lib/internal/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.E =
+      exports.AssertionError =
+      exports.message =
+      exports.RangeError =
+      exports.TypeError =
+      exports.Error =
+        void 0;
+    var assert = require_assert();
+    var util = require_util();
+    var kCode = typeof Symbol === "undefined" ? "_kCode" : Symbol("code");
+    var messages = {};
+    function makeNodeError(Base) {
+      return class NodeError extends Base {
+        constructor(key, ...args) {
+          super(message(key, args));
+          this.code = key;
+          this[kCode] = key;
+          this.name = `${super.name} [${this[kCode]}]`;
+        }
+      };
+    }
+    var g = typeof globalThis !== "undefined" ? globalThis : global;
+    var AssertionError = class extends g.Error {
+      constructor(options) {
+        if (typeof options !== "object" || options === null) {
+          throw new exports.TypeError(
+            "ERR_INVALID_ARG_TYPE",
+            "options",
+            "object",
+          );
+        }
+        if (options.message) {
+          super(options.message);
+        } else {
+          super(
+            `${util.inspect(options.actual).slice(0, 128)} ${options.operator} ${util.inspect(options.expected).slice(0, 128)}`,
+          );
+        }
+        this.generatedMessage = !options.message;
+        this.name = "AssertionError [ERR_ASSERTION]";
+        this.code = "ERR_ASSERTION";
+        this.actual = options.actual;
+        this.expected = options.expected;
+        this.operator = options.operator;
+        exports.Error.captureStackTrace(this, options.stackStartFunction);
+      }
+    };
+    exports.AssertionError = AssertionError;
+    function message(key, args) {
+      assert.strictEqual(typeof key, "string");
+      const msg = messages[key];
+      assert(msg, `An invalid error message key was used: ${key}.`);
+      let fmt;
+      if (typeof msg === "function") {
+        fmt = msg;
+      } else {
+        fmt = util.format;
+        if (args === void 0 || args.length === 0) return msg;
+        args.unshift(msg);
+      }
+      return String(fmt.apply(null, args));
+    }
+    exports.message = message;
+    function E(sym, val) {
+      messages[sym] = typeof val === "function" ? val : String(val);
+    }
+    exports.E = E;
+    exports.Error = makeNodeError(g.Error);
+    exports.TypeError = makeNodeError(g.TypeError);
+    exports.RangeError = makeNodeError(g.RangeError);
+    E("ERR_ARG_NOT_ITERABLE", "%s must be iterable");
+    E("ERR_ASSERTION", "%s");
+    E("ERR_BUFFER_OUT_OF_BOUNDS", bufferOutOfBounds);
+    E("ERR_CHILD_CLOSED_BEFORE_REPLY", "Child closed before reply received");
+    E(
+      "ERR_CONSOLE_WRITABLE_STREAM",
+      "Console expects a writable stream instance for %s",
+    );
+    E("ERR_CPU_USAGE", "Unable to obtain cpu usage %s");
+    E(
+      "ERR_DNS_SET_SERVERS_FAILED",
+      (err, servers) => `c-ares failed to set servers: "${err}" [${servers}]`,
+    );
+    E("ERR_FALSY_VALUE_REJECTION", "Promise was rejected with falsy value");
+    E(
+      "ERR_ENCODING_NOT_SUPPORTED",
+      (enc) => `The "${enc}" encoding is not supported`,
+    );
+    E(
+      "ERR_ENCODING_INVALID_ENCODED_DATA",
+      (enc) => `The encoded data was not valid for encoding ${enc}`,
+    );
+    E(
+      "ERR_HTTP_HEADERS_SENT",
+      "Cannot render headers after they are sent to the client",
+    );
+    E("ERR_HTTP_INVALID_STATUS_CODE", "Invalid status code: %s");
+    E(
+      "ERR_HTTP_TRAILER_INVALID",
+      "Trailers are invalid with this transfer encoding",
+    );
+    E("ERR_INDEX_OUT_OF_RANGE", "Index out of range");
+    E("ERR_INVALID_ARG_TYPE", invalidArgType);
+    E("ERR_INVALID_ARRAY_LENGTH", (name, len, actual) => {
+      assert.strictEqual(typeof actual, "number");
+      return `The array "${name}" (length ${actual}) must be of length ${len}.`;
+    });
+    E("ERR_INVALID_BUFFER_SIZE", "Buffer size must be a multiple of %s");
+    E("ERR_INVALID_CALLBACK", "Callback must be a function");
+    E("ERR_INVALID_CHAR", "Invalid character in %s");
+    E(
+      "ERR_INVALID_CURSOR_POS",
+      "Cannot set cursor row without setting its column",
+    );
+    E("ERR_INVALID_FD", '"fd" must be a positive integer: %s');
+    E(
+      "ERR_INVALID_FILE_URL_HOST",
+      'File URL host must be "localhost" or empty on %s',
+    );
+    E("ERR_INVALID_FILE_URL_PATH", "File URL path %s");
+    E("ERR_INVALID_HANDLE_TYPE", "This handle type cannot be sent");
+    E("ERR_INVALID_IP_ADDRESS", "Invalid IP address: %s");
+    E("ERR_INVALID_OPT_VALUE", (name, value) => {
+      return `The value "${String(value)}" is invalid for option "${name}"`;
+    });
+    E(
+      "ERR_INVALID_OPT_VALUE_ENCODING",
+      (value) =>
+        `The value "${String(value)}" is invalid for option "encoding"`,
+    );
+    E(
+      "ERR_INVALID_REPL_EVAL_CONFIG",
+      'Cannot specify both "breakEvalOnSigint" and "eval" for REPL',
+    );
+    E(
+      "ERR_INVALID_SYNC_FORK_INPUT",
+      "Asynchronous forks do not support Buffer, Uint8Array or string input: %s",
+    );
+    E("ERR_INVALID_THIS", 'Value of "this" must be of type %s');
+    E("ERR_INVALID_TUPLE", "%s must be an iterable %s tuple");
+    E("ERR_INVALID_URL", "Invalid URL: %s");
+    E(
+      "ERR_INVALID_URL_SCHEME",
+      (expected) => `The URL must be ${oneOf(expected, "scheme")}`,
+    );
+    E("ERR_IPC_CHANNEL_CLOSED", "Channel closed");
+    E("ERR_IPC_DISCONNECTED", "IPC channel is already disconnected");
+    E("ERR_IPC_ONE_PIPE", "Child process can have only one IPC pipe");
+    E("ERR_IPC_SYNC_FORK", "IPC cannot be used with synchronous forks");
+    E("ERR_MISSING_ARGS", missingArgs);
+    E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+    E("ERR_NAPI_CONS_FUNCTION", "Constructor must be a function");
+    E(
+      "ERR_NAPI_CONS_PROTOTYPE_OBJECT",
+      "Constructor.prototype must be an object",
+    );
+    E("ERR_NO_CRYPTO", "Node.js is not compiled with OpenSSL crypto support");
+    E("ERR_NO_LONGER_SUPPORTED", "%s is no longer supported");
+    E("ERR_PARSE_HISTORY_DATA", "Could not parse history data in %s");
+    E("ERR_SOCKET_ALREADY_BOUND", "Socket is already bound");
+    E("ERR_SOCKET_BAD_PORT", "Port should be > 0 and < 65536");
+    E(
+      "ERR_SOCKET_BAD_TYPE",
+      "Bad socket type specified. Valid types are: udp4, udp6",
+    );
+    E("ERR_SOCKET_CANNOT_SEND", "Unable to send data");
+    E("ERR_SOCKET_CLOSED", "Socket is closed");
+    E("ERR_SOCKET_DGRAM_NOT_RUNNING", "Not running");
+    E("ERR_STDERR_CLOSE", "process.stderr cannot be closed");
+    E("ERR_STDOUT_CLOSE", "process.stdout cannot be closed");
+    E("ERR_STREAM_WRAP", "Stream has StringDecoder set or is in objectMode");
+    E(
+      "ERR_TLS_CERT_ALTNAME_INVALID",
+      "Hostname/IP does not match certificate's altnames: %s",
+    );
+    E(
+      "ERR_TLS_DH_PARAM_SIZE",
+      (size) => `DH parameter size ${size} is less than 2048`,
+    );
+    E("ERR_TLS_HANDSHAKE_TIMEOUT", "TLS handshake timeout");
+    E("ERR_TLS_RENEGOTIATION_FAILED", "Failed to renegotiate");
+    E(
+      "ERR_TLS_REQUIRED_SERVER_NAME",
+      '"servername" is required parameter for Server.addContext',
+    );
+    E("ERR_TLS_SESSION_ATTACK", "TSL session renegotiation attack detected");
+    E(
+      "ERR_TRANSFORM_ALREADY_TRANSFORMING",
+      "Calling transform done when still transforming",
+    );
+    E(
+      "ERR_TRANSFORM_WITH_LENGTH_0",
+      "Calling transform done when writableState.length != 0",
+    );
+    E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s");
+    E("ERR_UNKNOWN_SIGNAL", "Unknown signal: %s");
+    E("ERR_UNKNOWN_STDIN_TYPE", "Unknown stdin file type");
+    E("ERR_UNKNOWN_STREAM_TYPE", "Unknown stream file type");
+    E(
+      "ERR_V8BREAKITERATOR",
+      "Full ICU data not installed. See https://github.com/nodejs/node/wiki/Intl",
+    );
+    function invalidArgType(name, expected, actual) {
+      assert(name, "name is required");
+      let determiner;
+      if (expected.includes("not ")) {
+        determiner = "must not be";
+        expected = expected.split("not ")[1];
+      } else {
+        determiner = "must be";
+      }
+      let msg;
+      if (Array.isArray(name)) {
+        const names = name.map((val) => `"${val}"`).join(", ");
+        msg = `The ${names} arguments ${determiner} ${oneOf(expected, "type")}`;
+      } else if (name.includes(" argument")) {
+        msg = `The ${name} ${determiner} ${oneOf(expected, "type")}`;
+      } else {
+        const type = name.includes(".") ? "property" : "argument";
+        msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, "type")}`;
+      }
+      if (arguments.length >= 3) {
+        msg += `. Received type ${actual !== null ? typeof actual : "null"}`;
+      }
+      return msg;
+    }
+    function missingArgs(...args) {
+      assert(args.length > 0, "At least one arg needs to be specified");
+      let msg = "The ";
+      const len = args.length;
+      args = args.map((a) => `"${a}"`);
+      switch (len) {
+        case 1:
+          msg += `${args[0]} argument`;
+          break;
+        case 2:
+          msg += `${args[0]} and ${args[1]} arguments`;
+          break;
+        default:
+          msg += args.slice(0, len - 1).join(", ");
+          msg += `, and ${args[len - 1]} arguments`;
+          break;
+      }
+      return `${msg} must be specified`;
+    }
+    function oneOf(expected, thing) {
+      assert(expected, "expected is required");
+      assert(typeof thing === "string", "thing is required");
+      if (Array.isArray(expected)) {
+        const len = expected.length;
+        assert(len > 0, "At least one expected value needs to be specified");
+        expected = expected.map((i) => String(i));
+        if (len > 2) {
+          return (
+            `one of ${thing} ${expected.slice(0, len - 1).join(", ")}, or ` +
+            expected[len - 1]
+          );
+        } else if (len === 2) {
+          return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+        } else {
+          return `of ${thing} ${expected[0]}`;
+        }
+      } else {
+        return `of ${thing} ${String(expected)}`;
+      }
+    }
+    function bufferOutOfBounds(name, isWriting) {
+      if (isWriting) {
+        return "Attempt to write outside buffer bounds";
+      } else {
+        return `"${name}" is outside of buffer bounds`;
+      }
+    }
+  },
+});
+
+// node_modules/memfs/lib/encoding.js
+var require_encoding = __commonJS({
+  "node_modules/memfs/lib/encoding.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.strToEncoding =
+      exports.assertEncoding =
+      exports.ENCODING_UTF8 =
+        void 0;
+    var buffer_1 = require_buffer2();
+    var errors = require_errors2();
+    exports.ENCODING_UTF8 = "utf8";
+    function assertEncoding(encoding) {
+      if (encoding && !buffer_1.Buffer.isEncoding(encoding))
+        throw new errors.TypeError("ERR_INVALID_OPT_VALUE_ENCODING", encoding);
+    }
+    exports.assertEncoding = assertEncoding;
+    function strToEncoding(str, encoding) {
+      if (!encoding || encoding === exports.ENCODING_UTF8) return str;
+      if (encoding === "buffer") return new buffer_1.Buffer(str);
+      return new buffer_1.Buffer(str).toString(encoding);
+    }
+    exports.strToEncoding = strToEncoding;
+  },
+});
+
+// node_modules/memfs/lib/Dirent.js
+var require_Dirent = __commonJS({
+  "node_modules/memfs/lib/Dirent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Dirent = void 0;
+    var constants_1 = require_constants();
+    var encoding_1 = require_encoding();
+    var {
+      S_IFMT,
+      S_IFDIR,
+      S_IFREG,
+      S_IFBLK,
+      S_IFCHR,
+      S_IFLNK,
+      S_IFIFO,
+      S_IFSOCK,
+    } = constants_1.constants;
+    var Dirent = class _Dirent {
+      constructor() {
+        this.name = "";
+        this.path = "";
+        this.mode = 0;
+      }
+      static build(link, encoding) {
+        const dirent = new _Dirent();
+        const { mode } = link.getNode();
+        dirent.name = (0, encoding_1.strToEncoding)(link.getName(), encoding);
+        dirent.mode = mode;
+        dirent.path = link.getPath();
+        return dirent;
+      }
+      _checkModeProperty(property) {
+        return (this.mode & S_IFMT) === property;
+      }
+      isDirectory() {
+        return this._checkModeProperty(S_IFDIR);
+      }
+      isFile() {
+        return this._checkModeProperty(S_IFREG);
+      }
+      isBlockDevice() {
+        return this._checkModeProperty(S_IFBLK);
+      }
+      isCharacterDevice() {
+        return this._checkModeProperty(S_IFCHR);
+      }
+      isSymbolicLink() {
+        return this._checkModeProperty(S_IFLNK);
+      }
+      isFIFO() {
+        return this._checkModeProperty(S_IFIFO);
+      }
+      isSocket() {
+        return this._checkModeProperty(S_IFSOCK);
+      }
+    };
+    exports.Dirent = Dirent;
+    exports.default = Dirent;
+  },
+});
+
+// node_modules/path/node_modules/util/support/isBufferBrowser.js
+var require_isBufferBrowser2 = __commonJS({
+  "node_modules/path/node_modules/util/support/isBufferBrowser.js"(
+    exports,
+    module,
+  ) {
+    module.exports = function isBuffer(arg) {
+      return (
+        arg &&
+        typeof arg === "object" &&
+        typeof arg.copy === "function" &&
+        typeof arg.fill === "function" &&
+        typeof arg.readUInt8 === "function"
+      );
+    };
+  },
+});
+
+// node_modules/path/node_modules/inherits/inherits_browser.js
+var require_inherits_browser2 = __commonJS({
+  "node_modules/path/node_modules/inherits/inherits_browser.js"(
+    exports,
+    module,
+  ) {
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
+          constructor: {
+            value: ctor,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+          },
+        });
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        ctor.super_ = superCtor;
+        var TempCtor = function () {};
+        TempCtor.prototype = superCtor.prototype;
+        ctor.prototype = new TempCtor();
+        ctor.prototype.constructor = ctor;
+      };
+    }
+  },
+});
+
+// node_modules/path/node_modules/util/util.js
+var require_util2 = __commonJS({
+  "node_modules/path/node_modules/util/util.js"(exports) {
+    var formatRegExp = /%[sdj%]/g;
+    exports.format = function (f) {
+      if (!isString(f)) {
+        var objects = [];
+        for (var i = 0; i < arguments.length; i++) {
+          objects.push(inspect(arguments[i]));
+        }
+        return objects.join(" ");
+      }
+      var i = 1;
+      var args = arguments;
+      var len = args.length;
+      var str = String(f).replace(formatRegExp, function (x2) {
+        if (x2 === "%%") return "%";
+        if (i >= len) return x2;
+        switch (x2) {
+          case "%s":
+            return String(args[i++]);
+          case "%d":
+            return Number(args[i++]);
+          case "%j":
+            try {
+              return JSON.stringify(args[i++]);
+            } catch (_) {
+              return "[Circular]";
+            }
+          default:
+            return x2;
+        }
+      });
+      for (var x = args[i]; i < len; x = args[++i]) {
+        if (isNull(x) || !isObject(x)) {
+          str += " " + x;
+        } else {
+          str += " " + inspect(x);
+        }
+      }
+      return str;
+    };
+    exports.deprecate = function (fn, msg) {
+      if (isUndefined(global.process)) {
+        return function () {
+          return exports.deprecate(fn, msg).apply(this, arguments);
+        };
+      }
+      if (process.noDeprecation === true) {
+        return fn;
+      }
+      var warned = false;
+      function deprecated() {
+        if (!warned) {
+          if (process.throwDeprecation) {
+            throw new Error(msg);
+          } else if (process.traceDeprecation) {
+            console.trace(msg);
+          } else {
+            console.error(msg);
+          }
+          warned = true;
+        }
+        return fn.apply(this, arguments);
+      }
+      return deprecated;
+    };
+    var debugs = {};
+    var debugEnviron;
+    exports.debuglog = function (set) {
+      if (isUndefined(debugEnviron))
+        debugEnviron = process.env.NODE_DEBUG || "";
+      set = set.toUpperCase();
+      if (!debugs[set]) {
+        if (new RegExp("\\b" + set + "\\b", "i").test(debugEnviron)) {
+          var pid = process.pid;
+          debugs[set] = function () {
+            var msg = exports.format.apply(exports, arguments);
+            console.error("%s %d: %s", set, pid, msg);
+          };
+        } else {
+          debugs[set] = function () {};
+        }
+      }
+      return debugs[set];
+    };
+    function inspect(obj, opts) {
+      var ctx = {
+        seen: [],
+        stylize: stylizeNoColor,
+      };
+      if (arguments.length >= 3) ctx.depth = arguments[2];
+      if (arguments.length >= 4) ctx.colors = arguments[3];
+      if (isBoolean(opts)) {
+        ctx.showHidden = opts;
+      } else if (opts) {
+        exports._extend(ctx, opts);
+      }
+      if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+      if (isUndefined(ctx.depth)) ctx.depth = 2;
+      if (isUndefined(ctx.colors)) ctx.colors = false;
+      if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+      if (ctx.colors) ctx.stylize = stylizeWithColor;
+      return formatValue(ctx, obj, ctx.depth);
+    }
+    exports.inspect = inspect;
+    inspect.colors = {
+      bold: [1, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      white: [37, 39],
+      grey: [90, 39],
+      black: [30, 39],
+      blue: [34, 39],
+      cyan: [36, 39],
+      green: [32, 39],
+      magenta: [35, 39],
+      red: [31, 39],
+      yellow: [33, 39],
+    };
+    inspect.styles = {
+      special: "cyan",
+      number: "yellow",
+      boolean: "yellow",
+      undefined: "grey",
+      null: "bold",
+      string: "green",
+      date: "magenta",
+      // "name": intentionally not styling
+      regexp: "red",
+    };
+    function stylizeWithColor(str, styleType) {
+      var style = inspect.styles[styleType];
+      if (style) {
+        return (
+          "\x1B[" +
+          inspect.colors[style][0] +
+          "m" +
+          str +
+          "\x1B[" +
+          inspect.colors[style][1] +
+          "m"
+        );
+      } else {
+        return str;
+      }
+    }
+    function stylizeNoColor(str, styleType) {
+      return str;
+    }
+    function arrayToHash(array) {
+      var hash = {};
+      array.forEach(function (val, idx) {
+        hash[val] = true;
+      });
+      return hash;
+    }
+    function formatValue(ctx, value, recurseTimes) {
+      if (
+        ctx.customInspect &&
+        value &&
+        isFunction(value.inspect) && // Filter out the util module, it's inspect function is special
+        value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
+        !(value.constructor && value.constructor.prototype === value)
+      ) {
+        var ret = value.inspect(recurseTimes, ctx);
+        if (!isString(ret)) {
+          ret = formatValue(ctx, ret, recurseTimes);
+        }
+        return ret;
+      }
+      var primitive = formatPrimitive(ctx, value);
+      if (primitive) {
+        return primitive;
+      }
+      var keys = Object.keys(value);
+      var visibleKeys = arrayToHash(keys);
+      if (ctx.showHidden) {
+        keys = Object.getOwnPropertyNames(value);
+      }
+      if (
+        isError(value) &&
+        (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)
+      ) {
+        return formatError(value);
+      }
+      if (keys.length === 0) {
+        if (isFunction(value)) {
+          var name = value.name ? ": " + value.name : "";
+          return ctx.stylize("[Function" + name + "]", "special");
+        }
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        }
+        if (isDate(value)) {
+          return ctx.stylize(Date.prototype.toString.call(value), "date");
+        }
+        if (isError(value)) {
+          return formatError(value);
+        }
+      }
+      var base = "",
+        array = false,
+        braces = ["{", "}"];
+      if (isArray(value)) {
+        array = true;
+        braces = ["[", "]"];
+      }
+      if (isFunction(value)) {
+        var n = value.name ? ": " + value.name : "";
+        base = " [Function" + n + "]";
+      }
+      if (isRegExp(value)) {
+        base = " " + RegExp.prototype.toString.call(value);
+      }
+      if (isDate(value)) {
+        base = " " + Date.prototype.toUTCString.call(value);
+      }
+      if (isError(value)) {
+        base = " " + formatError(value);
+      }
+      if (keys.length === 0 && (!array || value.length == 0)) {
+        return braces[0] + base + braces[1];
+      }
+      if (recurseTimes < 0) {
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        } else {
+          return ctx.stylize("[Object]", "special");
+        }
+      }
+      ctx.seen.push(value);
+      var output;
+      if (array) {
+        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+      } else {
+        output = keys.map(function (key) {
+          return formatProperty(
+            ctx,
+            value,
+            recurseTimes,
+            visibleKeys,
+            key,
+            array,
+          );
+        });
+      }
+      ctx.seen.pop();
+      return reduceToSingleString(output, base, braces);
+    }
+    function formatPrimitive(ctx, value) {
+      if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
+      if (isString(value)) {
+        var simple =
+          "'" +
+          JSON.stringify(value)
+            .replace(/^"|"$/g, "")
+            .replace(/'/g, "\\'")
+            .replace(/\\"/g, '"') +
+          "'";
+        return ctx.stylize(simple, "string");
+      }
+      if (isNumber(value)) return ctx.stylize("" + value, "number");
+      if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
+      if (isNull(value)) return ctx.stylize("null", "null");
+    }
+    function formatError(value) {
+      return "[" + Error.prototype.toString.call(value) + "]";
+    }
+    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+      var output = [];
+      for (var i = 0, l = value.length; i < l; ++i) {
+        if (hasOwnProperty(value, String(i))) {
+          output.push(
+            formatProperty(
+              ctx,
+              value,
+              recurseTimes,
+              visibleKeys,
+              String(i),
+              true,
+            ),
+          );
+        } else {
+          output.push("");
+        }
+      }
+      keys.forEach(function (key) {
+        if (!key.match(/^\d+$/)) {
+          output.push(
+            formatProperty(ctx, value, recurseTimes, visibleKeys, key, true),
+          );
+        }
+      });
+      return output;
+    }
+    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+      var name, str, desc;
+      desc = Object.getOwnPropertyDescriptor(value, key) || {
+        value: value[key],
+      };
+      if (desc.get) {
+        if (desc.set) {
+          str = ctx.stylize("[Getter/Setter]", "special");
+        } else {
+          str = ctx.stylize("[Getter]", "special");
+        }
+      } else {
+        if (desc.set) {
+          str = ctx.stylize("[Setter]", "special");
+        }
+      }
+      if (!hasOwnProperty(visibleKeys, key)) {
+        name = "[" + key + "]";
+      }
+      if (!str) {
+        if (ctx.seen.indexOf(desc.value) < 0) {
+          if (isNull(recurseTimes)) {
+            str = formatValue(ctx, desc.value, null);
+          } else {
+            str = formatValue(ctx, desc.value, recurseTimes - 1);
+          }
+          if (str.indexOf("\n") > -1) {
+            if (array) {
+              str = str
+                .split("\n")
+                .map(function (line) {
+                  return "  " + line;
+                })
+                .join("\n")
+                .substr(2);
+            } else {
+              str =
+                "\n" +
+                str
+                  .split("\n")
+                  .map(function (line) {
+                    return "   " + line;
+                  })
+                  .join("\n");
+            }
+          }
+        } else {
+          str = ctx.stylize("[Circular]", "special");
+        }
+      }
+      if (isUndefined(name)) {
+        if (array && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify("" + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.substr(1, name.length - 2);
+          name = ctx.stylize(name, "name");
+        } else {
+          name = name
+            .replace(/'/g, "\\'")
+            .replace(/\\"/g, '"')
+            .replace(/(^"|"$)/g, "'");
+          name = ctx.stylize(name, "string");
+        }
+      }
+      return name + ": " + str;
+    }
+    function reduceToSingleString(output, base, braces) {
+      var numLinesEst = 0;
+      var length = output.reduce(function (prev, cur) {
+        numLinesEst++;
+        if (cur.indexOf("\n") >= 0) numLinesEst++;
+        return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0);
+      if (length > 60) {
+        return (
+          braces[0] +
+          (base === "" ? "" : base + "\n ") +
+          " " +
+          output.join(",\n  ") +
+          " " +
+          braces[1]
+        );
+      }
+      return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+    }
+    function isArray(ar) {
+      return Array.isArray(ar);
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return isObject(re) && objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return isObject(d) && objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    function isError(e) {
+      return (
+        isObject(e) &&
+        (objectToString(e) === "[object Error]" || e instanceof Error)
+      );
+    }
+    exports.isError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return (
+        arg === null ||
+        typeof arg === "boolean" ||
+        typeof arg === "number" ||
+        typeof arg === "string" ||
+        typeof arg === "symbol" || // ES6 symbol
+        typeof arg === "undefined"
+      );
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = require_isBufferBrowser2();
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+    function pad(n) {
+      return n < 10 ? "0" + n.toString(10) : n.toString(10);
+    }
+    var months = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec",
+    ];
+    function timestamp() {
+      var d = /* @__PURE__ */ new Date();
+      var time = [
+        pad(d.getHours()),
+        pad(d.getMinutes()),
+        pad(d.getSeconds()),
+      ].join(":");
+      return [d.getDate(), months[d.getMonth()], time].join(" ");
+    }
+    exports.log = function () {
+      console.log(
+        "%s - %s",
+        timestamp(),
+        exports.format.apply(exports, arguments),
+      );
+    };
+    exports.inherits = require_inherits_browser2();
+    exports._extend = function (origin, add) {
+      if (!add || !isObject(add)) return origin;
+      var keys = Object.keys(add);
+      var i = keys.length;
+      while (i--) {
+        origin[keys[i]] = add[keys[i]];
+      }
+      return origin;
+    };
+    function hasOwnProperty(obj, prop) {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+  },
+});
+
+// node_modules/path/path.js
+var require_path = __commonJS({
+  "node_modules/path/path.js"(exports, module) {
+    "use strict";
+    var isWindows = process.platform === "win32";
+    var util = require_util2();
+    function normalizeArray(parts, allowAboveRoot) {
+      var res = [];
+      for (var i = 0; i < parts.length; i++) {
+        var p = parts[i];
+        if (!p || p === ".") continue;
+        if (p === "..") {
+          if (res.length && res[res.length - 1] !== "..") {
+            res.pop();
+          } else if (allowAboveRoot) {
+            res.push("..");
+          }
+        } else {
+          res.push(p);
+        }
+      }
+      return res;
+    }
+    function trimArray(arr) {
+      var lastIndex = arr.length - 1;
+      var start = 0;
+      for (; start <= lastIndex; start++) {
+        if (arr[start]) break;
+      }
+      var end = lastIndex;
+      for (; end >= 0; end--) {
+        if (arr[end]) break;
+      }
+      if (start === 0 && end === lastIndex) return arr;
+      if (start > end) return [];
+      return arr.slice(start, end + 1);
+    }
+    var splitDeviceRe =
+      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+    var splitTailRe =
+      /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+    var win32 = {};
+    function win32SplitPath(filename) {
+      var result = splitDeviceRe.exec(filename),
+        device = (result[1] || "") + (result[2] || ""),
+        tail = result[3] || "";
+      var result2 = splitTailRe.exec(tail),
+        dir = result2[1],
+        basename = result2[2],
+        ext = result2[3];
+      return [device, dir, basename, ext];
+    }
+    function win32StatPath(path) {
+      var result = splitDeviceRe.exec(path),
+        device = result[1] || "",
+        isUnc = !!device && device[1] !== ":";
+      return {
+        device,
+        isUnc,
+        isAbsolute: isUnc || !!result[2],
+        // UNC paths are always absolute
+        tail: result[3],
+      };
+    }
+    function normalizeUNCRoot(device) {
+      return "\\\\" + device.replace(/^[\\\/]+/, "").replace(/[\\\/]+/g, "\\");
+    }
+    win32.resolve = function () {
+      var resolvedDevice = "",
+        resolvedTail = "",
+        resolvedAbsolute = false;
+      for (var i = arguments.length - 1; i >= -1; i--) {
+        var path;
+        if (i >= 0) {
+          path = arguments[i];
+        } else if (!resolvedDevice) {
+          path = process.cwd();
+        } else {
+          path = process.env["=" + resolvedDevice];
+          if (
+            !path ||
+            path.substr(0, 3).toLowerCase() !==
+              resolvedDevice.toLowerCase() + "\\"
+          ) {
+            path = resolvedDevice + "\\";
+          }
+        }
+        if (!util.isString(path)) {
+          throw new TypeError("Arguments to path.resolve must be strings");
+        } else if (!path) {
+          continue;
+        }
+        var result = win32StatPath(path),
+          device = result.device,
+          isUnc = result.isUnc,
+          isAbsolute = result.isAbsolute,
+          tail = result.tail;
+        if (
+          device &&
+          resolvedDevice &&
+          device.toLowerCase() !== resolvedDevice.toLowerCase()
+        ) {
+          continue;
+        }
+        if (!resolvedDevice) {
+          resolvedDevice = device;
+        }
+        if (!resolvedAbsolute) {
+          resolvedTail = tail + "\\" + resolvedTail;
+          resolvedAbsolute = isAbsolute;
+        }
+        if (resolvedDevice && resolvedAbsolute) {
+          break;
+        }
+      }
+      if (isUnc) {
+        resolvedDevice = normalizeUNCRoot(resolvedDevice);
+      }
+      resolvedTail = normalizeArray(
+        resolvedTail.split(/[\\\/]+/),
+        !resolvedAbsolute,
+      ).join("\\");
+      return (
+        resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."
+      );
+    };
+    win32.normalize = function (path) {
+      var result = win32StatPath(path),
+        device = result.device,
+        isUnc = result.isUnc,
+        isAbsolute = result.isAbsolute,
+        tail = result.tail,
+        trailingSlash = /[\\\/]$/.test(tail);
+      tail = normalizeArray(tail.split(/[\\\/]+/), !isAbsolute).join("\\");
+      if (!tail && !isAbsolute) {
+        tail = ".";
+      }
+      if (tail && trailingSlash) {
+        tail += "\\";
+      }
+      if (isUnc) {
+        device = normalizeUNCRoot(device);
+      }
+      return device + (isAbsolute ? "\\" : "") + tail;
+    };
+    win32.isAbsolute = function (path) {
+      return win32StatPath(path).isAbsolute;
+    };
+    win32.join = function () {
+      var paths = [];
+      for (var i = 0; i < arguments.length; i++) {
+        var arg = arguments[i];
+        if (!util.isString(arg)) {
+          throw new TypeError("Arguments to path.join must be strings");
+        }
+        if (arg) {
+          paths.push(arg);
+        }
+      }
+      var joined = paths.join("\\");
+      if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+        joined = joined.replace(/^[\\\/]{2,}/, "\\");
+      }
+      return win32.normalize(joined);
+    };
+    win32.relative = function (from, to) {
+      from = win32.resolve(from);
+      to = win32.resolve(to);
+      var lowerFrom = from.toLowerCase();
+      var lowerTo = to.toLowerCase();
+      var toParts = trimArray(to.split("\\"));
+      var lowerFromParts = trimArray(lowerFrom.split("\\"));
+      var lowerToParts = trimArray(lowerTo.split("\\"));
+      var length = Math.min(lowerFromParts.length, lowerToParts.length);
+      var samePartsLength = length;
+      for (var i = 0; i < length; i++) {
+        if (lowerFromParts[i] !== lowerToParts[i]) {
+          samePartsLength = i;
+          break;
+        }
+      }
+      if (samePartsLength == 0) {
+        return to;
+      }
+      var outputParts = [];
+      for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+        outputParts.push("..");
+      }
+      outputParts = outputParts.concat(toParts.slice(samePartsLength));
+      return outputParts.join("\\");
+    };
+    win32._makeLong = function (path) {
+      if (!util.isString(path)) return path;
+      if (!path) {
+        return "";
+      }
+      var resolvedPath = win32.resolve(path);
+      if (/^[a-zA-Z]\:\\/.test(resolvedPath)) {
+        return "\\\\?\\" + resolvedPath;
+      } else if (/^\\\\[^?.]/.test(resolvedPath)) {
+        return "\\\\?\\UNC\\" + resolvedPath.substring(2);
+      }
+      return path;
+    };
+    win32.dirname = function (path) {
+      var result = win32SplitPath(path),
+        root = result[0],
+        dir = result[1];
+      if (!root && !dir) {
+        return ".";
+      }
+      if (dir) {
+        dir = dir.substr(0, dir.length - 1);
+      }
+      return root + dir;
+    };
+    win32.basename = function (path, ext) {
+      var f = win32SplitPath(path)[2];
+      if (ext && f.substr(-1 * ext.length) === ext) {
+        f = f.substr(0, f.length - ext.length);
+      }
+      return f;
+    };
+    win32.extname = function (path) {
+      return win32SplitPath(path)[3];
+    };
+    win32.format = function (pathObject) {
+      if (!util.isObject(pathObject)) {
+        throw new TypeError(
+          "Parameter 'pathObject' must be an object, not " + typeof pathObject,
+        );
+      }
+      var root = pathObject.root || "";
+      if (!util.isString(root)) {
+        throw new TypeError(
+          "'pathObject.root' must be a string or undefined, not " +
+            typeof pathObject.root,
+        );
+      }
+      var dir = pathObject.dir;
+      var base = pathObject.base || "";
+      if (!dir) {
+        return base;
+      }
+      if (dir[dir.length - 1] === win32.sep) {
+        return dir + base;
+      }
+      return dir + win32.sep + base;
+    };
+    win32.parse = function (pathString) {
+      if (!util.isString(pathString)) {
+        throw new TypeError(
+          "Parameter 'pathString' must be a string, not " + typeof pathString,
+        );
+      }
+      var allParts = win32SplitPath(pathString);
+      if (!allParts || allParts.length !== 4) {
+        throw new TypeError("Invalid path '" + pathString + "'");
+      }
+      return {
+        root: allParts[0],
+        dir: allParts[0] + allParts[1].slice(0, -1),
+        base: allParts[2],
+        ext: allParts[3],
+        name: allParts[2].slice(0, allParts[2].length - allParts[3].length),
+      };
+    };
+    win32.sep = "\\";
+    win32.delimiter = ";";
+    var splitPathRe =
+      /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+    var posix = {};
+    function posixSplitPath(filename) {
+      return splitPathRe.exec(filename).slice(1);
+    }
+    posix.resolve = function () {
+      var resolvedPath = "",
+        resolvedAbsolute = false;
+      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        var path = i >= 0 ? arguments[i] : process.cwd();
+        if (!util.isString(path)) {
+          throw new TypeError("Arguments to path.resolve must be strings");
+        } else if (!path) {
+          continue;
+        }
+        resolvedPath = path + "/" + resolvedPath;
+        resolvedAbsolute = path[0] === "/";
+      }
+      resolvedPath = normalizeArray(
+        resolvedPath.split("/"),
+        !resolvedAbsolute,
+      ).join("/");
+      return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+    };
+    posix.normalize = function (path) {
+      var isAbsolute = posix.isAbsolute(path),
+        trailingSlash = path && path[path.length - 1] === "/";
+      path = normalizeArray(path.split("/"), !isAbsolute).join("/");
+      if (!path && !isAbsolute) {
+        path = ".";
+      }
+      if (path && trailingSlash) {
+        path += "/";
+      }
+      return (isAbsolute ? "/" : "") + path;
+    };
+    posix.isAbsolute = function (path) {
+      return path.charAt(0) === "/";
+    };
+    posix.join = function () {
+      var path = "";
+      for (var i = 0; i < arguments.length; i++) {
+        var segment = arguments[i];
+        if (!util.isString(segment)) {
+          throw new TypeError("Arguments to path.join must be strings");
+        }
+        if (segment) {
+          if (!path) {
+            path += segment;
+          } else {
+            path += "/" + segment;
+          }
+        }
+      }
+      return posix.normalize(path);
+    };
+    posix.relative = function (from, to) {
+      from = posix.resolve(from).substr(1);
+      to = posix.resolve(to).substr(1);
+      var fromParts = trimArray(from.split("/"));
+      var toParts = trimArray(to.split("/"));
+      var length = Math.min(fromParts.length, toParts.length);
+      var samePartsLength = length;
+      for (var i = 0; i < length; i++) {
+        if (fromParts[i] !== toParts[i]) {
+          samePartsLength = i;
+          break;
+        }
+      }
+      var outputParts = [];
+      for (var i = samePartsLength; i < fromParts.length; i++) {
+        outputParts.push("..");
+      }
+      outputParts = outputParts.concat(toParts.slice(samePartsLength));
+      return outputParts.join("/");
+    };
+    posix._makeLong = function (path) {
+      return path;
+    };
+    posix.dirname = function (path) {
+      var result = posixSplitPath(path),
+        root = result[0],
+        dir = result[1];
+      if (!root && !dir) {
+        return ".";
+      }
+      if (dir) {
+        dir = dir.substr(0, dir.length - 1);
+      }
+      return root + dir;
+    };
+    posix.basename = function (path, ext) {
+      var f = posixSplitPath(path)[2];
+      if (ext && f.substr(-1 * ext.length) === ext) {
+        f = f.substr(0, f.length - ext.length);
+      }
+      return f;
+    };
+    posix.extname = function (path) {
+      return posixSplitPath(path)[3];
+    };
+    posix.format = function (pathObject) {
+      if (!util.isObject(pathObject)) {
+        throw new TypeError(
+          "Parameter 'pathObject' must be an object, not " + typeof pathObject,
+        );
+      }
+      var root = pathObject.root || "";
+      if (!util.isString(root)) {
+        throw new TypeError(
+          "'pathObject.root' must be a string or undefined, not " +
+            typeof pathObject.root,
+        );
+      }
+      var dir = pathObject.dir ? pathObject.dir + posix.sep : "";
+      var base = pathObject.base || "";
+      return dir + base;
+    };
+    posix.parse = function (pathString) {
+      if (!util.isString(pathString)) {
+        throw new TypeError(
+          "Parameter 'pathString' must be a string, not " + typeof pathString,
+        );
+      }
+      var allParts = posixSplitPath(pathString);
+      if (!allParts || allParts.length !== 4) {
+        throw new TypeError("Invalid path '" + pathString + "'");
+      }
+      allParts[1] = allParts[1] || "";
+      allParts[2] = allParts[2] || "";
+      allParts[3] = allParts[3] || "";
+      return {
+        root: allParts[0],
+        dir: allParts[0] + allParts[1].slice(0, -1),
+        base: allParts[2],
+        ext: allParts[3],
+        name: allParts[2].slice(0, allParts[2].length - allParts[3].length),
+      };
+    };
+    posix.sep = "/";
+    posix.delimiter = ":";
+    if (isWindows) module.exports = win32;
+    else module.exports = posix;
+    module.exports.posix = posix;
+    module.exports.win32 = win32;
+  },
+});
+
+// node_modules/process/browser.js
+var require_browser = __commonJS({
+  "node_modules/process/browser.js"(exports, module) {
+    var process2 = (module.exports = {});
+    var cachedSetTimeout;
+    var cachedClearTimeout;
+    function defaultSetTimout() {
+      throw new Error("setTimeout has not been defined");
+    }
+    function defaultClearTimeout() {
+      throw new Error("clearTimeout has not been defined");
+    }
+    (function () {
+      try {
+        if (typeof setTimeout === "function") {
+          cachedSetTimeout = setTimeout;
+        } else {
+          cachedSetTimeout = defaultSetTimout;
+        }
+      } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+      }
+      try {
+        if (typeof clearTimeout === "function") {
+          cachedClearTimeout = clearTimeout;
+        } else {
+          cachedClearTimeout = defaultClearTimeout;
+        }
+      } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+      }
+    })();
+    function runTimeout(fun) {
+      if (cachedSetTimeout === setTimeout) {
+        return setTimeout(fun, 0);
+      }
+      if (
+        (cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) &&
+        setTimeout
+      ) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+      }
+      try {
+        return cachedSetTimeout(fun, 0);
+      } catch (e) {
+        try {
+          return cachedSetTimeout.call(null, fun, 0);
+        } catch (e2) {
+          return cachedSetTimeout.call(this, fun, 0);
+        }
+      }
+    }
+    function runClearTimeout(marker) {
+      if (cachedClearTimeout === clearTimeout) {
+        return clearTimeout(marker);
+      }
+      if (
+        (cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) &&
+        clearTimeout
+      ) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+      }
+      try {
+        return cachedClearTimeout(marker);
+      } catch (e) {
+        try {
+          return cachedClearTimeout.call(null, marker);
+        } catch (e2) {
+          return cachedClearTimeout.call(this, marker);
+        }
+      }
+    }
+    var queue = [];
+    var draining = false;
+    var currentQueue;
+    var queueIndex = -1;
+    function cleanUpNextTick() {
+      if (!draining || !currentQueue) {
+        return;
+      }
+      draining = false;
+      if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+      } else {
+        queueIndex = -1;
+      }
+      if (queue.length) {
+        drainQueue();
+      }
+    }
+    function drainQueue() {
+      if (draining) {
+        return;
+      }
+      var timeout = runTimeout(cleanUpNextTick);
+      draining = true;
+      var len = queue.length;
+      while (len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+          if (currentQueue) {
+            currentQueue[queueIndex].run();
+          }
+        }
+        queueIndex = -1;
+        len = queue.length;
+      }
+      currentQueue = null;
+      draining = false;
+      runClearTimeout(timeout);
+    }
+    process2.nextTick = function (fun) {
+      var args = new Array(arguments.length - 1);
+      if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+          args[i - 1] = arguments[i];
+        }
+      }
+      queue.push(new Item(fun, args));
+      if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+      }
+    };
+    function Item(fun, array) {
+      this.fun = fun;
+      this.array = array;
+    }
+    Item.prototype.run = function () {
+      this.fun.apply(null, this.array);
+    };
+    process2.title = "browser";
+    process2.browser = true;
+    process2.env = {};
+    process2.argv = [];
+    process2.version = "";
+    process2.versions = {};
+    function noop() {}
+    process2.on = noop;
+    process2.addListener = noop;
+    process2.once = noop;
+    process2.off = noop;
+    process2.removeListener = noop;
+    process2.removeAllListeners = noop;
+    process2.emit = noop;
+    process2.prependListener = noop;
+    process2.prependOnceListener = noop;
+    process2.listeners = function (name) {
+      return [];
+    };
+    process2.binding = function (name) {
+      throw new Error("process.binding is not supported");
+    };
+    process2.cwd = function () {
+      return "/";
+    };
+    process2.chdir = function (dir) {
+      throw new Error("process.chdir is not supported");
+    };
+    process2.umask = function () {
+      return 0;
+    };
+  },
+});
+
+// node_modules/memfs/lib/process.js
+var require_process = __commonJS({
+  "node_modules/memfs/lib/process.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createProcess = void 0;
+    var maybeReturnProcess = () => {
+      if (typeof process !== "undefined") {
+        return process;
+      }
+      try {
+        return require_browser();
+      } catch (_a) {
+        return void 0;
+      }
+    };
+    function createProcess() {
+      const p = maybeReturnProcess() || {};
+      if (!p.cwd) p.cwd = () => "/";
+      if (!p.emitWarning)
+        p.emitWarning = (message, type) => {
+          console.warn(`${type}${type ? ": " : ""}${message}`);
+        };
+      if (!p.env) p.env = {};
+      return p;
+    }
+    exports.createProcess = createProcess;
+    exports.default = createProcess();
+  },
+});
+
+// node_modules/events/events.js
+var require_events = __commonJS({
+  "node_modules/events/events.js"(exports, module) {
+    "use strict";
+    var R = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply =
+      R && typeof R.apply === "function"
+        ? R.apply
+        : function ReflectApply2(target, receiver, args) {
+            return Function.prototype.apply.call(target, receiver, args);
+          };
+    var ReflectOwnKeys;
+    if (R && typeof R.ownKeys === "function") {
+      ReflectOwnKeys = R.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(
+          Object.getOwnPropertySymbols(target),
+        );
+      };
+    } else {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      };
+    }
+    function ProcessEmitWarning(warning) {
+      if (console && console.warn) console.warn(warning);
+    }
+    var NumberIsNaN =
+      Number.isNaN ||
+      function NumberIsNaN2(value) {
+        return value !== value;
+      };
+    function EventEmitter() {
+      EventEmitter.init.call(this);
+    }
+    module.exports = EventEmitter;
+    module.exports.once = once;
+    EventEmitter.EventEmitter = EventEmitter;
+    EventEmitter.prototype._events = void 0;
+    EventEmitter.prototype._eventsCount = 0;
+    EventEmitter.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError(
+          'The "listener" argument must be of type Function. Received type ' +
+            typeof listener,
+        );
+      }
+    }
+    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+      enumerable: true,
+      get: function () {
+        return defaultMaxListeners;
+      },
+      set: function (arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError(
+            'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
+              arg +
+              ".",
+          );
+        }
+        defaultMaxListeners = arg;
+      },
+    });
+    EventEmitter.init = function () {
+      if (
+        this._events === void 0 ||
+        this._events === Object.getPrototypeOf(this)._events
+      ) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError(
+          'The value of "n" is out of range. It must be a non-negative number. Received ' +
+            n +
+            ".",
+        );
+      }
+      this._maxListeners = n;
+      return this;
+    };
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+      return _getMaxListeners(this);
+    };
+    EventEmitter.prototype.emit = function emit(type) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+      var doError = type === "error";
+      var events = this._events;
+      if (events !== void 0) doError = doError && events.error === void 0;
+      else if (!doError) return false;
+      if (doError) {
+        var er;
+        if (args.length > 0) er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err = new Error(
+          "Unhandled error." + (er ? " (" + er.message + ")" : ""),
+        );
+        err.context = er;
+        throw err;
+      }
+      var handler = events[type];
+      if (handler === void 0) return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
+      }
+      return true;
+    };
+    function _addListener(target, type, listener, prepend) {
+      var m;
+      var events;
+      var existing;
+      checkListener(listener);
+      events = target._events;
+      if (events === void 0) {
+        events = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type,
+            listener.listener ? listener.listener : listener,
+          );
+          events = target._events;
+        }
+        existing = events[type];
+      }
+      if (existing === void 0) {
+        existing = events[type] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events[type] = prepend
+            ? [listener, existing]
+            : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+          existing.warned = true;
+          var w = new Error(
+            "Possible EventEmitter memory leak detected. " +
+              existing.length +
+              " " +
+              String(type) +
+              " listeners added. Use emitter.setMaxListeners() to increase limit",
+          );
+          w.name = "MaxListenersExceededWarning";
+          w.emitter = target;
+          w.type = type;
+          w.count = existing.length;
+          ProcessEmitWarning(w);
+        }
+      }
+      return target;
+    }
+    EventEmitter.prototype.addListener = function addListener(type, listener) {
+      return _addListener(this, type, listener, false);
+    };
+    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+    EventEmitter.prototype.prependListener = function prependListener(
+      type,
+      listener,
+    ) {
+      return _addListener(this, type, listener, true);
+    };
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0) return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    function _onceWrap(target, type, listener) {
+      var state = { fired: false, wrapFn: void 0, target, type, listener };
+      var wrapped = onceWrapper.bind(state);
+      wrapped.listener = listener;
+      state.wrapFn = wrapped;
+      return wrapped;
+    }
+    EventEmitter.prototype.once = function once2(type, listener) {
+      checkListener(listener);
+      this.on(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter.prototype.prependOnceListener = function prependOnceListener(
+      type,
+      listener,
+    ) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter.prototype.removeListener = function removeListener(
+      type,
+      listener,
+    ) {
+      var list, events, position, i, originalListener;
+      checkListener(listener);
+      events = this._events;
+      if (events === void 0) return this;
+      list = events[type];
+      if (list === void 0) return this;
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit("removeListener", type, list.listener || listener);
+        }
+      } else if (typeof list !== "function") {
+        position = -1;
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+        if (position < 0) return this;
+        if (position === 0) list.shift();
+        else {
+          spliceOne(list, position);
+        }
+        if (list.length === 1) events[type] = list[0];
+        if (events.removeListener !== void 0)
+          this.emit("removeListener", type, originalListener || listener);
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(
+      type,
+    ) {
+      var listeners, events, i;
+      events = this._events;
+      if (events === void 0) return this;
+      if (events.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else delete events[type];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === "removeListener") continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events[type];
+      if (typeof listeners === "function") {
+        this.removeListener(type, listeners);
+      } else if (listeners !== void 0) {
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+      return this;
+    };
+    function _listeners(target, type, unwrap) {
+      var events = target._events;
+      if (events === void 0) return [];
+      var evlistener = events[type];
+      if (evlistener === void 0) return [];
+      if (typeof evlistener === "function")
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap
+        ? unwrapListeners(evlistener)
+        : arrayClone(evlistener, evlistener.length);
+    }
+    EventEmitter.prototype.listeners = function listeners(type) {
+      return _listeners(this, type, true);
+    };
+    EventEmitter.prototype.rawListeners = function rawListeners(type) {
+      return _listeners(this, type, false);
+    };
+    EventEmitter.listenerCount = function (emitter, type) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type);
+      } else {
+        return listenerCount.call(emitter, type);
+      }
+    };
+    EventEmitter.prototype.listenerCount = listenerCount;
+    function listenerCount(type) {
+      var events = this._events;
+      if (events !== void 0) {
+        var evlistener = events[type];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    };
+    function arrayClone(arr, n) {
+      var copy = new Array(n);
+      for (var i = 0; i < n; ++i) copy[i] = arr[i];
+      return copy;
+    }
+    function spliceOne(list, index) {
+      for (; index + 1 < list.length; index++) list[index] = list[index + 1];
+      list.pop();
+    }
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+      }
+      return ret;
+    }
+    function once(emitter, name) {
+      return new Promise(function (resolve, reject) {
+        function errorListener(err) {
+          emitter.removeListener(name, resolver);
+          reject(err);
+        }
+        function resolver() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+        if (name !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name, listener);
+        } else {
+          emitter.on(name, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name, function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name, wrapListener);
+          }
+          listener(arg);
+        });
+      } else {
+        throw new TypeError(
+          'The "emitter" argument must be of type EventEmitter. Received type ' +
+            typeof emitter,
+        );
+      }
+    }
+  },
+});
+
+// node_modules/memfs/lib/node.js
+var require_node = __commonJS({
+  "node_modules/memfs/lib/node.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.File = exports.Link = exports.Node = exports.SEP = void 0;
+    var process_1 = require_process();
+    var buffer_1 = require_buffer2();
+    var constants_1 = require_constants();
+    var events_1 = require_events();
+    var Stats_1 = require_Stats();
+    var { S_IFMT, S_IFDIR, S_IFREG, S_IFLNK, O_APPEND } = constants_1.constants;
+    var getuid = () => {
+      var _a, _b;
+      return (_b =
+        (_a = process_1.default.getuid) === null || _a === void 0
+          ? void 0
+          : _a.call(process_1.default)) !== null && _b !== void 0
+        ? _b
+        : 0;
+    };
+    var getgid = () => {
+      var _a, _b;
+      return (_b =
+        (_a = process_1.default.getgid) === null || _a === void 0
+          ? void 0
+          : _a.call(process_1.default)) !== null && _b !== void 0
+        ? _b
+        : 0;
+    };
+    exports.SEP = "/";
+    var Node = class extends events_1.EventEmitter {
+      constructor(ino, perm = 438) {
+        super();
+        this._uid = getuid();
+        this._gid = getgid();
+        this._atime = /* @__PURE__ */ new Date();
+        this._mtime = /* @__PURE__ */ new Date();
+        this._ctime = /* @__PURE__ */ new Date();
+        this._perm = 438;
+        this.mode = S_IFREG;
+        this._nlink = 1;
+        this._perm = perm;
+        this.mode |= perm;
+        this.ino = ino;
+      }
+      set ctime(ctime) {
+        this._ctime = ctime;
+      }
+      get ctime() {
+        return this._ctime;
+      }
+      set uid(uid) {
+        this._uid = uid;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get uid() {
+        return this._uid;
+      }
+      set gid(gid) {
+        this._gid = gid;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get gid() {
+        return this._gid;
+      }
+      set atime(atime) {
+        this._atime = atime;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get atime() {
+        return this._atime;
+      }
+      set mtime(mtime) {
+        this._mtime = mtime;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get mtime() {
+        return this._mtime;
+      }
+      set perm(perm) {
+        this._perm = perm;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get perm() {
+        return this._perm;
+      }
+      set nlink(nlink) {
+        this._nlink = nlink;
+        this.ctime = /* @__PURE__ */ new Date();
+      }
+      get nlink() {
+        return this._nlink;
+      }
+      getString(encoding = "utf8") {
+        this.atime = /* @__PURE__ */ new Date();
+        return this.getBuffer().toString(encoding);
+      }
+      setString(str) {
+        this.buf = (0, buffer_1.bufferFrom)(str, "utf8");
+        this.touch();
+      }
+      getBuffer() {
+        this.atime = /* @__PURE__ */ new Date();
+        if (!this.buf) this.setBuffer((0, buffer_1.bufferAllocUnsafe)(0));
+        return (0, buffer_1.bufferFrom)(this.buf);
+      }
+      setBuffer(buf) {
+        this.buf = (0, buffer_1.bufferFrom)(buf);
+        this.touch();
+      }
+      getSize() {
+        return this.buf ? this.buf.length : 0;
+      }
+      setModeProperty(property) {
+        this.mode = (this.mode & ~S_IFMT) | property;
+      }
+      setIsFile() {
+        this.setModeProperty(S_IFREG);
+      }
+      setIsDirectory() {
+        this.setModeProperty(S_IFDIR);
+      }
+      setIsSymlink() {
+        this.setModeProperty(S_IFLNK);
+      }
+      isFile() {
+        return (this.mode & S_IFMT) === S_IFREG;
+      }
+      isDirectory() {
+        return (this.mode & S_IFMT) === S_IFDIR;
+      }
+      isSymlink() {
+        return (this.mode & S_IFMT) === S_IFLNK;
+      }
+      makeSymlink(steps) {
+        this.symlink = steps;
+        this.setIsSymlink();
+      }
+      write(buf, off = 0, len = buf.length, pos = 0) {
+        if (!this.buf) this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        if (pos + len > this.buf.length) {
+          const newBuf = (0, buffer_1.bufferAllocUnsafe)(pos + len);
+          this.buf.copy(newBuf, 0, 0, this.buf.length);
+          this.buf = newBuf;
+        }
+        buf.copy(this.buf, pos, off, off + len);
+        this.touch();
+        return len;
+      }
+      // Returns the number of bytes read.
+      read(buf, off = 0, len = buf.byteLength, pos = 0) {
+        this.atime = /* @__PURE__ */ new Date();
+        if (!this.buf) this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        let actualLen = len;
+        if (actualLen > buf.byteLength) {
+          actualLen = buf.byteLength;
+        }
+        if (actualLen + pos > this.buf.length) {
+          actualLen = this.buf.length - pos;
+        }
+        const buf2 =
+          buf instanceof buffer_1.Buffer
+            ? buf
+            : buffer_1.Buffer.from(buf.buffer);
+        this.buf.copy(buf2, off, pos, pos + actualLen);
+        return actualLen;
+      }
+      truncate(len = 0) {
+        if (!len) this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+        else {
+          if (!this.buf) this.buf = (0, buffer_1.bufferAllocUnsafe)(0);
+          if (len <= this.buf.length) {
+            this.buf = this.buf.slice(0, len);
+          } else {
+            const buf = (0, buffer_1.bufferAllocUnsafe)(len);
+            this.buf.copy(buf);
+            buf.fill(0, this.buf.length);
+            this.buf = buf;
+          }
+        }
+        this.touch();
+      }
+      chmod(perm) {
+        this.perm = perm;
+        this.mode = (this.mode & ~511) | perm;
+        this.touch();
+      }
+      chown(uid, gid) {
+        this.uid = uid;
+        this.gid = gid;
+        this.touch();
+      }
+      touch() {
+        this.mtime = /* @__PURE__ */ new Date();
+        this.emit("change", this);
+      }
+      canRead(uid = getuid(), gid = getgid()) {
+        if (this.perm & 4) {
+          return true;
+        }
+        if (gid === this.gid) {
+          if (this.perm & 32) {
+            return true;
+          }
+        }
+        if (uid === this.uid) {
+          if (this.perm & 256) {
+            return true;
+          }
+        }
+        return false;
+      }
+      canWrite(uid = getuid(), gid = getgid()) {
+        if (this.perm & 2) {
+          return true;
+        }
+        if (gid === this.gid) {
+          if (this.perm & 16) {
+            return true;
+          }
+        }
+        if (uid === this.uid) {
+          if (this.perm & 128) {
+            return true;
+          }
+        }
+        return false;
+      }
+      del() {
+        this.emit("delete", this);
+      }
+      toJSON() {
+        return {
+          ino: this.ino,
+          uid: this.uid,
+          gid: this.gid,
+          atime: this.atime.getTime(),
+          mtime: this.mtime.getTime(),
+          ctime: this.ctime.getTime(),
+          perm: this.perm,
+          mode: this.mode,
+          nlink: this.nlink,
+          symlink: this.symlink,
+          data: this.getString(),
+        };
+      }
+    };
+    exports.Node = Node;
+    var Link = class _Link extends events_1.EventEmitter {
+      get steps() {
+        return this._steps;
+      }
+      // Recursively sync children steps, e.g. in case of dir rename
+      set steps(val) {
+        this._steps = val;
+        for (const [child, link] of this.children.entries()) {
+          if (child === "." || child === "..") {
+            continue;
+          }
+          link === null || link === void 0 ? void 0 : link.syncSteps();
+        }
+      }
+      constructor(vol, parent, name) {
+        super();
+        this.children = /* @__PURE__ */ new Map();
+        this._steps = [];
+        this.ino = 0;
+        this.length = 0;
+        this.vol = vol;
+        this.parent = parent;
+        this.name = name;
+        this.syncSteps();
+      }
+      setNode(node) {
+        this.node = node;
+        this.ino = node.ino;
+      }
+      getNode() {
+        return this.node;
+      }
+      createChild(name, node = this.vol.createNode()) {
+        const link = new _Link(this.vol, this, name);
+        link.setNode(node);
+        if (node.isDirectory()) {
+          link.children.set(".", link);
+          link.getNode().nlink++;
+        }
+        this.setChild(name, link);
+        return link;
+      }
+      setChild(name, link = new _Link(this.vol, this, name)) {
+        this.children.set(name, link);
+        link.parent = this;
+        this.length++;
+        const node = link.getNode();
+        if (node.isDirectory()) {
+          link.children.set("..", this);
+          this.getNode().nlink++;
+        }
+        this.getNode().mtime = /* @__PURE__ */ new Date();
+        this.emit("child:add", link, this);
+        return link;
+      }
+      deleteChild(link) {
+        const node = link.getNode();
+        if (node.isDirectory()) {
+          link.children.delete("..");
+          this.getNode().nlink--;
+        }
+        this.children.delete(link.getName());
+        this.length--;
+        this.getNode().mtime = /* @__PURE__ */ new Date();
+        this.emit("child:delete", link, this);
+      }
+      getChild(name) {
+        this.getNode().mtime = /* @__PURE__ */ new Date();
+        return this.children.get(name);
+      }
+      getPath() {
+        return this.steps.join(exports.SEP);
+      }
+      getName() {
+        return this.steps[this.steps.length - 1];
+      }
+      // del() {
+      //     const parent = this.parent;
+      //     if(parent) {
+      //         parent.deleteChild(link);
+      //     }
+      //     this.parent = null;
+      //     this.vol = null;
+      // }
+      /**
+       * Walk the tree path and return the `Link` at that location, if any.
+       * @param steps {string[]} Desired location.
+       * @param stop {number} Max steps to go into.
+       * @param i {number} Current step in the `steps` array.
+       *
+       * @return {Link|null}
+       */
+      walk(steps, stop = steps.length, i = 0) {
+        if (i >= steps.length) return this;
+        if (i >= stop) return this;
+        const step = steps[i];
+        const link = this.getChild(step);
+        if (!link) return null;
+        return link.walk(steps, stop, i + 1);
+      }
+      toJSON() {
+        return {
+          steps: this.steps,
+          ino: this.ino,
+          children: Array.from(this.children.keys()),
+        };
+      }
+      syncSteps() {
+        this.steps = this.parent
+          ? this.parent.steps.concat([this.name])
+          : [this.name];
+      }
+    };
+    exports.Link = Link;
+    var File = class {
+      /**
+       * Open a Link-Node pair. `node` is provided separately as that might be a different node
+       * rather the one `link` points to, because it might be a symlink.
+       * @param link
+       * @param node
+       * @param flags
+       * @param fd
+       */
+      constructor(link, node, flags, fd) {
+        this.link = link;
+        this.node = node;
+        this.flags = flags;
+        this.fd = fd;
+        this.position = 0;
+        if (this.flags & O_APPEND) this.position = this.getSize();
+      }
+      getString(encoding = "utf8") {
+        return this.node.getString();
+      }
+      setString(str) {
+        this.node.setString(str);
+      }
+      getBuffer() {
+        return this.node.getBuffer();
+      }
+      setBuffer(buf) {
+        this.node.setBuffer(buf);
+      }
+      getSize() {
+        return this.node.getSize();
+      }
+      truncate(len) {
+        this.node.truncate(len);
+      }
+      seekTo(position) {
+        this.position = position;
+      }
+      stats() {
+        return Stats_1.default.build(this.node);
+      }
+      write(buf, offset = 0, length = buf.length, position) {
+        if (typeof position !== "number") position = this.position;
+        const bytes = this.node.write(buf, offset, length, position);
+        this.position = position + bytes;
+        return bytes;
+      }
+      read(buf, offset = 0, length = buf.byteLength, position) {
+        if (typeof position !== "number") position = this.position;
+        const bytes = this.node.read(buf, offset, length, position);
+        this.position = position + bytes;
+        return bytes;
+      }
+      chmod(perm) {
+        this.node.chmod(perm);
+      }
+      chown(uid, gid) {
+        this.node.chown(uid, gid);
+      }
+    };
+    exports.File = File;
+  },
+});
+
+// node_modules/memfs/lib/setImmediate.js
+var require_setImmediate = __commonJS({
+  "node_modules/memfs/lib/setImmediate.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _setImmediate;
+    if (typeof setImmediate === "function")
+      _setImmediate = setImmediate.bind(
+        typeof globalThis !== "undefined" ? globalThis : global,
+      );
+    else
+      _setImmediate = setTimeout.bind(
+        typeof globalThis !== "undefined" ? globalThis : global,
+      );
+    exports.default = _setImmediate;
+  },
+});
+
+// node_modules/memfs/lib/queueMicrotask.js
+var require_queueMicrotask = __commonJS({
+  "node_modules/memfs/lib/queueMicrotask.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default =
+      typeof queueMicrotask === "function"
+        ? queueMicrotask
+        : (cb) =>
+            Promise.resolve()
+              .then(() => cb())
+              .catch(() => {});
+  },
+});
+
+// node_modules/memfs/lib/setTimeoutUnref.js
+var require_setTimeoutUnref = __commonJS({
+  "node_modules/memfs/lib/setTimeoutUnref.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function setTimeoutUnref(callback, time, args) {
+      const ref = setTimeout.apply(
+        typeof globalThis !== "undefined" ? globalThis : global,
+        arguments,
+      );
+      if (ref && typeof ref === "object" && typeof ref.unref === "function")
+        ref.unref();
+      return ref;
+    }
+    exports.default = setTimeoutUnref;
+  },
+});
+
+// node_modules/emitter-component/index.js
+var require_emitter_component = __commonJS({
+  "node_modules/emitter-component/index.js"(exports, module) {
+    module.exports = Emitter;
+    function Emitter(obj) {
+      if (obj) return mixin(obj);
+    }
+    function mixin(obj) {
+      for (var key in Emitter.prototype) {
+        obj[key] = Emitter.prototype[key];
+      }
+      return obj;
+    }
+    Emitter.prototype.on = Emitter.prototype.addEventListener = function (
+      event,
+      fn,
+    ) {
+      this._callbacks = this._callbacks || {};
+      (this._callbacks[event] = this._callbacks[event] || []).push(fn);
+      return this;
+    };
+    Emitter.prototype.once = function (event, fn) {
+      var self = this;
+      this._callbacks = this._callbacks || {};
+      function on() {
+        self.off(event, on);
+        fn.apply(this, arguments);
+      }
+      on.fn = fn;
+      this.on(event, on);
+      return this;
+    };
+    Emitter.prototype.off =
+      Emitter.prototype.removeListener =
+      Emitter.prototype.removeAllListeners =
+      Emitter.prototype.removeEventListener =
+        function (event, fn) {
+          this._callbacks = this._callbacks || {};
+          if (0 == arguments.length) {
+            this._callbacks = {};
+            return this;
+          }
+          var callbacks = this._callbacks[event];
+          if (!callbacks) return this;
+          if (1 == arguments.length) {
+            delete this._callbacks[event];
+            return this;
+          }
+          var cb;
+          for (var i = 0; i < callbacks.length; i++) {
+            cb = callbacks[i];
+            if (cb === fn || cb.fn === fn) {
+              callbacks.splice(i, 1);
+              break;
+            }
+          }
+          return this;
+        };
+    Emitter.prototype.emit = function (event) {
+      this._callbacks = this._callbacks || {};
+      var args = [].slice.call(arguments, 1),
+        callbacks = this._callbacks[event];
+      if (callbacks) {
+        callbacks = callbacks.slice(0);
+        for (var i = 0, len = callbacks.length; i < len; ++i) {
+          callbacks[i].apply(this, args);
+        }
+      }
+      return this;
+    };
+    Emitter.prototype.listeners = function (event) {
+      this._callbacks = this._callbacks || {};
+      return this._callbacks[event] || [];
+    };
+    Emitter.prototype.hasListeners = function (event) {
+      return !!this.listeners(event).length;
+    };
+  },
+});
+
+// node_modules/stream/index.js
+var require_stream = __commonJS({
+  "node_modules/stream/index.js"(exports, module) {
+    var Emitter = require_emitter_component();
+    function Stream() {
+      Emitter.call(this);
+    }
+    Stream.prototype = new Emitter();
+    module.exports = Stream;
+    Stream.Stream = Stream;
+    Stream.prototype.pipe = function (dest, options) {
+      var source = this;
+      function ondata(chunk) {
+        if (dest.writable) {
+          if (false === dest.write(chunk) && source.pause) {
+            source.pause();
+          }
+        }
+      }
+      source.on("data", ondata);
+      function ondrain() {
+        if (source.readable && source.resume) {
+          source.resume();
+        }
+      }
+      dest.on("drain", ondrain);
+      if (!dest._isStdio && (!options || options.end !== false)) {
+        source.on("end", onend);
+        source.on("close", onclose);
+      }
+      var didOnEnd = false;
+      function onend() {
+        if (didOnEnd) return;
+        didOnEnd = true;
+        dest.end();
+      }
+      function onclose() {
+        if (didOnEnd) return;
+        didOnEnd = true;
+        if (typeof dest.destroy === "function") dest.destroy();
+      }
+      function onerror(er) {
+        cleanup();
+        if (!this.hasListeners("error")) {
+          throw er;
+        }
+      }
+      source.on("error", onerror);
+      dest.on("error", onerror);
+      function cleanup() {
+        source.off("data", ondata);
+        dest.off("drain", ondrain);
+        source.off("end", onend);
+        source.off("close", onclose);
+        source.off("error", onerror);
+        dest.off("error", onerror);
+        source.off("end", cleanup);
+        source.off("close", cleanup);
+        dest.off("end", cleanup);
+        dest.off("close", cleanup);
+      }
+      source.on("end", cleanup);
+      source.on("close", cleanup);
+      dest.on("end", cleanup);
+      dest.on("close", cleanup);
+      dest.emit("pipe", source);
+      return dest;
+    };
+  },
+});
+
+// node_modules/memfs/lib/node/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/memfs/lib/node/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FLAGS = exports.ERRSTR = void 0;
+    var constants_1 = require_constants();
+    exports.ERRSTR = {
+      PATH_STR: "path must be a string or Buffer",
+      // FD:             'file descriptor must be a unsigned 32-bit integer',
+      FD: "fd must be a file descriptor",
+      MODE_INT: "mode must be an int",
+      CB: "callback must be a function",
+      UID: "uid must be an unsigned int",
+      GID: "gid must be an unsigned int",
+      LEN: "len must be an integer",
+      ATIME: "atime must be an integer",
+      MTIME: "mtime must be an integer",
+      PREFIX: "filename prefix is required",
+      BUFFER: "buffer must be an instance of Buffer or StaticBuffer",
+      OFFSET: "offset must be an integer",
+      LENGTH: "length must be an integer",
+      POSITION: "position must be an integer",
+    };
+    var {
+      O_RDONLY,
+      O_WRONLY,
+      O_RDWR,
+      O_CREAT,
+      O_EXCL,
+      O_TRUNC,
+      O_APPEND,
+      O_SYNC,
+    } = constants_1.constants;
+    var FLAGS;
+    (function (FLAGS2) {
+      FLAGS2[(FLAGS2["r"] = O_RDONLY)] = "r";
+      FLAGS2[(FLAGS2["r+"] = O_RDWR)] = "r+";
+      FLAGS2[(FLAGS2["rs"] = O_RDONLY | O_SYNC)] = "rs";
+      FLAGS2[(FLAGS2["sr"] = FLAGS2.rs)] = "sr";
+      FLAGS2[(FLAGS2["rs+"] = O_RDWR | O_SYNC)] = "rs+";
+      FLAGS2[(FLAGS2["sr+"] = FLAGS2["rs+"])] = "sr+";
+      FLAGS2[(FLAGS2["w"] = O_WRONLY | O_CREAT | O_TRUNC)] = "w";
+      FLAGS2[(FLAGS2["wx"] = O_WRONLY | O_CREAT | O_TRUNC | O_EXCL)] = "wx";
+      FLAGS2[(FLAGS2["xw"] = FLAGS2.wx)] = "xw";
+      FLAGS2[(FLAGS2["w+"] = O_RDWR | O_CREAT | O_TRUNC)] = "w+";
+      FLAGS2[(FLAGS2["wx+"] = O_RDWR | O_CREAT | O_TRUNC | O_EXCL)] = "wx+";
+      FLAGS2[(FLAGS2["xw+"] = FLAGS2["wx+"])] = "xw+";
+      FLAGS2[(FLAGS2["a"] = O_WRONLY | O_APPEND | O_CREAT)] = "a";
+      FLAGS2[(FLAGS2["ax"] = O_WRONLY | O_APPEND | O_CREAT | O_EXCL)] = "ax";
+      FLAGS2[(FLAGS2["xa"] = FLAGS2.ax)] = "xa";
+      FLAGS2[(FLAGS2["a+"] = O_RDWR | O_APPEND | O_CREAT)] = "a+";
+      FLAGS2[(FLAGS2["ax+"] = O_RDWR | O_APPEND | O_CREAT | O_EXCL)] = "ax+";
+      FLAGS2[(FLAGS2["xa+"] = FLAGS2["ax+"])] = "xa+";
+    })(FLAGS || (exports.FLAGS = FLAGS = {}));
+  },
+});
+
+// node_modules/memfs/lib/node/util.js
+var require_util3 = __commonJS({
+  "node_modules/memfs/lib/node/util.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.unixify =
+      exports.bufferToEncoding =
+      exports.getWriteSyncArgs =
+      exports.getWriteArgs =
+      exports.bufToUint8 =
+      exports.dataToBuffer =
+      exports.validateFd =
+      exports.isFd =
+      exports.flagsToNumber =
+      exports.genRndStr6 =
+      exports.createError =
+      exports.pathToFilename =
+      exports.nullCheck =
+      exports.modeToNumber =
+      exports.validateCallback =
+      exports.promisify =
+      exports.isWin =
+        void 0;
+    var constants_1 = require_constants2();
+    var errors = require_errors2();
+    var buffer_1 = require_buffer2();
+    var encoding_1 = require_encoding();
+    var buffer_2 = require_buffer2();
+    var queueMicrotask_1 = require_queueMicrotask();
+    exports.isWin = process.platform === "win32";
+    function promisify(fs, fn, getResult = (input) => input) {
+      return (...args) =>
+        new Promise((resolve, reject) => {
+          fs[fn].bind(fs)(...args, (error, result) => {
+            if (error) return reject(error);
+            return resolve(getResult(result));
+          });
+        });
+    }
+    exports.promisify = promisify;
+    function validateCallback(callback) {
+      if (typeof callback !== "function")
+        throw TypeError(constants_1.ERRSTR.CB);
+      return callback;
+    }
+    exports.validateCallback = validateCallback;
+    function _modeToNumber(mode, def) {
+      if (typeof mode === "number") return mode;
+      if (typeof mode === "string") return parseInt(mode, 8);
+      if (def) return modeToNumber(def);
+      return void 0;
+    }
+    function modeToNumber(mode, def) {
+      const result = _modeToNumber(mode, def);
+      if (typeof result !== "number" || isNaN(result))
+        throw new TypeError(constants_1.ERRSTR.MODE_INT);
+      return result;
+    }
+    exports.modeToNumber = modeToNumber;
+    function nullCheck(path, callback) {
+      if (("" + path).indexOf("\0") !== -1) {
+        const er = new Error("Path must be a string without null bytes");
+        er.code = "ENOENT";
+        if (typeof callback !== "function") throw er;
+        (0, queueMicrotask_1.default)(() => {
+          callback(er);
+        });
+        return false;
+      }
+      return true;
+    }
+    exports.nullCheck = nullCheck;
+    function getPathFromURLPosix(url) {
+      if (url.hostname !== "") {
+        throw new errors.TypeError(
+          "ERR_INVALID_FILE_URL_HOST",
+          process.platform,
+        );
+      }
+      const pathname = url.pathname;
+      for (let n = 0; n < pathname.length; n++) {
+        if (pathname[n] === "%") {
+          const third = pathname.codePointAt(n + 2) | 32;
+          if (pathname[n + 1] === "2" && third === 102) {
+            throw new errors.TypeError(
+              "ERR_INVALID_FILE_URL_PATH",
+              "must not include encoded / characters",
+            );
+          }
+        }
+      }
+      return decodeURIComponent(pathname);
+    }
+    function pathToFilename(path) {
+      if (typeof path !== "string" && !buffer_1.Buffer.isBuffer(path)) {
+        try {
+          if (!(path instanceof __require("url").URL))
+            throw new TypeError(constants_1.ERRSTR.PATH_STR);
+        } catch (err) {
+          throw new TypeError(constants_1.ERRSTR.PATH_STR);
+        }
+        path = getPathFromURLPosix(path);
+      }
+      const pathString = String(path);
+      nullCheck(pathString);
+      return pathString;
+    }
+    exports.pathToFilename = pathToFilename;
+    var ENOENT = "ENOENT";
+    var EBADF = "EBADF";
+    var EINVAL = "EINVAL";
+    var EPERM = "EPERM";
+    var EPROTO = "EPROTO";
+    var EEXIST = "EEXIST";
+    var ENOTDIR = "ENOTDIR";
+    var EMFILE = "EMFILE";
+    var EACCES = "EACCES";
+    var EISDIR = "EISDIR";
+    var ENOTEMPTY = "ENOTEMPTY";
+    var ENOSYS = "ENOSYS";
+    var ERR_FS_EISDIR = "ERR_FS_EISDIR";
+    var ERR_OUT_OF_RANGE = "ERR_OUT_OF_RANGE";
+    function formatError(errorCode, func = "", path = "", path2 = "") {
+      let pathFormatted = "";
+      if (path) pathFormatted = ` '${path}'`;
+      if (path2) pathFormatted += ` -> '${path2}'`;
+      switch (errorCode) {
+        case ENOENT:
+          return `ENOENT: no such file or directory, ${func}${pathFormatted}`;
+        case EBADF:
+          return `EBADF: bad file descriptor, ${func}${pathFormatted}`;
+        case EINVAL:
+          return `EINVAL: invalid argument, ${func}${pathFormatted}`;
+        case EPERM:
+          return `EPERM: operation not permitted, ${func}${pathFormatted}`;
+        case EPROTO:
+          return `EPROTO: protocol error, ${func}${pathFormatted}`;
+        case EEXIST:
+          return `EEXIST: file already exists, ${func}${pathFormatted}`;
+        case ENOTDIR:
+          return `ENOTDIR: not a directory, ${func}${pathFormatted}`;
+        case EISDIR:
+          return `EISDIR: illegal operation on a directory, ${func}${pathFormatted}`;
+        case EACCES:
+          return `EACCES: permission denied, ${func}${pathFormatted}`;
+        case ENOTEMPTY:
+          return `ENOTEMPTY: directory not empty, ${func}${pathFormatted}`;
+        case EMFILE:
+          return `EMFILE: too many open files, ${func}${pathFormatted}`;
+        case ENOSYS:
+          return `ENOSYS: function not implemented, ${func}${pathFormatted}`;
+        case ERR_FS_EISDIR:
+          return `[ERR_FS_EISDIR]: Path is a directory: ${func} returned EISDIR (is a directory) ${path}`;
+        case ERR_OUT_OF_RANGE:
+          return `[ERR_OUT_OF_RANGE]: value out of range, ${func}${pathFormatted}`;
+        default:
+          return `${errorCode}: error occurred, ${func}${pathFormatted}`;
+      }
+    }
+    function createError(
+      errorCode,
+      func = "",
+      path = "",
+      path2 = "",
+      Constructor = Error,
+    ) {
+      const error = new Constructor(formatError(errorCode, func, path, path2));
+      error.code = errorCode;
+      if (path) {
+        error.path = path;
+      }
+      return error;
+    }
+    exports.createError = createError;
+    function genRndStr6() {
+      const str = (Math.random() + 1).toString(36).substring(2, 8);
+      if (str.length === 6) return str;
+      else return genRndStr6();
+    }
+    exports.genRndStr6 = genRndStr6;
+    function flagsToNumber(flags) {
+      if (typeof flags === "number") return flags;
+      if (typeof flags === "string") {
+        const flagsNum = constants_1.FLAGS[flags];
+        if (typeof flagsNum !== "undefined") return flagsNum;
+      }
+      throw new errors.TypeError("ERR_INVALID_OPT_VALUE", "flags", flags);
+    }
+    exports.flagsToNumber = flagsToNumber;
+    function isFd(path) {
+      return path >>> 0 === path;
+    }
+    exports.isFd = isFd;
+    function validateFd(fd) {
+      if (!isFd(fd)) throw TypeError(constants_1.ERRSTR.FD);
+    }
+    exports.validateFd = validateFd;
+    function dataToBuffer(data, encoding = encoding_1.ENCODING_UTF8) {
+      if (buffer_1.Buffer.isBuffer(data)) return data;
+      else if (data instanceof Uint8Array)
+        return (0, buffer_2.bufferFrom)(data);
+      else return (0, buffer_2.bufferFrom)(String(data), encoding);
+    }
+    exports.dataToBuffer = dataToBuffer;
+    var bufToUint8 = (buf) =>
+      new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    exports.bufToUint8 = bufToUint8;
+    var getWriteArgs = (fd, a, b, c, d, e) => {
+      validateFd(fd);
+      let offset = 0;
+      let length;
+      let position = null;
+      let encoding;
+      let callback;
+      const tipa = typeof a;
+      const tipb = typeof b;
+      const tipc = typeof c;
+      const tipd = typeof d;
+      if (tipa !== "string") {
+        if (tipb === "function") {
+          callback = b;
+        } else if (tipc === "function") {
+          offset = b | 0;
+          callback = c;
+        } else if (tipd === "function") {
+          offset = b | 0;
+          length = c;
+          callback = d;
+        } else {
+          offset = b | 0;
+          length = c;
+          position = d;
+          callback = e;
+        }
+      } else {
+        if (tipb === "function") {
+          callback = b;
+        } else if (tipc === "function") {
+          position = b;
+          callback = c;
+        } else if (tipd === "function") {
+          position = b;
+          encoding = c;
+          callback = d;
+        }
+      }
+      const buf = dataToBuffer(a, encoding);
+      if (tipa !== "string") {
+        if (typeof length === "undefined") length = buf.length;
+      } else {
+        offset = 0;
+        length = buf.length;
+      }
+      const cb = validateCallback(callback);
+      return [fd, tipa === "string", buf, offset, length, position, cb];
+    };
+    exports.getWriteArgs = getWriteArgs;
+    var getWriteSyncArgs = (fd, a, b, c, d) => {
+      validateFd(fd);
+      let encoding;
+      let offset;
+      let length;
+      let position;
+      const isBuffer = typeof a !== "string";
+      if (isBuffer) {
+        offset = (b || 0) | 0;
+        length = c;
+        position = d;
+      } else {
+        position = b;
+        encoding = c;
+      }
+      const buf = dataToBuffer(a, encoding);
+      if (isBuffer) {
+        if (typeof length === "undefined") {
+          length = buf.length;
+        }
+      } else {
+        offset = 0;
+        length = buf.length;
+      }
+      return [fd, buf, offset || 0, length, position];
+    };
+    exports.getWriteSyncArgs = getWriteSyncArgs;
+    function bufferToEncoding(buffer, encoding) {
+      if (!encoding || encoding === "buffer") return buffer;
+      else return buffer.toString(encoding);
+    }
+    exports.bufferToEncoding = bufferToEncoding;
+    var isSeparator = (str, i) => {
+      const char = str[i];
+      return i > 0 && (char === "/" || (exports.isWin && char === "\\"));
+    };
+    var removeTrailingSeparator = (str) => {
+      let i = str.length - 1;
+      if (i < 2) return str;
+      while (isSeparator(str, i)) i--;
+      return str.substr(0, i + 1);
+    };
+    var normalizePath = (str, stripTrailing) => {
+      if (typeof str !== "string") throw new TypeError("expected a string");
+      str = str.replace(/[\\\/]+/g, "/");
+      if (stripTrailing !== false) str = removeTrailingSeparator(str);
+      return str;
+    };
+    var unixify = (filepath, stripTrailing = true) => {
+      if (exports.isWin) {
+        filepath = normalizePath(filepath, stripTrailing);
+        return filepath.replace(/^([a-zA-Z]+:|\.\/)/, "");
+      }
+      return filepath;
+    };
+    exports.unixify = unixify;
+  },
+});
+
+// node_modules/memfs/lib/node/FileHandle.js
+var require_FileHandle = __commonJS({
+  "node_modules/memfs/lib/node/FileHandle.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FileHandle = void 0;
+    var util_1 = require_util3();
+    var FileHandle = class {
+      constructor(fs, fd) {
+        this.fs = fs;
+        this.fd = fd;
+      }
+      appendFile(data, options) {
+        return (0, util_1.promisify)(this.fs, "appendFile")(
+          this.fd,
+          data,
+          options,
+        );
+      }
+      chmod(mode) {
+        return (0, util_1.promisify)(this.fs, "fchmod")(this.fd, mode);
+      }
+      chown(uid, gid) {
+        return (0, util_1.promisify)(this.fs, "fchown")(this.fd, uid, gid);
+      }
+      close() {
+        return (0, util_1.promisify)(this.fs, "close")(this.fd);
+      }
+      datasync() {
+        return (0, util_1.promisify)(this.fs, "fdatasync")(this.fd);
+      }
+      read(buffer, offset, length, position) {
+        return (0, util_1.promisify)(this.fs, "read", (bytesRead) => ({
+          bytesRead,
+          buffer,
+        }))(this.fd, buffer, offset, length, position);
+      }
+      readv(buffers, position) {
+        return (0, util_1.promisify)(this.fs, "readv", (bytesRead) => ({
+          bytesRead,
+          buffers,
+        }))(this.fd, buffers, position);
+      }
+      readFile(options) {
+        return (0, util_1.promisify)(this.fs, "readFile")(this.fd, options);
+      }
+      stat(options) {
+        return (0, util_1.promisify)(this.fs, "fstat")(this.fd, options);
+      }
+      sync() {
+        return (0, util_1.promisify)(this.fs, "fsync")(this.fd);
+      }
+      truncate(len) {
+        return (0, util_1.promisify)(this.fs, "ftruncate")(this.fd, len);
+      }
+      utimes(atime, mtime) {
+        return (0, util_1.promisify)(this.fs, "futimes")(this.fd, atime, mtime);
+      }
+      write(buffer, offset, length, position) {
+        return (0, util_1.promisify)(this.fs, "write", (bytesWritten) => ({
+          bytesWritten,
+          buffer,
+        }))(this.fd, buffer, offset, length, position);
+      }
+      writev(buffers, position) {
+        return (0, util_1.promisify)(this.fs, "writev", (bytesWritten) => ({
+          bytesWritten,
+          buffers,
+        }))(this.fd, buffers, position);
+      }
+      writeFile(data, options) {
+        return (0, util_1.promisify)(this.fs, "writeFile")(
+          this.fd,
+          data,
+          options,
+        );
+      }
+    };
+    exports.FileHandle = FileHandle;
+  },
+});
+
+// node_modules/memfs/lib/node/FsPromises.js
+var require_FsPromises = __commonJS({
+  "node_modules/memfs/lib/node/FsPromises.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FsPromises = void 0;
+    var util_1 = require_util3();
+    var constants_1 = require_constants();
+    var FsPromises = class {
+      constructor(fs, FileHandle) {
+        this.fs = fs;
+        this.FileHandle = FileHandle;
+        this.constants = constants_1.constants;
+        this.cp = (0, util_1.promisify)(this.fs, "cp");
+        this.opendir = (0, util_1.promisify)(this.fs, "opendir");
+        this.statfs = (0, util_1.promisify)(this.fs, "statfs");
+        this.lutimes = (0, util_1.promisify)(this.fs, "lutimes");
+        this.access = (0, util_1.promisify)(this.fs, "access");
+        this.chmod = (0, util_1.promisify)(this.fs, "chmod");
+        this.chown = (0, util_1.promisify)(this.fs, "chown");
+        this.copyFile = (0, util_1.promisify)(this.fs, "copyFile");
+        this.lchmod = (0, util_1.promisify)(this.fs, "lchmod");
+        this.lchown = (0, util_1.promisify)(this.fs, "lchown");
+        this.link = (0, util_1.promisify)(this.fs, "link");
+        this.lstat = (0, util_1.promisify)(this.fs, "lstat");
+        this.mkdir = (0, util_1.promisify)(this.fs, "mkdir");
+        this.mkdtemp = (0, util_1.promisify)(this.fs, "mkdtemp");
+        this.readdir = (0, util_1.promisify)(this.fs, "readdir");
+        this.readlink = (0, util_1.promisify)(this.fs, "readlink");
+        this.realpath = (0, util_1.promisify)(this.fs, "realpath");
+        this.rename = (0, util_1.promisify)(this.fs, "rename");
+        this.rmdir = (0, util_1.promisify)(this.fs, "rmdir");
+        this.rm = (0, util_1.promisify)(this.fs, "rm");
+        this.stat = (0, util_1.promisify)(this.fs, "stat");
+        this.symlink = (0, util_1.promisify)(this.fs, "symlink");
+        this.truncate = (0, util_1.promisify)(this.fs, "truncate");
+        this.unlink = (0, util_1.promisify)(this.fs, "unlink");
+        this.utimes = (0, util_1.promisify)(this.fs, "utimes");
+        this.readFile = (id, options) => {
+          return (0, util_1.promisify)(this.fs, "readFile")(
+            id instanceof this.FileHandle ? id.fd : id,
+            options,
+          );
+        };
+        this.appendFile = (path, data, options) => {
+          return (0, util_1.promisify)(this.fs, "appendFile")(
+            path instanceof this.FileHandle ? path.fd : path,
+            data,
+            options,
+          );
+        };
+        this.open = (path, flags = "r", mode) => {
+          return (0, util_1.promisify)(
+            this.fs,
+            "open",
+            (fd) => new this.FileHandle(this.fs, fd),
+          )(path, flags, mode);
+        };
+        this.writeFile = (id, data, options) => {
+          return (0, util_1.promisify)(this.fs, "writeFile")(
+            id instanceof this.FileHandle ? id.fd : id,
+            data,
+            options,
+          );
+        };
+        this.watch = () => {
+          throw new Error("Not implemented");
+        };
+      }
+    };
+    exports.FsPromises = FsPromises;
+  },
+});
+
+// node_modules/memfs/lib/json-joy/util/print/printTree.js
+var require_printTree = __commonJS({
+  "node_modules/memfs/lib/json-joy/util/print/printTree.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.printTree = void 0;
+    var printTree = (tab = "", children) => {
+      children = children.filter(Boolean);
+      let str = "";
+      for (let i = 0; i < children.length; i++) {
+        const isLast = i >= children.length - 1;
+        const fn = children[i];
+        if (!fn) continue;
+        const child = fn(tab + `${isLast ? " " : "\u2502"}  `);
+        const branch = child
+          ? isLast
+            ? "\u2514\u2500"
+            : "\u251C\u2500"
+          : "\u2502 ";
+        str += `
+${tab}${branch} ${child}`;
+      }
+      return str;
+    };
+    exports.printTree = printTree;
+  },
+});
+
+// node_modules/memfs/lib/node-to-fsa/util.js
+var require_util4 = __commonJS({
+  "node_modules/memfs/lib/node-to-fsa/util.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.newNotAllowedError =
+      exports.newTypeMismatchError =
+      exports.newNotFoundError =
+      exports.assertCanWrite =
+      exports.assertName =
+      exports.basename =
+      exports.ctx =
+        void 0;
+    var ctx = (partial = {}) => {
+      return Object.assign(
+        { separator: "/", syncHandleAllowed: false, mode: "read" },
+        partial,
+      );
+    };
+    exports.ctx = ctx;
+    var basename = (path, separator) => {
+      if (path[path.length - 1] === separator) path = path.slice(0, -1);
+      const lastSlashIndex = path.lastIndexOf(separator);
+      return lastSlashIndex === -1 ? path : path.slice(lastSlashIndex + 1);
+    };
+    exports.basename = basename;
+    var nameRegex = /^(\.{1,2})$|^(.*([\/\\]).*)$/;
+    var assertName = (name, method, klass) => {
+      const isInvalid = !name || nameRegex.test(name);
+      if (isInvalid)
+        throw new TypeError(
+          `Failed to execute '${method}' on '${klass}': Name is not allowed.`,
+        );
+    };
+    exports.assertName = assertName;
+    var assertCanWrite = (mode) => {
+      if (mode !== "readwrite")
+        throw new DOMException(
+          "The request is not allowed by the user agent or the platform in the current context.",
+          "NotAllowedError",
+        );
+    };
+    exports.assertCanWrite = assertCanWrite;
+    var newNotFoundError = () =>
+      new DOMException(
+        "A requested file or directory could not be found at the time an operation was processed.",
+        "NotFoundError",
+      );
+    exports.newNotFoundError = newNotFoundError;
+    var newTypeMismatchError = () =>
+      new DOMException(
+        "The path supplied exists, but was not an entry of requested type.",
+        "TypeMismatchError",
+      );
+    exports.newTypeMismatchError = newTypeMismatchError;
+    var newNotAllowedError = () =>
+      new DOMException("Permission not granted.", "NotAllowedError");
+    exports.newNotAllowedError = newNotAllowedError;
+  },
+});
+
+// node_modules/memfs/lib/print/index.js
+var require_print = __commonJS({
+  "node_modules/memfs/lib/print/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toTreeSync = void 0;
+    var printTree_1 = require_printTree();
+    var util_1 = require_util4();
+    var toTreeSync = (fs, opts = {}) => {
+      var _a;
+      const separator = opts.separator || "/";
+      let dir = opts.dir || separator;
+      if (dir[dir.length - 1] !== separator) dir += separator;
+      const tab = opts.tab || "";
+      const depth = (_a = opts.depth) !== null && _a !== void 0 ? _a : 10;
+      let subtree = " (...)";
+      if (depth > 0) {
+        const list = fs.readdirSync(dir, { withFileTypes: true });
+        subtree = (0, printTree_1.printTree)(
+          tab,
+          list.map((entry) => (tab2) => {
+            if (entry.isDirectory()) {
+              return (0, exports.toTreeSync)(fs, {
+                dir: dir + entry.name,
+                depth: depth - 1,
+                tab: tab2,
+              });
+            } else if (entry.isSymbolicLink()) {
+              return (
+                "" + entry.name + " \u2192 " + fs.readlinkSync(dir + entry.name)
+              );
+            } else {
+              return "" + entry.name;
+            }
+          }),
+        );
+      }
+      const base = (0, util_1.basename)(dir, separator) + separator;
+      return base + subtree;
+    };
+    exports.toTreeSync = toTreeSync;
+  },
+});
+
+// node_modules/memfs/lib/node/options.js
+var require_options = __commonJS({
+  "node_modules/memfs/lib/node/options.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getWriteFileOptions =
+      exports.writeFileDefaults =
+      exports.getRealpathOptsAndCb =
+      exports.getRealpathOptions =
+      exports.getStatOptsAndCb =
+      exports.getStatOptions =
+      exports.getAppendFileOptsAndCb =
+      exports.getAppendFileOpts =
+      exports.getReaddirOptsAndCb =
+      exports.getReaddirOptions =
+      exports.getReadFileOptions =
+      exports.getRmOptsAndCb =
+      exports.getRmdirOptions =
+      exports.getDefaultOptsAndCb =
+      exports.getDefaultOpts =
+      exports.optsDefaults =
+      exports.optsAndCbGenerator =
+      exports.optsGenerator =
+      exports.getOptions =
+      exports.getMkdirOptions =
+        void 0;
+    var constants_1 = require_constants2();
+    var encoding_1 = require_encoding();
+    var util_1 = require_util3();
+    var mkdirDefaults = {
+      mode: 511,
+      recursive: false,
+    };
+    var getMkdirOptions = (options) => {
+      if (typeof options === "number")
+        return Object.assign({}, mkdirDefaults, { mode: options });
+      return Object.assign({}, mkdirDefaults, options);
+    };
+    exports.getMkdirOptions = getMkdirOptions;
+    var ERRSTR_OPTS = (tipeof) =>
+      `Expected options to be either an object or a string, but got ${tipeof} instead`;
+    function getOptions(defaults, options) {
+      let opts;
+      if (!options) return defaults;
+      else {
+        const tipeof = typeof options;
+        switch (tipeof) {
+          case "string":
+            opts = Object.assign({}, defaults, { encoding: options });
+            break;
+          case "object":
+            opts = Object.assign({}, defaults, options);
+            break;
+          default:
+            throw TypeError(ERRSTR_OPTS(tipeof));
+        }
+      }
+      if (opts.encoding !== "buffer")
+        (0, encoding_1.assertEncoding)(opts.encoding);
+      return opts;
+    }
+    exports.getOptions = getOptions;
+    function optsGenerator(defaults) {
+      return (options) => getOptions(defaults, options);
+    }
+    exports.optsGenerator = optsGenerator;
+    function optsAndCbGenerator(getOpts) {
+      return (options, callback) =>
+        typeof options === "function"
+          ? [getOpts(), options]
+          : [getOpts(options), (0, util_1.validateCallback)(callback)];
+    }
+    exports.optsAndCbGenerator = optsAndCbGenerator;
+    exports.optsDefaults = {
+      encoding: "utf8",
+    };
+    exports.getDefaultOpts = optsGenerator(exports.optsDefaults);
+    exports.getDefaultOptsAndCb = optsAndCbGenerator(exports.getDefaultOpts);
+    var rmdirDefaults = {
+      recursive: false,
+    };
+    var getRmdirOptions = (options) => {
+      return Object.assign({}, rmdirDefaults, options);
+    };
+    exports.getRmdirOptions = getRmdirOptions;
+    var getRmOpts = optsGenerator(exports.optsDefaults);
+    exports.getRmOptsAndCb = optsAndCbGenerator(getRmOpts);
+    var readFileOptsDefaults = {
+      flag: "r",
+    };
+    exports.getReadFileOptions = optsGenerator(readFileOptsDefaults);
+    var readdirDefaults = {
+      encoding: "utf8",
+      recursive: false,
+      withFileTypes: false,
+    };
+    exports.getReaddirOptions = optsGenerator(readdirDefaults);
+    exports.getReaddirOptsAndCb = optsAndCbGenerator(exports.getReaddirOptions);
+    var appendFileDefaults = {
+      encoding: "utf8",
+      mode: 438,
+      flag: constants_1.FLAGS[constants_1.FLAGS.a],
+    };
+    exports.getAppendFileOpts = optsGenerator(appendFileDefaults);
+    exports.getAppendFileOptsAndCb = optsAndCbGenerator(
+      exports.getAppendFileOpts,
+    );
+    var statDefaults = {
+      bigint: false,
+    };
+    var getStatOptions = (options = {}) =>
+      Object.assign({}, statDefaults, options);
+    exports.getStatOptions = getStatOptions;
+    var getStatOptsAndCb = (options, callback) =>
+      typeof options === "function"
+        ? [(0, exports.getStatOptions)(), options]
+        : [
+            (0, exports.getStatOptions)(options),
+            (0, util_1.validateCallback)(callback),
+          ];
+    exports.getStatOptsAndCb = getStatOptsAndCb;
+    var realpathDefaults = exports.optsDefaults;
+    exports.getRealpathOptions = optsGenerator(realpathDefaults);
+    exports.getRealpathOptsAndCb = optsAndCbGenerator(
+      exports.getRealpathOptions,
+    );
+    exports.writeFileDefaults = {
+      encoding: "utf8",
+      mode: 438,
+      flag: constants_1.FLAGS[constants_1.FLAGS.w],
+    };
+    exports.getWriteFileOptions = optsGenerator(exports.writeFileDefaults);
+  },
+});
+
+// node_modules/memfs/lib/volume.js
+var require_volume = __commonJS({
+  "node_modules/memfs/lib/volume.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FSWatcher =
+      exports.StatWatcher =
+      exports.Volume =
+      exports.toUnixTimestamp =
+      exports.dataToStr =
+      exports.pathToSteps =
+      exports.filenameToSteps =
+        void 0;
+    var pathModule = require_path();
+    var node_1 = require_node();
+    var Stats_1 = require_Stats();
+    var Dirent_1 = require_Dirent();
+    var buffer_1 = require_buffer2();
+    var setImmediate_1 = require_setImmediate();
+    var queueMicrotask_1 = require_queueMicrotask();
+    var process_1 = require_process();
+    var setTimeoutUnref_1 = require_setTimeoutUnref();
+    var stream_1 = require_stream();
+    var constants_1 = require_constants();
+    var events_1 = require_events();
+    var encoding_1 = require_encoding();
+    var FileHandle_1 = require_FileHandle();
+    var util = require_util();
+    var FsPromises_1 = require_FsPromises();
+    var print_1 = require_print();
+    var constants_2 = require_constants2();
+    var options_1 = require_options();
+    var util_1 = require_util3();
+    var resolveCrossPlatform = pathModule.resolve;
+    var {
+      O_RDONLY,
+      O_WRONLY,
+      O_RDWR,
+      O_CREAT,
+      O_EXCL,
+      O_TRUNC,
+      O_APPEND,
+      O_DIRECTORY,
+      O_SYMLINK,
+      F_OK,
+      COPYFILE_EXCL,
+      COPYFILE_FICLONE_FORCE,
+    } = constants_1.constants;
+    var { sep, relative, join, dirname } = pathModule.posix
+      ? pathModule.posix
+      : pathModule;
+    var kMinPoolSpace = 128;
+    var EPERM = "EPERM";
+    var ENOENT = "ENOENT";
+    var EBADF = "EBADF";
+    var EINVAL = "EINVAL";
+    var EEXIST = "EEXIST";
+    var ENOTDIR = "ENOTDIR";
+    var EMFILE = "EMFILE";
+    var EACCES = "EACCES";
+    var EISDIR = "EISDIR";
+    var ENOTEMPTY = "ENOTEMPTY";
+    var ENOSYS = "ENOSYS";
+    var ERR_FS_EISDIR = "ERR_FS_EISDIR";
+    var ERR_OUT_OF_RANGE = "ERR_OUT_OF_RANGE";
+    var resolve = (filename, base = process_1.default.cwd()) =>
+      resolveCrossPlatform(base, filename);
+    if (util_1.isWin) {
+      const _resolve = resolve;
+      resolve = (filename, base) =>
+        (0, util_1.unixify)(_resolve(filename, base));
+    }
+    function filenameToSteps(filename, base) {
+      const fullPath = resolve(filename, base);
+      const fullPathSansSlash = fullPath.substring(1);
+      if (!fullPathSansSlash) return [];
+      return fullPathSansSlash.split(sep);
+    }
+    exports.filenameToSteps = filenameToSteps;
+    function pathToSteps(path) {
+      return filenameToSteps((0, util_1.pathToFilename)(path));
+    }
+    exports.pathToSteps = pathToSteps;
+    function dataToStr(data, encoding = encoding_1.ENCODING_UTF8) {
+      if (buffer_1.Buffer.isBuffer(data)) return data.toString(encoding);
+      else if (data instanceof Uint8Array)
+        return (0, buffer_1.bufferFrom)(data).toString(encoding);
+      else return String(data);
+    }
+    exports.dataToStr = dataToStr;
+    function toUnixTimestamp(time) {
+      if (typeof time === "string" && +time == time) {
+        return +time;
+      }
+      if (time instanceof Date) {
+        return time.getTime() / 1e3;
+      }
+      if (isFinite(time)) {
+        if (time < 0) {
+          return Date.now() / 1e3;
+        }
+        return time;
+      }
+      throw new Error("Cannot parse time: " + time);
+    }
+    exports.toUnixTimestamp = toUnixTimestamp;
+    function validateUid(uid) {
+      if (typeof uid !== "number") throw TypeError(constants_2.ERRSTR.UID);
+    }
+    function validateGid(gid) {
+      if (typeof gid !== "number") throw TypeError(constants_2.ERRSTR.GID);
+    }
+    function flattenJSON(nestedJSON) {
+      const flatJSON = {};
+      function flatten(pathPrefix, node) {
+        for (const path in node) {
+          const contentOrNode = node[path];
+          const joinedPath = join(pathPrefix, path);
+          if (
+            typeof contentOrNode === "string" ||
+            contentOrNode instanceof buffer_1.Buffer
+          ) {
+            flatJSON[joinedPath] = contentOrNode;
+          } else if (
+            typeof contentOrNode === "object" &&
+            contentOrNode !== null &&
+            Object.keys(contentOrNode).length > 0
+          ) {
+            flatten(joinedPath, contentOrNode);
+          } else {
+            flatJSON[joinedPath] = null;
+          }
+        }
+      }
+      flatten("", nestedJSON);
+      return flatJSON;
+    }
+    var notImplemented = () => {
+      throw new Error("Not implemented");
+    };
+    var Volume = class _Volume {
+      static fromJSON(json, cwd) {
+        const vol = new _Volume();
+        vol.fromJSON(json, cwd);
+        return vol;
+      }
+      static fromNestedJSON(json, cwd) {
+        const vol = new _Volume();
+        vol.fromNestedJSON(json, cwd);
+        return vol;
+      }
+      get promises() {
+        if (this.promisesApi === null)
+          throw new Error("Promise is not supported in this environment.");
+        return this.promisesApi;
+      }
+      constructor(props = {}) {
+        this.ino = 0;
+        this.inodes = {};
+        this.releasedInos = [];
+        this.fds = {};
+        this.releasedFds = [];
+        this.maxFiles = 1e4;
+        this.openFiles = 0;
+        this.promisesApi = new FsPromises_1.FsPromises(
+          this,
+          FileHandle_1.FileHandle,
+        );
+        this.statWatchers = {};
+        this.cpSync = notImplemented;
+        this.lutimesSync = notImplemented;
+        this.statfsSync = notImplemented;
+        this.opendirSync = notImplemented;
+        this.cp = notImplemented;
+        this.lutimes = notImplemented;
+        this.statfs = notImplemented;
+        this.openAsBlob = notImplemented;
+        this.opendir = notImplemented;
+        this.props = Object.assign(
+          { Node: node_1.Node, Link: node_1.Link, File: node_1.File },
+          props,
+        );
+        const root = this.createLink();
+        root.setNode(this.createNode(true));
+        const self = this;
+        this.StatWatcher = class extends StatWatcher {
+          constructor() {
+            super(self);
+          }
+        };
+        const _ReadStream = FsReadStream;
+        this.ReadStream = class extends _ReadStream {
+          constructor(...args) {
+            super(self, ...args);
+          }
+        };
+        const _WriteStream = FsWriteStream;
+        this.WriteStream = class extends _WriteStream {
+          constructor(...args) {
+            super(self, ...args);
+          }
+        };
+        this.FSWatcher = class extends FSWatcher {
+          constructor() {
+            super(self);
+          }
+        };
+        root.setChild(".", root);
+        root.getNode().nlink++;
+        root.setChild("..", root);
+        root.getNode().nlink++;
+        this.root = root;
+      }
+      createLink(parent, name, isDirectory = false, perm) {
+        if (!parent) {
+          return new this.props.Link(this, null, "");
+        }
+        if (!name) {
+          throw new Error("createLink: name cannot be empty");
+        }
+        return parent.createChild(name, this.createNode(isDirectory, perm));
+      }
+      deleteLink(link) {
+        const parent = link.parent;
+        if (parent) {
+          parent.deleteChild(link);
+          return true;
+        }
+        return false;
+      }
+      newInoNumber() {
+        const releasedFd = this.releasedInos.pop();
+        if (releasedFd) return releasedFd;
+        else {
+          this.ino = (this.ino + 1) % 4294967295;
+          return this.ino;
+        }
+      }
+      newFdNumber() {
+        const releasedFd = this.releasedFds.pop();
+        return typeof releasedFd === "number" ? releasedFd : _Volume.fd--;
+      }
+      createNode(isDirectory = false, perm) {
+        const node = new this.props.Node(this.newInoNumber(), perm);
+        if (isDirectory) node.setIsDirectory();
+        this.inodes[node.ino] = node;
+        return node;
+      }
+      deleteNode(node) {
+        node.del();
+        delete this.inodes[node.ino];
+        this.releasedInos.push(node.ino);
+      }
+      // Returns a `Link` (hard link) referenced by path "split" into steps.
+      getLink(steps) {
+        return this.root.walk(steps);
+      }
+      // Just link `getLink`, but throws a correct user error, if link to found.
+      getLinkOrThrow(filename, funcName) {
+        const steps = filenameToSteps(filename);
+        const link = this.getLink(steps);
+        if (!link) throw (0, util_1.createError)(ENOENT, funcName, filename);
+        return link;
+      }
+      // Just like `getLink`, but also dereference/resolves symbolic links.
+      getResolvedLink(filenameOrSteps) {
+        let steps =
+          typeof filenameOrSteps === "string"
+            ? filenameToSteps(filenameOrSteps)
+            : filenameOrSteps;
+        let link = this.root;
+        let i = 0;
+        while (i < steps.length) {
+          const step = steps[i];
+          link = link.getChild(step);
+          if (!link) return null;
+          const node = link.getNode();
+          if (node.isSymlink()) {
+            steps = node.symlink.concat(steps.slice(i + 1));
+            link = this.root;
+            i = 0;
+            continue;
+          }
+          i++;
+        }
+        return link;
+      }
+      // Just like `getLinkOrThrow`, but also dereference/resolves symbolic links.
+      getResolvedLinkOrThrow(filename, funcName) {
+        const link = this.getResolvedLink(filename);
+        if (!link) throw (0, util_1.createError)(ENOENT, funcName, filename);
+        return link;
+      }
+      resolveSymlinks(link) {
+        return this.getResolvedLink(link.steps.slice(1));
+      }
+      // Just like `getLinkOrThrow`, but also verifies that the link is a directory.
+      getLinkAsDirOrThrow(filename, funcName) {
+        const link = this.getLinkOrThrow(filename, funcName);
+        if (!link.getNode().isDirectory())
+          throw (0, util_1.createError)(ENOTDIR, funcName, filename);
+        return link;
+      }
+      // Get the immediate parent directory of the link.
+      getLinkParent(steps) {
+        return this.root.walk(steps, steps.length - 1);
+      }
+      getLinkParentAsDirOrThrow(filenameOrSteps, funcName) {
+        const steps =
+          filenameOrSteps instanceof Array
+            ? filenameOrSteps
+            : filenameToSteps(filenameOrSteps);
+        const link = this.getLinkParent(steps);
+        if (!link)
+          throw (0, util_1.createError)(
+            ENOENT,
+            funcName,
+            sep + steps.join(sep),
+          );
+        if (!link.getNode().isDirectory())
+          throw (0, util_1.createError)(
+            ENOTDIR,
+            funcName,
+            sep + steps.join(sep),
+          );
+        return link;
+      }
+      getFileByFd(fd) {
+        return this.fds[String(fd)];
+      }
+      getFileByFdOrThrow(fd, funcName) {
+        if (!(0, util_1.isFd)(fd)) throw TypeError(constants_2.ERRSTR.FD);
+        const file = this.getFileByFd(fd);
+        if (!file) throw (0, util_1.createError)(EBADF, funcName);
+        return file;
+      }
+      /**
+       * @todo This is not used anymore. Remove.
+       */
+      /*
+        private getNodeByIdOrCreate(id: TFileId, flags: number, perm: number): Node {
+          if (typeof id === 'number') {
+            const file = this.getFileByFd(id);
+            if (!file) throw Error('File nto found');
+            return file.node;
+          } else {
+            const steps = pathToSteps(id as PathLike);
+            let link = this.getLink(steps);
+            if (link) return link.getNode();
+
+            // Try creating a node if not found.
+            if (flags & O_CREAT) {
+              const dirLink = this.getLinkParent(steps);
+              if (dirLink) {
+                const name = steps[steps.length - 1];
+                link = this.createLink(dirLink, name, false, perm);
+                return link.getNode();
+              }
+            }
+
+            throw createError(ENOENT, 'getNodeByIdOrCreate', pathToFilename(id));
+          }
+        }
+        */
+      wrapAsync(method, args, callback) {
+        (0, util_1.validateCallback)(callback);
+        (0, setImmediate_1.default)(() => {
+          let result;
+          try {
+            result = method.apply(this, args);
+          } catch (err) {
+            callback(err);
+            return;
+          }
+          callback(null, result);
+        });
+      }
+      _toJSON(link = this.root, json = {}, path, asBuffer) {
+        let isEmpty = true;
+        let children = link.children;
+        if (link.getNode().isFile()) {
+          children = /* @__PURE__ */ new Map([
+            [link.getName(), link.parent.getChild(link.getName())],
+          ]);
+          link = link.parent;
+        }
+        for (const name of children.keys()) {
+          if (name === "." || name === "..") {
+            continue;
+          }
+          isEmpty = false;
+          const child = link.getChild(name);
+          if (!child) {
+            throw new Error("_toJSON: unexpected undefined");
+          }
+          const node = child.getNode();
+          if (node.isFile()) {
+            let filename = child.getPath();
+            if (path) filename = relative(path, filename);
+            json[filename] = asBuffer ? node.getBuffer() : node.getString();
+          } else if (node.isDirectory()) {
+            this._toJSON(child, json, path);
+          }
+        }
+        let dirPath = link.getPath();
+        if (path) dirPath = relative(path, dirPath);
+        if (dirPath && isEmpty) {
+          json[dirPath] = null;
+        }
+        return json;
+      }
+      toJSON(paths, json = {}, isRelative = false, asBuffer = false) {
+        const links = [];
+        if (paths) {
+          if (!Array.isArray(paths)) paths = [paths];
+          for (const path of paths) {
+            const filename = (0, util_1.pathToFilename)(path);
+            const link = this.getResolvedLink(filename);
+            if (!link) continue;
+            links.push(link);
+          }
+        } else {
+          links.push(this.root);
+        }
+        if (!links.length) return json;
+        for (const link of links)
+          this._toJSON(link, json, isRelative ? link.getPath() : "", asBuffer);
+        return json;
+      }
+      // TODO: `cwd` should probably not invoke `process.cwd()`.
+      fromJSON(json, cwd = process_1.default.cwd()) {
+        for (let filename in json) {
+          const data = json[filename];
+          filename = resolve(filename, cwd);
+          if (typeof data === "string" || data instanceof buffer_1.Buffer) {
+            const dir = dirname(filename);
+            this.mkdirpBase(
+              dir,
+              511,
+              /* MODE.DIR */
+            );
+            this.writeFileSync(filename, data);
+          } else {
+            this.mkdirpBase(
+              filename,
+              511,
+              /* MODE.DIR */
+            );
+          }
+        }
+      }
+      fromNestedJSON(json, cwd) {
+        this.fromJSON(flattenJSON(json), cwd);
+      }
+      toTree(opts = { separator: sep }) {
+        return (0, print_1.toTreeSync)(this, opts);
+      }
+      reset() {
+        this.ino = 0;
+        this.inodes = {};
+        this.releasedInos = [];
+        this.fds = {};
+        this.releasedFds = [];
+        this.openFiles = 0;
+        this.root = this.createLink();
+        this.root.setNode(this.createNode(true));
+      }
+      // Legacy interface
+      mountSync(mountpoint, json) {
+        this.fromJSON(json, mountpoint);
+      }
+      openLink(link, flagsNum, resolveSymlinks = true) {
+        if (this.openFiles >= this.maxFiles) {
+          throw (0, util_1.createError)(EMFILE, "open", link.getPath());
+        }
+        let realLink = link;
+        if (resolveSymlinks) realLink = this.resolveSymlinks(link);
+        if (!realLink)
+          throw (0, util_1.createError)(ENOENT, "open", link.getPath());
+        const node = realLink.getNode();
+        if (node.isDirectory()) {
+          if ((flagsNum & (O_RDONLY | O_RDWR | O_WRONLY)) !== O_RDONLY)
+            throw (0, util_1.createError)(EISDIR, "open", link.getPath());
+        } else {
+          if (flagsNum & O_DIRECTORY)
+            throw (0, util_1.createError)(ENOTDIR, "open", link.getPath());
+        }
+        if (!(flagsNum & O_WRONLY)) {
+          if (!node.canRead()) {
+            throw (0, util_1.createError)(EACCES, "open", link.getPath());
+          }
+        }
+        if (flagsNum & O_RDWR) {
+        }
+        const file = new this.props.File(
+          link,
+          node,
+          flagsNum,
+          this.newFdNumber(),
+        );
+        this.fds[file.fd] = file;
+        this.openFiles++;
+        if (flagsNum & O_TRUNC) file.truncate();
+        return file;
+      }
+      openFile(filename, flagsNum, modeNum, resolveSymlinks = true) {
+        const steps = filenameToSteps(filename);
+        let link = resolveSymlinks
+          ? this.getResolvedLink(steps)
+          : this.getLink(steps);
+        if (link && flagsNum & O_EXCL)
+          throw (0, util_1.createError)(EEXIST, "open", filename);
+        if (!link && flagsNum & O_CREAT) {
+          const dirLink = this.getResolvedLink(
+            steps.slice(0, steps.length - 1),
+          );
+          if (!dirLink)
+            throw (0, util_1.createError)(
+              ENOENT,
+              "open",
+              sep + steps.join(sep),
+            );
+          if (flagsNum & O_CREAT && typeof modeNum === "number") {
+            link = this.createLink(
+              dirLink,
+              steps[steps.length - 1],
+              false,
+              modeNum,
+            );
+          }
+        }
+        if (link) return this.openLink(link, flagsNum, resolveSymlinks);
+        throw (0, util_1.createError)(ENOENT, "open", filename);
+      }
+      openBase(filename, flagsNum, modeNum, resolveSymlinks = true) {
+        const file = this.openFile(
+          filename,
+          flagsNum,
+          modeNum,
+          resolveSymlinks,
+        );
+        if (!file) throw (0, util_1.createError)(ENOENT, "open", filename);
+        return file.fd;
+      }
+      openSync(path, flags, mode = 438) {
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const fileName = (0, util_1.pathToFilename)(path);
+        const flagsNum = (0, util_1.flagsToNumber)(flags);
+        return this.openBase(
+          fileName,
+          flagsNum,
+          modeNum,
+          !(flagsNum & O_SYMLINK),
+        );
+      }
+      open(path, flags, a, b) {
+        let mode = a;
+        let callback = b;
+        if (typeof a === "function") {
+          mode = 438;
+          callback = a;
+        }
+        mode = mode || 438;
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const fileName = (0, util_1.pathToFilename)(path);
+        const flagsNum = (0, util_1.flagsToNumber)(flags);
+        this.wrapAsync(
+          this.openBase,
+          [fileName, flagsNum, modeNum, !(flagsNum & O_SYMLINK)],
+          callback,
+        );
+      }
+      closeFile(file) {
+        if (!this.fds[file.fd]) return;
+        this.openFiles--;
+        delete this.fds[file.fd];
+        this.releasedFds.push(file.fd);
+      }
+      closeSync(fd) {
+        (0, util_1.validateFd)(fd);
+        const file = this.getFileByFdOrThrow(fd, "close");
+        this.closeFile(file);
+      }
+      close(fd, callback) {
+        (0, util_1.validateFd)(fd);
+        this.wrapAsync(this.closeSync, [fd], callback);
+      }
+      openFileOrGetById(id, flagsNum, modeNum) {
+        if (typeof id === "number") {
+          const file = this.fds[id];
+          if (!file) throw (0, util_1.createError)(ENOENT);
+          return file;
+        } else {
+          return this.openFile(
+            (0, util_1.pathToFilename)(id),
+            flagsNum,
+            modeNum,
+          );
+        }
+      }
+      readBase(fd, buffer, offset, length, position) {
+        if (buffer.byteLength < length) {
+          throw (0, util_1.createError)(
+            ERR_OUT_OF_RANGE,
+            "read",
+            void 0,
+            void 0,
+            RangeError,
+          );
+        }
+        const file = this.getFileByFdOrThrow(fd);
+        if (file.node.isSymlink()) {
+          throw (0, util_1.createError)(EPERM, "read", file.link.getPath());
+        }
+        return file.read(
+          buffer,
+          Number(offset),
+          Number(length),
+          position === -1 || typeof position !== "number" ? void 0 : position,
+        );
+      }
+      readSync(fd, buffer, offset, length, position) {
+        (0, util_1.validateFd)(fd);
+        return this.readBase(fd, buffer, offset, length, position);
+      }
+      read(fd, buffer, offset, length, position, callback) {
+        (0, util_1.validateCallback)(callback);
+        if (length === 0) {
+          return (0, queueMicrotask_1.default)(() => {
+            if (callback) callback(null, 0, buffer);
+          });
+        }
+        (0, setImmediate_1.default)(() => {
+          try {
+            const bytes = this.readBase(fd, buffer, offset, length, position);
+            callback(null, bytes, buffer);
+          } catch (err) {
+            callback(err);
+          }
+        });
+      }
+      readvBase(fd, buffers, position) {
+        const file = this.getFileByFdOrThrow(fd);
+        let p = position !== null && position !== void 0 ? position : void 0;
+        if (p === -1) {
+          p = void 0;
+        }
+        let bytesRead = 0;
+        for (const buffer of buffers) {
+          const bytes = file.read(buffer, 0, buffer.byteLength, p);
+          p = void 0;
+          bytesRead += bytes;
+          if (bytes < buffer.byteLength) break;
+        }
+        return bytesRead;
+      }
+      readv(fd, buffers, a, b) {
+        let position = a;
+        let callback = b;
+        if (typeof a === "function") {
+          position = null;
+          callback = a;
+        }
+        (0, util_1.validateCallback)(callback);
+        (0, setImmediate_1.default)(() => {
+          try {
+            const bytes = this.readvBase(fd, buffers, position);
+            callback(null, bytes, buffers);
+          } catch (err) {
+            callback(err);
+          }
+        });
+      }
+      readvSync(fd, buffers, position) {
+        (0, util_1.validateFd)(fd);
+        return this.readvBase(fd, buffers, position);
+      }
+      readFileBase(id, flagsNum, encoding) {
+        let result;
+        const isUserFd = typeof id === "number";
+        const userOwnsFd = isUserFd && (0, util_1.isFd)(id);
+        let fd;
+        if (userOwnsFd) fd = id;
+        else {
+          const filename = (0, util_1.pathToFilename)(id);
+          const steps = filenameToSteps(filename);
+          const link = this.getResolvedLink(steps);
+          if (link) {
+            const node = link.getNode();
+            if (node.isDirectory())
+              throw (0, util_1.createError)(EISDIR, "open", link.getPath());
+          }
+          fd = this.openSync(id, flagsNum);
+        }
+        try {
+          result = (0, util_1.bufferToEncoding)(
+            this.getFileByFdOrThrow(fd).getBuffer(),
+            encoding,
+          );
+        } finally {
+          if (!userOwnsFd) {
+            this.closeSync(fd);
+          }
+        }
+        return result;
+      }
+      readFileSync(file, options) {
+        const opts = (0, options_1.getReadFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        return this.readFileBase(file, flagsNum, opts.encoding);
+      }
+      readFile(id, a, b) {
+        const [opts, callback] = (0, options_1.optsAndCbGenerator)(
+          options_1.getReadFileOptions,
+        )(a, b);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        this.wrapAsync(
+          this.readFileBase,
+          [id, flagsNum, opts.encoding],
+          callback,
+        );
+      }
+      writeBase(fd, buf, offset, length, position) {
+        const file = this.getFileByFdOrThrow(fd, "write");
+        if (file.node.isSymlink()) {
+          throw (0, util_1.createError)(EBADF, "write", file.link.getPath());
+        }
+        return file.write(
+          buf,
+          offset,
+          length,
+          position === -1 || typeof position !== "number" ? void 0 : position,
+        );
+      }
+      writeSync(fd, a, b, c, d) {
+        const [, buf, offset, length, position] = (0, util_1.getWriteSyncArgs)(
+          fd,
+          a,
+          b,
+          c,
+          d,
+        );
+        return this.writeBase(fd, buf, offset, length, position);
+      }
+      write(fd, a, b, c, d, e) {
+        const [, asStr, buf, offset, length, position, cb] = (0,
+        util_1.getWriteArgs)(fd, a, b, c, d, e);
+        (0, setImmediate_1.default)(() => {
+          try {
+            const bytes = this.writeBase(fd, buf, offset, length, position);
+            if (!asStr) {
+              cb(null, bytes, buf);
+            } else {
+              cb(null, bytes, a);
+            }
+          } catch (err) {
+            cb(err);
+          }
+        });
+      }
+      writevBase(fd, buffers, position) {
+        const file = this.getFileByFdOrThrow(fd);
+        let p = position !== null && position !== void 0 ? position : void 0;
+        if (p === -1) {
+          p = void 0;
+        }
+        let bytesWritten = 0;
+        for (const buffer of buffers) {
+          const nodeBuf = buffer_1.Buffer.from(
+            buffer.buffer,
+            buffer.byteOffset,
+            buffer.byteLength,
+          );
+          const bytes = file.write(nodeBuf, 0, nodeBuf.byteLength, p);
+          p = void 0;
+          bytesWritten += bytes;
+          if (bytes < nodeBuf.byteLength) break;
+        }
+        return bytesWritten;
+      }
+      writev(fd, buffers, a, b) {
+        let position = a;
+        let callback = b;
+        if (typeof a === "function") {
+          position = null;
+          callback = a;
+        }
+        (0, util_1.validateCallback)(callback);
+        (0, setImmediate_1.default)(() => {
+          try {
+            const bytes = this.writevBase(fd, buffers, position);
+            callback(null, bytes, buffers);
+          } catch (err) {
+            callback(err);
+          }
+        });
+      }
+      writevSync(fd, buffers, position) {
+        (0, util_1.validateFd)(fd);
+        return this.writevBase(fd, buffers, position);
+      }
+      writeFileBase(id, buf, flagsNum, modeNum) {
+        const isUserFd = typeof id === "number";
+        let fd;
+        if (isUserFd) fd = id;
+        else {
+          fd = this.openBase((0, util_1.pathToFilename)(id), flagsNum, modeNum);
+        }
+        let offset = 0;
+        let length = buf.length;
+        let position = flagsNum & O_APPEND ? void 0 : 0;
+        try {
+          while (length > 0) {
+            const written = this.writeSync(fd, buf, offset, length, position);
+            offset += written;
+            length -= written;
+            if (position !== void 0) position += written;
+          }
+        } finally {
+          if (!isUserFd) this.closeSync(fd);
+        }
+      }
+      writeFileSync(id, data, options) {
+        const opts = (0, options_1.getWriteFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode);
+        const buf = (0, util_1.dataToBuffer)(data, opts.encoding);
+        this.writeFileBase(id, buf, flagsNum, modeNum);
+      }
+      writeFile(id, data, a, b) {
+        let options = a;
+        let callback = b;
+        if (typeof a === "function") {
+          options = options_1.writeFileDefaults;
+          callback = a;
+        }
+        const cb = (0, util_1.validateCallback)(callback);
+        const opts = (0, options_1.getWriteFileOptions)(options);
+        const flagsNum = (0, util_1.flagsToNumber)(opts.flag);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode);
+        const buf = (0, util_1.dataToBuffer)(data, opts.encoding);
+        this.wrapAsync(this.writeFileBase, [id, buf, flagsNum, modeNum], cb);
+      }
+      linkBase(filename1, filename2) {
+        const steps1 = filenameToSteps(filename1);
+        const link1 = this.getLink(steps1);
+        if (!link1)
+          throw (0, util_1.createError)(ENOENT, "link", filename1, filename2);
+        const steps2 = filenameToSteps(filename2);
+        const dir2 = this.getLinkParent(steps2);
+        if (!dir2)
+          throw (0, util_1.createError)(ENOENT, "link", filename1, filename2);
+        const name = steps2[steps2.length - 1];
+        if (dir2.getChild(name))
+          throw (0, util_1.createError)(EEXIST, "link", filename1, filename2);
+        const node = link1.getNode();
+        node.nlink++;
+        dir2.createChild(name, node);
+      }
+      copyFileBase(src, dest, flags) {
+        const buf = this.readFileSync(src);
+        if (flags & COPYFILE_EXCL) {
+          if (this.existsSync(dest)) {
+            throw (0, util_1.createError)(EEXIST, "copyFile", src, dest);
+          }
+        }
+        if (flags & COPYFILE_FICLONE_FORCE) {
+          throw (0, util_1.createError)(ENOSYS, "copyFile", src, dest);
+        }
+        this.writeFileBase(
+          dest,
+          buf,
+          constants_2.FLAGS.w,
+          438,
+          /* MODE.DEFAULT */
+        );
+      }
+      copyFileSync(src, dest, flags) {
+        const srcFilename = (0, util_1.pathToFilename)(src);
+        const destFilename = (0, util_1.pathToFilename)(dest);
+        return this.copyFileBase(srcFilename, destFilename, (flags || 0) | 0);
+      }
+      copyFile(src, dest, a, b) {
+        const srcFilename = (0, util_1.pathToFilename)(src);
+        const destFilename = (0, util_1.pathToFilename)(dest);
+        let flags;
+        let callback;
+        if (typeof a === "function") {
+          flags = 0;
+          callback = a;
+        } else {
+          flags = a;
+          callback = b;
+        }
+        (0, util_1.validateCallback)(callback);
+        this.wrapAsync(
+          this.copyFileBase,
+          [srcFilename, destFilename, flags],
+          callback,
+        );
+      }
+      linkSync(existingPath, newPath) {
+        const existingPathFilename = (0, util_1.pathToFilename)(existingPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
+        this.linkBase(existingPathFilename, newPathFilename);
+      }
+      link(existingPath, newPath, callback) {
+        const existingPathFilename = (0, util_1.pathToFilename)(existingPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
+        this.wrapAsync(
+          this.linkBase,
+          [existingPathFilename, newPathFilename],
+          callback,
+        );
+      }
+      unlinkBase(filename) {
+        const steps = filenameToSteps(filename);
+        const link = this.getLink(steps);
+        if (!link) throw (0, util_1.createError)(ENOENT, "unlink", filename);
+        if (link.length) throw Error("Dir not empty...");
+        this.deleteLink(link);
+        const node = link.getNode();
+        node.nlink--;
+        if (node.nlink <= 0) {
+          this.deleteNode(node);
+        }
+      }
+      unlinkSync(path) {
+        const filename = (0, util_1.pathToFilename)(path);
+        this.unlinkBase(filename);
+      }
+      unlink(path, callback) {
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.unlinkBase, [filename], callback);
+      }
+      symlinkBase(targetFilename, pathFilename) {
+        const pathSteps = filenameToSteps(pathFilename);
+        const dirLink = this.getLinkParent(pathSteps);
+        if (!dirLink)
+          throw (0, util_1.createError)(
+            ENOENT,
+            "symlink",
+            targetFilename,
+            pathFilename,
+          );
+        const name = pathSteps[pathSteps.length - 1];
+        if (dirLink.getChild(name))
+          throw (0, util_1.createError)(
+            EEXIST,
+            "symlink",
+            targetFilename,
+            pathFilename,
+          );
+        const symlink = dirLink.createChild(name);
+        symlink.getNode().makeSymlink(filenameToSteps(targetFilename));
+        return symlink;
+      }
+      // `type` argument works only on Windows.
+      symlinkSync(target, path, type) {
+        const targetFilename = (0, util_1.pathToFilename)(target);
+        const pathFilename = (0, util_1.pathToFilename)(path);
+        this.symlinkBase(targetFilename, pathFilename);
+      }
+      symlink(target, path, a, b) {
+        const callback = (0, util_1.validateCallback)(
+          typeof a === "function" ? a : b,
+        );
+        const targetFilename = (0, util_1.pathToFilename)(target);
+        const pathFilename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(
+          this.symlinkBase,
+          [targetFilename, pathFilename],
+          callback,
+        );
+      }
+      realpathBase(filename, encoding) {
+        const steps = filenameToSteps(filename);
+        const realLink = this.getResolvedLink(steps);
+        if (!realLink)
+          throw (0, util_1.createError)(ENOENT, "realpath", filename);
+        return (0, encoding_1.strToEncoding)(
+          realLink.getPath() || "/",
+          encoding,
+        );
+      }
+      realpathSync(path, options) {
+        return this.realpathBase(
+          (0, util_1.pathToFilename)(path),
+          (0, options_1.getRealpathOptions)(options).encoding,
+        );
+      }
+      realpath(path, a, b) {
+        const [opts, callback] = (0, options_1.getRealpathOptsAndCb)(a, b);
+        const pathFilename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(
+          this.realpathBase,
+          [pathFilename, opts.encoding],
+          callback,
+        );
+      }
+      lstatBase(filename, bigint = false, throwIfNoEntry = false) {
+        const link = this.getLink(filenameToSteps(filename));
+        if (link) {
+          return Stats_1.default.build(link.getNode(), bigint);
+        } else if (!throwIfNoEntry) {
+          return void 0;
+        } else {
+          throw (0, util_1.createError)(ENOENT, "lstat", filename);
+        }
+      }
+      lstatSync(path, options) {
+        const { throwIfNoEntry = true, bigint = false } = (0,
+        options_1.getStatOptions)(options);
+        return this.lstatBase(
+          (0, util_1.pathToFilename)(path),
+          bigint,
+          throwIfNoEntry,
+        );
+      }
+      lstat(path, a, b) {
+        const [{ throwIfNoEntry = true, bigint = false }, callback] = (0,
+        options_1.getStatOptsAndCb)(a, b);
+        this.wrapAsync(
+          this.lstatBase,
+          [(0, util_1.pathToFilename)(path), bigint, throwIfNoEntry],
+          callback,
+        );
+      }
+      statBase(filename, bigint = false, throwIfNoEntry = true) {
+        const link = this.getResolvedLink(filenameToSteps(filename));
+        if (link) {
+          return Stats_1.default.build(link.getNode(), bigint);
+        } else if (!throwIfNoEntry) {
+          return void 0;
+        } else {
+          throw (0, util_1.createError)(ENOENT, "stat", filename);
+        }
+      }
+      statSync(path, options) {
+        const { bigint = true, throwIfNoEntry = true } = (0,
+        options_1.getStatOptions)(options);
+        return this.statBase(
+          (0, util_1.pathToFilename)(path),
+          bigint,
+          throwIfNoEntry,
+        );
+      }
+      stat(path, a, b) {
+        const [{ bigint = false, throwIfNoEntry = true }, callback] = (0,
+        options_1.getStatOptsAndCb)(a, b);
+        this.wrapAsync(
+          this.statBase,
+          [(0, util_1.pathToFilename)(path), bigint, throwIfNoEntry],
+          callback,
+        );
+      }
+      fstatBase(fd, bigint = false) {
+        const file = this.getFileByFd(fd);
+        if (!file) throw (0, util_1.createError)(EBADF, "fstat");
+        return Stats_1.default.build(file.node, bigint);
+      }
+      fstatSync(fd, options) {
+        return this.fstatBase(
+          fd,
+          (0, options_1.getStatOptions)(options).bigint,
+        );
+      }
+      fstat(fd, a, b) {
+        const [opts, callback] = (0, options_1.getStatOptsAndCb)(a, b);
+        this.wrapAsync(this.fstatBase, [fd, opts.bigint], callback);
+      }
+      renameBase(oldPathFilename, newPathFilename) {
+        const link = this.getLink(filenameToSteps(oldPathFilename));
+        if (!link)
+          throw (0, util_1.createError)(
+            ENOENT,
+            "rename",
+            oldPathFilename,
+            newPathFilename,
+          );
+        const newPathSteps = filenameToSteps(newPathFilename);
+        const newPathDirLink = this.getLinkParent(newPathSteps);
+        if (!newPathDirLink)
+          throw (0, util_1.createError)(
+            ENOENT,
+            "rename",
+            oldPathFilename,
+            newPathFilename,
+          );
+        const oldLinkParent = link.parent;
+        if (oldLinkParent) {
+          oldLinkParent.deleteChild(link);
+        }
+        const name = newPathSteps[newPathSteps.length - 1];
+        link.name = name;
+        link.steps = [...newPathDirLink.steps, name];
+        newPathDirLink.setChild(link.getName(), link);
+      }
+      renameSync(oldPath, newPath) {
+        const oldPathFilename = (0, util_1.pathToFilename)(oldPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
+        this.renameBase(oldPathFilename, newPathFilename);
+      }
+      rename(oldPath, newPath, callback) {
+        const oldPathFilename = (0, util_1.pathToFilename)(oldPath);
+        const newPathFilename = (0, util_1.pathToFilename)(newPath);
+        this.wrapAsync(
+          this.renameBase,
+          [oldPathFilename, newPathFilename],
+          callback,
+        );
+      }
+      existsBase(filename) {
+        return !!this.statBase(filename);
+      }
+      existsSync(path) {
+        try {
+          return this.existsBase((0, util_1.pathToFilename)(path));
+        } catch (err) {
+          return false;
+        }
+      }
+      exists(path, callback) {
+        const filename = (0, util_1.pathToFilename)(path);
+        if (typeof callback !== "function") throw Error(constants_2.ERRSTR.CB);
+        (0, setImmediate_1.default)(() => {
+          try {
+            callback(this.existsBase(filename));
+          } catch (err) {
+            callback(false);
+          }
+        });
+      }
+      accessBase(filename, mode) {
+        const link = this.getLinkOrThrow(filename, "access");
+      }
+      accessSync(path, mode = F_OK) {
+        const filename = (0, util_1.pathToFilename)(path);
+        mode = mode | 0;
+        this.accessBase(filename, mode);
+      }
+      access(path, a, b) {
+        let mode = F_OK;
+        let callback;
+        if (typeof a !== "function") {
+          mode = a | 0;
+          callback = (0, util_1.validateCallback)(b);
+        } else {
+          callback = a;
+        }
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.accessBase, [filename, mode], callback);
+      }
+      appendFileSync(id, data, options) {
+        const opts = (0, options_1.getAppendFileOpts)(options);
+        if (!opts.flag || (0, util_1.isFd)(id)) opts.flag = "a";
+        this.writeFileSync(id, data, opts);
+      }
+      appendFile(id, data, a, b) {
+        const [opts, callback] = (0, options_1.getAppendFileOptsAndCb)(a, b);
+        if (!opts.flag || (0, util_1.isFd)(id)) opts.flag = "a";
+        this.writeFile(id, data, opts, callback);
+      }
+      readdirBase(filename, options) {
+        const steps = filenameToSteps(filename);
+        const link = this.getResolvedLink(steps);
+        if (!link) throw (0, util_1.createError)(ENOENT, "readdir", filename);
+        const node = link.getNode();
+        if (!node.isDirectory())
+          throw (0, util_1.createError)(ENOTDIR, "scandir", filename);
+        const list = [];
+        for (const name of link.children.keys()) {
+          const child = link.getChild(name);
+          if (!child || name === "." || name === "..") continue;
+          list.push(Dirent_1.default.build(child, options.encoding));
+          if (options.recursive && child.children.size) {
+            const recurseOptions = Object.assign(Object.assign({}, options), {
+              recursive: true,
+              withFileTypes: true,
+            });
+            const childList = this.readdirBase(child.getPath(), recurseOptions);
+            list.push(...childList);
+          }
+        }
+        if (!util_1.isWin && options.encoding !== "buffer")
+          list.sort((a, b) => {
+            if (a.name < b.name) return -1;
+            if (a.name > b.name) return 1;
+            return 0;
+          });
+        if (options.withFileTypes) return list;
+        let filename2 = filename;
+        if (util_1.isWin) {
+          filename2 = filename2.replace(/\\/g, "/");
+        }
+        return list.map((dirent) => {
+          if (options.recursive) {
+            return dirent.path.replace(filename2 + pathModule.posix.sep, "");
+          }
+          return dirent.name;
+        });
+      }
+      readdirSync(path, options) {
+        const opts = (0, options_1.getReaddirOptions)(options);
+        const filename = (0, util_1.pathToFilename)(path);
+        return this.readdirBase(filename, opts);
+      }
+      readdir(path, a, b) {
+        const [options, callback] = (0, options_1.getReaddirOptsAndCb)(a, b);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.readdirBase, [filename, options], callback);
+      }
+      readlinkBase(filename, encoding) {
+        const link = this.getLinkOrThrow(filename, "readlink");
+        const node = link.getNode();
+        if (!node.isSymlink())
+          throw (0, util_1.createError)(EINVAL, "readlink", filename);
+        const str = sep + node.symlink.join(sep);
+        return (0, encoding_1.strToEncoding)(str, encoding);
+      }
+      readlinkSync(path, options) {
+        const opts = (0, options_1.getDefaultOpts)(options);
+        const filename = (0, util_1.pathToFilename)(path);
+        return this.readlinkBase(filename, opts.encoding);
+      }
+      readlink(path, a, b) {
+        const [opts, callback] = (0, options_1.getDefaultOptsAndCb)(a, b);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.readlinkBase, [filename, opts.encoding], callback);
+      }
+      fsyncBase(fd) {
+        this.getFileByFdOrThrow(fd, "fsync");
+      }
+      fsyncSync(fd) {
+        this.fsyncBase(fd);
+      }
+      fsync(fd, callback) {
+        this.wrapAsync(this.fsyncBase, [fd], callback);
+      }
+      fdatasyncBase(fd) {
+        this.getFileByFdOrThrow(fd, "fdatasync");
+      }
+      fdatasyncSync(fd) {
+        this.fdatasyncBase(fd);
+      }
+      fdatasync(fd, callback) {
+        this.wrapAsync(this.fdatasyncBase, [fd], callback);
+      }
+      ftruncateBase(fd, len) {
+        const file = this.getFileByFdOrThrow(fd, "ftruncate");
+        file.truncate(len);
+      }
+      ftruncateSync(fd, len) {
+        this.ftruncateBase(fd, len);
+      }
+      ftruncate(fd, a, b) {
+        const len = typeof a === "number" ? a : 0;
+        const callback = (0, util_1.validateCallback)(
+          typeof a === "number" ? b : a,
+        );
+        this.wrapAsync(this.ftruncateBase, [fd, len], callback);
+      }
+      truncateBase(path, len) {
+        const fd = this.openSync(path, "r+");
+        try {
+          this.ftruncateSync(fd, len);
+        } finally {
+          this.closeSync(fd);
+        }
+      }
+      /**
+       * `id` should be a file descriptor or a path. `id` as file descriptor will
+       * not be supported soon.
+       */
+      truncateSync(id, len) {
+        if ((0, util_1.isFd)(id)) return this.ftruncateSync(id, len);
+        this.truncateBase(id, len);
+      }
+      truncate(id, a, b) {
+        const len = typeof a === "number" ? a : 0;
+        const callback = (0, util_1.validateCallback)(
+          typeof a === "number" ? b : a,
+        );
+        if ((0, util_1.isFd)(id)) return this.ftruncate(id, len, callback);
+        this.wrapAsync(this.truncateBase, [id, len], callback);
+      }
+      futimesBase(fd, atime, mtime) {
+        const file = this.getFileByFdOrThrow(fd, "futimes");
+        const node = file.node;
+        node.atime = new Date(atime * 1e3);
+        node.mtime = new Date(mtime * 1e3);
+      }
+      futimesSync(fd, atime, mtime) {
+        this.futimesBase(fd, toUnixTimestamp(atime), toUnixTimestamp(mtime));
+      }
+      futimes(fd, atime, mtime, callback) {
+        this.wrapAsync(
+          this.futimesBase,
+          [fd, toUnixTimestamp(atime), toUnixTimestamp(mtime)],
+          callback,
+        );
+      }
+      utimesBase(filename, atime, mtime) {
+        const fd = this.openSync(filename, "r");
+        try {
+          this.futimesBase(fd, atime, mtime);
+        } finally {
+          this.closeSync(fd);
+        }
+      }
+      utimesSync(path, atime, mtime) {
+        this.utimesBase(
+          (0, util_1.pathToFilename)(path),
+          toUnixTimestamp(atime),
+          toUnixTimestamp(mtime),
+        );
+      }
+      utimes(path, atime, mtime, callback) {
+        this.wrapAsync(
+          this.utimesBase,
+          [
+            (0, util_1.pathToFilename)(path),
+            toUnixTimestamp(atime),
+            toUnixTimestamp(mtime),
+          ],
+          callback,
+        );
+      }
+      mkdirBase(filename, modeNum) {
+        const steps = filenameToSteps(filename);
+        if (!steps.length) {
+          throw (0, util_1.createError)(EEXIST, "mkdir", filename);
+        }
+        const dir = this.getLinkParentAsDirOrThrow(filename, "mkdir");
+        const name = steps[steps.length - 1];
+        if (dir.getChild(name))
+          throw (0, util_1.createError)(EEXIST, "mkdir", filename);
+        dir.createChild(name, this.createNode(true, modeNum));
+      }
+      /**
+       * Creates directory tree recursively.
+       * @param filename
+       * @param modeNum
+       */
+      mkdirpBase(filename, modeNum) {
+        const fullPath = resolve(filename);
+        const fullPathSansSlash = fullPath.substring(1);
+        const steps = !fullPathSansSlash ? [] : fullPathSansSlash.split(sep);
+        let link = this.root;
+        let created = false;
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          if (!link.getNode().isDirectory())
+            throw (0, util_1.createError)(ENOTDIR, "mkdir", link.getPath());
+          const child = link.getChild(step);
+          if (child) {
+            if (child.getNode().isDirectory()) link = child;
+            else
+              throw (0, util_1.createError)(ENOTDIR, "mkdir", child.getPath());
+          } else {
+            link = link.createChild(step, this.createNode(true, modeNum));
+            created = true;
+          }
+        }
+        return created ? fullPath : void 0;
+      }
+      mkdirSync(path, options) {
+        const opts = (0, options_1.getMkdirOptions)(options);
+        const modeNum = (0, util_1.modeToNumber)(opts.mode, 511);
+        const filename = (0, util_1.pathToFilename)(path);
+        if (opts.recursive) return this.mkdirpBase(filename, modeNum);
+        this.mkdirBase(filename, modeNum);
+      }
+      mkdir(path, a, b) {
+        const opts = (0, options_1.getMkdirOptions)(a);
+        const callback = (0, util_1.validateCallback)(
+          typeof a === "function" ? a : b,
+        );
+        const modeNum = (0, util_1.modeToNumber)(opts.mode, 511);
+        const filename = (0, util_1.pathToFilename)(path);
+        if (opts.recursive)
+          this.wrapAsync(this.mkdirpBase, [filename, modeNum], callback);
+        else this.wrapAsync(this.mkdirBase, [filename, modeNum], callback);
+      }
+      mkdtempBase(prefix, encoding, retry = 5) {
+        const filename = prefix + (0, util_1.genRndStr6)();
+        try {
+          this.mkdirBase(
+            filename,
+            511,
+            /* MODE.DIR */
+          );
+          return (0, encoding_1.strToEncoding)(filename, encoding);
+        } catch (err) {
+          if (err.code === EEXIST) {
+            if (retry > 1) return this.mkdtempBase(prefix, encoding, retry - 1);
+            else throw Error("Could not create temp dir.");
+          } else throw err;
+        }
+      }
+      mkdtempSync(prefix, options) {
+        const { encoding } = (0, options_1.getDefaultOpts)(options);
+        if (!prefix || typeof prefix !== "string")
+          throw new TypeError("filename prefix is required");
+        (0, util_1.nullCheck)(prefix);
+        return this.mkdtempBase(prefix, encoding);
+      }
+      mkdtemp(prefix, a, b) {
+        const [{ encoding }, callback] = (0, options_1.getDefaultOptsAndCb)(
+          a,
+          b,
+        );
+        if (!prefix || typeof prefix !== "string")
+          throw new TypeError("filename prefix is required");
+        if (!(0, util_1.nullCheck)(prefix)) return;
+        this.wrapAsync(this.mkdtempBase, [prefix, encoding], callback);
+      }
+      rmdirBase(filename, options) {
+        const opts = (0, options_1.getRmdirOptions)(options);
+        const link = this.getLinkAsDirOrThrow(filename, "rmdir");
+        if (link.length && !opts.recursive)
+          throw (0, util_1.createError)(ENOTEMPTY, "rmdir", filename);
+        this.deleteLink(link);
+      }
+      rmdirSync(path, options) {
+        this.rmdirBase((0, util_1.pathToFilename)(path), options);
+      }
+      rmdir(path, a, b) {
+        const opts = (0, options_1.getRmdirOptions)(a);
+        const callback = (0, util_1.validateCallback)(
+          typeof a === "function" ? a : b,
+        );
+        this.wrapAsync(
+          this.rmdirBase,
+          [(0, util_1.pathToFilename)(path), opts],
+          callback,
+        );
+      }
+      rmBase(filename, options = {}) {
+        const link = this.getResolvedLink(filename);
+        if (!link) {
+          if (!options.force)
+            throw (0, util_1.createError)(ENOENT, "stat", filename);
+          return;
+        }
+        if (link.getNode().isDirectory()) {
+          if (!options.recursive) {
+            throw (0, util_1.createError)(ERR_FS_EISDIR, "rm", filename);
+          }
+        }
+        this.deleteLink(link);
+      }
+      rmSync(path, options) {
+        this.rmBase((0, util_1.pathToFilename)(path), options);
+      }
+      rm(path, a, b) {
+        const [opts, callback] = (0, options_1.getRmOptsAndCb)(a, b);
+        this.wrapAsync(
+          this.rmBase,
+          [(0, util_1.pathToFilename)(path), opts],
+          callback,
+        );
+      }
+      fchmodBase(fd, modeNum) {
+        const file = this.getFileByFdOrThrow(fd, "fchmod");
+        file.chmod(modeNum);
+      }
+      fchmodSync(fd, mode) {
+        this.fchmodBase(fd, (0, util_1.modeToNumber)(mode));
+      }
+      fchmod(fd, mode, callback) {
+        this.wrapAsync(
+          this.fchmodBase,
+          [fd, (0, util_1.modeToNumber)(mode)],
+          callback,
+        );
+      }
+      chmodBase(filename, modeNum) {
+        const fd = this.openSync(filename, "r");
+        try {
+          this.fchmodBase(fd, modeNum);
+        } finally {
+          this.closeSync(fd);
+        }
+      }
+      chmodSync(path, mode) {
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.chmodBase(filename, modeNum);
+      }
+      chmod(path, mode, callback) {
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.chmodBase, [filename, modeNum], callback);
+      }
+      lchmodBase(filename, modeNum) {
+        const fd = this.openBase(filename, O_RDWR, 0, false);
+        try {
+          this.fchmodBase(fd, modeNum);
+        } finally {
+          this.closeSync(fd);
+        }
+      }
+      lchmodSync(path, mode) {
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.lchmodBase(filename, modeNum);
+      }
+      lchmod(path, mode, callback) {
+        const modeNum = (0, util_1.modeToNumber)(mode);
+        const filename = (0, util_1.pathToFilename)(path);
+        this.wrapAsync(this.lchmodBase, [filename, modeNum], callback);
+      }
+      fchownBase(fd, uid, gid) {
+        this.getFileByFdOrThrow(fd, "fchown").chown(uid, gid);
+      }
+      fchownSync(fd, uid, gid) {
+        validateUid(uid);
+        validateGid(gid);
+        this.fchownBase(fd, uid, gid);
+      }
+      fchown(fd, uid, gid, callback) {
+        validateUid(uid);
+        validateGid(gid);
+        this.wrapAsync(this.fchownBase, [fd, uid, gid], callback);
+      }
+      chownBase(filename, uid, gid) {
+        const link = this.getResolvedLinkOrThrow(filename, "chown");
+        const node = link.getNode();
+        node.chown(uid, gid);
+      }
+      chownSync(path, uid, gid) {
+        validateUid(uid);
+        validateGid(gid);
+        this.chownBase((0, util_1.pathToFilename)(path), uid, gid);
+      }
+      chown(path, uid, gid, callback) {
+        validateUid(uid);
+        validateGid(gid);
+        this.wrapAsync(
+          this.chownBase,
+          [(0, util_1.pathToFilename)(path), uid, gid],
+          callback,
+        );
+      }
+      lchownBase(filename, uid, gid) {
+        this.getLinkOrThrow(filename, "lchown").getNode().chown(uid, gid);
+      }
+      lchownSync(path, uid, gid) {
+        validateUid(uid);
+        validateGid(gid);
+        this.lchownBase((0, util_1.pathToFilename)(path), uid, gid);
+      }
+      lchown(path, uid, gid, callback) {
+        validateUid(uid);
+        validateGid(gid);
+        this.wrapAsync(
+          this.lchownBase,
+          [(0, util_1.pathToFilename)(path), uid, gid],
+          callback,
+        );
+      }
+      watchFile(path, a, b) {
+        const filename = (0, util_1.pathToFilename)(path);
+        let options = a;
+        let listener = b;
+        if (typeof options === "function") {
+          listener = a;
+          options = null;
+        }
+        if (typeof listener !== "function") {
+          throw Error('"watchFile()" requires a listener function');
+        }
+        let interval = 5007;
+        let persistent = true;
+        if (options && typeof options === "object") {
+          if (typeof options.interval === "number") interval = options.interval;
+          if (typeof options.persistent === "boolean")
+            persistent = options.persistent;
+        }
+        let watcher = this.statWatchers[filename];
+        if (!watcher) {
+          watcher = new this.StatWatcher();
+          watcher.start(filename, persistent, interval);
+          this.statWatchers[filename] = watcher;
+        }
+        watcher.addListener("change", listener);
+        return watcher;
+      }
+      unwatchFile(path, listener) {
+        const filename = (0, util_1.pathToFilename)(path);
+        const watcher = this.statWatchers[filename];
+        if (!watcher) return;
+        if (typeof listener === "function") {
+          watcher.removeListener("change", listener);
+        } else {
+          watcher.removeAllListeners("change");
+        }
+        if (watcher.listenerCount("change") === 0) {
+          watcher.stop();
+          delete this.statWatchers[filename];
+        }
+      }
+      createReadStream(path, options) {
+        return new this.ReadStream(path, options);
+      }
+      createWriteStream(path, options) {
+        return new this.WriteStream(path, options);
+      }
+      // watch(path: PathLike): FSWatcher;
+      // watch(path: PathLike, options?: IWatchOptions | string): FSWatcher;
+      watch(path, options, listener) {
+        const filename = (0, util_1.pathToFilename)(path);
+        let givenOptions = options;
+        if (typeof options === "function") {
+          listener = options;
+          givenOptions = null;
+        }
+        let { persistent, recursive, encoding } = (0, options_1.getDefaultOpts)(
+          givenOptions,
+        );
+        if (persistent === void 0) persistent = true;
+        if (recursive === void 0) recursive = false;
+        const watcher = new this.FSWatcher();
+        watcher.start(filename, persistent, recursive, encoding);
+        if (listener) {
+          watcher.addListener("change", listener);
+        }
+        return watcher;
+      }
+    };
+    exports.Volume = Volume;
+    Volume.fd = 2147483647;
+    function emitStop(self) {
+      self.emit("stop");
+    }
+    var StatWatcher = class extends events_1.EventEmitter {
+      constructor(vol) {
+        super();
+        this.onInterval = () => {
+          try {
+            const stats = this.vol.statSync(this.filename);
+            if (this.hasChanged(stats)) {
+              this.emit("change", stats, this.prev);
+              this.prev = stats;
+            }
+          } finally {
+            this.loop();
+          }
+        };
+        this.vol = vol;
+      }
+      loop() {
+        this.timeoutRef = this.setTimeout(this.onInterval, this.interval);
+      }
+      hasChanged(stats) {
+        if (stats.mtimeMs > this.prev.mtimeMs) return true;
+        if (stats.nlink !== this.prev.nlink) return true;
+        return false;
+      }
+      start(path, persistent = true, interval = 5007) {
+        this.filename = (0, util_1.pathToFilename)(path);
+        this.setTimeout = persistent
+          ? setTimeout.bind(
+              typeof globalThis !== "undefined" ? globalThis : global,
+            )
+          : setTimeoutUnref_1.default;
+        this.interval = interval;
+        this.prev = this.vol.statSync(this.filename);
+        this.loop();
+      }
+      stop() {
+        clearTimeout(this.timeoutRef);
+        (0, queueMicrotask_1.default)(() => {
+          emitStop.call(this, this);
+        });
+      }
+    };
+    exports.StatWatcher = StatWatcher;
+    var pool;
+    function allocNewPool(poolSize) {
+      pool = (0, buffer_1.bufferAllocUnsafe)(poolSize);
+      pool.used = 0;
+    }
+    util.inherits(FsReadStream, stream_1.Readable);
+    exports.ReadStream = FsReadStream;
+    function FsReadStream(vol, path, options) {
+      if (!(this instanceof FsReadStream))
+        return new FsReadStream(vol, path, options);
+      this._vol = vol;
+      options = Object.assign({}, (0, options_1.getOptions)(options, {}));
+      if (options.highWaterMark === void 0) options.highWaterMark = 64 * 1024;
+      stream_1.Readable.call(this, options);
+      this.path = (0, util_1.pathToFilename)(path);
+      this.fd = options.fd === void 0 ? null : options.fd;
+      this.flags = options.flags === void 0 ? "r" : options.flags;
+      this.mode = options.mode === void 0 ? 438 : options.mode;
+      this.start = options.start;
+      this.end = options.end;
+      this.autoClose = options.autoClose === void 0 ? true : options.autoClose;
+      this.pos = void 0;
+      this.bytesRead = 0;
+      if (this.start !== void 0) {
+        if (typeof this.start !== "number") {
+          throw new TypeError('"start" option must be a Number');
+        }
+        if (this.end === void 0) {
+          this.end = Infinity;
+        } else if (typeof this.end !== "number") {
+          throw new TypeError('"end" option must be a Number');
+        }
+        if (this.start > this.end) {
+          throw new Error('"start" option must be <= "end" option');
+        }
+        this.pos = this.start;
+      }
+      if (typeof this.fd !== "number") this.open();
+      this.on("end", function () {
+        if (this.autoClose) {
+          if (this.destroy) this.destroy();
+        }
+      });
+    }
+    FsReadStream.prototype.open = function () {
+      var self = this;
+      this._vol.open(this.path, this.flags, this.mode, (er, fd) => {
+        if (er) {
+          if (self.autoClose) {
+            if (self.destroy) self.destroy();
+          }
+          self.emit("error", er);
+          return;
+        }
+        self.fd = fd;
+        self.emit("open", fd);
+        self.read();
+      });
+    };
+    FsReadStream.prototype._read = function (n) {
+      if (typeof this.fd !== "number") {
+        return this.once("open", function () {
+          this._read(n);
+        });
+      }
+      if (this.destroyed) return;
+      if (!pool || pool.length - pool.used < kMinPoolSpace) {
+        allocNewPool(this._readableState.highWaterMark);
+      }
+      var thisPool = pool;
+      var toRead = Math.min(pool.length - pool.used, n);
+      var start = pool.used;
+      if (this.pos !== void 0)
+        toRead = Math.min(this.end - this.pos + 1, toRead);
+      if (toRead <= 0) return this.push(null);
+      var self = this;
+      this._vol.read(this.fd, pool, pool.used, toRead, this.pos, onread);
+      if (this.pos !== void 0) this.pos += toRead;
+      pool.used += toRead;
+      function onread(er, bytesRead) {
+        if (er) {
+          if (self.autoClose && self.destroy) {
+            self.destroy();
+          }
+          self.emit("error", er);
+        } else {
+          var b = null;
+          if (bytesRead > 0) {
+            self.bytesRead += bytesRead;
+            b = thisPool.slice(start, start + bytesRead);
+          }
+          self.push(b);
+        }
+      }
+    };
+    FsReadStream.prototype._destroy = function (err, cb) {
+      this.close((err2) => {
+        cb(err || err2);
+      });
+    };
+    FsReadStream.prototype.close = function (cb) {
+      var _a;
+      if (cb) this.once("close", cb);
+      if (this.closed || typeof this.fd !== "number") {
+        if (typeof this.fd !== "number") {
+          this.once("open", closeOnOpen);
+          return;
+        }
+        return (0, queueMicrotask_1.default)(() => this.emit("close"));
+      }
+      if (
+        typeof ((_a = this._readableState) === null || _a === void 0
+          ? void 0
+          : _a.closed) === "boolean"
+      ) {
+        this._readableState.closed = true;
+      } else {
+        this.closed = true;
+      }
+      this._vol.close(this.fd, (er) => {
+        if (er) this.emit("error", er);
+        else this.emit("close");
+      });
+      this.fd = null;
+    };
+    function closeOnOpen(fd) {
+      this.close();
+    }
+    util.inherits(FsWriteStream, stream_1.Writable);
+    exports.WriteStream = FsWriteStream;
+    function FsWriteStream(vol, path, options) {
+      if (!(this instanceof FsWriteStream))
+        return new FsWriteStream(vol, path, options);
+      this._vol = vol;
+      options = Object.assign({}, (0, options_1.getOptions)(options, {}));
+      stream_1.Writable.call(this, options);
+      this.path = (0, util_1.pathToFilename)(path);
+      this.fd = options.fd === void 0 ? null : options.fd;
+      this.flags = options.flags === void 0 ? "w" : options.flags;
+      this.mode = options.mode === void 0 ? 438 : options.mode;
+      this.start = options.start;
+      this.autoClose =
+        options.autoClose === void 0 ? true : !!options.autoClose;
+      this.pos = void 0;
+      this.bytesWritten = 0;
+      this.pending = true;
+      if (this.start !== void 0) {
+        if (typeof this.start !== "number") {
+          throw new TypeError('"start" option must be a Number');
+        }
+        if (this.start < 0) {
+          throw new Error('"start" must be >= zero');
+        }
+        this.pos = this.start;
+      }
+      if (options.encoding) this.setDefaultEncoding(options.encoding);
+      if (typeof this.fd !== "number") this.open();
+      this.once("finish", function () {
+        if (this.autoClose) {
+          this.close();
+        }
+      });
+    }
+    FsWriteStream.prototype.open = function () {
+      this._vol.open(
+        this.path,
+        this.flags,
+        this.mode,
+        function (er, fd) {
+          if (er) {
+            if (this.autoClose && this.destroy) {
+              this.destroy();
+            }
+            this.emit("error", er);
+            return;
+          }
+          this.fd = fd;
+          this.pending = false;
+          this.emit("open", fd);
+        }.bind(this),
+      );
+    };
+    FsWriteStream.prototype._write = function (data, encoding, cb) {
+      if (!(data instanceof buffer_1.Buffer || data instanceof Uint8Array))
+        return this.emit("error", new Error("Invalid data"));
+      if (typeof this.fd !== "number") {
+        return this.once("open", function () {
+          this._write(data, encoding, cb);
+        });
+      }
+      var self = this;
+      this._vol.write(this.fd, data, 0, data.length, this.pos, (er, bytes) => {
+        if (er) {
+          if (self.autoClose && self.destroy) {
+            self.destroy();
+          }
+          return cb(er);
+        }
+        self.bytesWritten += bytes;
+        cb();
+      });
+      if (this.pos !== void 0) this.pos += data.length;
+    };
+    FsWriteStream.prototype._writev = function (data, cb) {
+      if (typeof this.fd !== "number") {
+        return this.once("open", function () {
+          this._writev(data, cb);
+        });
+      }
+      const self = this;
+      const len = data.length;
+      const chunks = new Array(len);
+      var size = 0;
+      for (var i = 0; i < len; i++) {
+        var chunk = data[i].chunk;
+        chunks[i] = chunk;
+        size += chunk.length;
+      }
+      const buf = buffer_1.Buffer.concat(chunks);
+      this._vol.write(this.fd, buf, 0, buf.length, this.pos, (er, bytes) => {
+        if (er) {
+          if (self.destroy) self.destroy();
+          return cb(er);
+        }
+        self.bytesWritten += bytes;
+        cb();
+      });
+      if (this.pos !== void 0) this.pos += size;
+    };
+    FsWriteStream.prototype.close = function (cb) {
+      var _a;
+      if (cb) this.once("close", cb);
+      if (this.closed || typeof this.fd !== "number") {
+        if (typeof this.fd !== "number") {
+          this.once("open", closeOnOpen);
+          return;
+        }
+        return (0, queueMicrotask_1.default)(() => this.emit("close"));
+      }
+      if (
+        typeof ((_a = this._writableState) === null || _a === void 0
+          ? void 0
+          : _a.closed) === "boolean"
+      ) {
+        this._writableState.closed = true;
+      } else {
+        this.closed = true;
+      }
+      this._vol.close(this.fd, (er) => {
+        if (er) this.emit("error", er);
+        else this.emit("close");
+      });
+      this.fd = null;
+    };
+    FsWriteStream.prototype._destroy = FsReadStream.prototype._destroy;
+    FsWriteStream.prototype.destroySoon = FsWriteStream.prototype.end;
+    var FSWatcher = class extends events_1.EventEmitter {
+      constructor(vol) {
+        super();
+        this._filename = "";
+        this._filenameEncoded = "";
+        this._recursive = false;
+        this._encoding = encoding_1.ENCODING_UTF8;
+        this._listenerRemovers = /* @__PURE__ */ new Map();
+        this._onParentChild = (link) => {
+          if (link.getName() === this._getName()) {
+            this._emit("rename");
+          }
+        };
+        this._emit = (type) => {
+          this.emit("change", type, this._filenameEncoded);
+        };
+        this._persist = () => {
+          this._timer = setTimeout(this._persist, 1e6);
+        };
+        this._vol = vol;
+      }
+      _getName() {
+        return this._steps[this._steps.length - 1];
+      }
+      start(
+        path,
+        persistent = true,
+        recursive = false,
+        encoding = encoding_1.ENCODING_UTF8,
+      ) {
+        this._filename = (0, util_1.pathToFilename)(path);
+        this._steps = filenameToSteps(this._filename);
+        this._filenameEncoded = (0, encoding_1.strToEncoding)(this._filename);
+        this._recursive = recursive;
+        this._encoding = encoding;
+        try {
+          this._link = this._vol.getLinkOrThrow(this._filename, "FSWatcher");
+        } catch (err) {
+          const error = new Error(`watch ${this._filename} ${err.code}`);
+          error.code = err.code;
+          error.errno = err.code;
+          throw error;
+        }
+        const watchLinkNodeChanged = (link) => {
+          var _a;
+          const filepath = link.getPath();
+          const node = link.getNode();
+          const onNodeChange = () => {
+            let filename = relative(this._filename, filepath);
+            if (!filename) {
+              filename = this._getName();
+            }
+            return this.emit("change", "change", filename);
+          };
+          node.on("change", onNodeChange);
+          const removers =
+            (_a = this._listenerRemovers.get(node.ino)) !== null &&
+            _a !== void 0
+              ? _a
+              : [];
+          removers.push(() => node.removeListener("change", onNodeChange));
+          this._listenerRemovers.set(node.ino, removers);
+        };
+        const watchLinkChildrenChanged = (link) => {
+          var _a;
+          const node = link.getNode();
+          const onLinkChildAdd = (l) => {
+            this.emit(
+              "change",
+              "rename",
+              relative(this._filename, l.getPath()),
+            );
+            setTimeout(() => {
+              watchLinkNodeChanged(l);
+              watchLinkChildrenChanged(l);
+            });
+          };
+          const onLinkChildDelete = (l) => {
+            const removeLinkNodeListeners = (curLink) => {
+              const ino = curLink.getNode().ino;
+              const removers2 = this._listenerRemovers.get(ino);
+              if (removers2) {
+                removers2.forEach((r) => r());
+                this._listenerRemovers.delete(ino);
+              }
+              for (const [name, childLink] of curLink.children.entries()) {
+                if (childLink && name !== "." && name !== "..") {
+                  removeLinkNodeListeners(childLink);
+                }
+              }
+            };
+            removeLinkNodeListeners(l);
+            this.emit(
+              "change",
+              "rename",
+              relative(this._filename, l.getPath()),
+            );
+          };
+          for (const [name, childLink] of link.children.entries()) {
+            if (childLink && name !== "." && name !== "..") {
+              watchLinkNodeChanged(childLink);
+            }
+          }
+          link.on("child:add", onLinkChildAdd);
+          link.on("child:delete", onLinkChildDelete);
+          const removers =
+            (_a = this._listenerRemovers.get(node.ino)) !== null &&
+            _a !== void 0
+              ? _a
+              : [];
+          removers.push(() => {
+            link.removeListener("child:add", onLinkChildAdd);
+            link.removeListener("child:delete", onLinkChildDelete);
+          });
+          if (recursive) {
+            for (const [name, childLink] of link.children.entries()) {
+              if (childLink && name !== "." && name !== "..") {
+                watchLinkChildrenChanged(childLink);
+              }
+            }
+          }
+        };
+        watchLinkNodeChanged(this._link);
+        watchLinkChildrenChanged(this._link);
+        const parent = this._link.parent;
+        if (parent) {
+          parent.setMaxListeners(parent.getMaxListeners() + 1);
+          parent.on("child:delete", this._onParentChild);
+        }
+        if (persistent) this._persist();
+      }
+      close() {
+        clearTimeout(this._timer);
+        this._listenerRemovers.forEach((removers) => {
+          removers.forEach((r) => r());
+        });
+        this._listenerRemovers.clear();
+        const parent = this._link.parent;
+        if (parent) {
+          parent.removeListener("child:delete", this._onParentChild);
+        }
+      }
+    };
+    exports.FSWatcher = FSWatcher;
+  },
+});
+
+// node_modules/memfs/lib/node/lists/fsSynchronousApiList.js
+var require_fsSynchronousApiList = __commonJS({
+  "node_modules/memfs/lib/node/lists/fsSynchronousApiList.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fsSynchronousApiList = void 0;
+    exports.fsSynchronousApiList = [
+      "accessSync",
+      "appendFileSync",
+      "chmodSync",
+      "chownSync",
+      "closeSync",
+      "copyFileSync",
+      "existsSync",
+      "fchmodSync",
+      "fchownSync",
+      "fdatasyncSync",
+      "fstatSync",
+      "fsyncSync",
+      "ftruncateSync",
+      "futimesSync",
+      "lchmodSync",
+      "lchownSync",
+      "linkSync",
+      "lstatSync",
+      "mkdirSync",
+      "mkdtempSync",
+      "openSync",
+      "readdirSync",
+      "readFileSync",
+      "readlinkSync",
+      "readSync",
+      "readvSync",
+      "realpathSync",
+      "renameSync",
+      "rmdirSync",
+      "rmSync",
+      "statSync",
+      "symlinkSync",
+      "truncateSync",
+      "unlinkSync",
+      "utimesSync",
+      "writeFileSync",
+      "writeSync",
+      "writevSync",
+      // 'cpSync',
+      // 'lutimesSync',
+      // 'statfsSync',
+    ];
+  },
+});
+
+// node_modules/memfs/lib/node/lists/fsCallbackApiList.js
+var require_fsCallbackApiList = __commonJS({
+  "node_modules/memfs/lib/node/lists/fsCallbackApiList.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fsCallbackApiList = void 0;
+    exports.fsCallbackApiList = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "createReadStream",
+      "createWriteStream",
+      "exists",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "read",
+      "readv",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "unwatchFile",
+      "utimes",
+      "watch",
+      "watchFile",
+      "write",
+      "writev",
+      "writeFile",
+    ];
+  },
+});
+
+// node_modules/memfs/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/memfs/lib/index.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.memfs =
+      exports.fs =
+      exports.createFsFromVolume =
+      exports.vol =
+      exports.Volume =
+        void 0;
+    var Stats_1 = require_Stats();
+    var Dirent_1 = require_Dirent();
+    var volume_1 = require_volume();
+    var constants_1 = require_constants();
+    var fsSynchronousApiList_1 = require_fsSynchronousApiList();
+    var fsCallbackApiList_1 = require_fsCallbackApiList();
+    var { F_OK, R_OK, W_OK, X_OK } = constants_1.constants;
+    exports.Volume = volume_1.Volume;
+    exports.vol = new volume_1.Volume();
+    function createFsFromVolume(vol) {
+      const fs = {
+        F_OK,
+        R_OK,
+        W_OK,
+        X_OK,
+        constants: constants_1.constants,
+        Stats: Stats_1.default,
+        Dirent: Dirent_1.default,
+      };
+      for (const method of fsSynchronousApiList_1.fsSynchronousApiList)
+        if (typeof vol[method] === "function")
+          fs[method] = vol[method].bind(vol);
+      for (const method of fsCallbackApiList_1.fsCallbackApiList)
+        if (typeof vol[method] === "function")
+          fs[method] = vol[method].bind(vol);
+      fs.StatWatcher = vol.StatWatcher;
+      fs.FSWatcher = vol.FSWatcher;
+      fs.WriteStream = vol.WriteStream;
+      fs.ReadStream = vol.ReadStream;
+      fs.promises = vol.promises;
+      fs._toUnixTimestamp = volume_1.toUnixTimestamp;
+      fs.__vol = vol;
+      return fs;
+    }
+    exports.createFsFromVolume = createFsFromVolume;
+    exports.fs = createFsFromVolume(exports.vol);
+    var memfs2 = (json = {}, cwd = "/") => {
+      const vol = exports.Volume.fromNestedJSON(json, cwd);
+      const fs = createFsFromVolume(vol);
+      return { fs, vol };
+    };
+    exports.memfs = memfs2;
+    module.exports = Object.assign(
+      Object.assign({}, module.exports),
+      exports.fs,
+    );
+    module.exports.semantic = true;
+  },
+});
+
+// source.js
+var import_memfs = __toESM(require_lib(), 1);
+var source_default = import_memfs.default;
+export { source_default as default };
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+buffer/index.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+
+assert/build/internal/util/comparisons.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+   * @license  MIT
+   *)
+*/
diff --git a/packages/env/src/fs/memory.ts b/packages/env/src/fs/memory.ts
new file mode 100644
index 0000000000..d632e2031d
--- /dev/null
+++ b/packages/env/src/fs/memory.ts
@@ -0,0 +1,9 @@
+/**
+ * Memory file system, used by edge runtime, worker runtime which doesn't have access to the file system.
+ *
+ * @module
+ */
+// @ts-expect-error
+import memFS from "./memfs/index.js";
+
+export const fs = memFS.promises;
diff --git a/packages/env/src/fs/node.ts b/packages/env/src/fs/node.ts
new file mode 100644
index 0000000000..c6de760ec7
--- /dev/null
+++ b/packages/env/src/fs/node.ts
@@ -0,0 +1,10 @@
+/**
+ * Node.js built-in file system module.
+ *
+ * Bun, Deno support node:fs/promises so we don't need to re-implement it.
+ *
+ * @module
+ */
+import fs from "node:fs/promises";
+
+export { fs };
diff --git a/packages/env/src/index.edge-light.ts b/packages/env/src/index.edge-light.ts
new file mode 100644
index 0000000000..3d08a3cdfe
--- /dev/null
+++ b/packages/env/src/index.edge-light.ts
@@ -0,0 +1,6 @@
+/**
+ * Edge light environment polyfill.
+ *
+ * @module
+ */
+export * from "./polyfill.js";
diff --git a/packages/env/src/index.ts b/packages/env/src/index.ts
index 930b7f8997..a2d2c04fc7 100644
--- a/packages/env/src/index.ts
+++ b/packages/env/src/index.ts
@@ -13,7 +13,6 @@
  */
 import { ok } from "node:assert";
 import { createHash, randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
 import { EOL } from "node:os";
 import path from "node:path";
 import { pipeline } from "node:stream/promises";
@@ -22,8 +21,8 @@ import {
   TransformStream,
   WritableStream,
 } from "node:stream/web";
-import type { SHA256 } from "./index.polyfill.js";
-import type { CompleteFileSystem } from "./type.js";
+import { fs } from "./fs/node.js";
+import type { SHA256 } from "./polyfill.js";
 
 export function createSHA256(): SHA256 {
   const hash = createHash("sha256");
@@ -37,29 +36,13 @@ export function createSHA256(): SHA256 {
   };
 }
 
-export const defaultFS: CompleteFileSystem = {
-  writeFile: function (path: string, content: string) {
-    return fs.writeFile(path, content, "utf-8");
-  },
-  readRawFile(path: string): Promise<Buffer> {
-    return fs.readFile(path);
-  },
-  readFile: function (path: string) {
-    return fs.readFile(path, "utf-8");
-  },
-  access: fs.access,
-  mkdir: fs.mkdir,
-  readdir: fs.readdir,
-  stat: fs.stat,
-};
-
-export type * from "./type.js";
 export { AsyncLocalStorage, CustomEvent, getEnv, setEnvs } from "./utils.js";
 export {
   EOL,
   ReadableStream,
   TransformStream,
   WritableStream,
+  fs,
   ok,
   path,
   pipeline,
diff --git a/packages/env/src/index.workerd.ts b/packages/env/src/index.workerd.ts
index 8ec0a10698..02aceb29bf 100644
--- a/packages/env/src/index.workerd.ts
+++ b/packages/env/src/index.workerd.ts
@@ -7,7 +7,7 @@
  */
 import { INTERNAL_ENV } from "./utils.js";
 
-export * from "./index.polyfill.js";
+export * from "./polyfill.js";
 
 export function getEnv(name: string): string | undefined {
   return INTERNAL_ENV[name];
diff --git a/packages/env/src/index.polyfill.ts b/packages/env/src/polyfill.ts
similarity index 83%
rename from packages/env/src/index.polyfill.ts
rename to packages/env/src/polyfill.ts
index 88521fd06b..196a0e2913 100644
--- a/packages/env/src/index.polyfill.ts
+++ b/packages/env/src/polyfill.ts
@@ -1,19 +1,21 @@
 /**
- * Polyfill implementation some node.js APIs.
+ * Polyfill implementation for `@llamaindex/env`.
  *
  * The code should be compatible with any JS runtime.
  *
+ * Sometimes you should overwrite the polyfill with a native implementation.
+ *
  * @module
  */
 import { Sha256 } from "@aws-crypto/sha256-js";
 import pathe from "pathe";
-import { InMemoryFileSystem, type CompleteFileSystem } from "./type.js";
 // @ts-expect-error
 import { promises } from "readable-stream";
+import { fs } from "./fs/memory.js";
 
 const { pipeline } = promises;
 
-export { pathe as path, pipeline };
+export { fs, pathe as path, pipeline };
 
 export interface SHA256 {
   update(data: string | Uint8Array): void;
@@ -23,8 +25,6 @@ export interface SHA256 {
 
 export const EOL = "\n";
 
-export const defaultFS: CompleteFileSystem = new InMemoryFileSystem();
-
 export function ok(value: unknown, message?: string): asserts value {
   if (!value) {
     const error = Error(message);
@@ -49,7 +49,6 @@ export function createSHA256(): SHA256 {
 export function randomUUID(): string {
   return crypto.randomUUID();
 }
-export * from "./type.js";
 
 // @ts-expect-error
 const ReadableStream = globalThis.ReadableStream;
diff --git a/packages/env/src/type.ts b/packages/env/src/type.ts
deleted file mode 100644
index 4cb7f65994..0000000000
--- a/packages/env/src/type.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * A filesystem interface that is meant to be compatible with
- * the 'fs' module from Node.js.
- * Allows for the use of similar interface implementation on different JS runtimes.
- */
-export type GenericFileSystem = {
-  writeFile(path: string, content: string): Promise<void>;
-  /**
-   * Reads a file and returns its content as a raw buffer.
-   */
-  readRawFile(path: string): Promise<Buffer>;
-  /**
-   * Reads a file and returns its content as an utf-8 string.
-   */
-  readFile(path: string): Promise<string>;
-  access(path: string): Promise<void>;
-  mkdir(
-    path: string,
-    options: {
-      recursive: boolean;
-    },
-  ): Promise<string | undefined>;
-  mkdir(path: string): Promise<void>;
-};
-export type WalkableFileSystem = {
-  readdir(path: string): Promise<string[]>;
-  stat(path: string): Promise<any>;
-};
-export type CompleteFileSystem = GenericFileSystem & WalkableFileSystem;
-
-/**
- * A filesystem implementation that stores files in memory.
- */
-export class InMemoryFileSystem implements CompleteFileSystem {
-  private files: Record<string, any> = {};
-
-  async writeFile(
-    path: string,
-    content: string,
-    options?: unknown,
-  ): Promise<void> {
-    this.files[path] = structuredClone(content);
-  }
-
-  async readFile(path: string): Promise<string> {
-    if (!(path in this.files)) {
-      throw new Error(`File ${path} does not exist`);
-    }
-    return structuredClone(this.files[path]);
-  }
-
-  async access(path: string): Promise<void> {
-    if (!(path in this.files)) {
-      throw new Error(`File ${path} does not exist`);
-    }
-  }
-
-  async mkdir(path: string): Promise<undefined> {
-    this.files[path] = this.files[path] ?? null;
-  }
-
-  async readdir(path: string): Promise<string[]> {
-    throw new Error("Not implemented");
-  }
-
-  async stat(path: string): Promise<any> {
-    throw new Error("Not implemented");
-  }
-
-  async readRawFile(path: string): Promise<Buffer> {
-    throw new Error("Not implemented");
-  }
-}
diff --git a/packages/env/tests/memfs.test.ts b/packages/env/tests/memfs.test.ts
new file mode 100644
index 0000000000..ed87bd0f2f
--- /dev/null
+++ b/packages/env/tests/memfs.test.ts
@@ -0,0 +1,10 @@
+import { describe, expect, test } from "vitest";
+import { fs } from "../src/fs/memory.js";
+
+describe("memfs", () => {
+  test("should be able to read and write files", async () => {
+    await fs.writeFile("/foo", "bar");
+    const content = await fs.readFile("/foo", "utf8");
+    expect(content).toBe("bar");
+  });
+});
diff --git a/packages/env/tests/tsconfig.json b/packages/env/tests/tsconfig.json
new file mode 100644
index 0000000000..6511a99360
--- /dev/null
+++ b/packages/env/tests/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./lib",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "target": "ESNext"
+  },
+  "include": ["./**/*.ts"],
+  "references": [
+    {
+      "path": "../tsconfig.json"
+    }
+  ]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 018feb6a19..8dae7907e8 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -655,6 +655,9 @@ importers:
       readable-stream:
         specifier: ^4.5.2
         version: 4.5.2
+      vitest:
+        specifier: ^1.6.0
+        version: 1.6.0(@types/node@20.12.11)(terser@5.31.0)
 
   packages/experimental:
     dependencies:
diff --git a/tsconfig.json b/tsconfig.json
index c14327511a..d49ce788da 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -50,6 +50,9 @@
     {
       "path": "./packages/env/tsconfig.json"
     },
+    {
+      "path": "./packages/env/tests/tsconfig.json"
+    },
     {
       "path": "./examples"
     },