wesl-plugin 0.6.2 → 0.6.7

package/src/PluginApi.ts

@@ -0,0 +1,201 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "glob";
+import toml from "toml";
+import type { UnpluginBuildContext, UnpluginContext } from "unplugin";
+import { type ParsedRegistry, parseIntoRegistry, parsedRegistry } from "wesl";
+import { parseDependencies } from "wesl-tooling";
+import type { PluginExtensionApi } from "./PluginExtension.js";
+import type { PluginContext, WeslToml, WeslTomlInfo } from "./WeslPlugin.js";
+
+export function buildApi(
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): PluginExtensionApi {
+  return {
+    weslToml: async () => getWeslToml(context, unpluginCtx),
+    weslSrc: async () => loadWesl(context, unpluginCtx),
+    weslRegistry: async () => getRegistry(context, unpluginCtx),
+    weslMain: makeGetWeslMain(context, unpluginCtx),
+    weslDependencies: async () => findDependencies(context, unpluginCtx),
+  };
+}
+
+/** load the wesl.toml  */
+export async function getWeslToml(
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<WeslTomlInfo> {
+  const { cache } = context;
+  if (cache.weslToml) return cache.weslToml;
+
+  // find the wesl.toml file if it exists
+  const specifiedToml = context.options.weslToml;
+  let tomlFile: string | undefined;
+  if (specifiedToml) {
+    fs.access(specifiedToml);
+    tomlFile = specifiedToml;
+  } else {
+    tomlFile = await fs
+      .access("wesl.toml")
+      .then(() => "wesl.toml")
+      .catch(() => {
+        return undefined;
+      });
+  }
+
+  // load the toml contents
+  let parsedToml: WeslToml;
+  let tomlDir: string;
+  if (tomlFile) {
+    unpluginCtx.addWatchFile(tomlFile); // The cache gets cleared by the watchChange hook
+    parsedToml = await loadWeslToml(tomlFile);
+    tomlDir = path.dirname(tomlFile);
+    context.weslToml = tomlFile;
+  } else {
+    parsedToml = defaultWeslToml;
+    tomlDir = process.cwd();
+  }
+
+  const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.weslRoot);
+  const resolvedWeslRoot = path.relative(process.cwd(), tomlToWeslRoot);
+  cache.weslToml = { tomlFile, tomlDir, resolvedWeslRoot, toml: parsedToml };
+  return cache.weslToml;
+}
+
+const defaultWeslToml: WeslToml = {
+  weslFiles: ["shaders/**/*.w[eg]sl"],
+  weslRoot: "shaders",
+  dependencies: ["auto"],
+};
+
+/**
+ * Load and parse a wesl.toml file from the fs.
+ * Provide default values for any required WeslToml fields.
+ */
+async function loadWeslToml(tomlFile: string): Promise<WeslToml> {
+  const tomlString = await fs.readFile(tomlFile, "utf-8");
+  const parsed = toml.parse(tomlString) as WeslToml;
+  const weslToml = { ...defaultWeslToml, ...parsed };
+  return weslToml;
+}
+
+/** load and parse all the wesl files into a ParsedRegistry */
+async function getRegistry(
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<ParsedRegistry> {
+  const { cache } = context;
+  let { registry } = cache;
+  if (registry) return registry;
+
+  // load wesl files into registry
+  const loaded = await loadWesl(context, unpluginCtx);
+  const { resolvedWeslRoot } = await getWeslToml(context, unpluginCtx);
+
+  registry = parsedRegistry();
+  parseIntoRegistry(loaded, registry);
+
+  // The paths are relative to the weslRoot, but vite needs actual filesystem paths
+  const fullPaths = Object.keys(loaded).map(p =>
+    path.resolve(resolvedWeslRoot, p),
+  );
+
+  // trigger clearing cache on shader file change
+  fullPaths.forEach(f => {
+    unpluginCtx.addWatchFile(f);
+  });
+
+  cache.registry = registry;
+  return registry;
+}
+
+/** if the dependency list includes "auto", fill in the missing dependencies
+ * by parsing the source files to find references to packages
+ * @return the list of dependencies with "auto" replaced by the found dependencies
+ */
+async function findDependencies(
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<string[]> {
+  const { toml, tomlDir: projectDir } = await getWeslToml(context, unpluginCtx);
+  const weslSrc = await loadWesl(context, unpluginCtx);
+  const { dependencies = [] } = toml;
+  const hasAuto = dependencies.includes("auto");
+  if (!hasAuto) return dependencies;
+
+  const base = dependencies.filter(dep => dep !== "auto");
+  const deps = parseDependencies(weslSrc, projectDir);
+  const combined = new Set([...base, ...deps]);
+  return [...combined];
+}
+
+function makeGetWeslMain(
+  context: PluginContext,
+  unpluginContext: UnpluginBuildContext & UnpluginContext,
+): (baseId: string) => Promise<string> {
+  return getWeslMain;
+
+  /**
+   * @param shaderPath is an absolute path to the shader file
+   * @return the / separated path to the shader file, relative to the weslRoot
+   */
+  async function getWeslMain(shaderPath: string): Promise<string> {
+    const { resolvedWeslRoot } = await getWeslToml(context, unpluginContext);
+    await fs.access(shaderPath); // if file doesn't exist, report now when the user problem is clear.
+
+    const absRoot = path.join(process.cwd(), resolvedWeslRoot);
+    const weslRootToMain = path.relative(absRoot, shaderPath);
+    return toUnixPath(weslRootToMain);
+  }
+}
+
+/**
+ * Load the wesl files referenced in the wesl.toml file
+ *
+ * @return a record of wesl files with
+ *    keys as wesl file paths, and
+ *    values as wesl file contents.
+ */
+async function loadWesl(
+  context: PluginContext,
+  unpluginCtx: UnpluginBuildContext & UnpluginContext,
+): Promise<Record<string, string>> {
+  const {
+    toml: { weslFiles },
+    resolvedWeslRoot,
+    tomlDir,
+  } = await getWeslToml(context, unpluginCtx);
+  const futureFiles = weslFiles.map(g =>
+    glob(g, { cwd: tomlDir, absolute: true }),
+  );
+  const files = (await Promise.all(futureFiles)).flat();
+
+  // trigger rebuild on shader file change
+  files.forEach(f => unpluginCtx.addWatchFile(f));
+
+  return await loadFiles(files, resolvedWeslRoot);
+}
+
+/** load a set of shader files, converting to paths relative to the weslRoot directory */
+async function loadFiles(
+  files: string[],
+  weslRoot: string,
+): Promise<Record<string, string>> {
+  const loaded: [string, string][] = [];
+
+  for (const fullPath of files) {
+    const data = await fs.readFile(fullPath, "utf-8");
+    const relativePath = path.relative(weslRoot, fullPath);
+    loaded.push([toUnixPath(relativePath), data]);
+  }
+  return Object.fromEntries(loaded);
+}
+
+function toUnixPath(p: string): string {
+  if (path.sep !== "/") {
+    return p.replaceAll(path.sep, "/");
+  } else {
+    return p;
+  }
+}

package/src/PluginExtension.ts

@@ -1,5 +1,5 @@
-import { ParsedRegistry, WeslJsPlugin } from "wesl";
-import { WeslTomlInfo } from "./WeslPlugin.ts";
+import type { ParsedRegistry, WeslJsPlugin } from "wesl";
+import type { WeslTomlInfo } from "./WeslPlugin.ts";
 
 /** function type required for for emit extensions */
 export type ExtensionEmitFn = (
@@ -29,4 +29,5 @@ export interface PluginExtensionApi {
   weslSrc: () => Promise<Record<string, string>>;
   weslRegistry: () => Promise<ParsedRegistry>;
   weslMain: (baseId: string) => Promise<string>;
+  weslDependencies: () => Promise<string[]>;
 }

package/src/WeslPlugin.ts

@@ -1,24 +1,17 @@
-import { glob } from "glob";
-import fs from "node:fs/promises";
 import path from "node:path";
-import toml from "toml";
-import type {
-    ExternalIdResult,
-    Thenable,
-    TransformResult,
-    UnpluginBuildContext,
-    UnpluginContext,
-    UnpluginContextMeta,
-    UnpluginOptions
-} from "unplugin";
-import { createUnplugin } from "unplugin";
 import {
-    Conditions,
-    parsedRegistry,
-    ParsedRegistry,
-    parseIntoRegistry
-} from "wesl";
-import { PluginExtension, PluginExtensionApi } from "./PluginExtension.js";
+  type ExternalIdResult,
+  type Thenable,
+  type TransformResult,
+  type UnpluginBuildContext,
+  type UnpluginContext,
+  type UnpluginContextMeta,
+  type UnpluginOptions,
+  createUnplugin,
+} from "unplugin";
+import type { Conditions, ParsedRegistry } from "wesl";
+import { buildApi } from "./PluginApi.js";
+import type { PluginExtension } from "./PluginExtension.js";
 import type { WeslPluginOptions } from "./WeslPluginOptions.js";
 
 /** loaded (or synthesized) info from .toml */
@@ -74,7 +67,7 @@ type Loader = (
 ) => Thenable<TransformResult>;
 
 /** convenient state for local functions */
-interface PluginContext {
+export interface PluginContext {
   cache: PluginCache;
   options: WeslPluginOptions;
   meta: UnpluginContextMeta;
@@ -93,7 +86,7 @@ interface PluginContext {
  *  2. `import "./shaders/bar.wesl?link"` - produces a javascript file for preconstructed link functions
  */
 export function weslPlugin(
-  options: WeslPluginOptions = {},
+  options: WeslPluginOptions,
   meta: UnpluginContextMeta,
 ): UnpluginOptions {
   const cache: PluginCache = {};
@@ -103,7 +96,7 @@ export function weslPlugin(
     name: "wesl-plugin",
     resolveId: buildResolver(options, context),
     load: buildLoader(context),
-    watchChange(id, change) {
+    watchChange(id, _change) {
       if (id.endsWith("wesl.toml")) {
         // The cache is shared for multiple imports
         cache.weslToml = undefined;
@@ -204,18 +197,6 @@ function pluginSuffixMatch(id: string, suffixes: string[]): PluginMatch | null {
   };
 }
 
-function buildApi(
-  context: PluginContext,
-  unpluginCtx: UnpluginBuildContext & UnpluginContext,
-): PluginExtensionApi {
-  return {
-    weslToml: async () => getWeslToml(context, unpluginCtx),
-    weslSrc: async () => loadWesl(context, unpluginCtx),
-    weslRegistry: async () => getRegistry(context, unpluginCtx),
-    weslMain: makeGetWeslMain(context, unpluginCtx),
-  };
-}
-
 /** build plugin function for serving a javascript module in response to
  * an import of of our virtual import modules. */
 function buildLoader(context: PluginContext): Loader {
@@ -234,9 +215,8 @@ function buildLoader(context: PluginContext): Loader {
       const plugin = pluginsMap[matched.pluginName];
       const { baseId, importParams } = matched;
       const conditions = importParamsToConditions(importParams);
-      const shaderPath =
-        baseId.startsWith(resolvedPrefix) ?
-          baseId.slice(resolvedPrefix.length)
+      const shaderPath = baseId.startsWith(resolvedPrefix)
+        ? baseId.slice(resolvedPrefix.length)
         : baseId;
 
       return await plugin.emitFn(shaderPath, buildPluginApi, conditions);
@@ -271,167 +251,6 @@ function importParamsToConditions(
   return conditions;
 }
 
-export const defaultTomlMessage = `no wesl.toml found: assuming .wesl files are in ./shaders`;
-
-/** load the wesl.toml  */
-async function getWeslToml(
-  context: PluginContext,
-  unpluginCtx: UnpluginBuildContext & UnpluginContext,
-): Promise<WeslTomlInfo> {
-  const { cache } = context;
-  if (cache.weslToml) return cache.weslToml;
-
-  // find the wesl.toml file if it exists
-  const specifiedToml = context.options.weslToml;
-  let tomlFile: string | undefined;
-  if (specifiedToml) {
-    fs.access(specifiedToml);
-    tomlFile = specifiedToml;
-  } else {
-    tomlFile = await fs
-      .access("wesl.toml")
-      .then(() => "wesl.toml")
-      .catch(() => {
-        return undefined;
-      });
-  }
-
-  // load the toml contents
-  let parsedToml: WeslToml;
-  let tomlDir: string;
-  if (tomlFile) {
-    unpluginCtx.addWatchFile(tomlFile); // The cache gets cleared by the watchChange hook
-    parsedToml = await loadWeslToml(tomlFile);
-    tomlDir = path.dirname(tomlFile);
-    context.weslToml = tomlFile;
-  } else {
-    console.log(defaultTomlMessage);
-    parsedToml = defaultWeslToml;
-    tomlDir = process.cwd();
-  }
-
-  const tomlToWeslRoot = path.resolve(tomlDir, parsedToml.weslRoot);
-  const resolvedWeslRoot = path.relative(process.cwd(), tomlToWeslRoot);
-  cache.weslToml = { tomlFile, tomlDir, resolvedWeslRoot, toml: parsedToml };
-  return cache.weslToml;
-}
-
-const defaultWeslToml: WeslToml = {
-  weslFiles: ["shaders/**/*.w[eg]sl"],
-  weslRoot: "shaders",
-};
-
-/**
- * Load and parse a wesl.toml file from the fs.
- * Provide default values for any required WeslToml fields.
- */
-async function loadWeslToml(tomlFile: string): Promise<WeslToml> {
-  const tomlString = await fs.readFile(tomlFile, "utf-8");
-  const parsed = toml.parse(tomlString) as WeslToml;
-  const weslToml = { ...defaultWeslToml, ...parsed };
-  return weslToml;
-}
-
-/** load and parse all the wesl files into a ParsedRegistry */
-async function getRegistry(
-  context: PluginContext,
-  unpluginCtx: UnpluginBuildContext & UnpluginContext,
-): Promise<ParsedRegistry> {
-  const { cache } = context;
-  let { registry } = cache;
-  if (registry) return registry;
-
-  // load wesl files into registry
-  const loaded = await loadWesl(context, unpluginCtx);
-  const { resolvedWeslRoot } = await getWeslToml(context, unpluginCtx);
-
-  registry = parsedRegistry();
-  parseIntoRegistry(loaded, registry);
-
-  // The paths are relative to the weslRoot, but vite needs actual filesystem paths
-  const fullPaths = Object.keys(loaded).map(p =>
-    path.resolve(resolvedWeslRoot, p),
-  );
-
-  // trigger clearing cache on shader file change
-  fullPaths.forEach(f => {
-    unpluginCtx.addWatchFile(f);
-  });
-
-  cache.registry = registry;
-  return registry;
-}
-
-function makeGetWeslMain(
-  context: PluginContext,
-  unpluginContext: UnpluginBuildContext & UnpluginContext,
-): (baseId: string) => Promise<string> {
-  return getWeslMain;
-
-  /**
-   * @param shaderPath is an absolute path to the shader file
-   * @return the / separated path to the shader file, relative to the weslRoot
-   */
-  async function getWeslMain(shaderPath: string): Promise<string> {
-    const { resolvedWeslRoot } = await getWeslToml(context, unpluginContext);
-    await fs.access(shaderPath); // if file doesn't exist, report now when the user problem is clear.
-
-    const absRoot = path.join(process.cwd(), resolvedWeslRoot);
-    const weslRootToMain = path.relative(absRoot, shaderPath);
-    return toUnixPath(weslRootToMain);
-  }
-}
-
-/**
- * Load the wesl files referenced in the wesl.toml file
- *
- * @return a record of wesl files with
- *    keys as wesl file paths, and
- *    values as wesl file contents.
- */
-async function loadWesl(
-  context: PluginContext,
-  unpluginCtx: UnpluginBuildContext & UnpluginContext,
-): Promise<Record<string, string>> {
-  const {
-    toml: { weslFiles },
-    resolvedWeslRoot,
-    tomlDir,
-  } = await getWeslToml(context, unpluginCtx);
-  const futureFiles = weslFiles.map(g =>
-    glob(g, { cwd: tomlDir, absolute: true }),
-  );
-  const files = (await Promise.all(futureFiles)).flat();
-
-  // trigger rebuild on shader file change
-  files.forEach(f => unpluginCtx.addWatchFile(f));
-
-  return await loadFiles(files, resolvedWeslRoot);
-}
-
-/** load a set of shader files, converting to paths relative to the weslRoot directory */
-async function loadFiles(
-  files: string[],
-  weslRoot: string,
-): Promise<Record<string, string>> {
-  const loaded: [string, string][] = [];
-
-  for (const fullPath of files) {
-    const data = await fs.readFile(fullPath, "utf-8");
-    const relativePath = path.relative(weslRoot, fullPath);
-    loaded.push([toUnixPath(relativePath), data]);
-  }
-  return Object.fromEntries(loaded);
-}
-
-function toUnixPath(p: string): string {
-  if (path.sep !== "/") {
-    return p.replaceAll(path.sep, "/");
-  } else {
-    return p;
-  }
-}
-
 export const unplugin = createUnplugin(
   (options: WeslPluginOptions, meta: UnpluginContextMeta) => {
     return weslPlugin(options, meta);

package/src/WeslPluginOptions.ts

@@ -1,4 +1,4 @@
-import { PluginExtension } from "./PluginExtension.ts";
+import type { PluginExtension } from "./PluginExtension.ts";
 
 export interface WeslPluginOptions {
   weslToml?: string;

package/src/defaultSuffixTypes.d.ts

@@ -1,6 +1,6 @@
 /** @hidden */
 declare module "*?link" {
-  import { LinkParams } from "wesl";
+  import type { LinkParams } from "wesl";
   const linkParams: LinkParams;
   export default linkParams;
 }

package/src/extensions/LinkExtension.ts

@@ -1,6 +1,9 @@
 import path from "node:path";
-import { LinkParams, noSuffix } from "wesl";
-import { PluginExtension, PluginExtensionApi } from "../PluginExtension.ts";
+import { type LinkParams, noSuffix } from "wesl";
+import type {
+  PluginExtension,
+  PluginExtensionApi,
+} from "../PluginExtension.ts";
 
 export const linkBuildExtension: PluginExtension = {
   extensionName: "link",
@@ -12,8 +15,7 @@ async function emitLinkJs(
   baseId: string,
   api: PluginExtensionApi,
 ): Promise<string> {
-  const { resolvedWeslRoot, toml, tomlDir } = await api.weslToml();
-  const { dependencies = [] } = toml;
+  const { resolvedWeslRoot, tomlDir } = await api.weslToml();
 
   const weslSrc = await api.weslSrc();
 
@@ -23,9 +25,10 @@ async function emitLinkJs(
   const tomlRelative = path.relative(tomlDir, resolvedWeslRoot);
   const debugWeslRoot = tomlRelative.replaceAll(path.sep, "/");
 
-  const sanitizedDeps = dependencies.map(dep => dep.replaceAll("/", "_"));
+  const autoDeps = await api.weslDependencies();
+  const sanitizedDeps = autoDeps.map(dep => dep.replaceAll("/", "_"));
 
-  const bundleImports = dependencies
+  const bundleImports = autoDeps
     .map((p, i) => `import ${sanitizedDeps[i]} from "${p}";`)
     .join("\n");
 

package/src/extensions/StaticExtension.ts

@@ -1,8 +1,11 @@
-import { resolve } from "import-meta-resolve";
 import path from "node:path";
 import url from "node:url";
-import { Conditions, link, noSuffix } from "wesl";
-import { PluginExtension, PluginExtensionApi } from "../PluginExtension.ts";
+import { resolve } from "import-meta-resolve";
+import { type Conditions, link, noSuffix } from "wesl";
+import type {
+  PluginExtension,
+  PluginExtensionApi,
+} from "../PluginExtension.ts";
 
 /**
  * a wesl-js ?static build extension that statically links from the root file
@@ -25,13 +28,14 @@ async function emitStaticJs(
   api: PluginExtensionApi,
   conditions?: Conditions,
 ): Promise<string> {
-  const { resolvedWeslRoot, toml, tomlDir } = await api.weslToml();
-  const { dependencies = [] } = toml;
+  const { resolvedWeslRoot, tomlDir } = await api.weslToml();
 
   // resolve import module relative to the root of the shader project
   const parentModule = url
     .pathToFileURL(path.join(tomlDir, "wesl.toml"))
     .toString();
+
+  const dependencies = await api.weslDependencies();
   const libFileUrls = dependencies.map(d => resolve(d, parentModule));
 
   // load the lib modules

package/src/plugins/nuxt.ts

@@ -1,7 +1,7 @@
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
+import type { WeslPluginOptions } from "../WeslPluginOptions";
 import vite from "./vite";
 import webpack from "./webpack";
-import type { WeslPluginOptions } from "../WeslPluginOptions";
 import "@nuxt/schema";
 
 export interface ModuleOptions extends WeslPluginOptions {}

package/dist/PluginExtension-B_oge2T3.d.ts

@@ -1,48 +0,0 @@
-import { WeslJsPlugin, ParsedRegistry } from 'wesl';
-
-/** loaded (or synthesized) info from .toml */
-interface WeslToml {
-    /** glob search strings to find .wesl/.wgsl files. Relative to the toml directory. */
-    weslFiles: string[];
-    /** base directory for wesl files. Relative to the toml directory. */
-    weslRoot: string;
-    /** names of directly referenced wesl shader packages (e.g. npm package names) */
-    dependencies?: string[];
-}
-interface WeslTomlInfo {
-    /** The path to the toml file, relative to the cwd, undefined if no toml file */
-    tomlFile: string | undefined;
-    /** The absolute path to the directory that contains the toml.
-     * Paths inside the toml are relative to this. */
-    tomlDir: string;
-    /** The wesl root, relative to the cwd.
-     * This lets us correctly do `path.resolve(resolvedWeslRoot, someShaderFile)` */
-    resolvedWeslRoot: string;
-    /** The underlying toml file */
-    toml: WeslToml;
-}
-
-/** function type required for for emit extensions */
-type ExtensionEmitFn = (
-/** absolute path to the shader to which the extension is attached */
-shaderPath: string, 
-/** support functions available to plugin extensions */
-pluginApi: PluginExtensionApi, 
-/** static conditions specified on the js import */ conditions?: Record<string, boolean>) => Promise<string>;
-/** an extension that runs inside the wesl-js build plugin */
-interface PluginExtension extends WeslJsPlugin {
-    /** javascript imports with this suffix will trigger the plugin */
-    extensionName: string;
-    /** generate javascript text for js/ts importers to use.
-     *   e.g. import myPluginJs from "./foo.wesl?myPlugin"; */
-    emitFn: ExtensionEmitFn;
-}
-/** api supplied to plugin extensions */
-interface PluginExtensionApi {
-    weslToml: () => Promise<WeslTomlInfo>;
-    weslSrc: () => Promise<Record<string, string>>;
-    weslRegistry: () => Promise<ParsedRegistry>;
-    weslMain: (baseId: string) => Promise<string>;
-}
-
-export type { ExtensionEmitFn as E, PluginExtension as P, PluginExtensionApi as a };

package/dist/WeslPluginOptions-ZzGgegv3.d.ts

@@ -1,8 +0,0 @@
-import { P as PluginExtension } from './PluginExtension-B_oge2T3.js';
-
-interface WeslPluginOptions {
-    weslToml?: string;
-    extensions?: PluginExtension[];
-}
-
-export type { WeslPluginOptions as W };

package/dist/chunk-3YZCYXZ7.js

@@ -1,11 +0,0 @@
-import {
-  weslPlugin
-} from "./chunk-LHNI4JI3.js";
-
-// src/plugins/webpack.ts
-import { createWebpackPlugin } from "unplugin";
-var webpack_default = createWebpackPlugin(weslPlugin);
-
-export {
-  webpack_default
-};

package/dist/chunk-JSBRDJBE.js

@@ -1,30 +0,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 __commonJS = (cb, mod) => function __require() {
-  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 (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-export {
-  __commonJS,
-  __toESM
-};