@twick/vite-plugin 0.14.22 → 0.15.1

package/dist/index.cjs

@@ -0,0 +1,866 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PLUGIN_OPTIONS: () => PLUGIN_OPTIONS,
+  default: () => index_default,
+  isPlugin: () => isPlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/main.ts
+var import_path10 = __toESM(require("path"), 1);
+
+// src/partials/assets.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_stream = require("stream");
+var AUDIO_EXTENSION_REGEX = /\.(mp3|wav|ogg|aac|flac)(?:$|\?)/;
+var AUDIO_HMR_DELAY = 1e3;
+function assetsPlugin({ bufferedAssets }) {
+  let config;
+  return {
+    name: "twick:assets",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url && bufferedAssets && bufferedAssets.test(req.url)) {
+          const file = import_fs.default.readFileSync(
+            import_path.default.resolve(config.root, req.url.slice(1))
+          );
+          import_stream.Readable.from(file).pipe(res);
+          return;
+        }
+        next();
+      });
+    },
+    async handleHotUpdate(ctx) {
+      const urls = [];
+      const modules = [];
+      for (const module2 of ctx.modules) {
+        urls.push(module2.url);
+        if (!AUDIO_EXTENSION_REGEX.test(module2.url)) {
+          modules.push(module2);
+        } else {
+          await new Promise((resolve) => {
+            setTimeout(resolve, AUDIO_HMR_DELAY);
+          });
+        }
+      }
+      if (urls.length > 0) {
+        ctx.server.ws.send("twick:assets", { urls });
+      }
+      return modules;
+    }
+  };
+}
+
+// src/partials/editor.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function editorPlugin({ editor, projects }) {
+  const editorPath = import_path2.default.dirname(require.resolve(editor));
+  const editorFile = import_fs2.default.readFileSync(import_path2.default.resolve(editorPath, "editor.html"));
+  const htmlParts = editorFile.toString().replace("{{style}}", `/@fs/${import_path2.default.resolve(editorPath, "style.css")}`).split("{{source}}");
+  const createHtml = (src) => htmlParts[0] + src + htmlParts[1];
+  const resolvedEditorId = "\0virtual:editor";
+  return {
+    name: "twick:editor",
+    async load(id) {
+      const [, query] = id.split("?");
+      if (id.startsWith(resolvedEditorId)) {
+        if (projects.list.length === 1) {
+          return `import {editor} from '${editor}';
+import project from '${projects.list[0].url}';
+import {addEditorToProject} from '@twick/core';
+editor(await addEditorToProject(project));
+`;
+        }
+        if (query) {
+          const params = new URLSearchParams(query);
+          const name = params.get("project");
+          if (name && projects.lookup.has(name)) {
+            return `import {editor} from '${editor}';
+import project from '${projects.lookup.get(name).url}';
+import {addEditorToProject} from '@twick/core';
+editor(await addEditorToProject(project));
+`;
+          }
+        }
+        return `import {index} from '${editor}';
+index(${JSON.stringify(projects.list)});
+`;
+      }
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url) {
+          const url = new URL(req.url, `http://${req.headers.host}`);
+          if (url.pathname === "/") {
+            res.setHeader("Content-Type", "text/html");
+            res.end(createHtml("/@id/__x00__virtual:editor"));
+            return;
+          }
+          const name = url.pathname.slice(1);
+          if (name && projects.lookup.has(name)) {
+            res.setHeader("Content-Type", "text/html");
+            res.end(createHtml(`/@id/__x00__virtual:editor?project=${name}`));
+            return;
+          }
+        }
+        next();
+      });
+    }
+  };
+}
+
+// src/partials/ffmpegBridge.ts
+var import_ffmpeg = require("@twick/ffmpeg");
+var import_fs3 = require("fs");
+function ffmpegBridgePlugin({ output }) {
+  return {
+    name: "twick/ffmpeg",
+    configureServer(server) {
+      const ffmpegBridge = new FFmpegBridge(server.ws, { output });
+      const handlePostRequest = async (req, res, handler) => {
+        if (req.method !== "POST") {
+          res.statusCode = 405;
+          res.end("Method Not Allowed");
+          return;
+        }
+        try {
+          const body = await new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => data += chunk);
+            req.on("end", () => resolve(data));
+            req.on("error", reject);
+          });
+          const parsedBody = JSON.parse(body);
+          const result = await handler(parsedBody);
+          if (res.writableEnded) {
+            return;
+          }
+          res.statusCode = 200;
+          if (result) {
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(result));
+            return;
+          }
+          res.end("OK");
+        } catch (error) {
+          console.error("error in request handler", error);
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        }
+      };
+      server.middlewares.use(
+        "/audio-processing/generate-audio",
+        (req, res) => handlePostRequest(
+          req,
+          res,
+          async ({ tempDir, assets, startFrame, endFrame, fps }) => (0, import_ffmpeg.generateAudio)({
+            outputDir: output,
+            tempDir,
+            assets,
+            startFrame,
+            endFrame,
+            fps
+          })
+        )
+      );
+      server.middlewares.use(
+        "/audio-processing/merge-media",
+        (req, res) => handlePostRequest(
+          req,
+          res,
+          async ({ outputFilename, tempDir, format }) => (0, import_ffmpeg.mergeMedia)(outputFilename, output, tempDir, format)
+        )
+      );
+      server.middlewares.use(
+        "/twick-ffmpeg-decoder/video-frame",
+        (req, res) => handlePostRequest(req, res, async (data) => {
+          const { frame, width, height } = await ffmpegBridge.handleDecodeVideoFrame(data);
+          res.setHeader("X-Frame-Width", width.toString());
+          res.setHeader("X-Frame-Height", height.toString());
+          res.setHeader("Content-Type", "application/octet-stream");
+          res.end(Buffer.from(frame));
+        })
+      );
+      server.middlewares.use("/twick-ffmpeg-decoder/finished", (req, res) => {
+        handlePostRequest(req, res, async () => {
+          await ffmpegBridge.handleRenderFinished();
+        });
+      });
+      server.middlewares.use(
+        "/twick-ffmpeg-decoder/download-video-chunks",
+        (req, res) => handlePostRequest(req, res, async (videoDurations) => {
+          const downloadedPaths = await ffmpegBridge.handleDownloadVideoChunks(videoDurations);
+          return { success: true, paths: downloadedPaths };
+        })
+      );
+    }
+  };
+}
+var FFmpegBridge = class {
+  constructor(ws, config) {
+    this.ws = ws;
+    this.config = config;
+    this.process = null;
+    this.handleMessage = async ({ method, data }) => {
+      if (method === "start") {
+        try {
+          this.process = new import_ffmpeg.FFmpegExporterServer({
+            ...data,
+            ...this.config
+          });
+          this.respondSuccess(method, await this.process.start());
+        } catch (e) {
+          this.respondError(method, e?.message);
+        }
+        return;
+      }
+      if (!this.process) {
+        this.respondError(method, "The exporting process has not been started.");
+        return;
+      }
+      if (!(method in this.process)) {
+        this.respondError(method, `Unknown method: "${method}".`);
+        return;
+      }
+      try {
+        this.respondSuccess(method, await this.process[method](data));
+      } catch (e) {
+        this.respondError(method, e?.message);
+      }
+      if (method === "kill") {
+        this.process = null;
+        return;
+      }
+    };
+    // List of VideoFrameExtractors
+    this.videoFrameExtractors = /* @__PURE__ */ new Map();
+    ws.on("twick:ffmpeg-exporter", this.handleMessage);
+  }
+  respondSuccess(method, data = {}) {
+    this.ws.send("twick:ffmpeg-exporter-ack", {
+      status: "success",
+      method,
+      data
+    });
+  }
+  respondError(method, message = "Unknown error.") {
+    this.ws.send("twick:ffmpeg-exporter-ack", {
+      status: "error",
+      method,
+      message
+    });
+  }
+  async handleDownloadVideoChunks(videoDurations) {
+    const downloadPromises = videoDurations.map(
+      ({ src, startTime, endTime }) => import_ffmpeg.VideoFrameExtractor.downloadVideoChunk(src, startTime, endTime)
+    );
+    await Promise.all(downloadPromises);
+  }
+  async handleDecodeVideoFrame(data) {
+    const typedData = data;
+    const id = typedData.filePath + "-" + typedData.id;
+    let extractor = this.videoFrameExtractors.get(id);
+    const frameDuration = 1 / typedData.fps;
+    const isOldFrame = extractor && Math.abs(typedData.startTime - extractor.getLastTime()) < frameDuration / 2;
+    if (isOldFrame) {
+      const frame2 = extractor.getLastFrame();
+      return {
+        frame: frame2,
+        width: extractor.getWidth(),
+        height: extractor.getHeight()
+      };
+    }
+    if (extractor && typedData.startTime + frameDuration < extractor.getTime()) {
+      extractor.destroy();
+      this.videoFrameExtractors.delete(id);
+      extractor = void 0;
+    }
+    if (extractor && typedData.startTime > extractor.getTime() + frameDuration) {
+      extractor.destroy();
+      this.videoFrameExtractors.delete(id);
+      extractor = void 0;
+    }
+    if (!extractor) {
+      extractor = new import_ffmpeg.VideoFrameExtractor(
+        data.filePath,
+        data.startTime,
+        data.fps,
+        data.duration
+      );
+      this.videoFrameExtractors.set(id, extractor);
+    }
+    const frame = await extractor.popImage();
+    return {
+      frame,
+      width: extractor.getWidth(),
+      height: extractor.getHeight()
+    };
+  }
+  async handleRenderFinished() {
+    this.videoFrameExtractors.forEach((extractor) => {
+      extractor.destroy();
+      const localFile = import_ffmpeg.VideoFrameExtractor.downloadedVideoMap.get(
+        extractor.filePath
+      )?.localPath;
+      if (localFile && (0, import_fs3.existsSync)(localFile)) {
+        (0, import_fs3.unlinkSync)(localFile);
+      }
+    });
+    this.videoFrameExtractors.clear();
+  }
+};
+
+// src/partials/imageExporter.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var import_mime_types = __toESM(require("mime-types"), 1);
+var import_path3 = __toESM(require("path"), 1);
+
+// src/openInExplorer.ts
+var import_child_process = require("child_process");
+var import_os = require("os");
+function openInExplorer(file) {
+  let command = null;
+  let args = [file];
+  const os3 = (0, import_os.platform)();
+  switch (os3) {
+    case "win32":
+      command = "explorer";
+      break;
+    case "linux":
+      if (isRunningOnWSL()) {
+        command = "bash";
+        args = ["-c", `cd ${file} && explorer.exe .`];
+      } else {
+        command = "xdg-open";
+      }
+      break;
+    case "darwin":
+      command = "open";
+      break;
+  }
+  if (command) {
+    (0, import_child_process.spawn)(command, args, { detached: true }).unref();
+  } else {
+    console.warn(`Unsupported OS: ${os3}`);
+  }
+}
+function isRunningOnWSL() {
+  try {
+    const uname = (0, import_child_process.execSync)("uname -a").toString().toLowerCase();
+    return uname.includes("microsoft");
+  } catch (error) {
+    console.error(`exec error: ${error}`);
+    return false;
+  }
+}
+
+// src/partials/imageExporter.ts
+function exporterPlugin({ outputPath }) {
+  return {
+    name: "twick:exporter",
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url === "/__open-output-path") {
+          if (!import_fs4.default.existsSync(outputPath)) {
+            import_fs4.default.mkdirSync(outputPath, { recursive: true });
+          }
+          openInExplorer(outputPath);
+          res.end();
+          return;
+        }
+        next();
+      });
+      server.ws.on(
+        "twick:export",
+        async ({ data, frame, sceneFrame, subDirectories, mimeType, groupByScene }, client) => {
+          const name = (groupByScene ? sceneFrame : frame).toString().padStart(6, "0");
+          const extension = import_mime_types.default.extension(mimeType);
+          const outputFilePath = import_path3.default.join(
+            outputPath,
+            ...subDirectories,
+            `${name}.${extension}`
+          );
+          const outputDirectory = import_path3.default.dirname(outputFilePath);
+          if (!import_fs4.default.existsSync(outputDirectory)) {
+            import_fs4.default.mkdirSync(outputDirectory, { recursive: true });
+          }
+          const base64Data = data.slice(data.indexOf(",") + 1);
+          await import_fs4.default.promises.writeFile(outputFilePath, base64Data, {
+            encoding: "base64"
+          });
+          client.send("twick:export-ack", { frame });
+        }
+      );
+    }
+  };
+}
+
+// src/partials/meta.ts
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+function metaPlugin() {
+  const timeStamps = {};
+  let config;
+  return {
+    name: "twick:meta",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code, id) {
+      const [base] = id.split("?");
+      const { name, ext } = import_path4.default.posix.parse(base);
+      if (ext !== ".meta") {
+        return;
+      }
+      const sourceFile = config.command === "build" ? false : JSON.stringify(id);
+      return `import {MetaFile} from '@twick/core';
+let meta;
+if (import.meta.hot) {
+  meta = import.meta.hot.data.meta;
+}
+meta ??= new MetaFile('${name}', ${sourceFile});
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.data.meta = meta;
+}
+meta.loadData(${code});
+export default meta;
+`;
+    },
+    configureServer(server) {
+      server.ws.on("twick:meta", async ({ source, data }, client) => {
+        if (source.startsWith("\0")) {
+          return;
+        }
+        timeStamps[source] = Date.now();
+        if (!process.env.DONT_WRITE_TO_META_FILES) {
+          await import_fs5.default.promises.writeFile(
+            source,
+            JSON.stringify(data, void 0, 2),
+            "utf8"
+          );
+        }
+        client.send("twick:meta-ack", { source });
+      });
+    },
+    handleHotUpdate(ctx) {
+      const now = Date.now();
+      const modules = [];
+      for (const module2 of ctx.modules) {
+        if (module2.file !== null && timeStamps[module2.file] && timeStamps[module2.file] + 1e3 > now) {
+          continue;
+        }
+        modules.push(module2);
+      }
+      return modules;
+    }
+  };
+}
+
+// src/partials/metrics.ts
+var import_telemetry = require("@twick/telemetry");
+function metricsPlugin() {
+  return {
+    name: "twick:metrics",
+    async configResolved() {
+      (0, import_telemetry.sendEvent)(import_telemetry.EventName.ServerStarted);
+    }
+  };
+}
+
+// src/partials/projects.ts
+function projectsPlugin({
+  buildForEditor,
+  projects
+}) {
+  return {
+    name: "twick:project",
+    config(config) {
+      return {
+        build: {
+          target: buildForEditor ? "esnext" : "modules",
+          assetsDir: "./",
+          rollupOptions: {
+            preserveEntrySignatures: "strict",
+            input: Object.fromEntries(
+              projects.list.map((project) => [project.name, project.url])
+            )
+          }
+        },
+        server: {
+          port: config?.server?.port ?? 9e3
+        },
+        esbuild: {
+          jsx: "automatic",
+          jsxImportSource: "@twick/2d/lib"
+        },
+        optimizeDeps: {
+          entries: projects.list.map((project) => project.url),
+          exclude: ["preact", "preact/*", "@preact/signals"]
+        }
+      };
+    }
+  };
+}
+
+// src/partials/rive.ts
+var fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_stream2 = require("stream");
+async function getRiveWasmPath() {
+  try {
+    const packageJsonPath = require.resolve("@rive-app/canvas-advanced/package.json");
+    const packageDir = import_path5.default.dirname(packageJsonPath);
+    const wasmPath = import_path5.default.join(packageDir, "rive.wasm");
+    await fs5.promises.access(wasmPath, fs5.constants.F_OK);
+    return wasmPath;
+  } catch (error) {
+    console.error("Error finding Rive WASM file:", error);
+    throw new Error("Could not find Rive WASM file");
+  }
+}
+function rivePlugin() {
+  return {
+    name: "twick:rive-wasm",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url && req.url === "/@rive-wasm") {
+          try {
+            const wasmPath = await getRiveWasmPath();
+            const file = await fs5.promises.readFile(wasmPath);
+            res.setHeader("Content-Type", "application/wasm");
+            import_stream2.Readable.from(file).pipe(res);
+          } catch (error) {
+            console.error("Error serving Rive WASM file:", error);
+            res.statusCode = 500;
+            res.end("Error serving Rive WASM file");
+          }
+          return;
+        }
+        next();
+      });
+    }
+  };
+}
+
+// src/partials/settings.ts
+var import_fs6 = __toESM(require("fs"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var import_path6 = __toESM(require("path"), 1);
+function settingsPlugin() {
+  const settingsId = "virtual:settings.meta";
+  const resolvedSettingsId = "\0" + settingsId;
+  const settingsPath = import_path6.default.resolve(import_os2.default.homedir(), ".twick/settings.json");
+  const outputDirectory = import_path6.default.dirname(settingsPath);
+  return {
+    name: "twick:settings",
+    resolveId(id) {
+      if (id === settingsId) {
+        return resolvedSettingsId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedSettingsId) {
+        let parsed = {};
+        try {
+          parsed = JSON.parse(await import_fs6.default.promises.readFile(settingsPath, "utf8"));
+        } catch (_) {
+        }
+        return JSON.stringify(parsed);
+      }
+    },
+    configureServer(server) {
+      server.ws.on("twick:meta", async ({ source, data }, client) => {
+        if (source !== resolvedSettingsId) {
+          return;
+        }
+        await import_fs6.default.promises.mkdir(outputDirectory, { recursive: true });
+        const newData = JSON.stringify(data, void 0, 2);
+        let oldData = "";
+        try {
+          oldData = await import_fs6.default.promises.readFile(settingsPath, "utf8");
+        } catch (_) {
+        }
+        if (oldData !== newData) {
+          await Promise.all([
+            import_fs6.default.promises.writeFile(settingsPath, newData, "utf8"),
+            // Invalidate the module so that the settings are up-to-date next
+            // time the browser is refreshed.
+            server.moduleGraph.getModuleByUrl(source).then((module2) => {
+              if (module2) {
+                server.moduleGraph.invalidateModule(module2);
+              }
+            })
+          ]);
+        }
+        client.send("twick:meta-ack", { source });
+      });
+    }
+  };
+}
+
+// src/partials/wasmExporter.ts
+var import_formidable = require("formidable");
+var fs7 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_stream3 = require("stream");
+function wasmExporterPlugin() {
+  return {
+    name: "twick:mp4-wasm",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url && req.url === "/@mp4-wasm") {
+          const pathNew = import_path7.default.dirname(require.resolve("mp4-wasm"));
+          const filePath = import_path7.default.resolve(pathNew, "mp4.wasm");
+          const file = await fs7.promises.readFile(filePath);
+          res.setHeader("Content-Type", "application/wasm");
+          import_stream3.Readable.from(file).pipe(res);
+          return;
+        }
+        next();
+      });
+      server.middlewares.use("/uploadVideoFile", async (req, res) => {
+        if (req.method === "POST") {
+          const form = new import_formidable.IncomingForm({ maxFileSize: 1024 * 1024 * 1024 * 10 });
+          form.parse(req, async (err, fields, files) => {
+            if (err) {
+              console.error("Error parsing form:", err);
+              res.statusCode = 500;
+              res.end();
+              return;
+            }
+            try {
+              const tempDir = fields.tempDir[0];
+              const file = files.file[0];
+              const outputPath = import_path7.default.join(os2.tmpdir(), tempDir, "visuals.mp4");
+              const writeStream = fs7.createWriteStream(outputPath);
+              await new Promise((resolve, reject) => {
+                fs7.createReadStream(file.filepath).pipe(writeStream).on("finish", resolve).on("error", reject);
+              });
+              res.statusCode = 200;
+              res.end();
+            } catch (err2) {
+              console.error("Error uploading video:", err2);
+              res.statusCode = 500;
+              res.end();
+            }
+          });
+        }
+      });
+    }
+  };
+}
+
+// src/partials/webgl.ts
+var import_fs7 = __toESM(require("fs"), 1);
+var import_path8 = __toESM(require("path"), 1);
+var import_source_map = require("source-map");
+var import_vite = require("vite");
+var GLSL_EXTENSION_REGEX = /\.glsl(?:$|\?)/;
+var INCLUDE_REGEX = /^#include "([^"]+)"/;
+function webglPlugin() {
+  let config;
+  return {
+    name: "twick:webgl",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code, id) {
+      if (!GLSL_EXTENSION_REGEX.test(id)) {
+        return;
+      }
+      const [base, query] = id.split("?");
+      const { dir } = import_path8.default.posix.parse(base);
+      const params = new URLSearchParams(query);
+      if (params.has("raw")) {
+        return;
+      }
+      const context = {
+        rootDir: dir,
+        fileStack: [],
+        includeMap: /* @__PURE__ */ new Map(),
+        watchFile: (file) => this.addWatchFile(file),
+        resolve: async (source, importer) => {
+          const resolved = await this.resolve(source, importer);
+          return resolved?.id;
+        }
+      };
+      const glslSource = await resolveGlsl(context, id, code);
+      const sourceUrl = (0, import_vite.normalizePath)(import_path8.default.relative(config.root, base));
+      const result = glslSource.toStringWithSourceMap();
+      const map = result.map.toJSON();
+      map.includeMap = Object.fromEntries(context.includeMap);
+      return {
+        map,
+        code: `export default \`${result.code}
+//# sourceURL=${sourceUrl}\`;`
+      };
+    }
+  };
+}
+async function resolveGlsl(context, id, code) {
+  const lines = code.split(/\r?\n/);
+  const source = new import_source_map.SourceNode(1, 0, "", "");
+  if (context.fileStack.includes(id)) {
+    throw new Error(
+      `Circular dependency detected: ${context.fileStack.join(" -> ")}`
+    );
+  }
+  context.fileStack.push(id);
+  const sourceMapId = import_path8.default.posix.relative(context.rootDir, id);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(INCLUDE_REGEX);
+    if (match) {
+      const childId = await context.resolve(match[1], id);
+      if (!childId) {
+        continue;
+      }
+      const childSourceMapId = import_path8.default.posix.relative(context.rootDir, childId);
+      if (context.includeMap.has(childSourceMapId)) {
+        continue;
+      }
+      context.includeMap.set(childSourceMapId, [sourceMapId, i + 1]);
+      context.watchFile(childId);
+      const childCode = await import_fs7.default.promises.readFile(childId, "utf-8");
+      source.add(await resolveGlsl(context, childId, childCode));
+    } else {
+      let j = 0;
+      for (; j < line.length; j++) {
+        source.add(new import_source_map.SourceNode(i + 1, j, sourceMapId, line[j]));
+      }
+      source.add(new import_source_map.SourceNode(i + 1, j, sourceMapId, "\n"));
+    }
+  }
+  context.fileStack.pop();
+  return source;
+}
+
+// src/plugins.ts
+var PLUGIN_OPTIONS = /* @__PURE__ */ Symbol.for("@twick/vite-plugin/PLUGIN_OPTIONS");
+function isPlugin(value) {
+  return value && typeof value === "object" && PLUGIN_OPTIONS in value;
+}
+
+// src/utils.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
+function getProjects(project) {
+  const list = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const projectList = expandFilePaths(project);
+  for (const url of projectList) {
+    const { name, dir } = import_path9.default.posix.parse(url);
+    const metaFile = `${name}.meta`;
+    const metaData = getMeta(import_path9.default.join(dir, metaFile));
+    const data = { name: metaData?.name ?? name, fileName: name, url };
+    list.push(data);
+    lookup.set(data.name, data);
+  }
+  return { list, lookup };
+}
+function expandFilePaths(filePaths) {
+  const expandedFilePaths = [];
+  for (const filePath of typeof filePaths === "string" ? [filePaths] : filePaths) {
+    if (import_fast_glob.default.isDynamicPattern(filePath)) {
+      const matchingFilePaths = import_fast_glob.default.sync(filePath, { onlyFiles: true });
+      expandedFilePaths.push(...matchingFilePaths);
+    } else {
+      expandedFilePaths.push(filePath);
+    }
+  }
+  return expandedFilePaths;
+}
+function getMeta(metaPath) {
+  if (import_fs8.default.existsSync(metaPath)) {
+    return JSON.parse(import_fs8.default.readFileSync(metaPath, "utf8"));
+  }
+}
+
+// src/main.ts
+var main_default = ({
+  project = "./src/project.ts",
+  output = "./output",
+  bufferedAssets = /^$/,
+  editor = "@twick/ui",
+  buildForEditor
+} = {}) => {
+  const plugins = [];
+  const outputPath = import_path10.default.resolve(output);
+  const projects = getProjects(project);
+  return [
+    {
+      name: "twick",
+      async configResolved(resolvedConfig) {
+        plugins.push(
+          ...resolvedConfig.plugins.filter(isPlugin).map((plugin) => plugin[PLUGIN_OPTIONS])
+        );
+        await Promise.all(
+          plugins.map(
+            (plugin) => plugin.config?.({
+              output: outputPath,
+              projects: projects.list
+            })
+          )
+        );
+      }
+    },
+    metaPlugin(),
+    settingsPlugin(),
+    exporterPlugin({ outputPath }),
+    ffmpegBridgePlugin({ output: outputPath }),
+    editorPlugin({ editor, projects }),
+    projectsPlugin({ projects, plugins, buildForEditor }),
+    assetsPlugin({ bufferedAssets }),
+    wasmExporterPlugin(),
+    rivePlugin(),
+    webglPlugin(),
+    metricsPlugin()
+  ];
+};
+
+// src/index.ts
+var index_default = main_default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLUGIN_OPTIONS,
+  isPlugin
+});
+//# sourceMappingURL=index.cjs.map