@inspecto-dev/plugin 0.2.0-alpha.0

package/dist/legacy/rspack/index.js

@@ -0,0 +1,668 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/server/index.ts
+import http from "http";
+import fs3 from "fs";
+import path4 from "path";
+import os2 from "os";
+import { execSync, execFileSync } from "child_process";
+import portfinder from "portfinder";
+import { launchIDE } from "launch-ide";
+
+// src/server/snippet.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import * as parser from "@babel/parser";
+import traverse_ from "@babel/traverse";
+var traverse = typeof traverse_ === "function" ? traverse_ : traverse_.default || traverse_;
+var snippetCache = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_LINES = 100;
+var DEFAULT_CONTEXT_LINES_BEFORE = 5;
+async function extractSnippet(req) {
+  const { file, line, column, maxLines = DEFAULT_MAX_LINES } = req;
+  const absolutePath = path2.resolve(file);
+  let stat;
+  try {
+    stat = await fs.promises.stat(absolutePath);
+  } catch {
+    throw new Error(`FILE_NOT_FOUND: ${absolutePath}`);
+  }
+  const mtime = stat.mtimeMs;
+  let lines;
+  const cached = snippetCache.get(absolutePath);
+  if (cached && cached.mtime === mtime) {
+    lines = cached.lines;
+  } else {
+    const source = await fs.promises.readFile(absolutePath, "utf-8");
+    lines = source.split("\n");
+    snippetCache.set(absolutePath, { mtime, lines });
+  }
+  let snippetLines;
+  let startLine;
+  let componentName;
+  try {
+    const result = extractComponentBoundary(lines.join("\n"), line, column, maxLines);
+    snippetLines = result.lines;
+    startLine = result.startLine;
+    componentName = result.name;
+  } catch {
+    const before = Math.max(0, line - 1 - DEFAULT_CONTEXT_LINES_BEFORE);
+    const after = Math.min(lines.length, before + maxLines);
+    snippetLines = lines.slice(before, after);
+    startLine = before + 1;
+  }
+  if (snippetLines.length > maxLines) {
+    snippetLines = snippetLines.slice(0, maxLines);
+  }
+  return {
+    snippet: snippetLines.join("\n"),
+    startLine,
+    file: absolutePath,
+    ...componentName ? { name: componentName } : {}
+  };
+}
+function extractComponentBoundary(source, targetLine, _targetColumn, maxLines) {
+  const ast = parser.parse(source, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript", "decorators-legacy", "classProperties"],
+    errorRecovery: true
+  });
+  const allLines = source.split("\n");
+  let bestStart = 0;
+  let bestEnd = allLines.length - 1;
+  let bestName;
+  traverse(ast, {
+    "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ClassMethod"(nodePath) {
+      const node = nodePath.node;
+      if (!node.loc) return;
+      const nodeStart = node.loc.start.line;
+      const nodeEnd = node.loc.end.line;
+      if (targetLine < nodeStart || targetLine > nodeEnd) return;
+      if (nodeEnd - nodeStart < bestEnd - bestStart) {
+        bestStart = nodeStart - 1;
+        bestEnd = nodeEnd - 1;
+        bestName = extractFunctionName(nodePath);
+      }
+    }
+  });
+  let sliceStart = bestStart;
+  let sliceEnd = bestEnd + 1;
+  if (sliceEnd - sliceStart > maxLines) {
+    const targetIdx = targetLine - 1;
+    sliceStart = Math.max(bestStart, targetIdx - Math.floor(maxLines / 3));
+    sliceEnd = sliceStart + maxLines;
+    if (sliceEnd > bestEnd + 1) {
+      sliceEnd = bestEnd + 1;
+      sliceStart = Math.max(0, sliceEnd - maxLines);
+    }
+  }
+  return {
+    lines: allLines.slice(sliceStart, sliceEnd),
+    startLine: sliceStart + 1,
+    ...bestName ? { name: bestName } : {}
+  };
+}
+function extractFunctionName(nodePath) {
+  const node = nodePath.node;
+  if (node.type === "FunctionDeclaration" && node.id) {
+    return node.id.name;
+  }
+  const parent = nodePath.parent;
+  if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  if (node.type === "ClassMethod" && node.key.type === "Identifier") {
+    return node.key.name;
+  }
+  return void 0;
+}
+
+// src/config.ts
+import fs2 from "fs";
+import path3 from "path";
+import os from "os";
+import { createDefu } from "defu";
+import { DEFAULT_TOOL_MODE, VALID_MODES } from "@inspecto-dev/types";
+var loadedConfig = null;
+var loadedPrompts = null;
+var isWatching = false;
+var arrayReplaceMerge = createDefu((obj, key, val) => {
+  if (Array.isArray(val)) {
+    obj[key] = val;
+    return true;
+  }
+});
+function resolveConfigRoots(cwd, gitRoot) {
+  const roots = [];
+  let current = cwd;
+  const isUnderOrEqual = current === gitRoot || current.startsWith(gitRoot + path3.sep);
+  if (!isUnderOrEqual) {
+    if (fs2.existsSync(path3.join(cwd, ".inspecto"))) roots.push(cwd);
+    return roots;
+  }
+  while (true) {
+    if (fs2.existsSync(path3.join(current, ".inspecto"))) {
+      roots.push(current);
+    }
+    if (current === gitRoot) break;
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return roots;
+}
+function loadUserConfigSync(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedConfig && !force) return loadedConfig;
+  loadedConfig = null;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    layers.push(readJsonSafely(path3.join(root, ".inspecto", "settings.local.json")));
+    layers.push(readJsonSafely(path3.join(root, ".inspecto", "settings.json")));
+  }
+  layers.push(readJsonSafely(path3.join(os.homedir(), ".inspecto", "settings.json")));
+  layers.push({ providers: {} });
+  const validLayers = layers.filter((l) => l !== null);
+  loadedConfig = arrayReplaceMerge(...validLayers);
+  return loadedConfig;
+}
+async function loadPromptsConfig(force = false, cwd = process.cwd(), gitRoot) {
+  if (loadedPrompts && !force) return loadedPrompts;
+  const layers = [];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    const localPath = path3.join(root, ".inspecto", "prompts.local.json");
+    const jsonPath = path3.join(root, ".inspecto", "prompts.json");
+    layers.push(readJsonSafely(localPath));
+    layers.push(readJsonSafely(jsonPath));
+  }
+  layers.push(readJsonSafely(path3.join(os.homedir(), ".inspecto", "prompts.json")));
+  let finalPrompts = [];
+  for (const layer of layers) {
+    if (Array.isArray(layer) && layer.length > 0) {
+      finalPrompts = layer;
+      break;
+    }
+    if (layer && typeof layer === "object" && layer.$replace === true && Array.isArray(layer.items)) {
+      finalPrompts = layer;
+      break;
+    }
+  }
+  loadedPrompts = finalPrompts;
+  return loadedPrompts;
+}
+function readJsonSafely(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      const content = fs2.readFileSync(filePath, "utf-8").trim();
+      if (!content) return null;
+      const parsed = JSON.parse(content);
+      if (!Array.isArray(parsed) && parsed.prompts && Array.isArray(parsed.prompts)) {
+        return parsed.prompts;
+      }
+      return parsed;
+    }
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      console.warn(`[inspecto] Failed to parse config at ${filePath}: Invalid JSON`);
+    } else {
+      console.warn(`[inspecto] Failed to read config at ${filePath}:`, e);
+    }
+  }
+  return null;
+}
+function resolveTargetTool(config) {
+  if (config.prefer) {
+    return config.prefer;
+  }
+  if (config.providers && Object.keys(config.providers).length > 0) {
+    return Object.keys(config.providers)[0];
+  }
+  return "github-copilot";
+}
+function resolveToolMode(tool, ide, config) {
+  let requestedType = void 0;
+  if (config.providers && config.providers[tool] && config.providers[tool].type) {
+    const type = config.providers[tool].type;
+    if (type === "plugin" || type === "cli") {
+      requestedType = type;
+    }
+  }
+  requestedType = requestedType ?? DEFAULT_TOOL_MODE[tool];
+  const valid = VALID_MODES[tool] || [DEFAULT_TOOL_MODE[tool]];
+  return requestedType && valid.includes(requestedType) ? requestedType : valid[0];
+}
+function extractToolOverrides(ide, config) {
+  const result = {};
+  if (!config.providers) return result;
+  for (const [tool, cfg] of Object.entries(config.providers)) {
+    if (!cfg) continue;
+    const overrides = {
+      type: cfg.type || DEFAULT_TOOL_MODE[tool] || "plugin"
+    };
+    if (cfg.bin) overrides.binaryPath = cfg.bin;
+    if (cfg.args) overrides.args = cfg.args;
+    if (cfg.cwd) overrides.cwd = cfg.cwd;
+    if (cfg.autoSend !== void 0) overrides.autoSend = cfg.autoSend;
+    result[tool] = overrides;
+  }
+  return result;
+}
+var watchers = [];
+function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
+  if (isWatching) return;
+  isWatching = true;
+  const watchDirs = [path3.join(os.homedir(), ".inspecto")];
+  const roots = resolveConfigRoots(cwd, gitRoot ?? cwd);
+  for (const root of roots) {
+    watchDirs.push(path3.join(root, ".inspecto"));
+  }
+  const CONFIG_FILES = /* @__PURE__ */ new Set([
+    "settings.json",
+    "settings.local.json",
+    "prompts.json",
+    "prompts.local.json"
+  ]);
+  for (const dir of watchDirs) {
+    if (!fs2.existsSync(dir)) continue;
+    try {
+      const watcher = fs2.watch(dir, async (eventType, filename) => {
+        if (!filename || !CONFIG_FILES.has(filename)) return;
+        loadedConfig = null;
+        loadedPrompts = null;
+        loadUserConfigSync(true, cwd, gitRoot);
+        await loadPromptsConfig(true, cwd, gitRoot);
+        onReload();
+      });
+      watcher.unref();
+      watchers.push(watcher);
+    } catch (e) {
+    }
+  }
+}
+
+// src/server/index.ts
+var serverState = {
+  port: null,
+  running: false,
+  projectRoot: "",
+  configRoot: "",
+  cwd: process.cwd()
+};
+var serverInstance = null;
+function resolveProjectRoot() {
+  let gitRoot;
+  try {
+    gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  } catch {
+    gitRoot = process.cwd();
+  }
+  let current = gitRoot;
+  while (true) {
+    if (fs3.existsSync(path4.join(current, ".inspecto"))) return current;
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return gitRoot;
+}
+function launchURI(uri) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [uri]);
+    } else if (process.platform === "win32") {
+      execFileSync("cmd", ["/c", "start", '""', uri]);
+    } else {
+      execFileSync("xdg-open", [uri]);
+    }
+  } catch (e) {
+    console.error("[inspecto] Failed to launch URI via execFileSync, falling back to launchIDE:", e);
+    launchIDE({ file: uri });
+  }
+}
+async function startServer() {
+  if (serverState.running && serverState.port !== null) {
+    return serverState.port;
+  }
+  serverState.projectRoot = resolveProjectRoot();
+  serverState.configRoot = serverState.projectRoot;
+  serverState.cwd = process.cwd();
+  portfinder.basePort = 5678;
+  const port = await portfinder.getPortPromise();
+  watchConfig(
+    () => {
+      console.log("[inspecto] user config reloaded.");
+    },
+    serverState.cwd,
+    serverState.configRoot
+  );
+  serverInstance = http.createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    handleRequest(url, req, res).catch((err) => {
+      console.error("[inspecto] server error:", err);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(err) }));
+    });
+  });
+  await new Promise((resolve2, reject) => {
+    serverInstance.listen(port, "127.0.0.1", () => {
+      serverInstance.unref();
+      resolve2();
+    });
+    serverInstance.once("error", reject);
+  });
+  serverInstance.on("error", (err) => {
+    console.error("[inspecto] persistent server error:", err);
+  });
+  serverState.port = port;
+  serverState.running = true;
+  const portFile = path4.join(os2.tmpdir(), "inspecto.port");
+  try {
+    fs3.writeFileSync(portFile, String(port), "utf-8");
+  } catch {
+  }
+  process.once("exit", () => {
+    try {
+      fs3.unlinkSync(portFile);
+    } catch {
+    }
+  });
+  console.log(`[inspecto] server running at http://127.0.0.1:${port}`);
+  return port;
+}
+async function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function handleRequest(url, req, res) {
+  const pathname = url.pathname;
+  if (pathname === "/health" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, port: serverState.port }));
+    return;
+  }
+  if (pathname === "/config" && req.method === "GET") {
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const promptsConfig = await loadPromptsConfig(false, serverState.cwd, serverState.configRoot);
+    const effectiveIde = userConfig.ide ?? "vscode";
+    let info;
+    if (!serverState.ideInfo) {
+      const fallbackTargets = userConfig.providers ? Object.keys(userConfig.providers) : ["claude-code", "gemini", "coco", "codex"];
+      info = {
+        ide: effectiveIde,
+        providers: fallbackTargets.reduce(
+          (acc, target) => {
+            acc[target] = {
+              mode: resolveToolMode(target, effectiveIde, userConfig),
+              installed: false
+            };
+            return acc;
+          },
+          {}
+        )
+      };
+    } else {
+      const { scheme: _scheme, ...rest } = serverState.ideInfo;
+      info = rest;
+    }
+    const resolvedProviders = { ...info.providers };
+    for (const tool in resolvedProviders) {
+      resolvedProviders[tool].mode = resolveToolMode(tool, info.ide, userConfig);
+    }
+    const config = {
+      ...info,
+      providers: resolvedProviders,
+      providerOverrides: extractToolOverrides(info.ide, userConfig),
+      prompts: promptsConfig,
+      hotKeys: userConfig.hotKeys,
+      includeSnippet: userConfig.includeSnippet
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(config));
+    return;
+  }
+  if (pathname === "/config" && req.method === "POST") {
+    try {
+      const body = JSON.parse(await readBody(req));
+      serverState.ideInfo = body;
+      console.log(`[inspecto] Received IDE info from extension:`, body);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true }));
+    } catch (e) {
+      console.error("[inspecto] Error parsing /config POST request:", e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === "/open" && req.method === "POST") {
+    let body;
+    try {
+      body = JSON.parse(await readBody(req));
+    } catch (e) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON body" }));
+      return;
+    }
+    const absolutePath = path4.isAbsolute(body.file) ? body.file : path4.resolve(serverState.cwd, body.file);
+    const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+    const ide = userConfig.ide ?? "vscode";
+    const editorHint = "code";
+    launchIDE({
+      file: absolutePath,
+      line: body.line,
+      column: body.column,
+      editor: editorHint,
+      type: process.platform === "darwin" ? "open" : "exec"
+    });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true }));
+    return;
+  }
+  if (pathname === "/snippet" && req.method === "GET") {
+    const file = url.searchParams.get("file") ?? "";
+    const line = parseInt(url.searchParams.get("line") ?? "1", 10);
+    const column = parseInt(url.searchParams.get("column") ?? "1", 10);
+    const maxLines = parseInt(url.searchParams.get("maxLines") ?? "100", 10);
+    try {
+      const absolutePath = path4.isAbsolute(file) ? file : path4.resolve(serverState.cwd, file);
+      const result = await extractSnippet({ file: absolutePath, line, column, maxLines });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      const message = String(err.message || err);
+      const errorCode = message.startsWith("FILE_NOT_FOUND") ? "FILE_NOT_FOUND" : "UNKNOWN";
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: message, errorCode }));
+    }
+    return;
+  }
+  if (pathname === "/send-to-ai" && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      const result = await dispatchToAi(body);
+      res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (e) {
+      console.error("[inspecto] Error parsing /send-to-ai request:", e);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: String(e), errorCode: "INTERNAL_ERROR" }));
+    }
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "not found" }));
+}
+async function dispatchToAi(req) {
+  const { location, snippet, prompt } = req;
+  const userConfig = loadUserConfigSync(false, serverState.cwd, serverState.configRoot);
+  const ide = userConfig.ide ?? "vscode";
+  const resolvedTarget = resolveTargetTool(userConfig);
+  const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
+
+\`\`\`
+${snippet}
+\`\`\`
+`;
+  const params = new URLSearchParams();
+  params.set("target", resolvedTarget);
+  const overrides = extractToolOverrides(ide, userConfig)[resolvedTarget];
+  if (overrides) {
+    params.set("overrides", JSON.stringify(overrides));
+  }
+  params.set("prompt", formattedPrompt);
+  params.set("file", location.file);
+  params.set("line", String(location.line));
+  params.set("col", String(location.column));
+  params.set("snippet", snippet);
+  const scheme = serverState.ideInfo?.scheme || "vscode";
+  const uri = `${scheme}://inspecto.inspecto/send?${params.toString()}`;
+  console.log(`[inspecto] dispatchToAi: Generated URI: ${uri}`);
+  launchURI(uri);
+  return { success: true };
+}
+
+// src/injectors/utils.ts
+import { createRequire } from "module";
+var resolveClientModule = () => {
+  try {
+    return createRequire(import.meta.url).resolve("@inspecto-dev/core");
+  } catch {
+    try {
+      return __require.resolve("@inspecto-dev/core");
+    } catch {
+      console.warn("[inspecto] Could not resolve @inspecto-dev/core \u2014 falling back to bare specifier");
+      return "@inspecto-dev/core";
+    }
+  }
+};
+
+// src/injectors/webpack.ts
+function getWebpackHtmlScript(serverPort2) {
+  return `
+window.__AI_INSPECTOR_PORT__ = ${serverPort2};
+window.addEventListener('load', () => {
+  if (window.InspectoClient) {
+    window.InspectoClient.mountInspector({
+      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+    });
+  }
+});
+`;
+}
+
+// src/legacy/rspack/index.ts
+import path5 from "path";
+var _dirname = typeof __dirname !== "undefined" ? __dirname : __dirname;
+var DEFAULT_OPTIONS = {
+  include: [],
+  exclude: [],
+  escapeTags: [],
+  pathType: "absolute",
+  attributeName: "data-inspecto"
+};
+var serverPort = null;
+var ensureServer = async () => {
+  if (serverPort === null) {
+    serverPort = await startServer();
+  }
+  return serverPort;
+};
+var InspectoRspackLegacyPlugin = class {
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  apply(compiler) {
+    if (process.env["NODE_ENV"] === "production") return;
+    compiler.hooks.beforeCompile.tapPromise("inspecto-overlay", async () => {
+      await ensureServer().catch(console.error);
+    });
+    const clientPath = resolveClientModule();
+    new compiler.webpack.EntryPlugin(compiler.context, clientPath, {}).apply(compiler);
+    compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
+      const HtmlRspackPlugin = compiler.options.plugins.find(
+        (p) => p && p.constructor && p.constructor.name === "HtmlRspackPlugin"
+      );
+      if (HtmlRspackPlugin && HtmlRspackPlugin.constructor.getHooks) {
+        const hooks = HtmlRspackPlugin.constructor.getHooks(compilation);
+        hooks.alterAssetTagGroups.tapPromise("inspecto-overlay", async (data) => {
+          const port = await ensureServer();
+          data.headTags.unshift({
+            tagName: "script",
+            voidTag: false,
+            meta: { plugin: "inspecto-overlay" },
+            innerHTML: getWebpackHtmlScript(port)
+          });
+          return data;
+        });
+      } else {
+        compilation.hooks.processAssets.tapPromise(
+          {
+            name: "inspecto-overlay",
+            stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
+          },
+          async (assets) => {
+            const port = await ensureServer();
+            const scriptTag = `<script>${getWebpackHtmlScript(port)}</script>`;
+            for (const filename of Object.keys(assets)) {
+              if (filename.endsWith(".html")) {
+                const source = assets[filename].source();
+                if (typeof source === "string") {
+                  const newSource = source.replace("</head>", `${scriptTag}</head>`);
+                  assets[filename] = new compiler.webpack.sources.RawSource(newSource);
+                } else if (Buffer.isBuffer(source)) {
+                  const sourceStr = source.toString("utf-8");
+                  const newSource = sourceStr.replace("</head>", `${scriptTag}</head>`);
+                  assets[filename] = new compiler.webpack.sources.RawSource(newSource);
+                }
+              }
+            }
+          }
+        );
+      }
+    });
+    const loaderPath = path5.resolve(_dirname, "./loader.cjs");
+    compiler.options.module.rules.push({
+      test: /\.[jt]sx?$/,
+      use: [
+        {
+          loader: loaderPath,
+          options: this.options
+        }
+      ]
+    });
+  }
+};
+var rspackPlugin = (options) => new InspectoRspackLegacyPlugin(options);
+var rspack_default = rspackPlugin;
+export {
+  InspectoRspackLegacyPlugin,
+  rspack_default as default,
+  rspackPlugin
+};
+//# sourceMappingURL=index.js.map