@powerlines/plugin-esbuild 0.5.0 → 0.6.0

package/dist/chunk-FGTVQNHX.js

@@ -1,1461 +0,0 @@
-import { LogLevelLabel } from '@storm-software/config-tools/types';
-import '@stryke/fs/get-workspace-root';
-import { match } from 'bundle-require';
-import '@storm-software/config-tools/logger/console';
-import { toArray } from '@stryke/convert/to-array';
-import '@stryke/fs/copy-file';
-import '@stryke/fs/exists';
-import '@stryke/fs/helpers';
-import '@stryke/fs/install';
-import '@stryke/fs/list-files';
-import '@stryke/fs/package-fns';
-import { findFilePath, findFileExtensionSafe } from '@stryke/path/file-path-fns';
-import { isParentPath } from '@stryke/path/is-parent-path';
-import { joinPaths } from '@stryke/path/join-paths';
-import { replacePath } from '@stryke/path/replace';
-import '@stryke/type-checks/is-error';
-import { isFunction } from '@stryke/type-checks/is-function';
-import '@stryke/type-checks/is-number';
-import '@stryke/type-checks/is-set';
-import { isSetObject } from '@stryke/type-checks/is-set-object';
-import { isSetString } from '@stryke/type-checks/is-set-string';
-import chalk from 'chalk';
-import 'handlebars';
-import '@stryke/fs/json';
-import '@stryke/path/append';
-import defu5 from 'defu';
-import 'typescript';
-import { titleCase } from '@stryke/string-format/title-case';
-import '@stryke/fs/remove-file';
-import '@stryke/hash/hash-files';
-import '@stryke/helpers/get-unique';
-import '@stryke/string-format/kebab-case';
-import '@stryke/type-checks/is-undefined';
-import '@stryke/fs/write-file';
-import { format, resolveConfig } from 'prettier';
-import '@stryke/fs/resolve';
-import '@storm-software/config-tools/get-config';
-import 'c12';
-import '@stryke/env/get-env-paths';
-import { murmurhash } from '@stryke/hash/murmurhash';
-import { omit } from '@stryke/helpers/omit';
-import '@stryke/path/join';
-import '@stryke/type-checks/is-null';
-import { isString } from '@stryke/type-checks/is-string';
-import '@stryke/unique-id/uuid';
-import '@stryke/convert/parse-type-definition';
-import '@storm-software/config-tools/logger';
-import '@storm-software/config-tools/utilities/colors';
-import '@stryke/helpers/noop';
-import 'jiti';
-import { bufferToString } from '@stryke/convert/buffer-to-string';
-import { isAbsolutePath } from '@stryke/path/is-type';
-import { prettyBytes } from '@stryke/string-format/pretty-bytes';
-import { isBuffer } from '@stryke/type-checks/is-buffer';
-import { Volume } from 'memfs';
-import { Blob } from 'node:buffer';
-import fs from 'node:fs';
-import { Union } from 'unionfs';
-import '@stryke/type-checks/is-object';
-import '@stryke/fs/is-file';
-import '@stryke/fs/read-file';
-import '@stryke/fs/semver-fns';
-import '@stryke/path/get-parent-path';
-import 'node:path';
-import '@stryke/string-format/package';
-import '@babel/core';
-import 'magic-string';
-import '@babel/helper-plugin-utils';
-import '@babel/types';
-import '@donedeal0/superdiff';
-import '@stryke/fs/tsconfig';
-import '@stryke/json/storm-json';
-import 'minimatch';
-import { createEsbuildPlugin } from 'unplugin';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// ../powerlines/src/types/vfs.ts
-var __VFS_INIT__ = "__VFS_INIT__";
-var __VFS_REVERT__ = "__VFS_REVERT__";
-var __VFS_CACHE__ = "__VFS_CACHE__";
-var __VFS_RESOLVER__ = "__VFS_RESOLVER__";
-var __VFS_VIRTUAL__ = "__VFS_VIRTUAL__";
-var __VFS_UNIFIED__ = "__VFS_UNIFIED__";
-function resolveEntryInputFile(context, typeDefinition) {
-  return replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot));
-}
-__name(resolveEntryInputFile, "resolveEntryInputFile");
-function resolveEntryOutput(context, typeDefinition) {
-  return joinPaths(replacePath(replacePath(replacePath(replacePath(typeDefinition.file, joinPaths(context.workspaceConfig.workspaceRoot, context.config.sourceRoot)), joinPaths(context.workspaceConfig.workspaceRoot, context.config.projectRoot)), context.config.sourceRoot), context.config.projectRoot)).replace(`.${findFileExtensionSafe(typeDefinition.file)}`, "");
-}
-__name(resolveEntryOutput, "resolveEntryOutput");
-var BADGE_COLORS = [
-  "#00A0DD",
-  "#6FCE4E",
-  "#FBBF24",
-  "#F43F5E",
-  "#3B82F6",
-  "#A855F7",
-  "#469592",
-  "#288EDF",
-  "#10B981",
-  "#EF4444",
-  "#F0EC56",
-  "#F472B6",
-  "#22D3EE",
-  "#EAB308",
-  "#84CC16",
-  "#F87171",
-  "#0EA5E9",
-  "#D946EF",
-  "#FACC15",
-  "#34D399"
-];
-var extendLog = /* @__PURE__ */ __name((logFn, name) => {
-  return (type, ...args) => logFn(type, ` ${chalk.inverse.hex(BADGE_COLORS[name.split("").map((char) => char.charCodeAt(0)).reduce((ret, charCode) => ret + charCode, 0) % BADGE_COLORS.length] || BADGE_COLORS[0])(` ${titleCase(name)} `)}  ${args.join(" ")} `);
-}, "extendLog");
-(class {
-  static {
-    __name(this, "VirtualFileSystem");
-  }
-  /**
-  * The internal map of virtual files.
-  */
-  #builtinIdMap = /* @__PURE__ */ new Map();
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedFS = /* @__PURE__ */ new Map();
-  /**
-  * A map of virtual file paths to their underlying file content.
-  */
-  #cachedResolver = /* @__PURE__ */ new Map();
-  /**
-  * The internal map of virtual files.
-  */
-  #virtualFS = new Volume();
-  /**
-  * The physical file system.
-  */
-  #fs = cloneFS(fs);
-  /**
-  * The unified volume that combines the virtual file system with the real file system.
-  *
-  * @remarks
-  * This volume allows for seamless access to both virtual and real files.
-  */
-  #unifiedFS = new Union();
-  /**
-  * Indicator specifying if the file system module is patched
-  */
-  #isPatched = false;
-  /**
-  * Function to revert require patch
-  */
-  #revert;
-  /**
-  * The context of the virtual file system.
-  */
-  #context;
-  /**
-  * The file system's logging function.
-  */
-  #log;
-  /**
-  * Exposes the internal VFS map for advanced usage.
-  */
-  get [__VFS_CACHE__]() {
-    return this.#cachedFS;
-  }
-  /**
-  * Exposes the internal VFS resolver cache for advanced usage.
-  */
-  get [__VFS_RESOLVER__]() {
-    return this.#cachedResolver;
-  }
-  /**
-  * Exposes the internal VFS map for advanced usage.
-  */
-  get [__VFS_VIRTUAL__]() {
-    return this.#virtualFS;
-  }
-  /**
-  * Exposes the internal UFS map for advanced usage.
-  */
-  get [__VFS_UNIFIED__]() {
-    return this.#unifiedFS;
-  }
-  /**
-  * Creates a new instance of the VirtualFileSystem.
-  *
-  * @param context - The context of the virtual file system, typically containing options and logging functions.
-  * @param serialized - A map of files/file contents to populate in cache
-  */
-  constructor(context, serialized) {
-    this.#context = context;
-    this.#cachedFS = /* @__PURE__ */ new Map();
-    this.#builtinIdMap = new Map(Object.entries(serialized?.builtinIdMap ?? {}));
-    if (!this.#fs.existsSync(this.#context.dataPath)) {
-      this.#fs.mkdirSync(this.#context.dataPath, {
-        recursive: true
-      });
-    }
-    if (!this.#fs.existsSync(this.#context.cachePath)) {
-      this.#fs.mkdirSync(this.#context.cachePath, {
-        recursive: true
-      });
-    }
-    if (!this.#fs.existsSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
-      this.#fs.mkdirSync(joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath), {
-        recursive: true
-      });
-    }
-    this.#unifiedFS = this.#unifiedFS.use(this.#fs);
-    if (this.#context.config.output.mode !== "fs") {
-      if (serialized?.virtualFiles && Object.keys(serialized.virtualFiles).length > 0) {
-        this.#virtualFS = Volume.fromJSON(serialized.virtualFiles);
-      }
-      if (!this.#virtualFS.existsSync(this.#context.artifactsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.builtinsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.entryPath)) {
-        this.#virtualFS.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
-      }
-      if (!this.#virtualFS.existsSync(this.#context.dtsPath)) {
-        this.#virtualFS.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
-      }
-      this.#unifiedFS = this.#unifiedFS.use(this.#virtualFS);
-    } else if (this.#context.config.projectType === "application") {
-      if (!this.#fs.existsSync(this.#context.artifactsPath)) {
-        this.#fs.mkdirSync(this.#context.artifactsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.builtinsPath)) {
-        this.#fs.mkdirSync(this.#context.builtinsPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.entryPath)) {
-        this.#fs.mkdirSync(this.#context.entryPath, {
-          recursive: true
-        });
-      }
-      if (!this.#fs.existsSync(this.#context.dtsPath)) {
-        this.#fs.mkdirSync(this.#context.dtsPath, {
-          recursive: true
-        });
-      }
-    }
-    this.#log = extendLog(this.#context.log, "virtual-file-system");
-  }
-  [__VFS_INIT__]() {
-    if (!this.#isPatched && this.#context.config.output.mode !== "fs") {
-      this.#revert = patchFS(fs, this);
-      this.#isPatched = true;
-    }
-  }
-  [__VFS_REVERT__]() {
-    if (this.#isPatched && this.#context.config.output.mode !== "fs") {
-      if (!this.#revert) {
-        throw new Error("Attempting to revert File System patch prior to calling `__init__` function");
-      }
-      this.#revert?.();
-      this.#isPatched = false;
-    }
-  }
-  /**
-  * Returns a Map of all runtime file IDs and their corresponding paths in the virtual file system.
-  *
-  * @returns A Map where the keys are runtime file IDs (strings) and the values are their corresponding paths (strings).
-  */
-  get builtinIdMap() {
-    return this.#builtinIdMap;
-  }
-  /**
-  * Lists all runtime IDs in the virtual file system.
-  *
-  * @returns An array of formatted runtime IDs.
-  */
-  get runtimeIds() {
-    return Array.from(this.builtinIdMap.keys()).map((id) => this.formatRuntimeId(id));
-  }
-  /**
-  * Checks if a given path or ID corresponds to a runtime file.
-  *
-  * @param pathOrId - The path or ID to check.
-  * @param options - Options for resolving the path, such as paths to check.
-  * @returns `true` if the path or ID corresponds to a runtime file, otherwise `false`.
-  */
-  isBuiltinFile(pathOrId, options) {
-    return !!this.builtinIdMap.values().find((path2) => path2 === this.resolvePath(pathOrId, {
-      ...options,
-      type: "file"
-    }));
-  }
-  /**
-  * Checks if a provided string is a valid runtime ID (does not need to already be created in the file system).
-  *
-  * @param id - The ID to check.
-  * @returns Whether the ID is a valid runtime ID.
-  */
-  isValidBuiltinId(id) {
-    return id.startsWith(`${this.#context.config.output.builtinPrefix}:`);
-  }
-  /**
-  * Check if a path or ID corresponds to a virtual file.
-  *
-  * @param pathOrId - The path or ID to check.
-  * @param options - Options for resolving the path, such as paths to check.
-  * @returns Whether the path or ID corresponds to a virtual file.
-  */
-  isVirtualFile(pathOrId, options = {}) {
-    if (!pathOrId) {
-      return false;
-    }
-    const resolvedPath = this.resolvePath(pathOrId, {
-      ...options,
-      type: "file"
-    });
-    if (!resolvedPath) {
-      return false;
-    }
-    if (this.builtinIdMap.values().find((path2) => path2 === resolvedPath)) {
-      return true;
-    }
-    return this.#virtualFS.existsSync(resolvedPath);
-  }
-  /**
-  * Check if a path exists within one of the directories specified in the tsconfig.json's `path` field.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param pathOrId - The path or ID to check.
-  * @returns Whether the path or ID corresponds to a virtual file.
-  */
-  isTsconfigPath(pathOrId) {
-    return !!this.#context.tsconfig.options.paths && Object.keys(this.#context.tsconfig.options.paths).some((path2) => pathOrId.startsWith(path2.replaceAll("*", "")));
-  }
-  /**
-  * Checks if a given ID corresponds to a runtime file path.
-  *
-  * @param id - The unique identifier for the runtime file.
-  * @param pathOrId - The path or ID to check.
-  * @returns `true` if the ID corresponds to the path or ID of a runtime file, otherwise `false`.
-  */
-  isMatchingBuiltinId(id, pathOrId) {
-    const resolvedPath = this.resolvePath(pathOrId);
-    const resolvedId = this.resolveId(pathOrId);
-    return !!(this.isBuiltinFile(pathOrId) && (resolvedPath && (resolvedPath === this.builtinIdMap.get(id) || resolvedPath === this.builtinIdMap.get(this.formatRuntimeId(id))) || resolvedId && (resolvedId === this.builtinIdMap.get(id) || resolvedId === this.builtinIdMap.get(this.formatRuntimeId(id)))));
-  }
-  /**
-  * Lists all runtime files in the virtual file system.
-  *
-  * @returns A promise that resolves to an array of runtime files.
-  */
-  async listBuiltinFiles() {
-    const runtimeFiles = [];
-    for (const [id, path2] of this.builtinIdMap.entries()) {
-      const contents = await this.readFile(path2);
-      if (contents) {
-        runtimeFiles.push({
-          id: this.formatRuntimeId(id),
-          path: path2,
-          contents
-        });
-      }
-    }
-    return runtimeFiles;
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
-  */
-  readdirSync(path2, options = "utf8") {
-    return this.resolveFS(path2).readdirSync(toFilePath(path2), options);
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  unlinkSync(path2, options) {
-    const formattedPath = toFilePath(path2);
-    if (!this.fileExistsSync(path2)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing file: ${formattedPath}`);
-    this.resolveFS(path2, options).unlinkSync(formattedPath);
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  */
-  async unlink(path2, options) {
-    const formattedPath = toFilePath(path2);
-    if (!this.fileExistsSync(path2)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing file: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path2, options).promises.unlink)) {
-      await this.resolveFS(path2, options).promises.unlink(formattedPath);
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.unlinkSync(formattedPath, options);
-    }
-  }
-  /**
-  * Removes a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  */
-  rmdirSync(path2, options = {}) {
-    const formattedPath = toFilePath(path2);
-    if (!this.directoryExistsSync(path2)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Synchronously removing directory: ${formattedPath}`);
-    this.resolveFS(path2, options).rmdirSync(formattedPath, defu5(options, {
-      recursive: true
-    }));
-    this.#cachedFS.delete(formattedPath);
-    this.clearResolverCache(formattedPath);
-  }
-  /**
-  * Removes a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  async rmdir(path2, options = {}) {
-    const formattedPath = toFilePath(path2);
-    if (!this.directoryExistsSync(path2)) {
-      return;
-    }
-    this.#log(LogLevelLabel.TRACE, `Removing directory: ${formattedPath}`);
-    if (isFunction(this.resolveFS(path2, options).promises.rm)) {
-      await this.resolveFS(path2, options).promises.rm(formattedPath, defu5(options, {
-        force: true,
-        recursive: true
-      }));
-      this.#cachedFS.delete(formattedPath);
-      this.clearResolverCache(formattedPath);
-    } else {
-      this.rmdirSync(formattedPath, defu5(options ?? {}, {
-        force: true,
-        recursive: true
-      }));
-    }
-  }
-  /**
-  * Removes a file in the virtual file system (VFS).
-  *
-  * @param path - The path to the file to remove.
-  * @param options - Options for removing the file.
-  * @returns A promise that resolves when the file is removed.
-  */
-  async rm(path2, options = {}) {
-    this.#log(LogLevelLabel.TRACE, `Removing: ${toFilePath(path2)}`);
-    if (this.directoryExistsSync(path2)) {
-      return this.rmdir(path2, options);
-    }
-    return this.unlink(path2, options);
-  }
-  /**
-  * Creates a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  mkdirSync(path2, options = {}) {
-    const filePath = toFilePath(path2);
-    this.clearResolverCache(filePath);
-    return this.resolveFS(filePath, options).mkdirSync(filePath, defu5(options ?? {}, {
-      recursive: true
-    }));
-  }
-  /**
-  * Creates a directory in the virtual file system (VFS).
-  *
-  * @param path - The path to create the directory at.
-  * @param options - Options for creating the directory.
-  * @returns A promise that resolves to the path of the created directory, or undefined if the directory could not be created.
-  */
-  async mkdir(path2, options = {}) {
-    let result;
-    const filePath = toFilePath(path2);
-    if (isFunction(this.resolveFS(filePath, options).promises.mkdir)) {
-      result = await this.resolveFS(filePath, options).promises.mkdir(filePath, defu5(options ?? {}, {
-        recursive: true
-      }));
-    } else {
-      result = this.resolveFS(filePath, options).mkdirSync(filePath, defu5(options ?? {}, {
-        recursive: true
-      }));
-    }
-    this.clearResolverCache(filePath);
-    return result;
-  }
-  /**
-  * Lists files in a given path.
-  *
-  * @param path - The path to list files from.
-  * @param options - Options for listing files, such as encoding and recursion.
-  * @returns An array of file names in the specified path.
-  */
-  async readdir(path2, options = "utf8") {
-    return this.resolveFS(path2).promises.readdir(toFilePath(path2), options);
-  }
-  /**
-  * Asynchronously reads a file from the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to read.
-  * @returns A promise that resolves to the contents of the file as a string, or undefined if the file does not exist.
-  */
-  async readFile(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
-    }
-    const filePath = this.resolvePath(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      let result;
-      if (isFunction(this.resolveFS(filePath).promises.readFile)) {
-        result = (await this.resolveFS(filePath).promises.readFile(filePath, options))?.toString("utf8");
-      } else {
-        result = this.resolveFS(filePath).readFileSync(filePath, options);
-      }
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
-    }
-    return void 0;
-  }
-  /**
-  * Synchronously reads a file from the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to read.
-  * @returns The contents of the file as a string, or undefined if the file does not exist.
-  */
-  readFileSync(pathOrId, options = "utf8") {
-    if (!pathOrId) {
-      return void 0;
-    }
-    const filePath = this.resolvePath(toFilePath(pathOrId), {
-      type: "file"
-    });
-    if (filePath) {
-      if (this.#cachedFS.has(filePath)) {
-        return this.#cachedFS.get(filePath);
-      }
-      const result = this.resolveFS(filePath).readFileSync(filePath, options);
-      const content = isBuffer(result) ? bufferToString(result) : result;
-      this.#cachedFS.set(filePath, content);
-      return content;
-    }
-    return void 0;
-  }
-  /**
-  * Writes a file to the virtual file system (VFS).
-  *
-  * @param file - The path to the file.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeFile(file, data = "", options = "utf8") {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
-    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
-      await this.mkdir(findFilePath(absolutePath), options);
-    }
-    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "}file system (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const ifs = this.resolveFS(absolutePath, options);
-    if (isFunction(ifs.promises.writeFile)) {
-      return ifs.promises.writeFile(absolutePath, data, omit(options, [
-        "mode"
-      ]));
-    }
-    return ifs.writeFileSync(absolutePath, data, omit(options, [
-      "mode"
-    ]));
-  }
-  /**
-  * Synchronously writes a file to the virtual file system (VFS).
-  *
-  * @param file - The file to write.
-  * @param data - The contents of the file.
-  * @param options - Optional parameters for writing the file.
-  */
-  writeFileSync(file, data = "", options = "utf8") {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(file));
-    if (!this.directoryExistsSync(findFilePath(absolutePath))) {
-      this.mkdirSync(findFilePath(absolutePath));
-    }
-    this.#log(LogLevelLabel.TRACE, `Writing ${absolutePath} file to the ${this.resolveOutputMode(absolutePath, options) === "fs" ? "" : "virtual "} (size: ${prettyBytes(new Blob(toArray(data)).size)})`);
-    this.#cachedFS.set(absolutePath, data.toString());
-    this.clearResolverCache(absolutePath);
-    const writeStream = this.resolveFS(absolutePath, omit(options, [
-      "mode"
-    ])).createWriteStream(absolutePath);
-    try {
-      writeStream.write(data);
-    } finally {
-      writeStream.close();
-    }
-  }
-  /**
-  * Writes a runtime file to the virtual file system (VFS).
-  *
-  * @param id - The unique identifier for the runtime file.
-  * @param path - The path to the runtime file.
-  * @param contents - The contents of the runtime file.
-  * @param options - Optional parameters for writing the runtime file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeBuiltinFile(id, path2, contents, options = {}) {
-    const formattedId = this.formatRuntimeId(id);
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
-    this.builtinIdMap.set(formattedId, absolutePath);
-    let data = contents;
-    if (!options.skipFormat) {
-      data = await format(contents, {
-        absolutePath,
-        ...await resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu5(isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(LogLevelLabel.DEBUG, `Writing runtime file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "memory"}`);
-    return this.writeFile(absolutePath, data, _options);
-  }
-  /**
-  * Adds an entry file to the virtual file system.
-  *
-  * @param name - The file name or absolute path of the entry module.
-  * @param contents - The contents of the entry file.
-  * @param options - Optional parameters for writing the entry file.
-  */
-  async writeEntryFile(name, contents, options = {}) {
-    const absolutePath = this.formatAbsoluteFilePath(isAbsolutePath(toFilePath(name)) ? toFilePath(name) : toFilePath(joinPaths(this.#context.entryPath, name)));
-    let data = contents;
-    if (!options.skipFormat) {
-      data = await format(contents, {
-        absolutePath,
-        ...await resolveConfig(absolutePath)
-      });
-    }
-    const _options = defu5(isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8",
-      mode: "virtual"
-    });
-    this.#log(LogLevelLabel.DEBUG, `Writing entry file ${absolutePath} (size: ${prettyBytes(new Blob(toArray(data)).size)}) to ${this.resolveOutputMode(absolutePath, _options) === "fs" ? "disk" : "virtual memory"}`);
-    return this.writeFile(absolutePath, data, _options);
-  }
-  /**
-  * Writes a file to disk from the physical file system (on disk).
-  *
-  * @param path - The path to the file to write.
-  * @param contents - The contents of the file to write.
-  * @param options - Optional parameters for writing the file.
-  * @returns A promise that resolves when the file is written.
-  */
-  async writeFileToDisk(path2, contents, options = {}) {
-    const absolutePath = this.formatAbsoluteFilePath(toFilePath(path2));
-    let data = contents;
-    if (!options.skipFormat) {
-      const resolvedConfig = await resolveConfig(absolutePath);
-      if (resolvedConfig) {
-        data = await format(contents, {
-          absolutePath,
-          ...resolvedConfig
-        });
-      }
-    }
-    return this.writeFile(absolutePath, data, defu5({
-      mode: "fs"
-    }, isSetString(options) ? {} : options ?? {}, {
-      encoding: isSetString(options) ? options : "utf8"
-    }));
-  }
-  /**
-  * Synchronously checks if a file exists in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  existsSync(pathOrId) {
-    return this.pathExistsSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
-  }
-  /**
-  * Checks if a file exists in the virtual file system (VFS).
-  *
-  * @remarks
-  * This is a base method used by {@link existsSync} - it does not try to resolve the path prior to checking if it exists or not.
-  *
-  * @param path - The path of the file to check.
-  * @returns `true` if the file exists, otherwise `false`.
-  */
-  fileExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isFile() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isFile() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isFile();
-  }
-  /**
-  * Checks if a directory exists in the virtual file system (VFS).
-  *
-  * @param path - The path of the directory to check.
-  * @returns `true` if the directory exists, otherwise `false`.
-  */
-  directoryExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.#virtualFS.existsSync(formattedPath) && this.#virtualFS.lstatSync(formattedPath).isDirectory() || this.#fs.existsSync(formattedPath) && this.#fs.lstatSync(formattedPath).isDirectory() || this.resolveFS(path2).existsSync(formattedPath) && this.resolveFS(path2).lstatSync(formattedPath).isDirectory();
-  }
-  /**
-  * Checks if a path exists in the virtual file system (VFS).
-  *
-  * @param path - The path to check.
-  * @returns `true` if the path exists, otherwise `false`.
-  */
-  pathExistsSync(path2) {
-    const formattedPath = this.formatAbsoluteFilePath(toFilePath(path2));
-    return this.isValidBuiltinId(formattedPath) || this.#virtualFS.existsSync(formattedPath) || this.#fs.existsSync(formattedPath) || this.resolveFS(path2).existsSync(formattedPath);
-  }
-  /**
-  * Retrieves the status of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns A promise that resolves to the file's status information, or false if the file does not exist.
-  */
-  async stat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.stat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Synchronously retrieves the status of a file in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the file to retrieve status for.
-  * @returns The file's status information, or false if the file does not exist.
-  */
-  statSync(pathOrId) {
-    return this.resolveFS(pathOrId).statSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId));
-  }
-  /**
-  * Retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns A promise that resolves to the symbolic link's status information, or false if the link does not exist.
-  */
-  async lstat(pathOrId, options) {
-    return this.resolveFS(pathOrId).promises.lstat(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Synchronously retrieves the status of a symbolic link in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID of the symbolic link to retrieve status for.
-  * @returns The symbolic link's status information, or false if the link does not exist.
-  */
-  lstatSync(pathOrId, options) {
-    return this.resolveFS(pathOrId).lstatSync(this.resolvePath(toFilePath(pathOrId)) || toFilePath(pathOrId), options);
-  }
-  /**
-  * Resolves a path or ID to a runtime file id in the virtual file system.
-  *
-  * @param pathOrId - The path or id of the file to resolve.
-  * @returns The resolved id of the runtime file if it exists, otherwise false.
-  */
-  resolveId(pathOrId) {
-    if (this.builtinIdMap.has(this.formatRuntimeId(toFilePath(pathOrId)))) {
-      return this.formatRuntimeId(toFilePath(pathOrId));
-    }
-    const filePath = this.resolvePath(toFilePath(pathOrId));
-    if (filePath) {
-      return this.builtinIdMap.keys().find((id) => this.builtinIdMap.get(id) === filePath) || false;
-    }
-    return false;
-  }
-  /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolveTsconfigPath(path2) {
-    if (this.#context.tsconfig.options.paths) {
-      for (const tsconfigPathKey of Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")))) {
-        const resolvedPath = this.#context.tsconfig.options.paths[tsconfigPathKey]?.find((tsconfigPath) => this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, tsconfigPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), ""))) || this.formatAbsoluteFilePath(tsconfigPath) === this.formatAbsoluteFilePath(path2));
-        if (resolvedPath) {
-          return this.formatAbsoluteFilePath(resolvedPath) === this.formatAbsoluteFilePath(path2) ? this.formatAbsoluteFilePath(resolvedPath) : this.resolvePathName(joinPaths(this.#context.workspaceConfig.workspaceRoot, resolvedPath.replaceAll("*", ""), path2.replace(tsconfigPathKey.replaceAll("*", ""), "")));
-        }
-      }
-    }
-    return false;
-  }
-  /**
-  * Resolves a path based on TypeScript's `tsconfig.json` paths.
-  *
-  * @see https://www.typescriptlang.org/tsconfig#paths
-  *
-  * @param path - The path to check.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolveTsconfigPathPackage(path2) {
-    if (this.#context.tsconfig.options.paths) {
-      const tsconfigPathKeys = Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => path2.startsWith(tsconfigPath.replaceAll("*", "")));
-      if (tsconfigPathKeys.length > 0 && tsconfigPathKeys[0]) {
-        return tsconfigPathKeys[0].replace(/\/\*$/, "");
-      }
-    }
-    return false;
-  }
-  /**
-  * Resolves a path or ID to its real path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved real path if it exists, otherwise undefined.
-  */
-  realpathSync(pathOrId) {
-    const filePath = this.resolvePath(toFilePath(pathOrId));
-    if (!filePath) {
-      throw new Error(`File not found: ${toFilePath(pathOrId)}`);
-    }
-    return filePath;
-  }
-  /**
-  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @param options - Optional parameters for resolving the path, such as whether to include the file extension.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolvePath(pathOrId, options = {}) {
-    const formattedPath = toFilePath(pathOrId);
-    const resolverKey = `${formattedPath}${options.withExtension ? "-ext" : ""}${options.paths ? `-${murmurhash(options.paths)}` : ""}${options.type ? `-${options.type}` : ""}`;
-    if (this.#cachedResolver.has(resolverKey)) {
-      return this.#cachedResolver.get(resolverKey);
-    } else if (this.#cachedFS.has(formattedPath)) {
-      return formattedPath;
-    }
-    let result = false;
-    if (this.isValidBuiltinId(formattedPath)) {
-      result = this.builtinIdMap.get(this.formatRuntimeId(formattedPath));
-    } else {
-      result = this.resolvePathName(formattedPath, options);
-    }
-    if (!result) {
-      result = false;
-    } else {
-      result = toFilePath(result);
-    }
-    if (result && options.withExtension === false) {
-      return result.replace(/\.[m|c]?[t|j]sx?$/, "");
-    }
-    this.#cachedResolver.set(resolverKey, result);
-    return result;
-  }
-  /**
-  * Formats a file path by removing the runtime prefix and leading null character.
-  *
-  * @param path - The file path to format.
-  * @returns The formatted file path.
-  */
-  formatFilePath(path2) {
-    if (!isSetString(path2)) {
-      throw new Error(`Invalid path provided. Expected a string or a valid file path.`);
-    }
-    return path2.replace(new RegExp(`^${this.#context.config.output.builtinPrefix}:`), "").replace(/^\\0/, "");
-  }
-  /**
-  * Converts a relative path to an absolute path based on the workspace and project root.
-  *
-  * @param path - The relative path to convert.
-  * @returns The absolute path.
-  */
-  formatAbsoluteFilePath = /* @__PURE__ */ __name((path2) => {
-    const formattedPath = this.formatFilePath(path2);
-    if (isAbsolutePath(formattedPath) || formattedPath.startsWith(this.#context.workspaceConfig.workspaceRoot)) {
-      return formattedPath;
-    } else if (formattedPath.startsWith(this.#context.config.projectRoot)) {
-      return joinPaths(this.#context.workspaceConfig.workspaceRoot, formattedPath);
-    }
-    return formattedPath;
-  }, "formatAbsoluteFilePath");
-  /**
-  * Formats a runtime ID by removing the file extension and prepending the runtime prefix.
-  *
-  * @param id - The runtime ID to format.
-  * @returns The formatted runtime ID.
-  */
-  formatRuntimeId(id) {
-    return `${this.#context.config.output.builtinPrefix}:${this.formatFilePath(id).replace(/\.[m|c]?[t|j]sx?$/, "")}`;
-  }
-  /**
-  * Resolves a path or ID parameter to a corresponding virtual file path in the virtual file system (VFS).
-  *
-  * @param pathOrId - The path or ID to resolve.
-  * @returns The resolved file path if it exists, otherwise undefined.
-  */
-  resolvePathName(pathOrId, options = {}) {
-    if (pathOrId.startsWith(`${this.#context.config.output.builtinPrefix}:`)) {
-      return false;
-    }
-    if (isAbsolutePath(pathOrId)) {
-      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
-        return pathOrId;
-      }
-      const result = checkVariants(pathOrId, this);
-      if (result) {
-        return result;
-      }
-    }
-    for (const path2 of this.resolveParentPaths(pathOrId, options.paths)) {
-      const request = joinPaths(path2, pathOrId);
-      if (options.type === "file" ? this.fileExistsSync(pathOrId) : this.pathExistsSync(pathOrId)) {
-        return request;
-      }
-      const result = checkVariants(request, this);
-      if (result) {
-        return result;
-      }
-    }
-    return false;
-  }
-  resolveParentPaths(request, current = []) {
-    let paths = [
-      this.#context.workspaceConfig.workspaceRoot,
-      joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.projectRoot)
-    ];
-    if (this.#context.tsconfig.options.paths) {
-      paths = this.#context.tsconfig.options.paths ? Object.keys(this.#context.tsconfig.options.paths).filter((tsconfigPath) => request.startsWith(tsconfigPath.replaceAll("*", ""))).map((tsconfigPath) => this.#context.tsconfig.options.paths?.[tsconfigPath]).flat().reduce((ret, path2) => {
-        if (path2 && !ret.includes(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2))) {
-          ret.push(joinPaths(this.#context.workspaceConfig.workspaceRoot, path2));
-        }
-        return ret;
-      }, paths) : paths;
-    }
-    return paths.reduce((ret, path2) => {
-      if (!ret.includes(path2)) {
-        ret.push(path2);
-      }
-      return ret;
-    }, current.filter(Boolean).map((p) => this.formatAbsoluteFilePath(toFilePath(p))));
-  }
-  /**
-  * Select the file system module to use for the operation based on the path or URL.
-  *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
-  */
-  resolveFS(pathOrUrl, options = {}) {
-    const mode = this.resolveOutputMode(pathOrUrl, options);
-    if (mode === "virtual") {
-      return this.#virtualFS;
-    } else if (mode === "fs") {
-      return this.#fs;
-    }
-    return this.#unifiedFS;
-  }
-  /**
-  * Select the file system module to use for the operation based on the path or URL.
-  *
-  * @param pathOrUrl - The path to perform the file system operation on.
-  * @param options - Options for the operation, such as output mode.
-  * @returns The file system module used for the operation.
-  */
-  resolveOutputMode(pathOrUrl, options = {}) {
-    if (options.mode === "virtual" && this.#context.config.output.mode !== "fs" && isParentPath(toFilePath(pathOrUrl), this.#context.artifactsPath)) {
-      return "virtual";
-    } else if (options.mode === "fs" || this.#context.config.output.mode === "fs" || isParentPath(toFilePath(pathOrUrl), this.#context.dataPath) || isParentPath(toFilePath(pathOrUrl), this.#context.cachePath) || isParentPath(toFilePath(pathOrUrl), joinPaths(this.#context.workspaceConfig.workspaceRoot, this.#context.config.output.outputPath))) {
-      return "fs";
-    }
-    return null;
-  }
-  /**
-  * Clears the resolver cache for a given path.
-  *
-  * @param path - The path to clear the resolver cache for.
-  */
-  clearResolverCache(path2) {
-    this.#cachedResolver.keys().filter((key) => key.startsWith(toFilePath(path2))).forEach((key) => this.#cachedResolver.delete(key));
-  }
-});
-var FILE_PREFIX = "file://";
-function toFilePath(pathOrUrl) {
-  if (!pathOrUrl) {
-    throw new Error("No Path or URL provided to Virtual File System");
-  }
-  let result = pathOrUrl.toString();
-  if (result.startsWith(FILE_PREFIX)) {
-    result = result.slice(FILE_PREFIX.length);
-  }
-  return result;
-}
-__name(toFilePath, "toFilePath");
-var FS_METHODS = [
-  "mkdir",
-  "mkdirSync",
-  "rmdir",
-  "rmdirSync",
-  "unlink",
-  "unlinkSync",
-  "existsSync",
-  "realpathSync",
-  "writeFileSync",
-  "readFileSync",
-  "readdirSync",
-  "createWriteStream",
-  "WriteStream",
-  "createReadStream",
-  "ReadStream"
-];
-var FS_PROMISE_METHODS = [
-  "mkdir",
-  "rm",
-  "rmdir",
-  "unlink",
-  "writeFile",
-  "readFile",
-  "readdir",
-  "stat",
-  "lstat"
-];
-function cloneFS(originalFS) {
-  const clonedFS = {
-    ...originalFS,
-    promises: {
-      ...originalFS.promises ?? {}
-    }
-  };
-  for (const method of FS_METHODS) {
-    if (originalFS[method]) {
-      clonedFS[method] = originalFS[method];
-    }
-  }
-  originalFS.promises ??= {};
-  for (const method of FS_PROMISE_METHODS) {
-    if (originalFS.promises[method]) {
-      clonedFS.promises ??= {};
-      clonedFS.promises[method] = originalFS.promises[method];
-      clonedFS[method] = originalFS.promises[method];
-    }
-  }
-  for (const prop in clonedFS) {
-    if (isFunction(clonedFS[prop])) {
-      clonedFS[prop] = clonedFS[prop].bind(originalFS);
-      if (isFunction(clonedFS.promises[prop])) {
-        clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-      }
-    }
-  }
-  for (const prop in clonedFS.promises) {
-    if (isFunction(clonedFS.promises[prop])) {
-      clonedFS.promises[prop] = clonedFS.promises[prop].bind(originalFS);
-    }
-  }
-  return clonedFS;
-}
-__name(cloneFS, "cloneFS");
-function patchFS(originalFS, vfs) {
-  const clonedFS = cloneFS(originalFS);
-  originalFS.mkdirSync = (file, options) => vfs.mkdirSync(toFilePath(file), options);
-  originalFS.mkdir = (file, options, callback) => vfs.mkdir(toFilePath(file), options, callback);
-  originalFS.promises.mkdir = async (file, options) => vfs.mkdir(toFilePath(file), options);
-  originalFS.unlinkSync = (file) => vfs.unlinkSync(toFilePath(file));
-  originalFS.promises.rm = async (file, options) => vfs.rm(toFilePath(file), options);
-  originalFS.promises.unlink = async (file) => vfs.unlink(toFilePath(file));
-  originalFS.existsSync = (file) => vfs.existsSync(toFilePath(file));
-  Object.defineProperty(originalFS, "realpathSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.realpathSync(toFilePath(file), options), "value")
-  });
-  originalFS.writeFileSync = (file, data, options) => vfs.writeFileSync(toFilePath(file), data, options);
-  originalFS.promises.writeFile = async (file, data, options) => vfs.writeFile(toFilePath(file), data, options);
-  originalFS.readFileSync = (file, options) => vfs.readFileSync(toFilePath(file), options);
-  originalFS.promises.readFile = (file, options) => vfs.readFile(toFilePath(file), options);
-  originalFS.readdirSync = (file, options) => vfs.readdirSync(toFilePath(file), options);
-  originalFS.promises.readdir = (file, options) => vfs.readdir(toFilePath(file), options);
-  Object.defineProperty(originalFS, "statSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.statSync(toFilePath(file), options), "value")
-  });
-  originalFS.stat = (file, options) => vfs.statSync(toFilePath(file), options);
-  originalFS.promises.stat = (file, options) => vfs.stat(toFilePath(file), options);
-  Object.defineProperty(originalFS, "lstatSync", {
-    value: /* @__PURE__ */ __name((file, options) => vfs.lstatSync(toFilePath(file), options), "value")
-  });
-  originalFS.lstat = (file, options) => vfs.lstatSync(toFilePath(file), options);
-  originalFS.promises.lstat = (file, options) => vfs.lstat(toFilePath(file), options);
-  return () => {
-    originalFS.mkdirSync = clonedFS.mkdirSync;
-    originalFS.mkdir = clonedFS.mkdir;
-    originalFS.promises.mkdir = clonedFS.promises.mkdir;
-    originalFS.unlinkSync = clonedFS.unlinkSync;
-    originalFS.promises.rm = clonedFS.promises.rm;
-    originalFS.promises.unlink = clonedFS.promises.unlink;
-    originalFS.existsSync = clonedFS.existsSync;
-    originalFS.realpathSync = clonedFS.realpathSync;
-    originalFS.writeFileSync = clonedFS.writeFileSync;
-    originalFS.promises.writeFile = clonedFS.promises.writeFile;
-    originalFS.readFileSync = clonedFS.readFileSync;
-    originalFS.promises.readFile = clonedFS.promises.readFile;
-    originalFS.readdirSync = clonedFS.readdirSync;
-    originalFS.promises.readdir = clonedFS.promises.readdir;
-    Object.defineProperty(originalFS, "statSync", {
-      value: clonedFS.statSync
-    });
-    originalFS.stat = clonedFS.stat;
-    originalFS.promises.stat = clonedFS.promises.stat;
-    Object.defineProperty(originalFS, "lstatSync", {
-      value: clonedFS.lstatSync
-    });
-    originalFS.lstat = clonedFS.lstat;
-    originalFS.promises.lstat = clonedFS.promises.lstat;
-  };
-}
-__name(patchFS, "patchFS");
-function checkVariants(request, vfs, parentPath) {
-  const path2 = parentPath ? joinPaths(parentPath, request) : request;
-  let file = checkExtensions(path2, vfs);
-  if (file) {
-    return file;
-  }
-  file = checkIndex(path2, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-__name(checkVariants, "checkVariants");
-function checkIndex(request, vfs) {
-  let file = joinPaths(request, "index");
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = checkExtensions(file, vfs);
-  if (file) {
-    return file;
-  }
-  return false;
-}
-__name(checkIndex, "checkIndex");
-function checkExtensions(request, vfs) {
-  let file = `${request}.ts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.mts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.cts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.tsx`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.js`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.mjs`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.cjs`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.jsx`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.json`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  file = `${request}.d.ts`;
-  if (vfs.fileExistsSync(file)) {
-    return file;
-  }
-  return false;
-}
-__name(checkExtensions, "checkExtensions");
-
-// ../powerlines/src/internal/helpers/eslint.ts
-var MessageSeverity;
-(function(MessageSeverity2) {
-  MessageSeverity2[MessageSeverity2["Warning"] = 1] = "Warning";
-  MessageSeverity2[MessageSeverity2["Error"] = 2] = "Error";
-})(MessageSeverity || (MessageSeverity = {}));
-function getString(code) {
-  if (!code) {
-    return "";
-  }
-  if (isString(code)) {
-    return code;
-  }
-  if (isSetObject(code) && "code" in code) {
-    return code.code;
-  }
-  return code.toString();
-}
-__name(getString, "getString");
-var NON_NODE_MODULE_REGEX = /^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/;
-async function handleResolveId(context, args, options = {}) {
-  if (args.id) {
-    if (context.fs.isVirtualFile(args.id) || args.importer && context.fs.isVirtualFile(args.id, {
-      paths: [
-        args.importer
-      ]
-    })) {
-      const resolvedPath = args.importer ? context.fs.resolvePath(args.id, {
-        paths: [
-          args.importer
-        ]
-      }) : context.fs.resolvePath(args.id);
-      if (resolvedPath) {
-        return {
-          id: resolvedPath,
-          external: context.config.projectType !== "application"
-        };
-      }
-    }
-    if (context.fs.isTsconfigPath(args.id)) {
-      const tsconfigPath = context.fs.resolveTsconfigPath(args.id);
-      const tsconfigPathPackage = context.fs.resolveTsconfigPathPackage(args.id);
-      if (tsconfigPath && tsconfigPathPackage) {
-        return {
-          id: tsconfigPath,
-          external: Boolean(!options.noExternal?.includes(tsconfigPathPackage) && (options.external?.includes(tsconfigPathPackage) ?? context.config.projectType !== "application"))
-        };
-      }
-    }
-    if (options.skipResolve) {
-      return void 0;
-    }
-    if (options.skipNodeModulesBundle) {
-      if (match(args.id, options.resolvePatterns) || match(args.id, options.noExternal) || args.id.startsWith("internal:") || args.id.startsWith("virtual:")) {
-        return void 0;
-      }
-      if (match(args.id, options.external) || args.id.startsWith("node:")) {
-        return {
-          id: args.id,
-          external: true
-        };
-      }
-      if (!NON_NODE_MODULE_REGEX.test(args.id)) {
-        return {
-          id: args.id,
-          external: true
-        };
-      }
-    } else {
-      if (match(args.id, options.noExternal) || context.fs.isBuiltinFile(args.id) || args.importer && context.fs.isBuiltinFile(args.id, {
-        paths: [
-          args.importer
-        ]
-      })) {
-        return void 0;
-      }
-      if (match(args.id, options.external) || args.id.startsWith("node:")) {
-        return {
-          id: args.id,
-          external: true
-        };
-      }
-    }
-  }
-  return void 0;
-}
-__name(handleResolveId, "handleResolveId");
-function createUnplugin(context, options = {}) {
-  const ctx = context;
-  return () => {
-    const log = extendLog(ctx.log, "unplugin");
-    log(LogLevelLabel.DEBUG, "Initializing Unplugin");
-    try {
-      async function buildStart() {
-        log(LogLevelLabel.DEBUG, "Powerlines build plugin starting...");
-        await ctx.$$internal.callHook("buildStart", {
-          sequential: true
-        });
-      }
-      __name(buildStart, "buildStart");
-      async function resolveId(id, importer, opts = {
-        isEntry: false
-      }) {
-        let result = await ctx.$$internal.callHook("resolveId", {
-          sequential: true,
-          result: "first",
-          order: "pre"
-        }, id, importer, opts);
-        if (result) {
-          return result;
-        }
-        result = await ctx.$$internal.callHook("resolveId", {
-          sequential: true,
-          result: "first",
-          order: "normal"
-        }, id, importer, opts);
-        if (result) {
-          return result;
-        }
-        result = await handleResolveId(ctx, {
-          id,
-          importer,
-          options: opts
-        }, {
-          skipResolve: options.skipResolve,
-          skipNodeModulesBundle: ctx.config.build.skipNodeModulesBundle,
-          external: ctx.config.build.external,
-          noExternal: ctx.config.build.noExternal
-        });
-        if (result) {
-          return result;
-        }
-        return ctx.$$internal.callHook("resolveId", {
-          sequential: true,
-          result: "first",
-          order: "post"
-        }, id, importer, opts);
-      }
-      __name(resolveId, "resolveId");
-      async function load(id) {
-        let result = await ctx.$$internal.callHook("load", {
-          sequential: true,
-          result: "first",
-          order: "pre"
-        }, id);
-        if (result) {
-          return result;
-        }
-        result = await ctx.$$internal.callHook("load", {
-          sequential: true,
-          result: "first",
-          order: "normal"
-        }, id);
-        if (result) {
-          return result;
-        }
-        if (id) {
-          const resolvedPath = ctx.fs.resolvePath(id, {
-            type: "file"
-          });
-          if (resolvedPath) {
-            return ctx.fs.readFile(resolvedPath);
-          }
-        }
-        return ctx.$$internal.callHook("load", {
-          sequential: true,
-          result: "first",
-          order: "post"
-        }, id);
-      }
-      __name(load, "load");
-      async function transform(code, id) {
-        let transformed = code;
-        for (const handler of ctx.$$internal.environment.selectHooks("transform")) {
-          const result = await handler.apply(defu5(ctx, this), [
-            getString(transformed),
-            id
-          ]);
-          if (result) {
-            transformed = result;
-          }
-        }
-        return transformed;
-      }
-      __name(transform, "transform");
-      async function buildEnd() {
-        log(LogLevelLabel.DEBUG, "Powerlines build plugin finishing...");
-        return ctx.$$internal.callHook("buildEnd", {
-          sequential: true
-        });
-      }
-      __name(buildEnd, "buildEnd");
-      async function writeBundle() {
-        log(LogLevelLabel.DEBUG, "Finalizing Powerlines project output...");
-        return ctx.$$internal.callHook("writeBundle", {
-          sequential: true
-        });
-      }
-      __name(writeBundle, "writeBundle");
-      return {
-        name: "powerlines",
-        resolveId: {
-          filter: {
-            id: {
-              include: [
-                /.*/
-              ]
-            }
-          },
-          handler: resolveId
-        },
-        load: {
-          filter: {
-            id: {
-              include: [
-                /.*/,
-                /^storm:/
-              ]
-            }
-          },
-          handler: load
-        },
-        transform,
-        buildStart,
-        buildFinish: buildEnd,
-        writeBundle,
-        vite: {
-          sharedDuringBuild: true
-        }
-      };
-    } catch (error) {
-      log(LogLevelLabel.FATAL, error?.message);
-      throw error;
-    }
-  };
-}
-__name(createUnplugin, "createUnplugin");
-function createESBuildPlugin(context) {
-  return createEsbuildPlugin(createUnplugin(context, {
-    skipResolve: true
-  }))({});
-}
-__name(createESBuildPlugin, "createESBuildPlugin");
-
-export { __name, createESBuildPlugin, resolveEntryInputFile, resolveEntryOutput };
-//# sourceMappingURL=chunk-FGTVQNHX.js.map
-//# sourceMappingURL=chunk-FGTVQNHX.js.map