adtec-core-package 3.0.0 → 3.0.2

package/vite/umoIntegration.js

@@ -0,0 +1,661 @@
+// vite/highlightJsLibVirtual.ts
+import fs from "node:fs";
+import path from "node:path";
+import { transformWithEsbuild } from "vite";
+
+// vite/projectRoot.ts
+var projectRoot = process.cwd();
+function getProjectRoot() {
+  return projectRoot;
+}
+function createProjectRootPlugin() {
+  return {
+    name: "core-umo-project-root",
+    configResolved(config) {
+      projectRoot = config.root;
+    }
+  };
+}
+
+// vite/highlightJsLibVirtual.ts
+var VIRTUAL_HLJS_LIB_PREFIX = "\0virtual:highlight-js-lib:";
+function findHighlightJsRoot() {
+  const projectRoot2 = getProjectRoot();
+  const hoisted = path.join(projectRoot2, "node_modules/highlight.js");
+  if (fs.existsSync(path.join(hoisted, "lib/core.js"))) return hoisted;
+  const pnpmDir = path.join(projectRoot2, "node_modules/.pnpm");
+  if (!fs.existsSync(pnpmDir)) return null;
+  const hlDir = fs.readdirSync(pnpmDir).find((name) => name.startsWith("highlight.js@11."));
+  if (!hlDir) return null;
+  const hlRoot = path.join(pnpmDir, hlDir, "node_modules/highlight.js");
+  return fs.existsSync(path.join(hlRoot, "lib/core.js")) ? hlRoot : null;
+}
+function isHighlightJsLibCore(source, importer) {
+  if (source === "highlight.js/lib/core" || source === "highlight.js/lib/core.js") return true;
+  if (source.includes("highlight.js/lib/core.js")) return true;
+  if (importer?.includes("highlight.js/es/core") && (source === "../lib/core.js" || source.endsWith("lib/core.js"))) {
+    return true;
+  }
+  return false;
+}
+function resolveHighlightLibSub(source, importer) {
+  if (isHighlightJsLibCore(source, importer)) return "core";
+  if (source.startsWith("highlight.js/lib/")) {
+    return source.slice("highlight.js/lib/".length).replace(/\.js$/, "");
+  }
+  const libMarker = "highlight.js/lib/";
+  const libIdx = source.indexOf(libMarker);
+  if (libIdx !== -1 && source.endsWith(".js")) {
+    return source.slice(libIdx + libMarker.length).replace(/\.js$/, "");
+  }
+  if (importer?.includes("highlight.js/es/") && source.startsWith("../lib/")) {
+    return source.slice("../lib/".length).replace(/\.js$/, "");
+  }
+  if (/[/\\]highlight\.js[/\\]lib[/\\][^/\\]+\.js$/.test(source)) {
+    return path.basename(source, ".js");
+  }
+  return null;
+}
+function highlightJsLibVirtual() {
+  return {
+    name: "highlight-js-lib-virtual",
+    enforce: "pre",
+    config() {
+      return {
+        optimizeDeps: {
+          include: ["lowlight", "@tiptap/extension-code-block-lowlight"],
+          needsInterop: ["highlight.js", "lowlight"]
+        }
+      };
+    },
+    resolveId(source, importer) {
+      const sub = resolveHighlightLibSub(source, importer);
+      if (sub) {
+        return `${VIRTUAL_HLJS_LIB_PREFIX}${sub}`;
+      }
+      return null;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_HLJS_LIB_PREFIX)) return;
+      const sub = id.slice(VIRTUAL_HLJS_LIB_PREFIX.length);
+      const hlRoot = findHighlightJsRoot();
+      if (!hlRoot) return null;
+      const libPath = path.join(hlRoot, "lib", `${sub}.js`);
+      if (!fs.existsSync(libPath)) return null;
+      const code = fs.readFileSync(libPath, "utf-8");
+      const result = await transformWithEsbuild(code, libPath, {
+        loader: "js",
+        format: "esm",
+        platform: "browser"
+      });
+      return result.code;
+    }
+  };
+}
+
+// vite/tiptapUmoResolve.ts
+import { createRequire as createRequire2 } from "node:module";
+import fs3 from "node:fs";
+
+// vite/nodeModulesResolve.ts
+import { createRequire } from "node:module";
+import fs2 from "node:fs";
+import path2 from "node:path";
+function preferEsmEntry(resolved) {
+  if (resolved.endsWith(".cjs")) {
+    const js = resolved.replace(/\.cjs$/, ".js");
+    const mjs = resolved.replace(/\.cjs$/, ".mjs");
+    if (fs2.existsSync(mjs)) return mjs;
+    if (fs2.existsSync(js)) return js;
+  }
+  return resolved;
+}
+function readPkgVersion(pkgJsonPath) {
+  try {
+    const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isTiptapV3(version) {
+  return version != null && version.startsWith("3.");
+}
+function findCorePackageRoot() {
+  const root = getProjectRoot();
+  const linked = path2.join(root, "node_modules/adtec-core-package");
+  if (fs2.existsSync(path2.join(linked, "package.json"))) {
+    try {
+      return fs2.realpathSync(linked);
+    } catch {
+      return linked;
+    }
+  }
+  const sibling = path2.join(root, "../\u524D\u7AEF\u6838\u5FC3\u5305");
+  if (fs2.existsSync(path2.join(sibling, "package.json"))) {
+    return sibling;
+  }
+  const selfPkg = path2.join(root, "package.json");
+  if (fs2.existsSync(selfPkg)) {
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(selfPkg, "utf-8"));
+      if (pkg.name === "adtec-core-package") return root;
+    } catch {
+    }
+  }
+  return null;
+}
+function hostNodeModules() {
+  return path2.join(getProjectRoot(), "node_modules");
+}
+function pnpmStoreDir() {
+  return path2.join(hostNodeModules(), ".pnpm");
+}
+function findTiptapV3RootFromPnpm() {
+  const dir = pnpmStoreDir();
+  if (!fs2.existsSync(dir)) return null;
+  const entries = fs2.readdirSync(dir);
+  const coreDir = entries.find(
+    (name) => name.startsWith("@tiptap+core@3.20") && name.includes("@tiptap+pm@3.20")
+  ) ?? entries.find((name) => name.startsWith("@tiptap+core@3.") && name.includes("@tiptap+pm@3."));
+  if (!coreDir) return null;
+  const tiptapRoot = path2.join(dir, coreDir, "node_modules");
+  if (!fs2.existsSync(path2.join(tiptapRoot, "@tiptap/core/package.json"))) return null;
+  return tiptapRoot;
+}
+function findTiptapV3RootFromHoisted(baseNodeModules) {
+  const corePkg = path2.join(baseNodeModules, "@tiptap/core/package.json");
+  if (!fs2.existsSync(corePkg) || !isTiptapV3(readPkgVersion(corePkg))) return null;
+  return baseNodeModules;
+}
+function findTiptapV3Root() {
+  const fromPnpm = findTiptapV3RootFromPnpm();
+  if (fromPnpm) return fromPnpm;
+  const fromHost = findTiptapV3RootFromHoisted(hostNodeModules());
+  if (fromHost) return fromHost;
+  const coreRoot = findCorePackageRoot();
+  if (coreRoot) {
+    const fromCore = findTiptapV3RootFromHoisted(path2.join(coreRoot, "node_modules"));
+    if (fromCore) return fromCore;
+  }
+  return null;
+}
+function findTiptapCorePkgJson() {
+  const tiptapRoot = findTiptapV3Root();
+  if (!tiptapRoot) return null;
+  const corePkg = path2.join(tiptapRoot, "@tiptap/core/package.json");
+  return fs2.existsSync(corePkg) ? corePkg : null;
+}
+function findTiptapPmPackageJson() {
+  const dir = pnpmStoreDir();
+  const exact = path2.join(dir, "@tiptap+pm@3.20.0", "node_modules", "@tiptap/pm", "package.json");
+  if (fs2.existsSync(exact)) return exact;
+  if (fs2.existsSync(dir)) {
+    const pmDir = fs2.readdirSync(dir).find((name) => name.startsWith("@tiptap+pm@3.20") || name.startsWith("@tiptap+pm@3."));
+    if (pmDir) {
+      const candidate = path2.join(dir, pmDir, "node_modules", "@tiptap/pm", "package.json");
+      if (fs2.existsSync(candidate)) return candidate;
+    }
+  }
+  const tiptapRoot = findTiptapV3Root();
+  if (tiptapRoot) {
+    const inTree = path2.join(tiptapRoot, "@tiptap/pm/package.json");
+    if (fs2.existsSync(inTree) && isTiptapV3(readPkgVersion(inTree))) return inTree;
+  }
+  return null;
+}
+function resolveFromContext(source, contextPkgJson) {
+  try {
+    return preferEsmEntry(createRequire(contextPkgJson).resolve(source));
+  } catch {
+    return null;
+  }
+}
+function resolveFromHostOrCore(source) {
+  const root = getProjectRoot();
+  const hostPkg = path2.join(root, "package.json");
+  if (fs2.existsSync(hostPkg)) {
+    const resolved = resolveFromContext(source, hostPkg);
+    if (resolved) return resolved;
+  }
+  const coreRoot = findCorePackageRoot();
+  if (coreRoot) {
+    const corePkg = path2.join(coreRoot, "package.json");
+    const resolved = resolveFromContext(source, corePkg);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+function buildPeerAliases(packages) {
+  const aliases = [];
+  for (const pkg of packages) {
+    const resolved = resolveFromHostOrCore(pkg);
+    if (resolved) {
+      aliases.push({ find: pkg, replacement: resolved });
+    }
+  }
+  return aliases;
+}
+
+// vite/tiptapUmoResolve.ts
+var AIEDITOR_MARKERS = ["aieditor", "@tiptap+core@2", "@tiptap+pm@2", "@tiptap+vue-3@2"];
+var OPTIMIZE_DEPS_EXCLUDE = ["@tiptap/core", "@tiptap/pm", "@tiptap/vue-3"];
+function buildVue3Aliases(requireFromV3) {
+  const aliases = [];
+  try {
+    const menus = preferEsmEntry(requireFromV3.resolve("@tiptap/vue-3/menus"));
+    aliases.push({ find: "@tiptap/vue-3/menus", replacement: menus });
+  } catch {
+  }
+  return aliases;
+}
+function buildProsemirrorAliases() {
+  const pmPkgJson = findTiptapPmPackageJson();
+  if (!pmPkgJson) return [];
+  const pkg = JSON.parse(fs3.readFileSync(pmPkgJson, "utf-8"));
+  const aliases = [];
+  for (const dep of Object.keys(pkg.dependencies ?? {})) {
+    if (!dep.startsWith("prosemirror-")) continue;
+    const resolved = resolveFromContext(dep, pmPkgJson);
+    if (resolved) {
+      aliases.push({ find: dep, replacement: resolved });
+    }
+  }
+  return aliases;
+}
+function buildTiptapV3Aliases() {
+  const corePkgJson = findTiptapCorePkgJson();
+  if (!corePkgJson) return buildProsemirrorAliases();
+  const requireFromV3 = createRequire2(corePkgJson);
+  return [...buildProsemirrorAliases(), ...buildVue3Aliases(requireFromV3)];
+}
+function tiptapUmoResolve() {
+  return {
+    name: "tiptap-umo-resolve",
+    enforce: "pre",
+    config() {
+      return {
+        optimizeDeps: {
+          exclude: OPTIMIZE_DEPS_EXCLUDE
+        }
+      };
+    },
+    resolveId(source, importer) {
+      if (importer && AIEDITOR_MARKERS.some((marker) => importer.includes(marker))) return null;
+      if (source === "@tiptap/vue-3") return null;
+      const corePkgJson = findTiptapCorePkgJson();
+      const pmPkgJson = findTiptapPmPackageJson();
+      if (corePkgJson && source.startsWith("@tiptap/")) {
+        return resolveFromContext(source, corePkgJson);
+      }
+      if (pmPkgJson && source.startsWith("prosemirror-")) {
+        return resolveFromContext(source, pmPkgJson);
+      }
+      return null;
+    }
+  };
+}
+
+// vite/tiptapVueRendererFix.ts
+import fs4 from "node:fs";
+import path3 from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+var VIRTUAL_TIPTAP_VUE3 = "\0virtual:patched-tiptap-vue-3";
+var RAW_PROP_KEYS = [
+  "editor",
+  "node",
+  "view",
+  "extension",
+  "mark",
+  "decorations",
+  "innerDecorations"
+];
+var REACTIVE_PROPS_BUG = "this.props = reactive(props);";
+var REACTIVE_PROPS_FIX = `this.props = markRaw2(Object.fromEntries(Object.entries(props).map(([key, value]) => [key, value != null && ${JSON.stringify(RAW_PROP_KEYS)}.includes(key) ? markRaw2(value) : value])));`;
+var BROKEN_MARKRAW_END = "markRaw2(value) : value]));";
+var FIXED_MARKRAW_END = "markRaw2(value) : value])));";
+var UPDATE_PROPS_BUG = `Object.entries(props).forEach(([key, value]) => {
+      this.props[key] = value;
+    });`;
+var UPDATE_PROPS_FIX = `Object.entries(props).forEach(([key, value]) => {
+      this.props[key] = value != null && ${JSON.stringify(RAW_PROP_KEYS)}.includes(key) ? markRaw2(value) : value;
+    });`;
+var CONTENT_COMPONENT_GUARD_BUG = `if (!props.editor.contentComponent) {
+      return {};
+    }`;
+var CONTENT_COMPONENT_GUARD_FIX = `if (!props.editor.contentComponent && !props.editor.appContext) {
+      return {};
+    }`;
+function patchTiptapVueRendererCode(code) {
+  const needsPatch = code.includes(REACTIVE_PROPS_BUG) || code.includes(BROKEN_MARKRAW_END) || code.includes("this.props = Object.fromEntries(Object.entries(props)") || code.includes(UPDATE_PROPS_BUG) || code.includes(CONTENT_COMPONENT_GUARD_BUG);
+  if (!needsPatch) return code;
+  let next = code;
+  if (next.includes("this.props = markRaw2(Object.fromEntries(Object.entries(props)") && next.includes(BROKEN_MARKRAW_END) && !next.includes(FIXED_MARKRAW_END)) {
+    next = next.replace(BROKEN_MARKRAW_END, FIXED_MARKRAW_END);
+  }
+  if (next.includes(REACTIVE_PROPS_BUG)) {
+    next = next.replace(REACTIVE_PROPS_BUG, REACTIVE_PROPS_FIX);
+  } else if (next.includes("this.props = Object.fromEntries(Object.entries(props)") && !next.includes("this.props = markRaw2(Object.fromEntries(Object.entries(props)")) {
+    next = next.replace(
+      "this.props = Object.fromEntries(Object.entries(props)",
+      "this.props = markRaw2(Object.fromEntries(Object.entries(props)"
+    );
+    next = next.replace(BROKEN_MARKRAW_END, FIXED_MARKRAW_END);
+  }
+  if (next.includes(UPDATE_PROPS_BUG)) {
+    next = next.replace(UPDATE_PROPS_BUG, UPDATE_PROPS_FIX);
+  }
+  if (next.includes(CONTENT_COMPONENT_GUARD_BUG)) {
+    next = next.replaceAll(CONTENT_COMPONENT_GUARD_BUG, CONTENT_COMPONENT_GUARD_FIX);
+  }
+  return next;
+}
+function findCanonicalTiptapVue3Entry() {
+  const projectRoot2 = getProjectRoot();
+  const hoistedPkg = path3.join(projectRoot2, "node_modules/@tiptap/vue-3/package.json");
+  if (fs4.existsSync(hoistedPkg)) {
+    try {
+      const resolved = createRequire3(hoistedPkg).resolve("@tiptap/vue-3");
+      const js = resolved.endsWith(".cjs") ? resolved.replace(/\.cjs$/, ".js") : resolved;
+      return fs4.existsSync(js) ? js : resolved;
+    } catch {
+    }
+  }
+  const corePkgJson = findTiptapCorePkgJson();
+  if (!corePkgJson) return null;
+  const pkgJson = path3.join(path3.dirname(path3.dirname(corePkgJson)), "@tiptap/vue-3/package.json");
+  if (!fs4.existsSync(pkgJson)) return null;
+  try {
+    const resolved = createRequire3(pkgJson).resolve("@tiptap/vue-3");
+    const js = resolved.endsWith(".cjs") ? resolved.replace(/\.cjs$/, ".js") : resolved;
+    return fs4.existsSync(js) ? js : resolved;
+  } catch {
+    return null;
+  }
+}
+var cachedPatchedCode = null;
+function loadPatchedTiptapVue3Code() {
+  if (cachedPatchedCode) return cachedPatchedCode;
+  const entry = findCanonicalTiptapVue3Entry();
+  if (!entry) {
+    throw new Error("[tiptap-vue-renderer-fix] \u672A\u627E\u5230 @tiptap/vue-3@3.x\uFF0C\u8BF7\u5148 npm/pnpm install");
+  }
+  const patched = patchTiptapVueRendererCode(fs4.readFileSync(entry, "utf-8"));
+  if (patched.includes(REACTIVE_PROPS_BUG)) {
+    throw new Error(`[tiptap-vue-renderer-fix] patch \u5931\u8D25: ${entry}`);
+  }
+  if (patched.includes(BROKEN_MARKRAW_END) && !patched.includes(FIXED_MARKRAW_END)) {
+    throw new Error(`[tiptap-vue-renderer-fix] patch \u62EC\u53F7\u4E0D\u5B8C\u6574: ${entry}`);
+  }
+  cachedPatchedCode = patched;
+  return patched;
+}
+function isTiptapVue3DistFile(id) {
+  const norm = id.replace(/\\/g, "/");
+  return norm.includes("@tiptap/vue-3/dist/index.") && (norm.endsWith(".js") || norm.endsWith(".cjs"));
+}
+function tiptapVueRendererFix() {
+  return {
+    name: "tiptap-vue-renderer-fix",
+    enforce: "pre",
+    resolveId(source) {
+      if (source === "@tiptap/vue-3") {
+        return VIRTUAL_TIPTAP_VUE3;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === VIRTUAL_TIPTAP_VUE3) {
+        return loadPatchedTiptapVue3Code();
+      }
+      return null;
+    },
+    transform(code, id) {
+      if (id === VIRTUAL_TIPTAP_VUE3 || !isTiptapVue3DistFile(id)) return null;
+      const next = patchTiptapVueRendererCode(code);
+      return next === code ? null : next;
+    },
+    configureServer() {
+      cachedPatchedCode = null;
+    }
+  };
+}
+function writePatchedTiptapVue3ToDisk(targetPath) {
+  const out = targetPath ?? path3.join(getProjectRoot(), "node_modules/.cache/patched-tiptap-vue-3-index.js");
+  fs4.mkdirSync(path3.dirname(out), { recursive: true });
+  fs4.writeFileSync(out, loadPatchedTiptapVue3Code(), "utf-8");
+  return out;
+}
+
+// vite/umoCjsVirtual.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+import { createRequire as createRequire4 } from "node:module";
+import { pathToFileURL } from "node:url";
+import { transformWithEsbuild as transformWithEsbuild2 } from "vite";
+var UMO_CJS_SPECS = [
+  "dom-to-image-more",
+  "hotkeys-js",
+  "jsbarcode",
+  "file-saver",
+  "pretty-bytes",
+  "smooth-signature",
+  "pure-svg-code",
+  "nzh/cn"
+];
+var UMO_CJS_NAMED_EXPORTS = {
+  "file-saver": ["saveAs"],
+  "pure-svg-code": ["qrcode", "barcode", "svg2url"]
+};
+var VIRTUAL_UMO_CJS_PREFIX = "\0virtual:umo-cjs:";
+function requireFromProjectRoot() {
+  return createRequire4(path4.join(getProjectRoot(), "package.json"));
+}
+function resolvePackageMain(pkgDir) {
+  const pkgJsonPath = path4.join(pkgDir, "package.json");
+  if (!fs5.existsSync(pkgJsonPath)) return null;
+  const pkgJson = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf-8"));
+  const main = pkgJson.module || pkgJson.main || "index.js";
+  const entry = path4.join(pkgDir, main);
+  return fs5.existsSync(entry) ? entry : null;
+}
+function findUmoPackageDir(pkgName) {
+  const projectRoot2 = getProjectRoot();
+  const hoisted = path4.join(projectRoot2, "node_modules", pkgName);
+  if (fs5.existsSync(path4.join(hoisted, "package.json"))) return hoisted;
+  const pnpmDir = path4.join(projectRoot2, "node_modules/.pnpm");
+  if (!fs5.existsSync(pnpmDir)) return null;
+  const pnpmPrefix = pkgName.replace("/", "+");
+  const pkgDir = fs5.readdirSync(pnpmDir).find((name) => name.startsWith(`${pnpmPrefix}@`));
+  if (!pkgDir) return null;
+  const resolved = path4.join(pnpmDir, pkgDir, "node_modules", pkgName);
+  return fs5.existsSync(path4.join(resolved, "package.json")) ? resolved : null;
+}
+function findUmoPackageEntryForSpec(spec) {
+  const [pkgName, ...subParts] = spec.split("/");
+  const pkgDir = findUmoPackageDir(pkgName);
+  if (!pkgDir) return null;
+  if (subParts.length === 0) {
+    return resolvePackageMain(pkgDir);
+  }
+  const sub = subParts.join("/");
+  const candidates = [
+    path4.join(pkgDir, `${sub}.js`),
+    path4.join(pkgDir, sub, "index.js"),
+    path4.join(pkgDir, sub)
+  ];
+  for (const candidate of candidates) {
+    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+function matchesUmoCjsFile(source, spec) {
+  const [pkg, ...sub] = spec.split("/");
+  if (!source.includes(`/${pkg}/`)) return false;
+  if (sub.length === 0) {
+    return source.endsWith(".js") || source.includes(".js?");
+  }
+  const subPath = sub.join("/");
+  return source.includes(`/${pkg}/${subPath}.js`) || source.includes(`/${pkg}/${subPath}?`);
+}
+function augmentUmoCjsNamedExports(code, spec) {
+  const named = UMO_CJS_NAMED_EXPORTS[spec] ?? UMO_CJS_NAMED_EXPORTS[spec.split("/")[0] ?? ""];
+  if (!named?.length) return code;
+  const match = code.match(/export default (require_[A-Za-z0-9_]+\(\));?\s*$/);
+  if (!match) return code;
+  const call = match[1];
+  const namedLines = named.map((n) => `export const ${n} = __umoCjs.${n} ?? __umoCjs.default?.${n};`).join("\n");
+  return code.replace(
+    /export default require_[A-Za-z0-9_]+\(\);?\s*$/,
+    `const __umoCjs = ${call};
+export default __umoCjs;
+${namedLines}
+`
+  );
+}
+var cachedEsbuild;
+async function getEsbuild() {
+  if (cachedEsbuild) return cachedEsbuild;
+  try {
+    cachedEsbuild = requireFromProjectRoot()("esbuild");
+    return cachedEsbuild;
+  } catch {
+  }
+  const pnpmDir = path4.join(getProjectRoot(), "node_modules/.pnpm");
+  const esDir = fs5.existsSync(pnpmDir) ? fs5.readdirSync(pnpmDir).find((name) => name.startsWith("esbuild@")) : void 0;
+  if (esDir) {
+    const esMain = path4.join(pnpmDir, esDir, "node_modules/esbuild/lib/main.js");
+    if (fs5.existsSync(esMain)) {
+      const mod = await import(pathToFileURL(esMain).href);
+      cachedEsbuild = mod.default ?? mod;
+      return cachedEsbuild;
+    }
+  }
+  throw new Error("[umo-cjs-virtual] \u672A\u627E\u5230 esbuild\uFF0C\u8BF7\u5728\u5BBF\u4E3B\u9879\u76EE\u6267\u884C: pnpm add -D esbuild");
+}
+async function bundleUmoCjsToEsm(entry) {
+  const esbuild = await getEsbuild();
+  const result = await esbuild.build({
+    entryPoints: [entry],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    write: false,
+    logLevel: "silent"
+  });
+  const code = result.outputFiles[0]?.text ?? "";
+  if (code) return code;
+  const fallback = await transformWithEsbuild2(fs5.readFileSync(entry, "utf-8"), entry, {
+    loader: "js",
+    format: "esm",
+    platform: "browser"
+  });
+  return fallback.code;
+}
+function umoCjsVirtual() {
+  return {
+    name: "umo-cjs-virtual",
+    enforce: "pre",
+    resolveId(source) {
+      if (UMO_CJS_SPECS.includes(source)) {
+        return `${VIRTUAL_UMO_CJS_PREFIX}${source}`;
+      }
+      for (const spec of UMO_CJS_SPECS) {
+        if (matchesUmoCjsFile(source, spec)) {
+          return `${VIRTUAL_UMO_CJS_PREFIX}${spec}`;
+        }
+      }
+      return null;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_UMO_CJS_PREFIX)) return;
+      const spec = id.slice(VIRTUAL_UMO_CJS_PREFIX.length);
+      const entry = findUmoPackageEntryForSpec(spec);
+      if (!entry) return null;
+      const code = augmentUmoCjsNamedExports(await bundleUmoCjsToEsm(entry), spec);
+      return { code, map: null };
+    }
+  };
+}
+
+// vite/yjsPeerResolve.ts
+var UMO_PEER_PREFIXES = [
+  "yjs",
+  "y-protocols",
+  "y-prosemirror",
+  "lib0/",
+  "@tiptap/y-tiptap",
+  "@tiptap/extension-collaboration"
+];
+function isUmoPeerImport(source) {
+  return UMO_PEER_PREFIXES.some(
+    (prefix) => source === prefix.replace(/\/$/, "") || source.startsWith(prefix)
+  );
+}
+function buildYjsPeerAliases() {
+  return buildPeerAliases([
+    "yjs",
+    "y-protocols",
+    "y-prosemirror",
+    "@tiptap/y-tiptap",
+    "@tiptap/extension-collaboration"
+  ]);
+}
+function yjsPeerResolve() {
+  return {
+    name: "yjs-peer-resolve",
+    enforce: "pre",
+    config() {
+      return {
+        optimizeDeps: {
+          include: ["yjs", "y-protocols/awareness"]
+        }
+      };
+    },
+    resolveId(source) {
+      if (!isUmoPeerImport(source)) return null;
+      return resolveFromHostOrCore(source);
+    }
+  };
+}
+
+// vite/umoIntegration.ts
+function coreUmoVitePlugins() {
+  return [
+    createProjectRootPlugin(),
+    tiptapVueRendererFix(),
+    highlightJsLibVirtual(),
+    umoCjsVirtual(),
+    tiptapUmoResolve(),
+    yjsPeerResolve()
+  ];
+}
+function coreUmoResolveConfig() {
+  return {
+    dedupe: [
+      "vue",
+      "@tiptap/core",
+      "@tiptap/pm",
+      "@tiptap/vue-3",
+      "yjs",
+      "y-protocols",
+      "y-prosemirror",
+      "@tiptap/y-tiptap"
+    ],
+    alias: [...buildTiptapV3Aliases(), ...buildYjsPeerAliases()]
+  };
+}
+function coreUmoManualChunk(id) {
+  const norm = id.replace(/\\/g, "/");
+  if (norm.includes("editor-main/src") || norm.includes("prebuilt/umo-editor") || norm.includes("RichTextEditor")) {
+    return "umo-editor";
+  }
+  return void 0;
+}
+export {
+  coreUmoManualChunk,
+  coreUmoResolveConfig,
+  coreUmoVitePlugins,
+  patchTiptapVueRendererCode,
+  writePatchedTiptapVue3ToDisk
+};